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 BaseProperty
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.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class BasicSwarmProperties(BaseProperty):
contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_wait_time: float = dataclasses.field(default=1.0)
collision_radius: float = dataclasses.field(default=0.30000001192092896)
touch_radius: float = dataclasses.field(default=0.699999988079071)
damage_radius: float = dataclasses.field(default=0.0)
speed: float = dataclasses.field(default=3.0)
count: int = dataclasses.field(default=50)
max_count: int = dataclasses.field(default=0)
influence_radius: float = dataclasses.field(default=2.5)
unknown_0x61959f0d: float = dataclasses.field(default=1.0)
alignment_priority: float = dataclasses.field(default=0.699999988079071)
separation_priority: float = dataclasses.field(default=0.4000000059604645)
path_following_priority: float = dataclasses.field(default=0.699999988079071)
player_attract_priority: float = dataclasses.field(default=0.699999988079071)
player_attract_distance: float = dataclasses.field(default=10.0)
spawn_speed: float = dataclasses.field(default=6.0)
attacker_count: int = dataclasses.field(default=5)
attack_proximity: float = dataclasses.field(default=0.0)
attack_timer: float = dataclasses.field(default=0.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
damage_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
death_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x84f81f55: int = dataclasses.field(default=5)
unknown_0xe1bd61d8: float = dataclasses.field(default=1.0)
turn_rate: float = dataclasses.field(default=90.0)
unknown_0xc2208b0f: bool = dataclasses.field(default=False)
unknown_0x7eb5d9e8: bool = dataclasses.field(default=False)
is_orbitable: bool = dataclasses.field(default=True)
unknown_0xbc01a28e: bool = dataclasses.field(default=False)
locomotion_looped_sound: int = dataclasses.field(default=0, metadata={'sound': True})
attack_looped_sound: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0xd2986c43: float = dataclasses.field(default=0.0)
max_audible_distance: float = dataclasses.field(default=100.0)
min_volume: int = dataclasses.field(default=20)
max_volume: int = dataclasses.field(default=127)
freeze_duration: float = dataclasses.field(default=5.0)
life_time: float = dataclasses.field(default=100.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00%') # 37 properties
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': 11, 'di_damage': 5.0, 'di_radius': 5.0})
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'\x8aj\xb19') # 0x8a6ab139
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_radius))
data.write(b'\x06\x8c\x8e\x81') # 0x68c8e81
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.touch_radius))
data.write(b'\x0fY\x879') # 0xf598739
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_radius))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'2\x91\xb8\xa2') # 0x3291b8a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.count))
data.write(b'T\xb6\x8cL') # 0x54b68c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_count))
data.write(b'\xb1`E\x0e') # 0xb160450e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.influence_radius))
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'\xae\x11\xf9u') # 0xae11f975
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.path_following_priority))
data.write(b'\x87\xed\xbc\xf1') # 0x87edbcf1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_attract_priority))
data.write(b'T+\xc8\x12') # 0x542bc812
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_attract_distance))
data.write(b'\xa3U\xc0O') # 0xa355c04f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spawn_speed))
data.write(b'R:@\\') # 0x523a405c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.attacker_count))
data.write(b'\x1c\xa0\xe7`') # 0x1ca0e760
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_proximity))
data.write(b'\x88\xdf>\xa8') # 0x88df3ea8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_timer))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data, default_override={'health': 2.0, 'hi_knock_back_resistance': 2.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'8.@n') # 0x382e406e
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'}F)0') # 0x7d462930
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_particle_effect))
data.write(b'\x84\xf8\x1fU') # 0x84f81f55
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x84f81f55))
data.write(b'\xe1\xbda\xd8') # 0xe1bd61d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe1bd61d8))
data.write(b'\xe3M\xc7\x03') # 0xe34dc703
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_rate))
data.write(b'\xc2 \x8b\x0f') # 0xc2208b0f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc2208b0f))
data.write(b'~\xb5\xd9\xe8') # 0x7eb5d9e8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7eb5d9e8))
data.write(b'\x82k\xec\x80') # 0x826bec80
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_orbitable))
data.write(b'\xbc\x01\xa2\x8e') # 0xbc01a28e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbc01a28e))
data.write(b'\x97\x07\x0f\x80') # 0x97070f80
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.locomotion_looped_sound))
data.write(b'\xaaE3W') # 0xaa453357
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.attack_looped_sound))
data.write(b'\xd2\x98lC') # 0xd2986c43
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd2986c43))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'Wa\x94\x96') # 0x57619496
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.min_volume))
data.write(b'\xc7\x12\x84|') # 0xc712847c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_volume))
data.write(b'\xef;\xd8\xcf') # 0xef3bd8cf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.freeze_duration))
data.write(b'\xb0-\xe5U') # 0xb02de555
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.life_time))
@classmethod
def from_json(cls, data: dict):
return cls(
contact_damage=DamageInfo.from_json(data['contact_damage']),
damage_wait_time=data['damage_wait_time'],
collision_radius=data['collision_radius'],
touch_radius=data['touch_radius'],
damage_radius=data['damage_radius'],
speed=data['speed'],
count=data['count'],
max_count=data['max_count'],
influence_radius=data['influence_radius'],
unknown_0x61959f0d=data['unknown_0x61959f0d'],
alignment_priority=data['alignment_priority'],
separation_priority=data['separation_priority'],
path_following_priority=data['path_following_priority'],
player_attract_priority=data['player_attract_priority'],
player_attract_distance=data['player_attract_distance'],
spawn_speed=data['spawn_speed'],
attacker_count=data['attacker_count'],
attack_proximity=data['attack_proximity'],
attack_timer=data['attack_timer'],
health=HealthInfo.from_json(data['health']),
damage_vulnerability=DamageVulnerability.from_json(data['damage_vulnerability']),
death_particle_effect=data['death_particle_effect'],
unknown_0x84f81f55=data['unknown_0x84f81f55'],
unknown_0xe1bd61d8=data['unknown_0xe1bd61d8'],
turn_rate=data['turn_rate'],
unknown_0xc2208b0f=data['unknown_0xc2208b0f'],
unknown_0x7eb5d9e8=data['unknown_0x7eb5d9e8'],
is_orbitable=data['is_orbitable'],
unknown_0xbc01a28e=data['unknown_0xbc01a28e'],
locomotion_looped_sound=data['locomotion_looped_sound'],
attack_looped_sound=data['attack_looped_sound'],
unknown_0xd2986c43=data['unknown_0xd2986c43'],
max_audible_distance=data['max_audible_distance'],
min_volume=data['min_volume'],
max_volume=data['max_volume'],
freeze_duration=data['freeze_duration'],
life_time=data['life_time'],
)
def to_json(self) -> dict:
return {
'contact_damage': self.contact_damage.to_json(),
'damage_wait_time': self.damage_wait_time,
'collision_radius': self.collision_radius,
'touch_radius': self.touch_radius,
'damage_radius': self.damage_radius,
'speed': self.speed,
'count': self.count,
'max_count': self.max_count,
'influence_radius': self.influence_radius,
'unknown_0x61959f0d': self.unknown_0x61959f0d,
'alignment_priority': self.alignment_priority,
'separation_priority': self.separation_priority,
'path_following_priority': self.path_following_priority,
'player_attract_priority': self.player_attract_priority,
'player_attract_distance': self.player_attract_distance,
'spawn_speed': self.spawn_speed,
'attacker_count': self.attacker_count,
'attack_proximity': self.attack_proximity,
'attack_timer': self.attack_timer,
'health': self.health.to_json(),
'damage_vulnerability': self.damage_vulnerability.to_json(),
'death_particle_effect': self.death_particle_effect,
'unknown_0x84f81f55': self.unknown_0x84f81f55,
'unknown_0xe1bd61d8': self.unknown_0xe1bd61d8,
'turn_rate': self.turn_rate,
'unknown_0xc2208b0f': self.unknown_0xc2208b0f,
'unknown_0x7eb5d9e8': self.unknown_0x7eb5d9e8,
'is_orbitable': self.is_orbitable,
'unknown_0xbc01a28e': self.unknown_0xbc01a28e,
'locomotion_looped_sound': self.locomotion_looped_sound,
'attack_looped_sound': self.attack_looped_sound,
'unknown_0xd2986c43': self.unknown_0xd2986c43,
'max_audible_distance': self.max_audible_distance,
'min_volume': self.min_volume,
'max_volume': self.max_volume,
'freeze_duration': self.freeze_duration,
'life_time': self.life_time,
}
def _dependencies_for_contact_damage(self, asset_manager):
yield from self.contact_damage.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_damage_vulnerability(self, asset_manager):
yield from self.damage_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_death_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_particle_effect)
def _dependencies_for_locomotion_looped_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.locomotion_looped_sound)
def _dependencies_for_attack_looped_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.attack_looped_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_contact_damage, "contact_damage", "DamageInfo"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_damage_vulnerability, "damage_vulnerability", "DamageVulnerability"),
(self._dependencies_for_death_particle_effect, "death_particle_effect", "AssetId"),
(self._dependencies_for_locomotion_looped_sound, "locomotion_looped_sound", "int"),
(self._dependencies_for_attack_looped_sound, "attack_looped_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for BasicSwarmProperties.{field_name} ({field_type}): {e}"
)
def _decode_contact_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_radius': 5.0})
def _decode_damage_wait_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_touch_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_radius(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_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_influence_radius(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_path_following_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_attract_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_attract_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spawn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attacker_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_attack_proximity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_timer(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, default_override={'health': 2.0, 'hi_knock_back_resistance': 2.0})
def _decode_damage_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_death_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x84f81f55(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xe1bd61d8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc2208b0f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7eb5d9e8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_orbitable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbc01a28e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_locomotion_looped_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_attack_looped_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd2986c43(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_freeze_duration(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd756416e: ('contact_damage', _decode_contact_damage),
0xe0cdc7e3: ('damage_wait_time', _decode_damage_wait_time),
0x8a6ab139: ('collision_radius', _decode_collision_radius),
0x68c8e81: ('touch_radius', _decode_touch_radius),
0xf598739: ('damage_radius', _decode_damage_radius),
0x6392404e: ('speed', _decode_speed),
0x3291b8a2: ('count', _decode_count),
0x54b68c4c: ('max_count', _decode_max_count),
0xb160450e: ('influence_radius', _decode_influence_radius),
0x61959f0d: ('unknown_0x61959f0d', _decode_unknown_0x61959f0d),
0x4841f1de: ('alignment_priority', _decode_alignment_priority),
0xd293ebc4: ('separation_priority', _decode_separation_priority),
0xae11f975: ('path_following_priority', _decode_path_following_priority),
0x87edbcf1: ('player_attract_priority', _decode_player_attract_priority),
0x542bc812: ('player_attract_distance', _decode_player_attract_distance),
0xa355c04f: ('spawn_speed', _decode_spawn_speed),
0x523a405c: ('attacker_count', _decode_attacker_count),
0x1ca0e760: ('attack_proximity', _decode_attack_proximity),
0x88df3ea8: ('attack_timer', _decode_attack_timer),
0xcf90d15e: ('health', _decode_health),
0x382e406e: ('damage_vulnerability', _decode_damage_vulnerability),
0x7d462930: ('death_particle_effect', _decode_death_particle_effect),
0x84f81f55: ('unknown_0x84f81f55', _decode_unknown_0x84f81f55),
0xe1bd61d8: ('unknown_0xe1bd61d8', _decode_unknown_0xe1bd61d8),
0xe34dc703: ('turn_rate', _decode_turn_rate),
0xc2208b0f: ('unknown_0xc2208b0f', _decode_unknown_0xc2208b0f),
0x7eb5d9e8: ('unknown_0x7eb5d9e8', _decode_unknown_0x7eb5d9e8),
0x826bec80: ('is_orbitable', _decode_is_orbitable),
0xbc01a28e: ('unknown_0xbc01a28e', _decode_unknown_0xbc01a28e),
0x97070f80: ('locomotion_looped_sound', _decode_locomotion_looped_sound),
0xaa453357: ('attack_looped_sound', _decode_attack_looped_sound),
0xd2986c43: ('unknown_0xd2986c43', _decode_unknown_0xd2986c43),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x57619496: ('min_volume', _decode_min_volume),
0xc712847c: ('max_volume', _decode_max_volume),
0xef3bd8cf: ('freeze_duration', _decode_freeze_duration),
0xb02de555: ('life_time', _decode_life_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/BasicSwarmProperties.py | 0.599602 | 0.241048 | BasicSwarmProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct6(BaseProperty):
override: bool = dataclasses.field(default=False)
unknown: float = dataclasses.field(default=55.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x7f\xf8n\xe2') # 0x7ff86ee2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override))
data.write(b'\x12<\xac\x0e') # 0x123cac0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
override=data['override'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'override': self.override,
'unknown': self.unknown,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x7ff86ee2, 0x123cac0e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct6]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct6(
dec[2],
dec[5],
)
def _decode_override(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7ff86ee2: ('override', _decode_override),
0x123cac0e: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct6.py | 0.642993 | 0.296145 | UnknownStruct6.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct16(BaseProperty):
unknown_0x7ee77018: float = dataclasses.field(default=50.0)
unknown_0xbfb7ca5c: float = dataclasses.field(default=100.0)
unknown_0x1e2debc6: float = dataclasses.field(default=100.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'~\xe7p\x18') # 0x7ee77018
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7ee77018))
data.write(b'\xbf\xb7\xca\\') # 0xbfb7ca5c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbfb7ca5c))
data.write(b'\x1e-\xeb\xc6') # 0x1e2debc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1e2debc6))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x7ee77018=data['unknown_0x7ee77018'],
unknown_0xbfb7ca5c=data['unknown_0xbfb7ca5c'],
unknown_0x1e2debc6=data['unknown_0x1e2debc6'],
)
def to_json(self) -> dict:
return {
'unknown_0x7ee77018': self.unknown_0x7ee77018,
'unknown_0xbfb7ca5c': self.unknown_0xbfb7ca5c,
'unknown_0x1e2debc6': self.unknown_0x1e2debc6,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x7ee77018, 0xbfb7ca5c, 0x1e2debc6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct16]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct16(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown_0x7ee77018(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbfb7ca5c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1e2debc6(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]]] = {
0x7ee77018: ('unknown_0x7ee77018', _decode_unknown_0x7ee77018),
0xbfb7ca5c: ('unknown_0xbfb7ca5c', _decode_unknown_0xbfb7ca5c),
0x1e2debc6: ('unknown_0x1e2debc6', _decode_unknown_0x1e2debc6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct16.py | 0.631822 | 0.303267 | UnknownStruct16.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class AudioPlaybackParms(BaseProperty):
maximum_distance: float = dataclasses.field(default=100.0)
fall_off: float = dataclasses.field(default=0.10000000149011612)
sound_id: int = dataclasses.field(default=0, metadata={'sound': True})
max_volume: int = dataclasses.field(default=127)
min_volume: int = dataclasses.field(default=0)
use_room_acoustics: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\x0eD\x9fr') # 0xe449f72
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_distance))
data.write(b'rS\x18g') # 0x72531867
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fall_off))
data.write(b'\xaf\x85\xa3t') # 0xaf85a374
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_id))
data.write(b'\xc7\x12\x84|') # 0xc712847c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_volume))
data.write(b'Wa\x94\x96') # 0x57619496
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.min_volume))
data.write(b'\x85psT') # 0x85707354
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_room_acoustics))
@classmethod
def from_json(cls, data: dict):
return cls(
maximum_distance=data['maximum_distance'],
fall_off=data['fall_off'],
sound_id=data['sound_id'],
max_volume=data['max_volume'],
min_volume=data['min_volume'],
use_room_acoustics=data['use_room_acoustics'],
)
def to_json(self) -> dict:
return {
'maximum_distance': self.maximum_distance,
'fall_off': self.fall_off,
'sound_id': self.sound_id,
'max_volume': self.max_volume,
'min_volume': self.min_volume,
'use_room_acoustics': self.use_room_acoustics,
}
def _dependencies_for_sound_id(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_id)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_sound_id, "sound_id", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AudioPlaybackParms.{field_name} ({field_type}): {e}"
)
_FAST_FORMAT = None
_FAST_IDS = (0xe449f72, 0x72531867, 0xaf85a374, 0xc712847c, 0x57619496, 0x85707354)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AudioPlaybackParms]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHlLHlLHlLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(57))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return AudioPlaybackParms(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_maximum_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fall_off(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_id(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_min_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_use_room_acoustics(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]]] = {
0xe449f72: ('maximum_distance', _decode_maximum_distance),
0x72531867: ('fall_off', _decode_fall_off),
0xaf85a374: ('sound_id', _decode_sound_id),
0xc712847c: ('max_volume', _decode_max_volume),
0x57619496: ('min_volume', _decode_min_volume),
0x85707354: ('use_room_acoustics', _decode_use_room_acoustics),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/AudioPlaybackParms.py | 0.664976 | 0.26341 | AudioPlaybackParms.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.TDamageInfo import TDamageInfo
@dataclasses.dataclass()
class TWeaponDamage(BaseProperty):
normal: TDamageInfo = dataclasses.field(default_factory=TDamageInfo)
charged: TDamageInfo = dataclasses.field(default_factory=TDamageInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b"\x8a\xc4'\x8a") # 0x8ac4278a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal.to_stream(data, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9\xac\x01\xd2') # 0xc9ac01d2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.charged.to_stream(data, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
normal=TDamageInfo.from_json(data['normal']),
charged=TDamageInfo.from_json(data['charged']),
)
def to_json(self) -> dict:
return {
'normal': self.normal.to_json(),
'charged': self.charged.to_json(),
}
def _dependencies_for_normal(self, asset_manager):
yield from self.normal.dependencies_for(asset_manager)
def _dependencies_for_charged(self, asset_manager):
yield from self.charged.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_normal, "normal", "TDamageInfo"),
(self._dependencies_for_charged, "charged", "TDamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TWeaponDamage.{field_name} ({field_type}): {e}"
)
def _decode_normal(data: typing.BinaryIO, property_size: int):
return TDamageInfo.from_stream(data, property_size, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
def _decode_charged(data: typing.BinaryIO, property_size: int):
return TDamageInfo.from_stream(data, property_size, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8ac4278a: ('normal', _decode_normal),
0xc9ac01d2: ('charged', _decode_charged),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/TWeaponDamage.py | 0.566139 | 0.304888 | TWeaponDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct7(BaseProperty):
override: bool = dataclasses.field(default=False)
speed: float = dataclasses.field(default=120.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x7f\xf8n\xe2') # 0x7ff86ee2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
@classmethod
def from_json(cls, data: dict):
return cls(
override=data['override'],
speed=data['speed'],
)
def to_json(self) -> dict:
return {
'override': self.override,
'speed': self.speed,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x7ff86ee2, 0x6392404e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct7]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct7(
dec[2],
dec[5],
)
def _decode_override(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_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]]] = {
0x7ff86ee2: ('override', _decode_override),
0x6392404e: ('speed', _decode_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct7.py | 0.665737 | 0.299483 | UnknownStruct7.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class CameraHintStructB(BaseProperty):
override: bool = dataclasses.field(default=False)
distance: float = dataclasses.field(default=8.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x7f\xf8n\xe2') # 0x7ff86ee2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override))
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
@classmethod
def from_json(cls, data: dict):
return cls(
override=data['override'],
distance=data['distance'],
)
def to_json(self) -> dict:
return {
'override': self.override,
'distance': self.distance,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x7ff86ee2, 0xc3bf43be)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraHintStructB]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return CameraHintStructB(
dec[2],
dec[5],
)
def _decode_override(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_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]]] = {
0x7ff86ee2: ('override', _decode_override),
0xc3bf43be: ('distance', _decode_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/CameraHintStructB.py | 0.69285 | 0.305264 | CameraHintStructB.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class GrappleParameters(BaseProperty):
grapple_length: float = dataclasses.field(default=10.0)
grapple_attach_length: float = dataclasses.field(default=10.0)
grapple_spring_constant: float = dataclasses.field(default=1.0)
grapple_spring_length: float = dataclasses.field(default=1.0)
unknown_0x987f68c7: float = dataclasses.field(default=1.0)
swing_force: float = dataclasses.field(default=1.0)
swing_max_force: float = dataclasses.field(default=1.0)
swing_arc_angle: float = dataclasses.field(default=45.0)
swing_turn_angle: float = dataclasses.field(default=90.0)
swing_camera_pitch: float = dataclasses.field(default=0.0)
unknown_0xf9e45827: float = dataclasses.field(default=0.0)
unknown_0x11b6a17a: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'zy~O') # 0x7a797e4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grapple_length))
data.write(b'\x1d\x85$\x15') # 0x1d852415
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grapple_attach_length))
data.write(b'\xfd\xf5\xcb\x82') # 0xfdf5cb82
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grapple_spring_constant))
data.write(b'.\xc2T\xe3') # 0x2ec254e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grapple_spring_length))
data.write(b'\x98\x7fh\xc7') # 0x987f68c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x987f68c7))
data.write(b'\x1akI\xab') # 0x1a6b49ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_force))
data.write(b'\x1eQ$\xd4') # 0x1e5124d4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_max_force))
data.write(b'E\x0e\xa10') # 0x450ea130
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_arc_angle))
data.write(b'U\xf2\xbc\x8f') # 0x55f2bc8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_turn_angle))
data.write(b'\xf1+\xac\xe9') # 0xf12bace9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_camera_pitch))
data.write(b"\xf9\xe4X'") # 0xf9e45827
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf9e45827))
data.write(b'\x11\xb6\xa1z') # 0x11b6a17a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x11b6a17a))
@classmethod
def from_json(cls, data: dict):
return cls(
grapple_length=data['grapple_length'],
grapple_attach_length=data['grapple_attach_length'],
grapple_spring_constant=data['grapple_spring_constant'],
grapple_spring_length=data['grapple_spring_length'],
unknown_0x987f68c7=data['unknown_0x987f68c7'],
swing_force=data['swing_force'],
swing_max_force=data['swing_max_force'],
swing_arc_angle=data['swing_arc_angle'],
swing_turn_angle=data['swing_turn_angle'],
swing_camera_pitch=data['swing_camera_pitch'],
unknown_0xf9e45827=data['unknown_0xf9e45827'],
unknown_0x11b6a17a=data['unknown_0x11b6a17a'],
)
def to_json(self) -> dict:
return {
'grapple_length': self.grapple_length,
'grapple_attach_length': self.grapple_attach_length,
'grapple_spring_constant': self.grapple_spring_constant,
'grapple_spring_length': self.grapple_spring_length,
'unknown_0x987f68c7': self.unknown_0x987f68c7,
'swing_force': self.swing_force,
'swing_max_force': self.swing_max_force,
'swing_arc_angle': self.swing_arc_angle,
'swing_turn_angle': self.swing_turn_angle,
'swing_camera_pitch': self.swing_camera_pitch,
'unknown_0xf9e45827': self.unknown_0xf9e45827,
'unknown_0x11b6a17a': self.unknown_0x11b6a17a,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x7a797e4f, 0x1d852415, 0xfdf5cb82, 0x2ec254e3, 0x987f68c7, 0x1a6b49ab, 0x1e5124d4, 0x450ea130, 0x55f2bc8f, 0xf12bace9, 0xf9e45827, 0x11b6a17a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[GrappleParameters]:
if property_count != 12:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(117))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33]) != _FAST_IDS:
data.seek(before)
return None
return GrappleParameters(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
)
def _decode_grapple_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grapple_attach_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grapple_spring_constant(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grapple_spring_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x987f68c7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_force(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_max_force(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_arc_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_turn_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_camera_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf9e45827(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x11b6a17a(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]]] = {
0x7a797e4f: ('grapple_length', _decode_grapple_length),
0x1d852415: ('grapple_attach_length', _decode_grapple_attach_length),
0xfdf5cb82: ('grapple_spring_constant', _decode_grapple_spring_constant),
0x2ec254e3: ('grapple_spring_length', _decode_grapple_spring_length),
0x987f68c7: ('unknown_0x987f68c7', _decode_unknown_0x987f68c7),
0x1a6b49ab: ('swing_force', _decode_swing_force),
0x1e5124d4: ('swing_max_force', _decode_swing_max_force),
0x450ea130: ('swing_arc_angle', _decode_swing_arc_angle),
0x55f2bc8f: ('swing_turn_angle', _decode_swing_turn_angle),
0xf12bace9: ('swing_camera_pitch', _decode_swing_camera_pitch),
0xf9e45827: ('unknown_0xf9e45827', _decode_unknown_0xf9e45827),
0x11b6a17a: ('unknown_0x11b6a17a', _decode_unknown_0x11b6a17a),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/GrappleParameters.py | 0.695958 | 0.235944 | GrappleParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.echoes as enums
@dataclasses.dataclass()
class DamageInfo(BaseProperty):
di_weapon_type: enums.WeaponType = dataclasses.field(default=enums.WeaponType.Power)
di_damage: float = dataclasses.field(default=0.0)
di_radius: float = dataclasses.field(default=0.0)
di_knock_back_power: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x11\x9f\xbd1') # 0x119fbd31
data.write(b'\x00\x04') # size
self.di_weapon_type.to_stream(data)
data.write(b'\xf2\xd0&\x13') # 0xf2d02613
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_damage))
data.write(b'\xee\x1b\xe9\x14') # 0xee1be914
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_radius))
data.write(b'U_\xf8\n') # 0x555ff80a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_knock_back_power))
@classmethod
def from_json(cls, data: dict):
return cls(
di_weapon_type=enums.WeaponType.from_json(data['di_weapon_type']),
di_damage=data['di_damage'],
di_radius=data['di_radius'],
di_knock_back_power=data['di_knock_back_power'],
)
def to_json(self) -> dict:
return {
'di_weapon_type': self.di_weapon_type.to_json(),
'di_damage': self.di_damage,
'di_radius': self.di_radius,
'di_knock_back_power': self.di_knock_back_power,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x119fbd31, 0xf2d02613, 0xee1be914, 0x555ff80a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DamageInfo]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return DamageInfo(
enums.WeaponType(dec[2]),
dec[5],
dec[8],
dec[11],
)
def _decode_di_weapon_type(data: typing.BinaryIO, property_size: int):
return enums.WeaponType.from_stream(data)
def _decode_di_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_knock_back_power(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x119fbd31: ('di_weapon_type', _decode_di_weapon_type),
0xf2d02613: ('di_damage', _decode_di_damage),
0xee1be914: ('di_radius', _decode_di_radius),
0x555ff80a: ('di_knock_back_power', _decode_di_knock_back_power),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DamageInfo.py | 0.627038 | 0.271128 | DamageInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct24(BaseProperty):
beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x15\x98\x01*') # 0x1598012a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_info.to_stream(data, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
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'_|5.') # 0x5f7c352e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
@classmethod
def from_json(cls, data: dict):
return cls(
beam_info=PlasmaBeamInfo.from_json(data['beam_info']),
damage=DamageInfo.from_json(data['damage']),
sound=data['sound'],
)
def to_json(self) -> dict:
return {
'beam_info': self.beam_info.to_json(),
'damage': self.damage.to_json(),
'sound': self.sound,
}
def _dependencies_for_beam_info(self, asset_manager):
yield from self.beam_info.dependencies_for(asset_manager)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_beam_info, "beam_info", "PlasmaBeamInfo"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_sound, "sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct24.{field_name} ({field_type}): {e}"
)
def _decode_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_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]]] = {
0x1598012a: ('beam_info', _decode_beam_info),
0x337f9524: ('damage', _decode_damage),
0x5f7c352e: ('sound', _decode_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct24.py | 0.597373 | 0.281218 | UnknownStruct24.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class EmperorIngStage2TentacleData(BaseProperty):
detection_time: float = dataclasses.field(default=0.0)
forget_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xba\xa9%J') # 0xbaa9254a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_time))
data.write(b'\x1f\xe2\x8a6') # 0x1fe28a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forget_time))
@classmethod
def from_json(cls, data: dict):
return cls(
detection_time=data['detection_time'],
forget_time=data['forget_time'],
)
def to_json(self) -> dict:
return {
'detection_time': self.detection_time,
'forget_time': self.forget_time,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xbaa9254a, 0x1fe28a36)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[EmperorIngStage2TentacleData]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return EmperorIngStage2TentacleData(
dec[2],
dec[5],
)
def _decode_detection_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_forget_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]]] = {
0xbaa9254a: ('detection_time', _decode_detection_time),
0x1fe28a36: ('forget_time', _decode_forget_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EmperorIngStage2TentacleData.py | 0.658857 | 0.326043 | EmperorIngStage2TentacleData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SwampBossStage2Struct(BaseProperty):
unknown_0x95e7a2c2: float = dataclasses.field(default=3.0)
unknown_0x76ba1c18: float = dataclasses.field(default=7.0)
unknown_0x29e6ead6: float = dataclasses.field(default=1.0)
unknown_0x1753225e: float = dataclasses.field(default=2.0)
dash_chance: float = dataclasses.field(default=0.20000000298023224)
taunt_chance: float = dataclasses.field(default=0.20000000298023224)
first_attack: int = dataclasses.field(default=0)
second_attack: int = dataclasses.field(default=0)
third_attack: int = dataclasses.field(default=0)
fourth_attack: int = dataclasses.field(default=7)
fifth_attack: int = dataclasses.field(default=7)
health: float = dataclasses.field(default=10.0)
unknown_0x2e7e55f2: int = dataclasses.field(default=5)
unknown_0xef3efec0: int = dataclasses.field(default=2)
unknown_0x2b0bfd51: int = dataclasses.field(default=10)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x95\xe7\xa2\xc2') # 0x95e7a2c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x95e7a2c2))
data.write(b'v\xba\x1c\x18') # 0x76ba1c18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76ba1c18))
data.write(b')\xe6\xea\xd6') # 0x29e6ead6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x29e6ead6))
data.write(b'\x17S"^') # 0x1753225e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1753225e))
data.write(b'\xbe\x1a\xfb\xf8') # 0xbe1afbf8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dash_chance))
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\xfa\x9a\xcb') # 0x9cfa9acb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.first_attack))
data.write(b'\x18\x0f\x81\xdd') # 0x180f81dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.second_attack))
data.write(b'Ba|\xfd') # 0x42617cfd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.third_attack))
data.write(b'\xc3\x9f\x86N') # 0xc39f864e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fourth_attack))
data.write(b'\x19\x94\xd5\x06') # 0x1994d506
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fifth_attack))
data.write(b'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
data.write(b'.~U\xf2') # 0x2e7e55f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2e7e55f2))
data.write(b'\xef>\xfe\xc0') # 0xef3efec0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xef3efec0))
data.write(b'+\x0b\xfdQ') # 0x2b0bfd51
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2b0bfd51))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x95e7a2c2=data['unknown_0x95e7a2c2'],
unknown_0x76ba1c18=data['unknown_0x76ba1c18'],
unknown_0x29e6ead6=data['unknown_0x29e6ead6'],
unknown_0x1753225e=data['unknown_0x1753225e'],
dash_chance=data['dash_chance'],
taunt_chance=data['taunt_chance'],
first_attack=data['first_attack'],
second_attack=data['second_attack'],
third_attack=data['third_attack'],
fourth_attack=data['fourth_attack'],
fifth_attack=data['fifth_attack'],
health=data['health'],
unknown_0x2e7e55f2=data['unknown_0x2e7e55f2'],
unknown_0xef3efec0=data['unknown_0xef3efec0'],
unknown_0x2b0bfd51=data['unknown_0x2b0bfd51'],
)
def to_json(self) -> dict:
return {
'unknown_0x95e7a2c2': self.unknown_0x95e7a2c2,
'unknown_0x76ba1c18': self.unknown_0x76ba1c18,
'unknown_0x29e6ead6': self.unknown_0x29e6ead6,
'unknown_0x1753225e': self.unknown_0x1753225e,
'dash_chance': self.dash_chance,
'taunt_chance': self.taunt_chance,
'first_attack': self.first_attack,
'second_attack': self.second_attack,
'third_attack': self.third_attack,
'fourth_attack': self.fourth_attack,
'fifth_attack': self.fifth_attack,
'health': self.health,
'unknown_0x2e7e55f2': self.unknown_0x2e7e55f2,
'unknown_0xef3efec0': self.unknown_0xef3efec0,
'unknown_0x2b0bfd51': self.unknown_0x2b0bfd51,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x95e7a2c2, 0x76ba1c18, 0x29e6ead6, 0x1753225e, 0xbe1afbf8, 0xa77f6212, 0x9cfa9acb, 0x180f81dd, 0x42617cfd, 0xc39f864e, 0x1994d506, 0xf0668919, 0x2e7e55f2, 0xef3efec0, 0x2b0bfd51)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SwampBossStage2Struct]:
if property_count != 15:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHlLHlLHlLHlLHlLHfLHlLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(150))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33], dec[36], dec[39], dec[42]) != _FAST_IDS:
data.seek(before)
return None
return SwampBossStage2Struct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
dec[38],
dec[41],
dec[44],
)
def _decode_unknown_0x95e7a2c2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x76ba1c18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x29e6ead6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1753225e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dash_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_taunt_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_first_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_second_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_third_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fourth_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fifth_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2e7e55f2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xef3efec0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2b0bfd51(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]]] = {
0x95e7a2c2: ('unknown_0x95e7a2c2', _decode_unknown_0x95e7a2c2),
0x76ba1c18: ('unknown_0x76ba1c18', _decode_unknown_0x76ba1c18),
0x29e6ead6: ('unknown_0x29e6ead6', _decode_unknown_0x29e6ead6),
0x1753225e: ('unknown_0x1753225e', _decode_unknown_0x1753225e),
0xbe1afbf8: ('dash_chance', _decode_dash_chance),
0xa77f6212: ('taunt_chance', _decode_taunt_chance),
0x9cfa9acb: ('first_attack', _decode_first_attack),
0x180f81dd: ('second_attack', _decode_second_attack),
0x42617cfd: ('third_attack', _decode_third_attack),
0xc39f864e: ('fourth_attack', _decode_fourth_attack),
0x1994d506: ('fifth_attack', _decode_fifth_attack),
0xf0668919: ('health', _decode_health),
0x2e7e55f2: ('unknown_0x2e7e55f2', _decode_unknown_0x2e7e55f2),
0xef3efec0: ('unknown_0xef3efec0', _decode_unknown_0xef3efec0),
0x2b0bfd51: ('unknown_0x2b0bfd51', _decode_unknown_0x2b0bfd51),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SwampBossStage2Struct.py | 0.585457 | 0.307722 | SwampBossStage2Struct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.IngSpiderballGuardianStruct import IngSpiderballGuardianStruct
@dataclasses.dataclass()
class UnknownStruct31(BaseProperty):
ing_spiderball_guardian_struct_0x152db484: IngSpiderballGuardianStruct = dataclasses.field(default_factory=IngSpiderballGuardianStruct)
ing_spiderball_guardian_struct_0x2d163ff7: IngSpiderballGuardianStruct = dataclasses.field(default_factory=IngSpiderballGuardianStruct)
ing_spiderball_guardian_struct_0x8c2fbb19: IngSpiderballGuardianStruct = dataclasses.field(default_factory=IngSpiderballGuardianStruct)
ing_spiderball_guardian_struct_0x5d612911: IngSpiderballGuardianStruct = dataclasses.field(default_factory=IngSpiderballGuardianStruct)
ing_spiderball_guardian_struct_0xfc58adff: IngSpiderballGuardianStruct = dataclasses.field(default_factory=IngSpiderballGuardianStruct)
ing_spiderball_guardian_struct_0xc463268c: IngSpiderballGuardianStruct = dataclasses.field(default_factory=IngSpiderballGuardianStruct)
damage_radius: float = dataclasses.field(default=2.0)
proximity_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown: float = dataclasses.field(default=20.0)
audio_playback_parms_0xaed23abc: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
sound_spiderball_rolling: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0xcee38f10: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x796fa303: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
sound_enter_stunned: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x44c1f241: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x15-\xb4\x84') # 0x152db484
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_spiderball_guardian_struct_0x152db484.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-\x16?\xf7') # 0x2d163ff7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_spiderball_guardian_struct_0x2d163ff7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c/\xbb\x19') # 0x8c2fbb19
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_spiderball_guardian_struct_0x8c2fbb19.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']a)\x11') # 0x5d612911
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_spiderball_guardian_struct_0x5d612911.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfcX\xad\xff') # 0xfc58adff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_spiderball_guardian_struct_0xfc58adff.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4c&\x8c') # 0xc463268c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_spiderball_guardian_struct_0xc463268c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0fY\x879') # 0xf598739
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_radius))
data.write(b'\xbax\xd2\x81') # 0xba78d281
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.proximity_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 40.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'2\x13;9') # 0x32133b39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xae\xd2:\xbc') # 0xaed23abc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0xaed23abc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b':^/R') # 0x3a5e2f52
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_spiderball_rolling.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xce\xe3\x8f\x10') # 0xcee38f10
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0xcee38f10.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'yo\xa3\x03') # 0x796fa303
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x796fa303.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd5\xf3\xe9\xc4') # 0xd5f3e9c4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_enter_stunned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D\xc1\xf2A') # 0x44c1f241
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x44c1f241.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
ing_spiderball_guardian_struct_0x152db484=IngSpiderballGuardianStruct.from_json(data['ing_spiderball_guardian_struct_0x152db484']),
ing_spiderball_guardian_struct_0x2d163ff7=IngSpiderballGuardianStruct.from_json(data['ing_spiderball_guardian_struct_0x2d163ff7']),
ing_spiderball_guardian_struct_0x8c2fbb19=IngSpiderballGuardianStruct.from_json(data['ing_spiderball_guardian_struct_0x8c2fbb19']),
ing_spiderball_guardian_struct_0x5d612911=IngSpiderballGuardianStruct.from_json(data['ing_spiderball_guardian_struct_0x5d612911']),
ing_spiderball_guardian_struct_0xfc58adff=IngSpiderballGuardianStruct.from_json(data['ing_spiderball_guardian_struct_0xfc58adff']),
ing_spiderball_guardian_struct_0xc463268c=IngSpiderballGuardianStruct.from_json(data['ing_spiderball_guardian_struct_0xc463268c']),
damage_radius=data['damage_radius'],
proximity_damage=DamageInfo.from_json(data['proximity_damage']),
unknown=data['unknown'],
audio_playback_parms_0xaed23abc=AudioPlaybackParms.from_json(data['audio_playback_parms_0xaed23abc']),
sound_spiderball_rolling=AudioPlaybackParms.from_json(data['sound_spiderball_rolling']),
audio_playback_parms_0xcee38f10=AudioPlaybackParms.from_json(data['audio_playback_parms_0xcee38f10']),
audio_playback_parms_0x796fa303=AudioPlaybackParms.from_json(data['audio_playback_parms_0x796fa303']),
sound_enter_stunned=AudioPlaybackParms.from_json(data['sound_enter_stunned']),
audio_playback_parms_0x44c1f241=AudioPlaybackParms.from_json(data['audio_playback_parms_0x44c1f241']),
)
def to_json(self) -> dict:
return {
'ing_spiderball_guardian_struct_0x152db484': self.ing_spiderball_guardian_struct_0x152db484.to_json(),
'ing_spiderball_guardian_struct_0x2d163ff7': self.ing_spiderball_guardian_struct_0x2d163ff7.to_json(),
'ing_spiderball_guardian_struct_0x8c2fbb19': self.ing_spiderball_guardian_struct_0x8c2fbb19.to_json(),
'ing_spiderball_guardian_struct_0x5d612911': self.ing_spiderball_guardian_struct_0x5d612911.to_json(),
'ing_spiderball_guardian_struct_0xfc58adff': self.ing_spiderball_guardian_struct_0xfc58adff.to_json(),
'ing_spiderball_guardian_struct_0xc463268c': self.ing_spiderball_guardian_struct_0xc463268c.to_json(),
'damage_radius': self.damage_radius,
'proximity_damage': self.proximity_damage.to_json(),
'unknown': self.unknown,
'audio_playback_parms_0xaed23abc': self.audio_playback_parms_0xaed23abc.to_json(),
'sound_spiderball_rolling': self.sound_spiderball_rolling.to_json(),
'audio_playback_parms_0xcee38f10': self.audio_playback_parms_0xcee38f10.to_json(),
'audio_playback_parms_0x796fa303': self.audio_playback_parms_0x796fa303.to_json(),
'sound_enter_stunned': self.sound_enter_stunned.to_json(),
'audio_playback_parms_0x44c1f241': self.audio_playback_parms_0x44c1f241.to_json(),
}
def _dependencies_for_ing_spiderball_guardian_struct_0x152db484(self, asset_manager):
yield from self.ing_spiderball_guardian_struct_0x152db484.dependencies_for(asset_manager)
def _dependencies_for_ing_spiderball_guardian_struct_0x2d163ff7(self, asset_manager):
yield from self.ing_spiderball_guardian_struct_0x2d163ff7.dependencies_for(asset_manager)
def _dependencies_for_ing_spiderball_guardian_struct_0x8c2fbb19(self, asset_manager):
yield from self.ing_spiderball_guardian_struct_0x8c2fbb19.dependencies_for(asset_manager)
def _dependencies_for_ing_spiderball_guardian_struct_0x5d612911(self, asset_manager):
yield from self.ing_spiderball_guardian_struct_0x5d612911.dependencies_for(asset_manager)
def _dependencies_for_ing_spiderball_guardian_struct_0xfc58adff(self, asset_manager):
yield from self.ing_spiderball_guardian_struct_0xfc58adff.dependencies_for(asset_manager)
def _dependencies_for_ing_spiderball_guardian_struct_0xc463268c(self, asset_manager):
yield from self.ing_spiderball_guardian_struct_0xc463268c.dependencies_for(asset_manager)
def _dependencies_for_proximity_damage(self, asset_manager):
yield from self.proximity_damage.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0xaed23abc(self, asset_manager):
yield from self.audio_playback_parms_0xaed23abc.dependencies_for(asset_manager)
def _dependencies_for_sound_spiderball_rolling(self, asset_manager):
yield from self.sound_spiderball_rolling.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0xcee38f10(self, asset_manager):
yield from self.audio_playback_parms_0xcee38f10.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x796fa303(self, asset_manager):
yield from self.audio_playback_parms_0x796fa303.dependencies_for(asset_manager)
def _dependencies_for_sound_enter_stunned(self, asset_manager):
yield from self.sound_enter_stunned.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x44c1f241(self, asset_manager):
yield from self.audio_playback_parms_0x44c1f241.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_ing_spiderball_guardian_struct_0x152db484, "ing_spiderball_guardian_struct_0x152db484", "IngSpiderballGuardianStruct"),
(self._dependencies_for_ing_spiderball_guardian_struct_0x2d163ff7, "ing_spiderball_guardian_struct_0x2d163ff7", "IngSpiderballGuardianStruct"),
(self._dependencies_for_ing_spiderball_guardian_struct_0x8c2fbb19, "ing_spiderball_guardian_struct_0x8c2fbb19", "IngSpiderballGuardianStruct"),
(self._dependencies_for_ing_spiderball_guardian_struct_0x5d612911, "ing_spiderball_guardian_struct_0x5d612911", "IngSpiderballGuardianStruct"),
(self._dependencies_for_ing_spiderball_guardian_struct_0xfc58adff, "ing_spiderball_guardian_struct_0xfc58adff", "IngSpiderballGuardianStruct"),
(self._dependencies_for_ing_spiderball_guardian_struct_0xc463268c, "ing_spiderball_guardian_struct_0xc463268c", "IngSpiderballGuardianStruct"),
(self._dependencies_for_proximity_damage, "proximity_damage", "DamageInfo"),
(self._dependencies_for_audio_playback_parms_0xaed23abc, "audio_playback_parms_0xaed23abc", "AudioPlaybackParms"),
(self._dependencies_for_sound_spiderball_rolling, "sound_spiderball_rolling", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0xcee38f10, "audio_playback_parms_0xcee38f10", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x796fa303, "audio_playback_parms_0x796fa303", "AudioPlaybackParms"),
(self._dependencies_for_sound_enter_stunned, "sound_enter_stunned", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x44c1f241, "audio_playback_parms_0x44c1f241", "AudioPlaybackParms"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct31.{field_name} ({field_type}): {e}"
)
def _decode_ing_spiderball_guardian_struct_0x152db484(data: typing.BinaryIO, property_size: int):
return IngSpiderballGuardianStruct.from_stream(data, property_size)
def _decode_ing_spiderball_guardian_struct_0x2d163ff7(data: typing.BinaryIO, property_size: int):
return IngSpiderballGuardianStruct.from_stream(data, property_size)
def _decode_ing_spiderball_guardian_struct_0x8c2fbb19(data: typing.BinaryIO, property_size: int):
return IngSpiderballGuardianStruct.from_stream(data, property_size)
def _decode_ing_spiderball_guardian_struct_0x5d612911(data: typing.BinaryIO, property_size: int):
return IngSpiderballGuardianStruct.from_stream(data, property_size)
def _decode_ing_spiderball_guardian_struct_0xfc58adff(data: typing.BinaryIO, property_size: int):
return IngSpiderballGuardianStruct.from_stream(data, property_size)
def _decode_ing_spiderball_guardian_struct_0xc463268c(data: typing.BinaryIO, property_size: int):
return IngSpiderballGuardianStruct.from_stream(data, property_size)
def _decode_damage_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_proximity_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 40.0, 'di_knock_back_power': 10.0})
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_audio_playback_parms_0xaed23abc(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_sound_spiderball_rolling(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0xcee38f10(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x796fa303(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_sound_enter_stunned(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x44c1f241(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x152db484: ('ing_spiderball_guardian_struct_0x152db484', _decode_ing_spiderball_guardian_struct_0x152db484),
0x2d163ff7: ('ing_spiderball_guardian_struct_0x2d163ff7', _decode_ing_spiderball_guardian_struct_0x2d163ff7),
0x8c2fbb19: ('ing_spiderball_guardian_struct_0x8c2fbb19', _decode_ing_spiderball_guardian_struct_0x8c2fbb19),
0x5d612911: ('ing_spiderball_guardian_struct_0x5d612911', _decode_ing_spiderball_guardian_struct_0x5d612911),
0xfc58adff: ('ing_spiderball_guardian_struct_0xfc58adff', _decode_ing_spiderball_guardian_struct_0xfc58adff),
0xc463268c: ('ing_spiderball_guardian_struct_0xc463268c', _decode_ing_spiderball_guardian_struct_0xc463268c),
0xf598739: ('damage_radius', _decode_damage_radius),
0xba78d281: ('proximity_damage', _decode_proximity_damage),
0x32133b39: ('unknown', _decode_unknown),
0xaed23abc: ('audio_playback_parms_0xaed23abc', _decode_audio_playback_parms_0xaed23abc),
0x3a5e2f52: ('sound_spiderball_rolling', _decode_sound_spiderball_rolling),
0xcee38f10: ('audio_playback_parms_0xcee38f10', _decode_audio_playback_parms_0xcee38f10),
0x796fa303: ('audio_playback_parms_0x796fa303', _decode_audio_playback_parms_0x796fa303),
0xd5f3e9c4: ('sound_enter_stunned', _decode_sound_enter_stunned),
0x44c1f241: ('audio_playback_parms_0x44c1f241', _decode_audio_playback_parms_0x44c1f241),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct31.py | 0.467575 | 0.202502 | UnknownStruct31.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.TGunResources import TGunResources
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class TBallTransitionResources(BaseProperty):
unknown_0xd48e4124: str = dataclasses.field(default='')
unknown_0x01e12c84: TGunResources = dataclasses.field(default_factory=TGunResources)
unknown_0xf24b055d: TGunResources = dataclasses.field(default_factory=TGunResources)
unknown_0xa342c3a6: Spline = dataclasses.field(default_factory=Spline)
unknown_0x15b6840d: Spline = dataclasses.field(default_factory=Spline)
unknown_0x23fb0e93: Spline = dataclasses.field(default_factory=Spline)
unknown_0x564262f0: Spline = dataclasses.field(default_factory=Spline)
movement_control: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\xd4\x8eA$') # 0xd48e4124
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xd48e4124.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01\xe1,\x84') # 0x1e12c84
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x01e12c84.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf2K\x05]') # 0xf24b055d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xf24b055d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa3B\xc3\xa6') # 0xa342c3a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xa342c3a6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\xb6\x84\r') # 0x15b6840d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x15b6840d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#\xfb\x0e\x93') # 0x23fb0e93
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x23fb0e93.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'VBb\xf0') # 0x564262f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x564262f0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\x83\xa2b') # 0x9183a262
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.movement_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xd48e4124=data['unknown_0xd48e4124'],
unknown_0x01e12c84=TGunResources.from_json(data['unknown_0x01e12c84']),
unknown_0xf24b055d=TGunResources.from_json(data['unknown_0xf24b055d']),
unknown_0xa342c3a6=Spline.from_json(data['unknown_0xa342c3a6']),
unknown_0x15b6840d=Spline.from_json(data['unknown_0x15b6840d']),
unknown_0x23fb0e93=Spline.from_json(data['unknown_0x23fb0e93']),
unknown_0x564262f0=Spline.from_json(data['unknown_0x564262f0']),
movement_control=Spline.from_json(data['movement_control']),
)
def to_json(self) -> dict:
return {
'unknown_0xd48e4124': self.unknown_0xd48e4124,
'unknown_0x01e12c84': self.unknown_0x01e12c84.to_json(),
'unknown_0xf24b055d': self.unknown_0xf24b055d.to_json(),
'unknown_0xa342c3a6': self.unknown_0xa342c3a6.to_json(),
'unknown_0x15b6840d': self.unknown_0x15b6840d.to_json(),
'unknown_0x23fb0e93': self.unknown_0x23fb0e93.to_json(),
'unknown_0x564262f0': self.unknown_0x564262f0.to_json(),
'movement_control': self.movement_control.to_json(),
}
def _dependencies_for_unknown_0x01e12c84(self, asset_manager):
yield from self.unknown_0x01e12c84.dependencies_for(asset_manager)
def _dependencies_for_unknown_0xf24b055d(self, asset_manager):
yield from self.unknown_0xf24b055d.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unknown_0x01e12c84, "unknown_0x01e12c84", "TGunResources"),
(self._dependencies_for_unknown_0xf24b055d, "unknown_0xf24b055d", "TGunResources"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TBallTransitionResources.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xd48e4124(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x01e12c84(data: typing.BinaryIO, property_size: int):
return TGunResources.from_stream(data, property_size)
def _decode_unknown_0xf24b055d(data: typing.BinaryIO, property_size: int):
return TGunResources.from_stream(data, property_size)
def _decode_unknown_0xa342c3a6(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x15b6840d(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x23fb0e93(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x564262f0(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_movement_control(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd48e4124: ('unknown_0xd48e4124', _decode_unknown_0xd48e4124),
0x1e12c84: ('unknown_0x01e12c84', _decode_unknown_0x01e12c84),
0xf24b055d: ('unknown_0xf24b055d', _decode_unknown_0xf24b055d),
0xa342c3a6: ('unknown_0xa342c3a6', _decode_unknown_0xa342c3a6),
0x15b6840d: ('unknown_0x15b6840d', _decode_unknown_0x15b6840d),
0x23fb0e93: ('unknown_0x23fb0e93', _decode_unknown_0x23fb0e93),
0x564262f0: ('unknown_0x564262f0', _decode_unknown_0x564262f0),
0x9183a262: ('movement_control', _decode_movement_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/TBallTransitionResources.py | 0.500977 | 0.281541 | TBallTransitionResources.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
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.ShockWaveInfo import ShockWaveInfo
from retro_data_structures.properties.echoes.archetypes.SwampBossStage1Struct import SwampBossStage1Struct
from retro_data_structures.properties.echoes.archetypes.UnknownStruct36 import UnknownStruct36
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct37(BaseProperty):
dark_water_ring_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x27a06f6a: float = dataclasses.field(default=3.0)
unknown_0x233a5e40: float = dataclasses.field(default=6.0)
pre_jump_telegraph_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
splash_shock_wave: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
tongue_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
tongue_particle_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
tongue_tip_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
damage_info: DamageInfo = dataclasses.field(default_factory=DamageInfo)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x78755da3: float = dataclasses.field(default=50.0)
unknown_0x74e1a041: float = dataclasses.field(default=5.0)
unknown_0x1f4e7c2c: float = dataclasses.field(default=15.0)
unknown_0xee6b6f47: float = dataclasses.field(default=180.0)
unknown_0x3ce96c9d: float = dataclasses.field(default=100.0)
weak_spot_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
weak_spot_damage_multiplier: float = dataclasses.field(default=2.0)
spit_projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
spit_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
spit_visor_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_spit_visor: int = dataclasses.field(default=0, metadata={'sound': True})
spit_projectile_radius: float = dataclasses.field(default=2.0)
unknown_struct36: UnknownStruct36 = dataclasses.field(default_factory=UnknownStruct36)
swamp_boss_stage1_struct_0x4500f774: SwampBossStage1Struct = dataclasses.field(default_factory=SwampBossStage1Struct)
swamp_boss_stage1_struct_0x3e1e7597: SwampBossStage1Struct = dataclasses.field(default_factory=SwampBossStage1Struct)
swamp_boss_stage1_struct_0xa1c4f609: SwampBossStage1Struct = dataclasses.field(default_factory=SwampBossStage1Struct)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1a') # 26 properties
data.write(b'l\xed\xf3d') # 0x6cedf364
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.dark_water_ring_effect))
data.write(b"'\xa0oj") # 0x27a06f6a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x27a06f6a))
data.write(b'#:^@') # 0x233a5e40
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x233a5e40))
data.write(b'\xef|e\xac') # 0xef7c65ac
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.pre_jump_telegraph_effect))
data.write(b'l\x0fz\xa3') # 0x6c0f7aa3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.splash_shock_wave.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v,\xd5\xb7') # 0x762cd5b7
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.tongue_particle_effect))
data.write(b'\xd8\xabv\xf0') # 0xd8ab76f0
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.tongue_particle_model))
data.write(b'\x14]\xeb\xea') # 0x145debea
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.tongue_tip_model))
data.write(b'\xd0\xb0\xf2\x1f') # 0xd0b0f21f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\n\x07\x85\x86') # 0xa078586
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'xu]\xa3') # 0x78755da3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x78755da3))
data.write(b't\xe1\xa0A') # 0x74e1a041
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x74e1a041))
data.write(b'\x1fN|,') # 0x1f4e7c2c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1f4e7c2c))
data.write(b'\xeekoG') # 0xee6b6f47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xee6b6f47))
data.write(b'<\xe9l\x9d') # 0x3ce96c9d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3ce96c9d))
data.write(b'\x95\x03\x18\xf0') # 0x950318f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weak_spot_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbaiIA') # 0xba694941
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.weak_spot_damage_multiplier))
data.write(b'\xcf\xe3~\xbf') # 0xcfe37ebf
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.spit_projectile))
data.write(b'\xda<\x9b2') # 0xda3c9b32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spit_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'\x00\x8b\xec\xab') # 0x8becab
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.spit_visor_effect))
data.write(b'\xf3\xaf\x84\x17') # 0xf3af8417
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_spit_visor))
data.write(b'\xda\xdc[\xc9') # 0xdadc5bc9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_projectile_radius))
data.write(b'\xd4\x02\t_') # 0xd402095f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct36.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\x00\xf7t') # 0x4500f774
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swamp_boss_stage1_struct_0x4500f774.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'>\x1eu\x97') # 0x3e1e7597
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swamp_boss_stage1_struct_0x3e1e7597.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\xc4\xf6\t') # 0xa1c4f609
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swamp_boss_stage1_struct_0xa1c4f609.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
dark_water_ring_effect=data['dark_water_ring_effect'],
unknown_0x27a06f6a=data['unknown_0x27a06f6a'],
unknown_0x233a5e40=data['unknown_0x233a5e40'],
pre_jump_telegraph_effect=data['pre_jump_telegraph_effect'],
splash_shock_wave=ShockWaveInfo.from_json(data['splash_shock_wave']),
tongue_particle_effect=data['tongue_particle_effect'],
tongue_particle_model=data['tongue_particle_model'],
tongue_tip_model=data['tongue_tip_model'],
damage_info=DamageInfo.from_json(data['damage_info']),
part=data['part'],
unknown_0x78755da3=data['unknown_0x78755da3'],
unknown_0x74e1a041=data['unknown_0x74e1a041'],
unknown_0x1f4e7c2c=data['unknown_0x1f4e7c2c'],
unknown_0xee6b6f47=data['unknown_0xee6b6f47'],
unknown_0x3ce96c9d=data['unknown_0x3ce96c9d'],
weak_spot_vulnerability=DamageVulnerability.from_json(data['weak_spot_vulnerability']),
weak_spot_damage_multiplier=data['weak_spot_damage_multiplier'],
spit_projectile=data['spit_projectile'],
spit_damage=DamageInfo.from_json(data['spit_damage']),
spit_visor_effect=data['spit_visor_effect'],
sound_spit_visor=data['sound_spit_visor'],
spit_projectile_radius=data['spit_projectile_radius'],
unknown_struct36=UnknownStruct36.from_json(data['unknown_struct36']),
swamp_boss_stage1_struct_0x4500f774=SwampBossStage1Struct.from_json(data['swamp_boss_stage1_struct_0x4500f774']),
swamp_boss_stage1_struct_0x3e1e7597=SwampBossStage1Struct.from_json(data['swamp_boss_stage1_struct_0x3e1e7597']),
swamp_boss_stage1_struct_0xa1c4f609=SwampBossStage1Struct.from_json(data['swamp_boss_stage1_struct_0xa1c4f609']),
)
def to_json(self) -> dict:
return {
'dark_water_ring_effect': self.dark_water_ring_effect,
'unknown_0x27a06f6a': self.unknown_0x27a06f6a,
'unknown_0x233a5e40': self.unknown_0x233a5e40,
'pre_jump_telegraph_effect': self.pre_jump_telegraph_effect,
'splash_shock_wave': self.splash_shock_wave.to_json(),
'tongue_particle_effect': self.tongue_particle_effect,
'tongue_particle_model': self.tongue_particle_model,
'tongue_tip_model': self.tongue_tip_model,
'damage_info': self.damage_info.to_json(),
'part': self.part,
'unknown_0x78755da3': self.unknown_0x78755da3,
'unknown_0x74e1a041': self.unknown_0x74e1a041,
'unknown_0x1f4e7c2c': self.unknown_0x1f4e7c2c,
'unknown_0xee6b6f47': self.unknown_0xee6b6f47,
'unknown_0x3ce96c9d': self.unknown_0x3ce96c9d,
'weak_spot_vulnerability': self.weak_spot_vulnerability.to_json(),
'weak_spot_damage_multiplier': self.weak_spot_damage_multiplier,
'spit_projectile': self.spit_projectile,
'spit_damage': self.spit_damage.to_json(),
'spit_visor_effect': self.spit_visor_effect,
'sound_spit_visor': self.sound_spit_visor,
'spit_projectile_radius': self.spit_projectile_radius,
'unknown_struct36': self.unknown_struct36.to_json(),
'swamp_boss_stage1_struct_0x4500f774': self.swamp_boss_stage1_struct_0x4500f774.to_json(),
'swamp_boss_stage1_struct_0x3e1e7597': self.swamp_boss_stage1_struct_0x3e1e7597.to_json(),
'swamp_boss_stage1_struct_0xa1c4f609': self.swamp_boss_stage1_struct_0xa1c4f609.to_json(),
}
def _dependencies_for_dark_water_ring_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dark_water_ring_effect)
def _dependencies_for_pre_jump_telegraph_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.pre_jump_telegraph_effect)
def _dependencies_for_splash_shock_wave(self, asset_manager):
yield from self.splash_shock_wave.dependencies_for(asset_manager)
def _dependencies_for_tongue_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.tongue_particle_effect)
def _dependencies_for_tongue_particle_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.tongue_particle_model)
def _dependencies_for_tongue_tip_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.tongue_tip_model)
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_weak_spot_vulnerability(self, asset_manager):
yield from self.weak_spot_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_spit_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.spit_projectile)
def _dependencies_for_spit_damage(self, asset_manager):
yield from self.spit_damage.dependencies_for(asset_manager)
def _dependencies_for_spit_visor_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.spit_visor_effect)
def _dependencies_for_sound_spit_visor(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_spit_visor)
def _dependencies_for_unknown_struct36(self, asset_manager):
yield from self.unknown_struct36.dependencies_for(asset_manager)
def _dependencies_for_swamp_boss_stage1_struct_0x4500f774(self, asset_manager):
yield from self.swamp_boss_stage1_struct_0x4500f774.dependencies_for(asset_manager)
def _dependencies_for_swamp_boss_stage1_struct_0x3e1e7597(self, asset_manager):
yield from self.swamp_boss_stage1_struct_0x3e1e7597.dependencies_for(asset_manager)
def _dependencies_for_swamp_boss_stage1_struct_0xa1c4f609(self, asset_manager):
yield from self.swamp_boss_stage1_struct_0xa1c4f609.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_dark_water_ring_effect, "dark_water_ring_effect", "AssetId"),
(self._dependencies_for_pre_jump_telegraph_effect, "pre_jump_telegraph_effect", "AssetId"),
(self._dependencies_for_splash_shock_wave, "splash_shock_wave", "ShockWaveInfo"),
(self._dependencies_for_tongue_particle_effect, "tongue_particle_effect", "AssetId"),
(self._dependencies_for_tongue_particle_model, "tongue_particle_model", "AssetId"),
(self._dependencies_for_tongue_tip_model, "tongue_tip_model", "AssetId"),
(self._dependencies_for_damage_info, "damage_info", "DamageInfo"),
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_weak_spot_vulnerability, "weak_spot_vulnerability", "DamageVulnerability"),
(self._dependencies_for_spit_projectile, "spit_projectile", "AssetId"),
(self._dependencies_for_spit_damage, "spit_damage", "DamageInfo"),
(self._dependencies_for_spit_visor_effect, "spit_visor_effect", "AssetId"),
(self._dependencies_for_sound_spit_visor, "sound_spit_visor", "int"),
(self._dependencies_for_unknown_struct36, "unknown_struct36", "UnknownStruct36"),
(self._dependencies_for_swamp_boss_stage1_struct_0x4500f774, "swamp_boss_stage1_struct_0x4500f774", "SwampBossStage1Struct"),
(self._dependencies_for_swamp_boss_stage1_struct_0x3e1e7597, "swamp_boss_stage1_struct_0x3e1e7597", "SwampBossStage1Struct"),
(self._dependencies_for_swamp_boss_stage1_struct_0xa1c4f609, "swamp_boss_stage1_struct_0xa1c4f609", "SwampBossStage1Struct"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct37.{field_name} ({field_type}): {e}"
)
def _decode_dark_water_ring_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x27a06f6a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x233a5e40(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pre_jump_telegraph_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_splash_shock_wave(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.from_stream(data, property_size)
def _decode_tongue_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_tongue_particle_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_tongue_tip_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_damage_info(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_unknown_0x78755da3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x74e1a041(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1f4e7c2c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xee6b6f47(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3ce96c9d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_weak_spot_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_weak_spot_damage_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_spit_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_spit_visor_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_spit_visor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spit_projectile_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct36(data: typing.BinaryIO, property_size: int):
return UnknownStruct36.from_stream(data, property_size)
def _decode_swamp_boss_stage1_struct_0x4500f774(data: typing.BinaryIO, property_size: int):
return SwampBossStage1Struct.from_stream(data, property_size)
def _decode_swamp_boss_stage1_struct_0x3e1e7597(data: typing.BinaryIO, property_size: int):
return SwampBossStage1Struct.from_stream(data, property_size)
def _decode_swamp_boss_stage1_struct_0xa1c4f609(data: typing.BinaryIO, property_size: int):
return SwampBossStage1Struct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6cedf364: ('dark_water_ring_effect', _decode_dark_water_ring_effect),
0x27a06f6a: ('unknown_0x27a06f6a', _decode_unknown_0x27a06f6a),
0x233a5e40: ('unknown_0x233a5e40', _decode_unknown_0x233a5e40),
0xef7c65ac: ('pre_jump_telegraph_effect', _decode_pre_jump_telegraph_effect),
0x6c0f7aa3: ('splash_shock_wave', _decode_splash_shock_wave),
0x762cd5b7: ('tongue_particle_effect', _decode_tongue_particle_effect),
0xd8ab76f0: ('tongue_particle_model', _decode_tongue_particle_model),
0x145debea: ('tongue_tip_model', _decode_tongue_tip_model),
0xd0b0f21f: ('damage_info', _decode_damage_info),
0xa078586: ('part', _decode_part),
0x78755da3: ('unknown_0x78755da3', _decode_unknown_0x78755da3),
0x74e1a041: ('unknown_0x74e1a041', _decode_unknown_0x74e1a041),
0x1f4e7c2c: ('unknown_0x1f4e7c2c', _decode_unknown_0x1f4e7c2c),
0xee6b6f47: ('unknown_0xee6b6f47', _decode_unknown_0xee6b6f47),
0x3ce96c9d: ('unknown_0x3ce96c9d', _decode_unknown_0x3ce96c9d),
0x950318f0: ('weak_spot_vulnerability', _decode_weak_spot_vulnerability),
0xba694941: ('weak_spot_damage_multiplier', _decode_weak_spot_damage_multiplier),
0xcfe37ebf: ('spit_projectile', _decode_spit_projectile),
0xda3c9b32: ('spit_damage', _decode_spit_damage),
0x8becab: ('spit_visor_effect', _decode_spit_visor_effect),
0xf3af8417: ('sound_spit_visor', _decode_sound_spit_visor),
0xdadc5bc9: ('spit_projectile_radius', _decode_spit_projectile_radius),
0xd402095f: ('unknown_struct36', _decode_unknown_struct36),
0x4500f774: ('swamp_boss_stage1_struct_0x4500f774', _decode_swamp_boss_stage1_struct_0x4500f774),
0x3e1e7597: ('swamp_boss_stage1_struct_0x3e1e7597', _decode_swamp_boss_stage1_struct_0x3e1e7597),
0xa1c4f609: ('swamp_boss_stage1_struct_0xa1c4f609', _decode_swamp_boss_stage1_struct_0xa1c4f609),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct37.py | 0.533641 | 0.174762 | UnknownStruct37.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
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 UnknownStruct22(BaseProperty):
portal_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
attack_tip: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
stab_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0xecfab026: int = dataclasses.field(default=0)
unknown_0x94880277: int = dataclasses.field(default=0)
sound_0x1c3e84b6: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0xa93f0198: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'J|N\xc2') # 0x4a7c4ec2
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.portal_effect))
data.write(b'\xf1\x0bn\xf6') # 0xf10b6ef6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_tip.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94`\x16\xa9') # 0x946016a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.stab_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xec\xfa\xb0&') # 0xecfab026
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xecfab026))
data.write(b'\x94\x88\x02w') # 0x94880277
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x94880277))
data.write(b'\x1c>\x84\xb6') # 0x1c3e84b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x1c3e84b6))
data.write(b'\xa9?\x01\x98') # 0xa93f0198
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xa93f0198))
@classmethod
def from_json(cls, data: dict):
return cls(
portal_effect=data['portal_effect'],
attack_tip=AnimationParameters.from_json(data['attack_tip']),
stab_damage=DamageInfo.from_json(data['stab_damage']),
unknown_0xecfab026=data['unknown_0xecfab026'],
unknown_0x94880277=data['unknown_0x94880277'],
sound_0x1c3e84b6=data['sound_0x1c3e84b6'],
sound_0xa93f0198=data['sound_0xa93f0198'],
)
def to_json(self) -> dict:
return {
'portal_effect': self.portal_effect,
'attack_tip': self.attack_tip.to_json(),
'stab_damage': self.stab_damage.to_json(),
'unknown_0xecfab026': self.unknown_0xecfab026,
'unknown_0x94880277': self.unknown_0x94880277,
'sound_0x1c3e84b6': self.sound_0x1c3e84b6,
'sound_0xa93f0198': self.sound_0xa93f0198,
}
def _dependencies_for_portal_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.portal_effect)
def _dependencies_for_attack_tip(self, asset_manager):
yield from self.attack_tip.dependencies_for(asset_manager)
def _dependencies_for_stab_damage(self, asset_manager):
yield from self.stab_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_0x1c3e84b6(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x1c3e84b6)
def _dependencies_for_sound_0xa93f0198(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xa93f0198)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_portal_effect, "portal_effect", "AssetId"),
(self._dependencies_for_attack_tip, "attack_tip", "AnimationParameters"),
(self._dependencies_for_stab_damage, "stab_damage", "DamageInfo"),
(self._dependencies_for_sound_0x1c3e84b6, "sound_0x1c3e84b6", "int"),
(self._dependencies_for_sound_0xa93f0198, "sound_0xa93f0198", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct22.{field_name} ({field_type}): {e}"
)
def _decode_portal_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_attack_tip(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_stab_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown_0xecfab026(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x94880277(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x1c3e84b6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0xa93f0198(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]]] = {
0x4a7c4ec2: ('portal_effect', _decode_portal_effect),
0xf10b6ef6: ('attack_tip', _decode_attack_tip),
0x946016a9: ('stab_damage', _decode_stab_damage),
0xecfab026: ('unknown_0xecfab026', _decode_unknown_0xecfab026),
0x94880277: ('unknown_0x94880277', _decode_unknown_0x94880277),
0x1c3e84b6: ('sound_0x1c3e84b6', _decode_sound_0x1c3e84b6),
0xa93f0198: ('sound_0xa93f0198', _decode_sound_0xa93f0198),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct22.py | 0.570212 | 0.203173 | UnknownStruct22.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class DynamicLightParent(BaseProperty):
unknown_0xddd74295: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x88f018b3: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
locator_name: str = dataclasses.field(default='')
use_parent_rotation: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xdd\xd7B\x95') # 0xddd74295
data.write(b'\x00\x0c') # size
self.unknown_0xddd74295.to_stream(data)
data.write(b'\x88\xf0\x18\xb3') # 0x88f018b3
data.write(b'\x00\x0c') # size
self.unknown_0x88f018b3.to_stream(data)
data.write(b'\xfb\xc6\xc1\x10') # 0xfbc6c110
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.locator_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7.\xef\xbd') # 0xf72eefbd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_parent_rotation))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xddd74295=Vector.from_json(data['unknown_0xddd74295']),
unknown_0x88f018b3=Vector.from_json(data['unknown_0x88f018b3']),
locator_name=data['locator_name'],
use_parent_rotation=data['use_parent_rotation'],
)
def to_json(self) -> dict:
return {
'unknown_0xddd74295': self.unknown_0xddd74295.to_json(),
'unknown_0x88f018b3': self.unknown_0x88f018b3.to_json(),
'locator_name': self.locator_name,
'use_parent_rotation': self.use_parent_rotation,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_unknown_0xddd74295(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x88f018b3(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_locator_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_use_parent_rotation(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]]] = {
0xddd74295: ('unknown_0xddd74295', _decode_unknown_0xddd74295),
0x88f018b3: ('unknown_0x88f018b3', _decode_unknown_0x88f018b3),
0xfbc6c110: ('locator_name', _decode_locator_name),
0xf72eefbd: ('use_parent_rotation', _decode_use_parent_rotation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DynamicLightParent.py | 0.682785 | 0.345768 | DynamicLightParent.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
@dataclasses.dataclass()
class EmperorIngStage1TentacleData(BaseProperty):
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
normal_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
warp_attack_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
melee_attack_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
projectile_attack_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
stay_retracted_time: float = dataclasses.field(default=0.0)
tentacle_damaged_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\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')\xdfa\xe1') # 0x29df61e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8dsx\xa4') # 0x8d7378a4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.warp_attack_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'ly\x05O') # 0x6c79054f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.melee_attack_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<-$\x92') # 0x3c2d2492
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_attack_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'I\x1c&W') # 0x491c2657
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stay_retracted_time))
data.write(b'\xe1\x9fF\x08') # 0xe19f4608
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.tentacle_damaged_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
health=HealthInfo.from_json(data['health']),
normal_vulnerability=DamageVulnerability.from_json(data['normal_vulnerability']),
warp_attack_vulnerability=DamageVulnerability.from_json(data['warp_attack_vulnerability']),
melee_attack_vulnerability=DamageVulnerability.from_json(data['melee_attack_vulnerability']),
projectile_attack_vulnerability=DamageVulnerability.from_json(data['projectile_attack_vulnerability']),
stay_retracted_time=data['stay_retracted_time'],
tentacle_damaged_sound=data['tentacle_damaged_sound'],
)
def to_json(self) -> dict:
return {
'health': self.health.to_json(),
'normal_vulnerability': self.normal_vulnerability.to_json(),
'warp_attack_vulnerability': self.warp_attack_vulnerability.to_json(),
'melee_attack_vulnerability': self.melee_attack_vulnerability.to_json(),
'projectile_attack_vulnerability': self.projectile_attack_vulnerability.to_json(),
'stay_retracted_time': self.stay_retracted_time,
'tentacle_damaged_sound': self.tentacle_damaged_sound,
}
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_normal_vulnerability(self, asset_manager):
yield from self.normal_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_warp_attack_vulnerability(self, asset_manager):
yield from self.warp_attack_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_melee_attack_vulnerability(self, asset_manager):
yield from self.melee_attack_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_projectile_attack_vulnerability(self, asset_manager):
yield from self.projectile_attack_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_tentacle_damaged_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.tentacle_damaged_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_normal_vulnerability, "normal_vulnerability", "DamageVulnerability"),
(self._dependencies_for_warp_attack_vulnerability, "warp_attack_vulnerability", "DamageVulnerability"),
(self._dependencies_for_melee_attack_vulnerability, "melee_attack_vulnerability", "DamageVulnerability"),
(self._dependencies_for_projectile_attack_vulnerability, "projectile_attack_vulnerability", "DamageVulnerability"),
(self._dependencies_for_tentacle_damaged_sound, "tentacle_damaged_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage1TentacleData.{field_name} ({field_type}): {e}"
)
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_normal_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_warp_attack_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_melee_attack_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_projectile_attack_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_stay_retracted_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tentacle_damaged_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]]] = {
0xcf90d15e: ('health', _decode_health),
0x29df61e1: ('normal_vulnerability', _decode_normal_vulnerability),
0x8d7378a4: ('warp_attack_vulnerability', _decode_warp_attack_vulnerability),
0x6c79054f: ('melee_attack_vulnerability', _decode_melee_attack_vulnerability),
0x3c2d2492: ('projectile_attack_vulnerability', _decode_projectile_attack_vulnerability),
0x491c2657: ('stay_retracted_time', _decode_stay_retracted_time),
0xe19f4608: ('tentacle_damaged_sound', _decode_tentacle_damaged_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EmperorIngStage1TentacleData.py | 0.55929 | 0.307157 | EmperorIngStage1TentacleData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SandwormStruct(BaseProperty):
unknown_0x98106ee2: float = dataclasses.field(default=1.0)
unknown_0x95081226: float = dataclasses.field(default=3.0)
unknown_0xc2064265: float = dataclasses.field(default=5.0)
move_speed_multiplier: float = dataclasses.field(default=1.0)
unknown_0x59f14d7c: int = dataclasses.field(default=3)
unknown_0x9606b4b0: int = dataclasses.field(default=5)
unknown_0xfc2697dd: int = dataclasses.field(default=5)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x98\x10n\xe2') # 0x98106ee2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x98106ee2))
data.write(b'\x95\x08\x12&') # 0x95081226
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x95081226))
data.write(b'\xc2\x06Be') # 0xc2064265
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc2064265))
data.write(b'\xfe\x913\xcd') # 0xfe9133cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.move_speed_multiplier))
data.write(b'Y\xf1M|') # 0x59f14d7c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x59f14d7c))
data.write(b'\x96\x06\xb4\xb0') # 0x9606b4b0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x9606b4b0))
data.write(b'\xfc&\x97\xdd') # 0xfc2697dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xfc2697dd))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x98106ee2=data['unknown_0x98106ee2'],
unknown_0x95081226=data['unknown_0x95081226'],
unknown_0xc2064265=data['unknown_0xc2064265'],
move_speed_multiplier=data['move_speed_multiplier'],
unknown_0x59f14d7c=data['unknown_0x59f14d7c'],
unknown_0x9606b4b0=data['unknown_0x9606b4b0'],
unknown_0xfc2697dd=data['unknown_0xfc2697dd'],
)
def to_json(self) -> dict:
return {
'unknown_0x98106ee2': self.unknown_0x98106ee2,
'unknown_0x95081226': self.unknown_0x95081226,
'unknown_0xc2064265': self.unknown_0xc2064265,
'move_speed_multiplier': self.move_speed_multiplier,
'unknown_0x59f14d7c': self.unknown_0x59f14d7c,
'unknown_0x9606b4b0': self.unknown_0x9606b4b0,
'unknown_0xfc2697dd': self.unknown_0xfc2697dd,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x98106ee2, 0x95081226, 0xc2064265, 0xfe9133cd, 0x59f14d7c, 0x9606b4b0, 0xfc2697dd)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SandwormStruct]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHlLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return SandwormStruct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_unknown_0x98106ee2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x95081226(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc2064265(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_move_speed_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x59f14d7c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x9606b4b0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xfc2697dd(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]]] = {
0x98106ee2: ('unknown_0x98106ee2', _decode_unknown_0x98106ee2),
0x95081226: ('unknown_0x95081226', _decode_unknown_0x95081226),
0xc2064265: ('unknown_0xc2064265', _decode_unknown_0xc2064265),
0xfe9133cd: ('move_speed_multiplier', _decode_move_speed_multiplier),
0x59f14d7c: ('unknown_0x59f14d7c', _decode_unknown_0x59f14d7c),
0x9606b4b0: ('unknown_0x9606b4b0', _decode_unknown_0x9606b4b0),
0xfc2697dd: ('unknown_0xfc2697dd', _decode_unknown_0xfc2697dd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SandwormStruct.py | 0.599837 | 0.283536 | SandwormStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct40(BaseProperty):
unknown_0xbed8a4ba: float = dataclasses.field(default=1.5)
unknown_0xc2b98161: float = dataclasses.field(default=2.5)
unknown_0x5fb66017: float = dataclasses.field(default=3.0)
unknown_0xbab42316: float = dataclasses.field(default=150.0)
part_0x8f06342a: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_0xd8b11129: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0xe99e5316: int = dataclasses.field(default=0, metadata={'sound': True})
damage_info: DamageInfo = dataclasses.field(default_factory=DamageInfo)
part_0x686489fd: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\xbe\xd8\xa4\xba') # 0xbed8a4ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbed8a4ba))
data.write(b'\xc2\xb9\x81a') # 0xc2b98161
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc2b98161))
data.write(b'_\xb6`\x17') # 0x5fb66017
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5fb66017))
data.write(b'\xba\xb4#\x16') # 0xbab42316
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbab42316))
data.write(b'\x8f\x064*') # 0x8f06342a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x8f06342a))
data.write(b'\xd8\xb1\x11)') # 0xd8b11129
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xd8b11129))
data.write(b'\xe9\x9eS\x16') # 0xe99e5316
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xe99e5316))
data.write(b'\x14@\xd1R') # 0x1440d152
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_radius': 13.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'hd\x89\xfd') # 0x686489fd
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x686489fd))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xbed8a4ba=data['unknown_0xbed8a4ba'],
unknown_0xc2b98161=data['unknown_0xc2b98161'],
unknown_0x5fb66017=data['unknown_0x5fb66017'],
unknown_0xbab42316=data['unknown_0xbab42316'],
part_0x8f06342a=data['part_0x8f06342a'],
sound_0xd8b11129=data['sound_0xd8b11129'],
sound_0xe99e5316=data['sound_0xe99e5316'],
damage_info=DamageInfo.from_json(data['damage_info']),
part_0x686489fd=data['part_0x686489fd'],
)
def to_json(self) -> dict:
return {
'unknown_0xbed8a4ba': self.unknown_0xbed8a4ba,
'unknown_0xc2b98161': self.unknown_0xc2b98161,
'unknown_0x5fb66017': self.unknown_0x5fb66017,
'unknown_0xbab42316': self.unknown_0xbab42316,
'part_0x8f06342a': self.part_0x8f06342a,
'sound_0xd8b11129': self.sound_0xd8b11129,
'sound_0xe99e5316': self.sound_0xe99e5316,
'damage_info': self.damage_info.to_json(),
'part_0x686489fd': self.part_0x686489fd,
}
def _dependencies_for_part_0x8f06342a(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x8f06342a)
def _dependencies_for_sound_0xd8b11129(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xd8b11129)
def _dependencies_for_sound_0xe99e5316(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xe99e5316)
def _dependencies_for_damage_info(self, asset_manager):
yield from self.damage_info.dependencies_for(asset_manager)
def _dependencies_for_part_0x686489fd(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x686489fd)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_part_0x8f06342a, "part_0x8f06342a", "AssetId"),
(self._dependencies_for_sound_0xd8b11129, "sound_0xd8b11129", "int"),
(self._dependencies_for_sound_0xe99e5316, "sound_0xe99e5316", "int"),
(self._dependencies_for_damage_info, "damage_info", "DamageInfo"),
(self._dependencies_for_part_0x686489fd, "part_0x686489fd", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct40.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xbed8a4ba(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc2b98161(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5fb66017(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbab42316(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part_0x8f06342a(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_0xd8b11129(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0xe99e5316(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', 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': 20.0, 'di_radius': 13.0, 'di_knock_back_power': 10.0})
def _decode_part_0x686489fd(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]]] = {
0xbed8a4ba: ('unknown_0xbed8a4ba', _decode_unknown_0xbed8a4ba),
0xc2b98161: ('unknown_0xc2b98161', _decode_unknown_0xc2b98161),
0x5fb66017: ('unknown_0x5fb66017', _decode_unknown_0x5fb66017),
0xbab42316: ('unknown_0xbab42316', _decode_unknown_0xbab42316),
0x8f06342a: ('part_0x8f06342a', _decode_part_0x8f06342a),
0xd8b11129: ('sound_0xd8b11129', _decode_sound_0xd8b11129),
0xe99e5316: ('sound_0xe99e5316', _decode_sound_0xe99e5316),
0x1440d152: ('damage_info', _decode_damage_info),
0x686489fd: ('part_0x686489fd', _decode_part_0x686489fd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct40.py | 0.573678 | 0.191536 | UnknownStruct40.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightFalloff(BaseProperty):
falloff_type: int = dataclasses.field(default=0)
falloff_rate: Spline = dataclasses.field(default_factory=Spline)
falloff_rate_duration: float = dataclasses.field(default=0.0)
falloff_rate_loops: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'Em\xf2\x0c') # 0x456df20c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.falloff_type))
data.write(b'/|c\xa3') # 0x2f7c63a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.falloff_rate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1fh\x13\xf1') # 0x1f6813f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.falloff_rate_duration))
data.write(b'm2>\xa3') # 0x6d323ea3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.falloff_rate_loops))
@classmethod
def from_json(cls, data: dict):
return cls(
falloff_type=data['falloff_type'],
falloff_rate=Spline.from_json(data['falloff_rate']),
falloff_rate_duration=data['falloff_rate_duration'],
falloff_rate_loops=data['falloff_rate_loops'],
)
def to_json(self) -> dict:
return {
'falloff_type': self.falloff_type,
'falloff_rate': self.falloff_rate.to_json(),
'falloff_rate_duration': self.falloff_rate_duration,
'falloff_rate_loops': self.falloff_rate_loops,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_falloff_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_falloff_rate(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_falloff_rate_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_falloff_rate_loops(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]]] = {
0x456df20c: ('falloff_type', _decode_falloff_type),
0x2f7c63a3: ('falloff_rate', _decode_falloff_rate),
0x1f6813f1: ('falloff_rate_duration', _decode_falloff_rate_duration),
0x6d323ea3: ('falloff_rate_loops', _decode_falloff_rate_loops),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DynamicLightFalloff.py | 0.623492 | 0.34091 | DynamicLightFalloff.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
from retro_data_structures.properties.echoes.archetypes.SandBossStructB import SandBossStructB
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct41(BaseProperty):
sand_boss_struct_b_0xb9784f0e: SandBossStructB = dataclasses.field(default_factory=SandBossStructB)
sand_boss_struct_b_0xb8ae1bdc: SandBossStructB = dataclasses.field(default_factory=SandBossStructB)
charge_beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xb9xO\x0e') # 0xb9784f0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sand_boss_struct_b_0xb9784f0e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8\xae\x1b\xdc') # 0xb8ae1bdc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sand_boss_struct_b_0xb8ae1bdc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94\xdad5') # 0x94da6435
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.charge_beam_info.to_stream(data, default_override={'length': 500.0, 'radius': 1.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
sand_boss_struct_b_0xb9784f0e=SandBossStructB.from_json(data['sand_boss_struct_b_0xb9784f0e']),
sand_boss_struct_b_0xb8ae1bdc=SandBossStructB.from_json(data['sand_boss_struct_b_0xb8ae1bdc']),
charge_beam_info=PlasmaBeamInfo.from_json(data['charge_beam_info']),
)
def to_json(self) -> dict:
return {
'sand_boss_struct_b_0xb9784f0e': self.sand_boss_struct_b_0xb9784f0e.to_json(),
'sand_boss_struct_b_0xb8ae1bdc': self.sand_boss_struct_b_0xb8ae1bdc.to_json(),
'charge_beam_info': self.charge_beam_info.to_json(),
}
def _dependencies_for_sand_boss_struct_b_0xb9784f0e(self, asset_manager):
yield from self.sand_boss_struct_b_0xb9784f0e.dependencies_for(asset_manager)
def _dependencies_for_sand_boss_struct_b_0xb8ae1bdc(self, asset_manager):
yield from self.sand_boss_struct_b_0xb8ae1bdc.dependencies_for(asset_manager)
def _dependencies_for_charge_beam_info(self, asset_manager):
yield from self.charge_beam_info.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_sand_boss_struct_b_0xb9784f0e, "sand_boss_struct_b_0xb9784f0e", "SandBossStructB"),
(self._dependencies_for_sand_boss_struct_b_0xb8ae1bdc, "sand_boss_struct_b_0xb8ae1bdc", "SandBossStructB"),
(self._dependencies_for_charge_beam_info, "charge_beam_info", "PlasmaBeamInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct41.{field_name} ({field_type}): {e}"
)
def _decode_sand_boss_struct_b_0xb9784f0e(data: typing.BinaryIO, property_size: int):
return SandBossStructB.from_stream(data, property_size)
def _decode_sand_boss_struct_b_0xb8ae1bdc(data: typing.BinaryIO, property_size: int):
return SandBossStructB.from_stream(data, property_size)
def _decode_charge_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size, default_override={'length': 500.0, 'radius': 1.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb9784f0e: ('sand_boss_struct_b_0xb9784f0e', _decode_sand_boss_struct_b_0xb9784f0e),
0xb8ae1bdc: ('sand_boss_struct_b_0xb8ae1bdc', _decode_sand_boss_struct_b_0xb8ae1bdc),
0x94da6435: ('charge_beam_info', _decode_charge_beam_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct41.py | 0.575349 | 0.376967 | UnknownStruct41.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
from retro_data_structures.properties.echoes.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
from retro_data_structures.properties.echoes.archetypes.UnknownStruct42 import UnknownStruct42
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 UnknownStruct43(BaseProperty):
unknown_0xbd80fd94: int = dataclasses.field(default=10)
max_linear_velocity: float = dataclasses.field(default=20.0)
max_turn_speed: float = dataclasses.field(default=720.0)
scanning_turn_speed: float = dataclasses.field(default=20.0)
unknown_0xe32fcae9: float = dataclasses.field(default=4.0)
unknown_0xc5e0b92c: float = dataclasses.field(default=10.0)
unknown_0xc17a8806: float = dataclasses.field(default=20.0)
unknown_0xe75bae9e: int = dataclasses.field(default=3)
laser_pulse_projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
laser_pulse_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0xeda45014: int = dataclasses.field(default=1)
unknown_0x7dd740fe: int = dataclasses.field(default=3)
dodge_chance: float = dataclasses.field(default=100.0)
reset_shield_time: float = dataclasses.field(default=10.0)
split_destroyed_priority: float = dataclasses.field(default=100.0)
laser_sweep_turn_speed: float = dataclasses.field(default=45.0)
laser_sweep_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
laser_sweep_beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
unknown_struct42: UnknownStruct42 = dataclasses.field(default_factory=UnknownStruct42)
sound_laser_sweep: int = dataclasses.field(default=0, metadata={'sound': True})
sound_laser_charge_up: int = dataclasses.field(default=0, metadata={'sound': True})
sound_docking: int = dataclasses.field(default=0, metadata={'sound': True})
sound_scanning: int = dataclasses.field(default=0, metadata={'sound': True})
sound_light_shield: int = dataclasses.field(default=0)
sound_dark_shield: int = dataclasses.field(default=0)
sound_shield_on: int = dataclasses.field(default=0, metadata={'sound': True})
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
light_shield_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
dark_shield_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1d') # 29 properties
data.write(b'\xbd\x80\xfd\x94') # 0xbd80fd94
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xbd80fd94))
data.write(b'\x00\xd7O\xc3') # 0xd74fc3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_linear_velocity))
data.write(b'\x0b\\<\x1a') # 0xb5c3c1a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_turn_speed))
data.write(b'\xa0\xb3\xe1\xbe') # 0xa0b3e1be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scanning_turn_speed))
data.write(b'\xe3/\xca\xe9') # 0xe32fcae9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe32fcae9))
data.write(b'\xc5\xe0\xb9,') # 0xc5e0b92c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc5e0b92c))
data.write(b'\xc1z\x88\x06') # 0xc17a8806
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc17a8806))
data.write(b'\xe7[\xae\x9e') # 0xe75bae9e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe75bae9e))
data.write(b'Mw\xb7\xaa') # 0x4d77b7aa
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.laser_pulse_projectile))
data.write(b'\xb7c\xeb\x10') # 0xb763eb10
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.laser_pulse_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xa4P\x14') # 0xeda45014
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xeda45014))
data.write(b'}\xd7@\xfe') # 0x7dd740fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7dd740fe))
data.write(b'G\xbe2\x98') # 0x47be3298
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dodge_chance))
data.write(b'\xd3\xde\xc6\xdc') # 0xd3dec6dc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reset_shield_time))
data.write(b'\xec\xd9\xd9-') # 0xecd9d92d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.split_destroyed_priority))
data.write(b'_\xf0\x06\xd1') # 0x5ff006d1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.laser_sweep_turn_speed))
data.write(b'\x1b\xd0\x17\xce') # 0x1bd017ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.laser_sweep_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J7\xc47') # 0x4a37c437
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.laser_sweep_beam_info.to_stream(data, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9e\xc5\x1f\xe4') # 0x9ec51fe4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct42.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea0uH') # 0xea307548
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_laser_sweep))
data.write(b'7y\xbd\x93') # 0x3779bd93
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_laser_charge_up))
data.write(b'\xc9\r\xbd\xb4') # 0xc90dbdb4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_docking))
data.write(b'\xe7rH\x02') # 0xe7724802
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_scanning))
data.write(b'\xd4\xa0bs') # 0xd4a06273
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_light_shield))
data.write(b'\xaf\xc2\x061') # 0xafc20631
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_dark_shield))
data.write(b'/\xf5\xa8\t') # 0x2ff5a809
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_shield_on))
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'\x80\xa8\xef;') # 0x80a8ef3b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.light_shield_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2\x1c\x90\xea') # 0xa21c90ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_shield_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xbd80fd94=data['unknown_0xbd80fd94'],
max_linear_velocity=data['max_linear_velocity'],
max_turn_speed=data['max_turn_speed'],
scanning_turn_speed=data['scanning_turn_speed'],
unknown_0xe32fcae9=data['unknown_0xe32fcae9'],
unknown_0xc5e0b92c=data['unknown_0xc5e0b92c'],
unknown_0xc17a8806=data['unknown_0xc17a8806'],
unknown_0xe75bae9e=data['unknown_0xe75bae9e'],
laser_pulse_projectile=data['laser_pulse_projectile'],
laser_pulse_damage=DamageInfo.from_json(data['laser_pulse_damage']),
unknown_0xeda45014=data['unknown_0xeda45014'],
unknown_0x7dd740fe=data['unknown_0x7dd740fe'],
dodge_chance=data['dodge_chance'],
reset_shield_time=data['reset_shield_time'],
split_destroyed_priority=data['split_destroyed_priority'],
laser_sweep_turn_speed=data['laser_sweep_turn_speed'],
laser_sweep_damage=DamageInfo.from_json(data['laser_sweep_damage']),
laser_sweep_beam_info=PlasmaBeamInfo.from_json(data['laser_sweep_beam_info']),
unknown_struct42=UnknownStruct42.from_json(data['unknown_struct42']),
sound_laser_sweep=data['sound_laser_sweep'],
sound_laser_charge_up=data['sound_laser_charge_up'],
sound_docking=data['sound_docking'],
sound_scanning=data['sound_scanning'],
sound_light_shield=data['sound_light_shield'],
sound_dark_shield=data['sound_dark_shield'],
sound_shield_on=data['sound_shield_on'],
ing_possession_data=IngPossessionData.from_json(data['ing_possession_data']),
light_shield_vulnerability=DamageVulnerability.from_json(data['light_shield_vulnerability']),
dark_shield_vulnerability=DamageVulnerability.from_json(data['dark_shield_vulnerability']),
)
def to_json(self) -> dict:
return {
'unknown_0xbd80fd94': self.unknown_0xbd80fd94,
'max_linear_velocity': self.max_linear_velocity,
'max_turn_speed': self.max_turn_speed,
'scanning_turn_speed': self.scanning_turn_speed,
'unknown_0xe32fcae9': self.unknown_0xe32fcae9,
'unknown_0xc5e0b92c': self.unknown_0xc5e0b92c,
'unknown_0xc17a8806': self.unknown_0xc17a8806,
'unknown_0xe75bae9e': self.unknown_0xe75bae9e,
'laser_pulse_projectile': self.laser_pulse_projectile,
'laser_pulse_damage': self.laser_pulse_damage.to_json(),
'unknown_0xeda45014': self.unknown_0xeda45014,
'unknown_0x7dd740fe': self.unknown_0x7dd740fe,
'dodge_chance': self.dodge_chance,
'reset_shield_time': self.reset_shield_time,
'split_destroyed_priority': self.split_destroyed_priority,
'laser_sweep_turn_speed': self.laser_sweep_turn_speed,
'laser_sweep_damage': self.laser_sweep_damage.to_json(),
'laser_sweep_beam_info': self.laser_sweep_beam_info.to_json(),
'unknown_struct42': self.unknown_struct42.to_json(),
'sound_laser_sweep': self.sound_laser_sweep,
'sound_laser_charge_up': self.sound_laser_charge_up,
'sound_docking': self.sound_docking,
'sound_scanning': self.sound_scanning,
'sound_light_shield': self.sound_light_shield,
'sound_dark_shield': self.sound_dark_shield,
'sound_shield_on': self.sound_shield_on,
'ing_possession_data': self.ing_possession_data.to_json(),
'light_shield_vulnerability': self.light_shield_vulnerability.to_json(),
'dark_shield_vulnerability': self.dark_shield_vulnerability.to_json(),
}
def _dependencies_for_laser_pulse_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.laser_pulse_projectile)
def _dependencies_for_laser_pulse_damage(self, asset_manager):
yield from self.laser_pulse_damage.dependencies_for(asset_manager)
def _dependencies_for_laser_sweep_damage(self, asset_manager):
yield from self.laser_sweep_damage.dependencies_for(asset_manager)
def _dependencies_for_laser_sweep_beam_info(self, asset_manager):
yield from self.laser_sweep_beam_info.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct42(self, asset_manager):
yield from self.unknown_struct42.dependencies_for(asset_manager)
def _dependencies_for_sound_laser_sweep(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_laser_sweep)
def _dependencies_for_sound_laser_charge_up(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_laser_charge_up)
def _dependencies_for_sound_docking(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_docking)
def _dependencies_for_sound_scanning(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_scanning)
def _dependencies_for_sound_shield_on(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_shield_on)
def _dependencies_for_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def _dependencies_for_light_shield_vulnerability(self, asset_manager):
yield from self.light_shield_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_dark_shield_vulnerability(self, asset_manager):
yield from self.dark_shield_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_laser_pulse_projectile, "laser_pulse_projectile", "AssetId"),
(self._dependencies_for_laser_pulse_damage, "laser_pulse_damage", "DamageInfo"),
(self._dependencies_for_laser_sweep_damage, "laser_sweep_damage", "DamageInfo"),
(self._dependencies_for_laser_sweep_beam_info, "laser_sweep_beam_info", "PlasmaBeamInfo"),
(self._dependencies_for_unknown_struct42, "unknown_struct42", "UnknownStruct42"),
(self._dependencies_for_sound_laser_sweep, "sound_laser_sweep", "int"),
(self._dependencies_for_sound_laser_charge_up, "sound_laser_charge_up", "int"),
(self._dependencies_for_sound_docking, "sound_docking", "int"),
(self._dependencies_for_sound_scanning, "sound_scanning", "int"),
(self._dependencies_for_sound_shield_on, "sound_shield_on", "int"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
(self._dependencies_for_light_shield_vulnerability, "light_shield_vulnerability", "DamageVulnerability"),
(self._dependencies_for_dark_shield_vulnerability, "dark_shield_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct43.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xbd80fd94(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_linear_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scanning_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe32fcae9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc5e0b92c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc17a8806(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe75bae9e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_laser_pulse_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_laser_pulse_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 10.0})
def _decode_unknown_0xeda45014(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7dd740fe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dodge_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reset_shield_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_split_destroyed_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_laser_sweep_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_laser_sweep_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 10.0})
def _decode_laser_sweep_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
def _decode_unknown_struct42(data: typing.BinaryIO, property_size: int):
return UnknownStruct42.from_stream(data, property_size)
def _decode_sound_laser_sweep(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_laser_charge_up(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_docking(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_scanning(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_light_shield(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_dark_shield(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_shield_on(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)
def _decode_light_shield_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_dark_shield_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbd80fd94: ('unknown_0xbd80fd94', _decode_unknown_0xbd80fd94),
0xd74fc3: ('max_linear_velocity', _decode_max_linear_velocity),
0xb5c3c1a: ('max_turn_speed', _decode_max_turn_speed),
0xa0b3e1be: ('scanning_turn_speed', _decode_scanning_turn_speed),
0xe32fcae9: ('unknown_0xe32fcae9', _decode_unknown_0xe32fcae9),
0xc5e0b92c: ('unknown_0xc5e0b92c', _decode_unknown_0xc5e0b92c),
0xc17a8806: ('unknown_0xc17a8806', _decode_unknown_0xc17a8806),
0xe75bae9e: ('unknown_0xe75bae9e', _decode_unknown_0xe75bae9e),
0x4d77b7aa: ('laser_pulse_projectile', _decode_laser_pulse_projectile),
0xb763eb10: ('laser_pulse_damage', _decode_laser_pulse_damage),
0xeda45014: ('unknown_0xeda45014', _decode_unknown_0xeda45014),
0x7dd740fe: ('unknown_0x7dd740fe', _decode_unknown_0x7dd740fe),
0x47be3298: ('dodge_chance', _decode_dodge_chance),
0xd3dec6dc: ('reset_shield_time', _decode_reset_shield_time),
0xecd9d92d: ('split_destroyed_priority', _decode_split_destroyed_priority),
0x5ff006d1: ('laser_sweep_turn_speed', _decode_laser_sweep_turn_speed),
0x1bd017ce: ('laser_sweep_damage', _decode_laser_sweep_damage),
0x4a37c437: ('laser_sweep_beam_info', _decode_laser_sweep_beam_info),
0x9ec51fe4: ('unknown_struct42', _decode_unknown_struct42),
0xea307548: ('sound_laser_sweep', _decode_sound_laser_sweep),
0x3779bd93: ('sound_laser_charge_up', _decode_sound_laser_charge_up),
0xc90dbdb4: ('sound_docking', _decode_sound_docking),
0xe7724802: ('sound_scanning', _decode_sound_scanning),
0xd4a06273: ('sound_light_shield', _decode_sound_light_shield),
0xafc20631: ('sound_dark_shield', _decode_sound_dark_shield),
0x2ff5a809: ('sound_shield_on', _decode_sound_shield_on),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
0x80a8ef3b: ('light_shield_vulnerability', _decode_light_shield_vulnerability),
0xa21c90ea: ('dark_shield_vulnerability', _decode_dark_shield_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct43.py | 0.566258 | 0.198064 | UnknownStruct43.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.IngBoostBallGuardianStruct import IngBoostBallGuardianStruct
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Spline import Spline
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct29(BaseProperty):
boost_ball_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.7999999523162842, y=1.7999999523162842, z=1.7999999523162842))
boost_ball_mass: float = dataclasses.field(default=150.0)
unknown_0xbea96fb7: float = dataclasses.field(default=0.5)
boost_ball_speed: Spline = dataclasses.field(default_factory=Spline)
damage_info_0x0e1a78bd: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info_0x19c3d263: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0xd8047cba: float = dataclasses.field(default=10.0)
unknown_0x7b21e31a: float = dataclasses.field(default=3.0)
boost_ball_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
part_0x15534429: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
boost_ball_shield_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
spsc: AssetId = dataclasses.field(metadata={'asset_types': ['SPSC']}, default=default_asset_id)
sound_bounce: int = dataclasses.field(default=0, metadata={'sound': True})
sound_into_ball: int = dataclasses.field(default=0, metadata={'sound': True})
sound_outof_ball: int = dataclasses.field(default=0, metadata={'sound': True})
sound: int = dataclasses.field(default=0, metadata={'sound': True})
sound_boost: int = dataclasses.field(default=0, metadata={'sound': True})
sound_rolling: int = dataclasses.field(default=0, metadata={'sound': True})
boost_ball_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0xee69b993: int = dataclasses.field(default=2)
unknown_0x4b2de673: int = dataclasses.field(default=3)
search_cone_angle: float = dataclasses.field(default=80.0)
unknown_0xb0e85d53: float = dataclasses.field(default=0.20000000298023224)
damage_info_0x5616d5f1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info_0xed685533: DamageInfo = dataclasses.field(default_factory=DamageInfo)
part_0xd771ec43: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0x2009a977: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0x62ab33a2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
ing_boost_ball_guardian_struct_0xbab98497: IngBoostBallGuardianStruct = dataclasses.field(default_factory=IngBoostBallGuardianStruct)
ing_boost_ball_guardian_struct_0xfe18a18f: IngBoostBallGuardianStruct = dataclasses.field(default_factory=IngBoostBallGuardianStruct)
ing_boost_ball_guardian_struct_0xc2784287: IngBoostBallGuardianStruct = dataclasses.field(default_factory=IngBoostBallGuardianStruct)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1f') # 31 properties
data.write(b'\xa3"\xf5\x1d') # 0xa322f51d
data.write(b'\x00\x0c') # size
self.boost_ball_scale.to_stream(data)
data.write(b'R\x8d\x95\x1e') # 0x528d951e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_ball_mass))
data.write(b'\xbe\xa9o\xb7') # 0xbea96fb7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbea96fb7))
data.write(b'\xa2[\x96\xe1') # 0xa25b96e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.boost_ball_speed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0e\x1ax\xbd') # 0xe1a78bd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x0e1a78bd.to_stream(data, default_override={'di_weapon_type': 7, 'di_damage': 30.0, 'di_radius': 1.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'\x19\xc3\xd2c') # 0x19c3d263
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x19c3d263.to_stream(data, default_override={'di_weapon_type': 7, 'di_damage': 30.0, 'di_radius': 1.5, 'di_knock_back_power': 6.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd8\x04|\xba') # 0xd8047cba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd8047cba))
data.write(b'{!\xe3\x1a') # 0x7b21e31a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7b21e31a))
data.write(b'\x188\x14y') # 0x18381479
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.boost_ball_model))
data.write(b'\x15SD)') # 0x15534429
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x15534429))
data.write(b'L\xce\xb7\xad') # 0x4cceb7ad
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.boost_ball_shield_effect))
data.write(b'\xe4\x1c\xb4I') # 0xe41cb449
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.spsc))
data.write(b'gX\xbf\x01') # 0x6758bf01
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_bounce))
data.write(b'\x8d\x9e\x01O') # 0x8d9e014f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_into_ball))
data.write(b'\xe3Z\xe4\xbe') # 0xe35ae4be
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_outof_ball))
data.write(b'\x9fsr\xb3') # 0x9f7372b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'\xddi\xa1\x16') # 0xdd69a116
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_boost))
data.write(b'\xbfB\xc3\xec') # 0xbf42c3ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_rolling))
data.write(b'B\xec\xa5#') # 0x42eca523
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.boost_ball_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeei\xb9\x93') # 0xee69b993
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xee69b993))
data.write(b'K-\xe6s') # 0x4b2de673
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x4b2de673))
data.write(b'*ps\xce') # 0x2a7073ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_cone_angle))
data.write(b'\xb0\xe8]S') # 0xb0e85d53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb0e85d53))
data.write(b'V\x16\xd5\xf1') # 0x5616d5f1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x5616d5f1.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xedhU3') # 0xed685533
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0xed685533.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'\xd7q\xecC') # 0xd771ec43
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0xd771ec43))
data.write(b' \t\xa9w') # 0x2009a977
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x2009a977))
data.write(b'b\xab3\xa2') # 0x62ab33a2
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x62ab33a2))
data.write(b'\xba\xb9\x84\x97') # 0xbab98497
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_boost_ball_guardian_struct_0xbab98497.to_stream(data, default_override={'locomotion_speed_scale': 1.0, 'ing_spot_speed_scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe\x18\xa1\x8f') # 0xfe18a18f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_boost_ball_guardian_struct_0xfe18a18f.to_stream(data, default_override={'locomotion_speed_scale': 1.0, 'ing_spot_speed_scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2xB\x87') # 0xc2784287
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_boost_ball_guardian_struct_0xc2784287.to_stream(data, default_override={'locomotion_speed_scale': 1.0, 'ing_spot_speed_scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
boost_ball_scale=Vector.from_json(data['boost_ball_scale']),
boost_ball_mass=data['boost_ball_mass'],
unknown_0xbea96fb7=data['unknown_0xbea96fb7'],
boost_ball_speed=Spline.from_json(data['boost_ball_speed']),
damage_info_0x0e1a78bd=DamageInfo.from_json(data['damage_info_0x0e1a78bd']),
damage_info_0x19c3d263=DamageInfo.from_json(data['damage_info_0x19c3d263']),
unknown_0xd8047cba=data['unknown_0xd8047cba'],
unknown_0x7b21e31a=data['unknown_0x7b21e31a'],
boost_ball_model=data['boost_ball_model'],
part_0x15534429=data['part_0x15534429'],
boost_ball_shield_effect=data['boost_ball_shield_effect'],
spsc=data['spsc'],
sound_bounce=data['sound_bounce'],
sound_into_ball=data['sound_into_ball'],
sound_outof_ball=data['sound_outof_ball'],
sound=data['sound'],
sound_boost=data['sound_boost'],
sound_rolling=data['sound_rolling'],
boost_ball_vulnerability=DamageVulnerability.from_json(data['boost_ball_vulnerability']),
unknown_0xee69b993=data['unknown_0xee69b993'],
unknown_0x4b2de673=data['unknown_0x4b2de673'],
search_cone_angle=data['search_cone_angle'],
unknown_0xb0e85d53=data['unknown_0xb0e85d53'],
damage_info_0x5616d5f1=DamageInfo.from_json(data['damage_info_0x5616d5f1']),
damage_info_0xed685533=DamageInfo.from_json(data['damage_info_0xed685533']),
part_0xd771ec43=data['part_0xd771ec43'],
part_0x2009a977=data['part_0x2009a977'],
part_0x62ab33a2=data['part_0x62ab33a2'],
ing_boost_ball_guardian_struct_0xbab98497=IngBoostBallGuardianStruct.from_json(data['ing_boost_ball_guardian_struct_0xbab98497']),
ing_boost_ball_guardian_struct_0xfe18a18f=IngBoostBallGuardianStruct.from_json(data['ing_boost_ball_guardian_struct_0xfe18a18f']),
ing_boost_ball_guardian_struct_0xc2784287=IngBoostBallGuardianStruct.from_json(data['ing_boost_ball_guardian_struct_0xc2784287']),
)
def to_json(self) -> dict:
return {
'boost_ball_scale': self.boost_ball_scale.to_json(),
'boost_ball_mass': self.boost_ball_mass,
'unknown_0xbea96fb7': self.unknown_0xbea96fb7,
'boost_ball_speed': self.boost_ball_speed.to_json(),
'damage_info_0x0e1a78bd': self.damage_info_0x0e1a78bd.to_json(),
'damage_info_0x19c3d263': self.damage_info_0x19c3d263.to_json(),
'unknown_0xd8047cba': self.unknown_0xd8047cba,
'unknown_0x7b21e31a': self.unknown_0x7b21e31a,
'boost_ball_model': self.boost_ball_model,
'part_0x15534429': self.part_0x15534429,
'boost_ball_shield_effect': self.boost_ball_shield_effect,
'spsc': self.spsc,
'sound_bounce': self.sound_bounce,
'sound_into_ball': self.sound_into_ball,
'sound_outof_ball': self.sound_outof_ball,
'sound': self.sound,
'sound_boost': self.sound_boost,
'sound_rolling': self.sound_rolling,
'boost_ball_vulnerability': self.boost_ball_vulnerability.to_json(),
'unknown_0xee69b993': self.unknown_0xee69b993,
'unknown_0x4b2de673': self.unknown_0x4b2de673,
'search_cone_angle': self.search_cone_angle,
'unknown_0xb0e85d53': self.unknown_0xb0e85d53,
'damage_info_0x5616d5f1': self.damage_info_0x5616d5f1.to_json(),
'damage_info_0xed685533': self.damage_info_0xed685533.to_json(),
'part_0xd771ec43': self.part_0xd771ec43,
'part_0x2009a977': self.part_0x2009a977,
'part_0x62ab33a2': self.part_0x62ab33a2,
'ing_boost_ball_guardian_struct_0xbab98497': self.ing_boost_ball_guardian_struct_0xbab98497.to_json(),
'ing_boost_ball_guardian_struct_0xfe18a18f': self.ing_boost_ball_guardian_struct_0xfe18a18f.to_json(),
'ing_boost_ball_guardian_struct_0xc2784287': self.ing_boost_ball_guardian_struct_0xc2784287.to_json(),
}
def _dependencies_for_damage_info_0x0e1a78bd(self, asset_manager):
yield from self.damage_info_0x0e1a78bd.dependencies_for(asset_manager)
def _dependencies_for_damage_info_0x19c3d263(self, asset_manager):
yield from self.damage_info_0x19c3d263.dependencies_for(asset_manager)
def _dependencies_for_boost_ball_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.boost_ball_model)
def _dependencies_for_part_0x15534429(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x15534429)
def _dependencies_for_boost_ball_shield_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.boost_ball_shield_effect)
def _dependencies_for_spsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.spsc)
def _dependencies_for_sound_bounce(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_bounce)
def _dependencies_for_sound_into_ball(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_into_ball)
def _dependencies_for_sound_outof_ball(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_outof_ball)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def _dependencies_for_sound_boost(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_boost)
def _dependencies_for_sound_rolling(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_rolling)
def _dependencies_for_boost_ball_vulnerability(self, asset_manager):
yield from self.boost_ball_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_damage_info_0x5616d5f1(self, asset_manager):
yield from self.damage_info_0x5616d5f1.dependencies_for(asset_manager)
def _dependencies_for_damage_info_0xed685533(self, asset_manager):
yield from self.damage_info_0xed685533.dependencies_for(asset_manager)
def _dependencies_for_part_0xd771ec43(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0xd771ec43)
def _dependencies_for_part_0x2009a977(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x2009a977)
def _dependencies_for_part_0x62ab33a2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x62ab33a2)
def _dependencies_for_ing_boost_ball_guardian_struct_0xbab98497(self, asset_manager):
yield from self.ing_boost_ball_guardian_struct_0xbab98497.dependencies_for(asset_manager)
def _dependencies_for_ing_boost_ball_guardian_struct_0xfe18a18f(self, asset_manager):
yield from self.ing_boost_ball_guardian_struct_0xfe18a18f.dependencies_for(asset_manager)
def _dependencies_for_ing_boost_ball_guardian_struct_0xc2784287(self, asset_manager):
yield from self.ing_boost_ball_guardian_struct_0xc2784287.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_damage_info_0x0e1a78bd, "damage_info_0x0e1a78bd", "DamageInfo"),
(self._dependencies_for_damage_info_0x19c3d263, "damage_info_0x19c3d263", "DamageInfo"),
(self._dependencies_for_boost_ball_model, "boost_ball_model", "AssetId"),
(self._dependencies_for_part_0x15534429, "part_0x15534429", "AssetId"),
(self._dependencies_for_boost_ball_shield_effect, "boost_ball_shield_effect", "AssetId"),
(self._dependencies_for_spsc, "spsc", "AssetId"),
(self._dependencies_for_sound_bounce, "sound_bounce", "int"),
(self._dependencies_for_sound_into_ball, "sound_into_ball", "int"),
(self._dependencies_for_sound_outof_ball, "sound_outof_ball", "int"),
(self._dependencies_for_sound, "sound", "int"),
(self._dependencies_for_sound_boost, "sound_boost", "int"),
(self._dependencies_for_sound_rolling, "sound_rolling", "int"),
(self._dependencies_for_boost_ball_vulnerability, "boost_ball_vulnerability", "DamageVulnerability"),
(self._dependencies_for_damage_info_0x5616d5f1, "damage_info_0x5616d5f1", "DamageInfo"),
(self._dependencies_for_damage_info_0xed685533, "damage_info_0xed685533", "DamageInfo"),
(self._dependencies_for_part_0xd771ec43, "part_0xd771ec43", "AssetId"),
(self._dependencies_for_part_0x2009a977, "part_0x2009a977", "AssetId"),
(self._dependencies_for_part_0x62ab33a2, "part_0x62ab33a2", "AssetId"),
(self._dependencies_for_ing_boost_ball_guardian_struct_0xbab98497, "ing_boost_ball_guardian_struct_0xbab98497", "IngBoostBallGuardianStruct"),
(self._dependencies_for_ing_boost_ball_guardian_struct_0xfe18a18f, "ing_boost_ball_guardian_struct_0xfe18a18f", "IngBoostBallGuardianStruct"),
(self._dependencies_for_ing_boost_ball_guardian_struct_0xc2784287, "ing_boost_ball_guardian_struct_0xc2784287", "IngBoostBallGuardianStruct"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct29.{field_name} ({field_type}): {e}"
)
def _decode_boost_ball_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_boost_ball_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbea96fb7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_ball_speed(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_damage_info_0x0e1a78bd(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 7, 'di_damage': 30.0, 'di_radius': 1.5, 'di_knock_back_power': 4.0})
def _decode_damage_info_0x19c3d263(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 7, 'di_damage': 30.0, 'di_radius': 1.5, 'di_knock_back_power': 6.0})
def _decode_unknown_0xd8047cba(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7b21e31a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_ball_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0x15534429(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_boost_ball_shield_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_spsc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_into_ball(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_outof_ball(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_sound_boost(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_rolling(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_boost_ball_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0xee69b993(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x4b2de673(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_search_cone_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb0e85d53(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_info_0x5616d5f1(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
def _decode_damage_info_0xed685533(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_part_0xd771ec43(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0x2009a977(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0x62ab33a2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_ing_boost_ball_guardian_struct_0xbab98497(data: typing.BinaryIO, property_size: int):
return IngBoostBallGuardianStruct.from_stream(data, property_size, default_override={'locomotion_speed_scale': 1.0, 'ing_spot_speed_scale': 1.0})
def _decode_ing_boost_ball_guardian_struct_0xfe18a18f(data: typing.BinaryIO, property_size: int):
return IngBoostBallGuardianStruct.from_stream(data, property_size, default_override={'locomotion_speed_scale': 1.0, 'ing_spot_speed_scale': 1.0})
def _decode_ing_boost_ball_guardian_struct_0xc2784287(data: typing.BinaryIO, property_size: int):
return IngBoostBallGuardianStruct.from_stream(data, property_size, default_override={'locomotion_speed_scale': 1.0, 'ing_spot_speed_scale': 1.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa322f51d: ('boost_ball_scale', _decode_boost_ball_scale),
0x528d951e: ('boost_ball_mass', _decode_boost_ball_mass),
0xbea96fb7: ('unknown_0xbea96fb7', _decode_unknown_0xbea96fb7),
0xa25b96e1: ('boost_ball_speed', _decode_boost_ball_speed),
0xe1a78bd: ('damage_info_0x0e1a78bd', _decode_damage_info_0x0e1a78bd),
0x19c3d263: ('damage_info_0x19c3d263', _decode_damage_info_0x19c3d263),
0xd8047cba: ('unknown_0xd8047cba', _decode_unknown_0xd8047cba),
0x7b21e31a: ('unknown_0x7b21e31a', _decode_unknown_0x7b21e31a),
0x18381479: ('boost_ball_model', _decode_boost_ball_model),
0x15534429: ('part_0x15534429', _decode_part_0x15534429),
0x4cceb7ad: ('boost_ball_shield_effect', _decode_boost_ball_shield_effect),
0xe41cb449: ('spsc', _decode_spsc),
0x6758bf01: ('sound_bounce', _decode_sound_bounce),
0x8d9e014f: ('sound_into_ball', _decode_sound_into_ball),
0xe35ae4be: ('sound_outof_ball', _decode_sound_outof_ball),
0x9f7372b3: ('sound', _decode_sound),
0xdd69a116: ('sound_boost', _decode_sound_boost),
0xbf42c3ec: ('sound_rolling', _decode_sound_rolling),
0x42eca523: ('boost_ball_vulnerability', _decode_boost_ball_vulnerability),
0xee69b993: ('unknown_0xee69b993', _decode_unknown_0xee69b993),
0x4b2de673: ('unknown_0x4b2de673', _decode_unknown_0x4b2de673),
0x2a7073ce: ('search_cone_angle', _decode_search_cone_angle),
0xb0e85d53: ('unknown_0xb0e85d53', _decode_unknown_0xb0e85d53),
0x5616d5f1: ('damage_info_0x5616d5f1', _decode_damage_info_0x5616d5f1),
0xed685533: ('damage_info_0xed685533', _decode_damage_info_0xed685533),
0xd771ec43: ('part_0xd771ec43', _decode_part_0xd771ec43),
0x2009a977: ('part_0x2009a977', _decode_part_0x2009a977),
0x62ab33a2: ('part_0x62ab33a2', _decode_part_0x62ab33a2),
0xbab98497: ('ing_boost_ball_guardian_struct_0xbab98497', _decode_ing_boost_ball_guardian_struct_0xbab98497),
0xfe18a18f: ('ing_boost_ball_guardian_struct_0xfe18a18f', _decode_ing_boost_ball_guardian_struct_0xfe18a18f),
0xc2784287: ('ing_boost_ball_guardian_struct_0xc2784287', _decode_ing_boost_ball_guardian_struct_0xc2784287),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct29.py | 0.54698 | 0.18866 | UnknownStruct29.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class EchoParameters(BaseProperty):
is_echo_emitter: bool = dataclasses.field(default=False)
only_emit_damage: bool = dataclasses.field(default=False)
num_sound_waves: int = dataclasses.field(default=3)
space_between_waves: float = dataclasses.field(default=0.20000000298023224)
wave_line_size: float = dataclasses.field(default=4.0)
forced_minimum_vis: float = dataclasses.field(default=0.5)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\x17\xad\xdf\xc6') # 0x17addfc6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_echo_emitter))
data.write(b'\xf5\xdfb\xad') # 0xf5df62ad
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.only_emit_damage))
data.write(b'\xd0\x07:\x0c') # 0xd0073a0c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_sound_waves))
data.write(b'\xedmg\x82') # 0xed6d6782
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.space_between_waves))
data.write(b'\xdb\x19\x0fh') # 0xdb190f68
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wave_line_size))
data.write(b'\xf8z\x15\xe7') # 0xf87a15e7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forced_minimum_vis))
@classmethod
def from_json(cls, data: dict):
return cls(
is_echo_emitter=data['is_echo_emitter'],
only_emit_damage=data['only_emit_damage'],
num_sound_waves=data['num_sound_waves'],
space_between_waves=data['space_between_waves'],
wave_line_size=data['wave_line_size'],
forced_minimum_vis=data['forced_minimum_vis'],
)
def to_json(self) -> dict:
return {
'is_echo_emitter': self.is_echo_emitter,
'only_emit_damage': self.only_emit_damage,
'num_sound_waves': self.num_sound_waves,
'space_between_waves': self.space_between_waves,
'wave_line_size': self.wave_line_size,
'forced_minimum_vis': self.forced_minimum_vis,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x17addfc6, 0xf5df62ad, 0xd0073a0c, 0xed6d6782, 0xdb190f68, 0xf87a15e7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[EchoParameters]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHlLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(54))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return EchoParameters(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_is_echo_emitter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_only_emit_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_num_sound_waves(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_space_between_waves(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wave_line_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_forced_minimum_vis(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]]] = {
0x17addfc6: ('is_echo_emitter', _decode_is_echo_emitter),
0xf5df62ad: ('only_emit_damage', _decode_only_emit_damage),
0xd0073a0c: ('num_sound_waves', _decode_num_sound_waves),
0xed6d6782: ('space_between_waves', _decode_space_between_waves),
0xdb190f68: ('wave_line_size', _decode_wave_line_size),
0xf87a15e7: ('forced_minimum_vis', _decode_forced_minimum_vis),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EchoParameters.py | 0.621656 | 0.264056 | EchoParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class PlatformMotionProperties(BaseProperty):
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
motion_spline_duration: float = dataclasses.field(default=10.0)
initial_time: float = dataclasses.field(default=0.0)
unknown: int = dataclasses.field(default=288)
roll_control_spline: Spline = dataclasses.field(default_factory=Spline)
yaw_control_spline: Spline = dataclasses.field(default_factory=Spline)
pitch_control_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'I=j-') # 0x493d6a2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x1e/V') # 0xfd1e2f56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.motion_spline_duration))
data.write(b'\xa5u=R') # 0xa5753d52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_time))
data.write(b'\xae\x80b\x8f') # 0xae80628f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'b\x8b\xdf\x0f') # 0x628bdf0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.roll_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'x\xd0:2') # 0x78d03a32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.yaw_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'\xb4\xa2\xe1Z') # 0xb4a2e15a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pitch_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
motion_spline_duration=data['motion_spline_duration'],
initial_time=data['initial_time'],
unknown=data['unknown'],
roll_control_spline=Spline.from_json(data['roll_control_spline']),
yaw_control_spline=Spline.from_json(data['yaw_control_spline']),
pitch_control_spline=Spline.from_json(data['pitch_control_spline']),
)
def to_json(self) -> dict:
return {
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'motion_spline_duration': self.motion_spline_duration,
'initial_time': self.initial_time,
'unknown': self.unknown,
'roll_control_spline': self.roll_control_spline.to_json(),
'yaw_control_spline': self.yaw_control_spline.to_json(),
'pitch_control_spline': self.pitch_control_spline.to_json(),
}
def _dependencies_for_motion_spline_type(self, asset_manager):
yield from self.motion_spline_type.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_motion_spline_type, "motion_spline_type", "SplineType"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlatformMotionProperties.{field_name} ({field_type}): {e}"
)
def _decode_motion_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_motion_spline_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_roll_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_yaw_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pitch_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
0xa5753d52: ('initial_time', _decode_initial_time),
0xae80628f: ('unknown', _decode_unknown),
0x628bdf0f: ('roll_control_spline', _decode_roll_control_spline),
0x78d03a32: ('yaw_control_spline', _decode_yaw_control_spline),
0xb4a2e15a: ('pitch_control_spline', _decode_pitch_control_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/PlatformMotionProperties.py | 0.576423 | 0.287368 | PlatformMotionProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class BehaveChance(BaseProperty):
lurk: float = dataclasses.field(default=-0.0)
unknown: float = dataclasses.field(default=0.0)
attack: float = dataclasses.field(default=0.0)
move: float = dataclasses.field(default=0.0)
lurk_time: float = dataclasses.field(default=0.0)
charge_attack: float = dataclasses.field(default=0.0)
num_bolts: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xd3\xa3\x13\xa5') # 0xd3a313a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lurk))
data.write(b'<\xfai\xf1') # 0x3cfa69f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x1a\xf8\x9fK') # 0x1af89f4b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack))
data.write(b'\xe7\xe6of') # 0xe7e66f66
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.move))
data.write(b'\xb9\xd9\xc2\xd2') # 0xb9d9c2d2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lurk_time))
data.write(b'\xcf\xab\xdd_') # 0xcfabdd5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.charge_attack))
data.write(b'Z\xb2(\xb6') # 0x5ab228b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_bolts))
@classmethod
def from_json(cls, data: dict):
return cls(
lurk=data['lurk'],
unknown=data['unknown'],
attack=data['attack'],
move=data['move'],
lurk_time=data['lurk_time'],
charge_attack=data['charge_attack'],
num_bolts=data['num_bolts'],
)
def to_json(self) -> dict:
return {
'lurk': self.lurk,
'unknown': self.unknown,
'attack': self.attack,
'move': self.move,
'lurk_time': self.lurk_time,
'charge_attack': self.charge_attack,
'num_bolts': self.num_bolts,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xd3a313a5, 0x3cfa69f1, 0x1af89f4b, 0xe7e66f66, 0xb9d9c2d2, 0xcfabdd5f, 0x5ab228b6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BehaveChance]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return BehaveChance(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_lurk(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_move(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lurk_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_charge_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_num_bolts(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]]] = {
0xd3a313a5: ('lurk', _decode_lurk),
0x3cfa69f1: ('unknown', _decode_unknown),
0x1af89f4b: ('attack', _decode_attack),
0xe7e66f66: ('move', _decode_move),
0xb9d9c2d2: ('lurk_time', _decode_lurk_time),
0xcfabdd5f: ('charge_attack', _decode_charge_attack),
0x5ab228b6: ('num_bolts', _decode_num_bolts),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/BehaveChance.py | 0.61057 | 0.266196 | BehaveChance.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class TGunResources(BaseProperty):
power_beam: str = dataclasses.field(default='')
ice_beam: str = dataclasses.field(default='')
wave_beam: str = dataclasses.field(default='')
plasma_beam: str = dataclasses.field(default='')
phazon_beam: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b"'\x051\x8d") # 0x2705318d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.power_beam.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'|\xc2\x87\x9f') # 0x7cc2879f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.ice_beam.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"8'e\xb0") # 0x382765b0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.wave_beam.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'\xcb&\x9a\xc8') # 0xcb269ac8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.plasma_beam.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'\xa3\x89\x035') # 0xa3890335
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.phazon_beam.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
power_beam=data['power_beam'],
ice_beam=data['ice_beam'],
wave_beam=data['wave_beam'],
plasma_beam=data['plasma_beam'],
phazon_beam=data['phazon_beam'],
)
def to_json(self) -> dict:
return {
'power_beam': self.power_beam,
'ice_beam': self.ice_beam,
'wave_beam': self.wave_beam,
'plasma_beam': self.plasma_beam,
'phazon_beam': self.phazon_beam,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_power_beam(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_ice_beam(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_wave_beam(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_plasma_beam(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_phazon_beam(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]]] = {
0x2705318d: ('power_beam', _decode_power_beam),
0x7cc2879f: ('ice_beam', _decode_ice_beam),
0x382765b0: ('wave_beam', _decode_wave_beam),
0xcb269ac8: ('plasma_beam', _decode_plasma_beam),
0xa3890335: ('phazon_beam', _decode_phazon_beam),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/TGunResources.py | 0.582254 | 0.343645 | TGunResources.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.UnknownStruct12 import UnknownStruct12
from retro_data_structures.properties.echoes.archetypes.UnknownStruct13 import UnknownStruct13
from retro_data_structures.properties.echoes.archetypes.UnknownStruct14 import UnknownStruct14
@dataclasses.dataclass()
class DarkCommandoData(BaseProperty):
lurk_chance: float = dataclasses.field(default=12.5)
taunt_chance: float = dataclasses.field(default=12.5)
unknown: float = dataclasses.field(default=25.0)
charge_beam_attack_chance: float = dataclasses.field(default=50.0)
blade_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_impact_rag_doll: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
sound_hurled_death: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
unknown_struct12: UnknownStruct12 = dataclasses.field(default_factory=UnknownStruct12)
unknown_struct13: UnknownStruct13 = dataclasses.field(default_factory=UnknownStruct13)
unknown_struct14: UnknownStruct14 = dataclasses.field(default_factory=UnknownStruct14)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\xa4\x85\x8f}') # 0xa4858f7d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lurk_chance))
data.write(b'\xa7\x7fb\x12') # 0xa77f6212
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_chance))
data.write(b'H\xea\xc7&') # 0x48eac726
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xb6\x92\x1a\xc3') # 0xb6921ac3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.charge_beam_attack_chance))
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': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2i\xea9') # 0xa269ea39
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_impact_rag_doll.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'N\xb6s\xbe') # 0x4eb673be
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_hurled_death.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'^\xc7\xf2\xba') # 0x5ec7f2ba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct12.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6\xc6@\x15') # 0xe6c64015
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18$z\xec') # 0x18247aec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct14.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
lurk_chance=data['lurk_chance'],
taunt_chance=data['taunt_chance'],
unknown=data['unknown'],
charge_beam_attack_chance=data['charge_beam_attack_chance'],
blade_damage=DamageInfo.from_json(data['blade_damage']),
sound_impact_rag_doll=AudioPlaybackParms.from_json(data['sound_impact_rag_doll']),
sound_hurled_death=AudioPlaybackParms.from_json(data['sound_hurled_death']),
unknown_struct12=UnknownStruct12.from_json(data['unknown_struct12']),
unknown_struct13=UnknownStruct13.from_json(data['unknown_struct13']),
unknown_struct14=UnknownStruct14.from_json(data['unknown_struct14']),
)
def to_json(self) -> dict:
return {
'lurk_chance': self.lurk_chance,
'taunt_chance': self.taunt_chance,
'unknown': self.unknown,
'charge_beam_attack_chance': self.charge_beam_attack_chance,
'blade_damage': self.blade_damage.to_json(),
'sound_impact_rag_doll': self.sound_impact_rag_doll.to_json(),
'sound_hurled_death': self.sound_hurled_death.to_json(),
'unknown_struct12': self.unknown_struct12.to_json(),
'unknown_struct13': self.unknown_struct13.to_json(),
'unknown_struct14': self.unknown_struct14.to_json(),
}
def _dependencies_for_blade_damage(self, asset_manager):
yield from self.blade_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_impact_rag_doll(self, asset_manager):
yield from self.sound_impact_rag_doll.dependencies_for(asset_manager)
def _dependencies_for_sound_hurled_death(self, asset_manager):
yield from self.sound_hurled_death.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct12(self, asset_manager):
yield from self.unknown_struct12.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct13(self, asset_manager):
yield from self.unknown_struct13.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct14(self, asset_manager):
yield from self.unknown_struct14.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_blade_damage, "blade_damage", "DamageInfo"),
(self._dependencies_for_sound_impact_rag_doll, "sound_impact_rag_doll", "AudioPlaybackParms"),
(self._dependencies_for_sound_hurled_death, "sound_hurled_death", "AudioPlaybackParms"),
(self._dependencies_for_unknown_struct12, "unknown_struct12", "UnknownStruct12"),
(self._dependencies_for_unknown_struct13, "unknown_struct13", "UnknownStruct13"),
(self._dependencies_for_unknown_struct14, "unknown_struct14", "UnknownStruct14"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DarkCommandoData.{field_name} ({field_type}): {e}"
)
def _decode_lurk_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_taunt_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_charge_beam_attack_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', 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': 20.0, 'di_knock_back_power': 10.0})
def _decode_sound_impact_rag_doll(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_sound_hurled_death(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_unknown_struct12(data: typing.BinaryIO, property_size: int):
return UnknownStruct12.from_stream(data, property_size)
def _decode_unknown_struct13(data: typing.BinaryIO, property_size: int):
return UnknownStruct13.from_stream(data, property_size)
def _decode_unknown_struct14(data: typing.BinaryIO, property_size: int):
return UnknownStruct14.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa4858f7d: ('lurk_chance', _decode_lurk_chance),
0xa77f6212: ('taunt_chance', _decode_taunt_chance),
0x48eac726: ('unknown', _decode_unknown),
0xb6921ac3: ('charge_beam_attack_chance', _decode_charge_beam_attack_chance),
0xa5912430: ('blade_damage', _decode_blade_damage),
0xa269ea39: ('sound_impact_rag_doll', _decode_sound_impact_rag_doll),
0x4eb673be: ('sound_hurled_death', _decode_sound_hurled_death),
0x5ec7f2ba: ('unknown_struct12', _decode_unknown_struct12),
0xe6c64015: ('unknown_struct13', _decode_unknown_struct13),
0x18247aec: ('unknown_struct14', _decode_unknown_struct14),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DarkCommandoData.py | 0.543106 | 0.197251 | DarkCommandoData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
@dataclasses.dataclass()
class SandBossStructB(BaseProperty):
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
duration: float = dataclasses.field(default=15.0)
change_direction_interval: float = dataclasses.field(default=3.0)
unknown_0x1b57d422: float = dataclasses.field(default=2.0)
change_direction_chance: float = dataclasses.field(default=50.0)
inner_radius: float = dataclasses.field(default=50.0)
outer_radius: float = dataclasses.field(default=50.0)
unknown_0x52642b7e: float = dataclasses.field(default=2.0)
unknown_0xfda3eb4b: float = dataclasses.field(default=1.0)
turn_speed: float = dataclasses.field(default=10.0)
unknown_0x47cde539: float = dataclasses.field(default=0.0)
sound_charge_beam: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x8d4f3b88: int = dataclasses.field(default=1)
unknown_0xbf88fe4f: float = dataclasses.field(default=3.0)
unknown_0x74c702b3: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 0.5, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\x82\xbe\x06\xba') # 0x82be06ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.change_direction_interval))
data.write(b'\x1bW\xd4"') # 0x1b57d422
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1b57d422))
data.write(b'\x06\x0b\x9b\x84') # 0x60b9b84
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.change_direction_chance))
data.write(b'?Z\xf4o') # 0x3f5af46f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.inner_radius))
data.write(b'B\xd8B\xcd') # 0x42d842cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.outer_radius))
data.write(b'Rd+~') # 0x52642b7e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x52642b7e))
data.write(b'\xfd\xa3\xebK') # 0xfda3eb4b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfda3eb4b))
data.write(b'\x02\x0cx\xbb') # 0x20c78bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed))
data.write(b'G\xcd\xe59') # 0x47cde539
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x47cde539))
data.write(b')\xd8tJ') # 0x29d8744a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_charge_beam))
data.write(b'\x8dO;\x88') # 0x8d4f3b88
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8d4f3b88))
data.write(b'\xbf\x88\xfeO') # 0xbf88fe4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbf88fe4f))
data.write(b't\xc7\x02\xb3') # 0x74c702b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x74c702b3))
@classmethod
def from_json(cls, data: dict):
return cls(
damage=DamageInfo.from_json(data['damage']),
duration=data['duration'],
change_direction_interval=data['change_direction_interval'],
unknown_0x1b57d422=data['unknown_0x1b57d422'],
change_direction_chance=data['change_direction_chance'],
inner_radius=data['inner_radius'],
outer_radius=data['outer_radius'],
unknown_0x52642b7e=data['unknown_0x52642b7e'],
unknown_0xfda3eb4b=data['unknown_0xfda3eb4b'],
turn_speed=data['turn_speed'],
unknown_0x47cde539=data['unknown_0x47cde539'],
sound_charge_beam=data['sound_charge_beam'],
unknown_0x8d4f3b88=data['unknown_0x8d4f3b88'],
unknown_0xbf88fe4f=data['unknown_0xbf88fe4f'],
unknown_0x74c702b3=data['unknown_0x74c702b3'],
)
def to_json(self) -> dict:
return {
'damage': self.damage.to_json(),
'duration': self.duration,
'change_direction_interval': self.change_direction_interval,
'unknown_0x1b57d422': self.unknown_0x1b57d422,
'change_direction_chance': self.change_direction_chance,
'inner_radius': self.inner_radius,
'outer_radius': self.outer_radius,
'unknown_0x52642b7e': self.unknown_0x52642b7e,
'unknown_0xfda3eb4b': self.unknown_0xfda3eb4b,
'turn_speed': self.turn_speed,
'unknown_0x47cde539': self.unknown_0x47cde539,
'sound_charge_beam': self.sound_charge_beam,
'unknown_0x8d4f3b88': self.unknown_0x8d4f3b88,
'unknown_0xbf88fe4f': self.unknown_0xbf88fe4f,
'unknown_0x74c702b3': self.unknown_0x74c702b3,
}
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def _dependencies_for_sound_charge_beam(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_charge_beam)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_sound_charge_beam, "sound_charge_beam", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SandBossStructB.{field_name} ({field_type}): {e}"
)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 0.5, 'di_knock_back_power': 10.0})
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_change_direction_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1b57d422(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_change_direction_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_inner_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_outer_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x52642b7e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfda3eb4b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x47cde539(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_charge_beam(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x8d4f3b88(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xbf88fe4f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x74c702b3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x337f9524: ('damage', _decode_damage),
0x8b51e23f: ('duration', _decode_duration),
0x82be06ba: ('change_direction_interval', _decode_change_direction_interval),
0x1b57d422: ('unknown_0x1b57d422', _decode_unknown_0x1b57d422),
0x60b9b84: ('change_direction_chance', _decode_change_direction_chance),
0x3f5af46f: ('inner_radius', _decode_inner_radius),
0x42d842cd: ('outer_radius', _decode_outer_radius),
0x52642b7e: ('unknown_0x52642b7e', _decode_unknown_0x52642b7e),
0xfda3eb4b: ('unknown_0xfda3eb4b', _decode_unknown_0xfda3eb4b),
0x20c78bb: ('turn_speed', _decode_turn_speed),
0x47cde539: ('unknown_0x47cde539', _decode_unknown_0x47cde539),
0x29d8744a: ('sound_charge_beam', _decode_sound_charge_beam),
0x8d4f3b88: ('unknown_0x8d4f3b88', _decode_unknown_0x8d4f3b88),
0xbf88fe4f: ('unknown_0xbf88fe4f', _decode_unknown_0xbf88fe4f),
0x74c702b3: ('unknown_0x74c702b3', _decode_unknown_0x74c702b3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SandBossStructB.py | 0.561696 | 0.3213 | SandBossStructB.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class TDamageInfo(BaseProperty):
weapon_type: int = dataclasses.field(default=0)
damage_amount: float = dataclasses.field(default=10.0)
radius_damage_amount: float = dataclasses.field(default=5.0)
damage_radius: float = dataclasses.field(default=1.0)
knock_back_power: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'MWy\x10') # 0x4d577910
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.weapon_type))
data.write(b'\xf3\xec\x87H') # 0xf3ec8748
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_amount))
data.write(b'7\xb6\xdf=') # 0x37b6df3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius_damage_amount))
data.write(b'\x0fY\x879') # 0xf598739
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_radius))
data.write(b'V\xf9\x8cI') # 0x56f98c49
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.knock_back_power))
@classmethod
def from_json(cls, data: dict):
return cls(
weapon_type=data['weapon_type'],
damage_amount=data['damage_amount'],
radius_damage_amount=data['radius_damage_amount'],
damage_radius=data['damage_radius'],
knock_back_power=data['knock_back_power'],
)
def to_json(self) -> dict:
return {
'weapon_type': self.weapon_type,
'damage_amount': self.damage_amount,
'radius_damage_amount': self.radius_damage_amount,
'damage_radius': self.damage_radius,
'knock_back_power': self.knock_back_power,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x4d577910, 0xf3ec8748, 0x37b6df3d, 0xf598739, 0x56f98c49)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TDamageInfo]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return TDamageInfo(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_weapon_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_damage_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radius_damage_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_knock_back_power(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]]] = {
0x4d577910: ('weapon_type', _decode_weapon_type),
0xf3ec8748: ('damage_amount', _decode_damage_amount),
0x37b6df3d: ('radius_damage_amount', _decode_radius_damage_amount),
0xf598739: ('damage_radius', _decode_damage_radius),
0x56f98c49: ('knock_back_power', _decode_knock_back_power),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/TDamageInfo.py | 0.628977 | 0.310603 | TDamageInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class CameraHintStructA(BaseProperty):
type: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
@classmethod
def from_json(cls, data: dict):
return cls(
type=data['type'],
)
def to_json(self) -> dict:
return {
'type': self.type,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xf53dcdd6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraHintStructA]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return CameraHintStructA(
dec[2],
)
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]]] = {
0xf53dcdd6: ('type', _decode_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/CameraHintStructA.py | 0.634204 | 0.295516 | CameraHintStructA.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct12(BaseProperty):
unknown_0xb33a0cbc: float = dataclasses.field(default=2.0)
min_attack_range: float = dataclasses.field(default=35.0)
max_attack_range: float = dataclasses.field(default=100.0)
grenade_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=25.0)
unknown_0xed086ce0: float = dataclasses.field(default=0.4000000059604645)
unknown_0x00fc6646: float = dataclasses.field(default=20.0)
unknown_0xa7c8e63f: float = dataclasses.field(default=50.0)
unknown_0x454f16b1: int = dataclasses.field(default=0)
unknown_0x2d4706e8: float = dataclasses.field(default=8.0)
sound_grenade_bounce: int = dataclasses.field(default=0, metadata={'sound': True})
sound_grenade_explode: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\xb3:\x0c\xbc') # 0xb33a0cbc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb33a0cbc))
data.write(b'XCI\x16') # 0x58434916
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attack_range))
data.write(b'\xffw\xc9o') # 0xff77c96f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_range))
data.write(b'\x14\xd1\xa3\xa8') # 0x14d1a3a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grenade_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\x00\xfcfF') # 0xfc6646
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x00fc6646))
data.write(b'\xa7\xc8\xe6?') # 0xa7c8e63f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa7c8e63f))
data.write(b'EO\x16\xb1') # 0x454f16b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x454f16b1))
data.write(b'-G\x06\xe8') # 0x2d4706e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2d4706e8))
data.write(b'%\x8c>\x1b') # 0x258c3e1b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_grenade_bounce))
data.write(b'\xafj\xad\x88') # 0xaf6aad88
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_grenade_explode))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xb33a0cbc=data['unknown_0xb33a0cbc'],
min_attack_range=data['min_attack_range'],
max_attack_range=data['max_attack_range'],
grenade_damage=DamageInfo.from_json(data['grenade_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_0x00fc6646=data['unknown_0x00fc6646'],
unknown_0xa7c8e63f=data['unknown_0xa7c8e63f'],
unknown_0x454f16b1=data['unknown_0x454f16b1'],
unknown_0x2d4706e8=data['unknown_0x2d4706e8'],
sound_grenade_bounce=data['sound_grenade_bounce'],
sound_grenade_explode=data['sound_grenade_explode'],
)
def to_json(self) -> dict:
return {
'unknown_0xb33a0cbc': self.unknown_0xb33a0cbc,
'min_attack_range': self.min_attack_range,
'max_attack_range': self.max_attack_range,
'grenade_damage': self.grenade_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_0x00fc6646': self.unknown_0x00fc6646,
'unknown_0xa7c8e63f': self.unknown_0xa7c8e63f,
'unknown_0x454f16b1': self.unknown_0x454f16b1,
'unknown_0x2d4706e8': self.unknown_0x2d4706e8,
'sound_grenade_bounce': self.sound_grenade_bounce,
'sound_grenade_explode': self.sound_grenade_explode,
}
def _dependencies_for_grenade_damage(self, asset_manager):
yield from self.grenade_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_sound_grenade_bounce(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_grenade_bounce)
def _dependencies_for_sound_grenade_explode(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_grenade_explode)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_grenade_damage, "grenade_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_sound_grenade_bounce, "sound_grenade_bounce", "int"),
(self._dependencies_for_sound_grenade_explode, "sound_grenade_explode", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct12.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xb33a0cbc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
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_0x00fc6646(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa7c8e63f(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_0x2d4706e8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_grenade_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_grenade_explode(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]]] = {
0xb33a0cbc: ('unknown_0xb33a0cbc', _decode_unknown_0xb33a0cbc),
0x58434916: ('min_attack_range', _decode_min_attack_range),
0xff77c96f: ('max_attack_range', _decode_max_attack_range),
0x14d1a3a8: ('grenade_damage', _decode_grenade_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),
0xfc6646: ('unknown_0x00fc6646', _decode_unknown_0x00fc6646),
0xa7c8e63f: ('unknown_0xa7c8e63f', _decode_unknown_0xa7c8e63f),
0x454f16b1: ('unknown_0x454f16b1', _decode_unknown_0x454f16b1),
0x2d4706e8: ('unknown_0x2d4706e8', _decode_unknown_0x2d4706e8),
0x258c3e1b: ('sound_grenade_bounce', _decode_sound_grenade_bounce),
0xaf6aad88: ('sound_grenade_explode', _decode_sound_grenade_explode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct12.py | 0.523908 | 0.20201 | UnknownStruct12.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct14(BaseProperty):
unknown_0xa0d037ee: float = dataclasses.field(default=25.0)
unknown_0x4f522994: float = dataclasses.field(default=40.0)
shadow_dash_speed: float = dataclasses.field(default=25.0)
unknown_0x5d02f384: float = dataclasses.field(default=20.0)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
audio_playback_parms: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
sound_cloak: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
sound_de_cloak: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
shadow_decoy_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
shadow_dash_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\xa0\xd07\xee') # 0xa0d037ee
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa0d037ee))
data.write(b'OR)\x94') # 0x4f522994
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4f522994))
data.write(b'\x87F\x1c\xc6') # 0x87461cc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_dash_speed))
data.write(b']\x02\xf3\x84') # 0x5d02f384
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5d02f384))
data.write(b'-\xc8\x0bK') # 0x2dc80b4b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'\x039"\x83') # 0x3392283
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9d\xed\xcf\xf1') # 0x9dedcff1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_cloak.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7@\xe0\x1d') # 0xf740e01d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_de_cloak.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2\xf6K\xb4') # 0xb2f64bb4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_decoy_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\x06tG') # 0xed067447
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_dash_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xa0d037ee=data['unknown_0xa0d037ee'],
unknown_0x4f522994=data['unknown_0x4f522994'],
shadow_dash_speed=data['shadow_dash_speed'],
unknown_0x5d02f384=data['unknown_0x5d02f384'],
part=data['part'],
audio_playback_parms=AudioPlaybackParms.from_json(data['audio_playback_parms']),
sound_cloak=AudioPlaybackParms.from_json(data['sound_cloak']),
sound_de_cloak=AudioPlaybackParms.from_json(data['sound_de_cloak']),
shadow_decoy_vulnerability=DamageVulnerability.from_json(data['shadow_decoy_vulnerability']),
shadow_dash_vulnerability=DamageVulnerability.from_json(data['shadow_dash_vulnerability']),
)
def to_json(self) -> dict:
return {
'unknown_0xa0d037ee': self.unknown_0xa0d037ee,
'unknown_0x4f522994': self.unknown_0x4f522994,
'shadow_dash_speed': self.shadow_dash_speed,
'unknown_0x5d02f384': self.unknown_0x5d02f384,
'part': self.part,
'audio_playback_parms': self.audio_playback_parms.to_json(),
'sound_cloak': self.sound_cloak.to_json(),
'sound_de_cloak': self.sound_de_cloak.to_json(),
'shadow_decoy_vulnerability': self.shadow_decoy_vulnerability.to_json(),
'shadow_dash_vulnerability': self.shadow_dash_vulnerability.to_json(),
}
def _dependencies_for_part(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part)
def _dependencies_for_audio_playback_parms(self, asset_manager):
yield from self.audio_playback_parms.dependencies_for(asset_manager)
def _dependencies_for_sound_cloak(self, asset_manager):
yield from self.sound_cloak.dependencies_for(asset_manager)
def _dependencies_for_sound_de_cloak(self, asset_manager):
yield from self.sound_de_cloak.dependencies_for(asset_manager)
def _dependencies_for_shadow_decoy_vulnerability(self, asset_manager):
yield from self.shadow_decoy_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_shadow_dash_vulnerability(self, asset_manager):
yield from self.shadow_dash_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_audio_playback_parms, "audio_playback_parms", "AudioPlaybackParms"),
(self._dependencies_for_sound_cloak, "sound_cloak", "AudioPlaybackParms"),
(self._dependencies_for_sound_de_cloak, "sound_de_cloak", "AudioPlaybackParms"),
(self._dependencies_for_shadow_decoy_vulnerability, "shadow_decoy_vulnerability", "DamageVulnerability"),
(self._dependencies_for_shadow_dash_vulnerability, "shadow_dash_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct14.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xa0d037ee(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4f522994(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_dash_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5d02f384(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_audio_playback_parms(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_sound_cloak(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_sound_de_cloak(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_shadow_decoy_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_shadow_dash_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa0d037ee: ('unknown_0xa0d037ee', _decode_unknown_0xa0d037ee),
0x4f522994: ('unknown_0x4f522994', _decode_unknown_0x4f522994),
0x87461cc6: ('shadow_dash_speed', _decode_shadow_dash_speed),
0x5d02f384: ('unknown_0x5d02f384', _decode_unknown_0x5d02f384),
0x2dc80b4b: ('part', _decode_part),
0x3392283: ('audio_playback_parms', _decode_audio_playback_parms),
0x9dedcff1: ('sound_cloak', _decode_sound_cloak),
0xf740e01d: ('sound_de_cloak', _decode_sound_de_cloak),
0xb2f64bb4: ('shadow_decoy_vulnerability', _decode_shadow_decoy_vulnerability),
0xed067447: ('shadow_dash_vulnerability', _decode_shadow_dash_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct14.py | 0.553988 | 0.216198 | UnknownStruct14.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.echoes as enums
@dataclasses.dataclass()
class WeaponVulnerability(BaseProperty):
damage_multiplier: float = dataclasses.field(default=100.0)
effect: enums.Effect = dataclasses.field(default=enums.Effect.Normal)
ignore_radius: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x01') # 1 properties
num_properties_written = 1
if self.damage_multiplier != default_override.get('damage_multiplier', 100.0):
num_properties_written += 1
data.write(b'\x85-8q') # 0x852d3871
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_multiplier))
if self.effect != default_override.get('effect', enums.Effect.Normal):
num_properties_written += 1
data.write(b'h\xac\xbd\x86') # 0x68acbd86
data.write(b'\x00\x04') # size
self.effect.to_stream(data)
data.write(b'\x93g}\xa2') # 0x93677da2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_radius))
if num_properties_written != 1:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
damage_multiplier=data['damage_multiplier'],
effect=enums.Effect.from_json(data['effect']),
ignore_radius=data['ignore_radius'],
)
def to_json(self) -> dict:
return {
'damage_multiplier': self.damage_multiplier,
'effect': self.effect.to_json(),
'ignore_radius': self.ignore_radius,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x852d3871, 0x68acbd86, 0x93677da2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[WeaponVulnerability]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHLLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(27))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return WeaponVulnerability(
dec[2],
enums.Effect(dec[5]),
dec[8],
)
def _decode_damage_multiplier(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_ignore_radius(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]]] = {
0x852d3871: ('damage_multiplier', _decode_damage_multiplier),
0x68acbd86: ('effect', _decode_effect),
0x93677da2: ('ignore_radius', _decode_ignore_radius),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/WeaponVulnerability.py | 0.647575 | 0.316026 | WeaponVulnerability.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct3(BaseProperty):
unknown_0x17cd8b2a: float = dataclasses.field(default=90.0)
unknown_0x1473dad2: float = dataclasses.field(default=90.0)
unknown_0x3650ce75: float = dataclasses.field(default=60.0)
unknown_0x78520e6e: float = dataclasses.field(default=60.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)
unknown_0xf9bd253e: float = dataclasses.field(default=0.0)
max_attack_angle: float = dataclasses.field(default=90.0)
max_attack_range: float = dataclasses.field(default=40.0)
start_attack_range: float = dataclasses.field(default=20.0)
attack_leash_timer: float = dataclasses.field(default=2.0)
weapon_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
weapon_effect: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
state_machine: AssetId = dataclasses.field(metadata={'asset_types': ['AFSM', 'FSM2']}, default=default_asset_id)
telegraph_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x13') # 19 properties
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'\xf9\xbd%>') # 0xf9bd253e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf9bd253e))
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'\xffw\xc9o') # 0xff77c96f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_range))
data.write(b"\xb6?'L") # 0xb63f274c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_attack_range))
data.write(b'\xf8\xd1\xeaw') # 0xf8d1ea77
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_leash_timer))
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'\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'UtA`') # 0x55744160
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.state_machine))
data.write(b'\x8fh\xac!') # 0x8f68ac21
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.telegraph_effect))
@classmethod
def from_json(cls, data: dict):
return cls(
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'],
unknown_0xf9bd253e=data['unknown_0xf9bd253e'],
max_attack_angle=data['max_attack_angle'],
max_attack_range=data['max_attack_range'],
start_attack_range=data['start_attack_range'],
attack_leash_timer=data['attack_leash_timer'],
weapon_damage=DamageInfo.from_json(data['weapon_damage']),
weapon_effect=data['weapon_effect'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
state_machine=data['state_machine'],
telegraph_effect=data['telegraph_effect'],
)
def to_json(self) -> dict:
return {
'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,
'unknown_0xf9bd253e': self.unknown_0xf9bd253e,
'max_attack_angle': self.max_attack_angle,
'max_attack_range': self.max_attack_range,
'start_attack_range': self.start_attack_range,
'attack_leash_timer': self.attack_leash_timer,
'weapon_damage': self.weapon_damage.to_json(),
'weapon_effect': self.weapon_effect,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'state_machine': self.state_machine,
'telegraph_effect': self.telegraph_effect,
}
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_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_state_machine(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.state_machine)
def _dependencies_for_telegraph_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.telegraph_effect)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_weapon_damage, "weapon_damage", "DamageInfo"),
(self._dependencies_for_weapon_effect, "weapon_effect", "AssetId"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_state_machine, "state_machine", "AssetId"),
(self._dependencies_for_telegraph_effect, "telegraph_effect", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct3.{field_name} ({field_type}): {e}"
)
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_unknown_0xf9bd253e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_leash_timer(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_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_state_machine(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_telegraph_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]]] = {
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),
0xf9bd253e: ('unknown_0xf9bd253e', _decode_unknown_0xf9bd253e),
0xf11f7384: ('max_attack_angle', _decode_max_attack_angle),
0xff77c96f: ('max_attack_range', _decode_max_attack_range),
0xb63f274c: ('start_attack_range', _decode_start_attack_range),
0xf8d1ea77: ('attack_leash_timer', _decode_attack_leash_timer),
0x8e5f7e96: ('weapon_damage', _decode_weapon_damage),
0xc43360a7: ('weapon_effect', _decode_weapon_effect),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x55744160: ('state_machine', _decode_state_machine),
0x8f68ac21: ('telegraph_effect', _decode_telegraph_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct3.py | 0.529507 | 0.25174 | UnknownStruct3.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class Vector2f(BaseProperty):
x: float = dataclasses.field(default=0.0)
y: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xa1g}N') # 0xa1677d4e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.x))
data.write(b'j;\xae\xeb') # 0x6a3baeeb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.y))
@classmethod
def from_json(cls, data: dict):
return cls(
x=data['x'],
y=data['y'],
)
def to_json(self) -> dict:
return {
'x': self.x,
'y': self.y,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xa1677d4e, 0x6a3baeeb)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Vector2f]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return Vector2f(
dec[2],
dec[5],
)
def _decode_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa1677d4e: ('x', _decode_x),
0x6a3baeeb: ('y', _decode_y),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/Vector2f.py | 0.68056 | 0.337381 | Vector2f.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class EmperorIngStage3StructA(BaseProperty):
beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
beam_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x15\x98\x01*') # 0x1598012a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_info.to_stream(data, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
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'\xf6\xf1\x85\xd6') # 0xf6f185d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.beam_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
beam_info=PlasmaBeamInfo.from_json(data['beam_info']),
damage=DamageInfo.from_json(data['damage']),
beam_sound=data['beam_sound'],
)
def to_json(self) -> dict:
return {
'beam_info': self.beam_info.to_json(),
'damage': self.damage.to_json(),
'beam_sound': self.beam_sound,
}
def _dependencies_for_beam_info(self, asset_manager):
yield from self.beam_info.dependencies_for(asset_manager)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def _dependencies_for_beam_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.beam_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_beam_info, "beam_info", "PlasmaBeamInfo"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_beam_sound, "beam_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage3StructA.{field_name} ({field_type}): {e}"
)
def _decode_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_beam_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]]] = {
0x1598012a: ('beam_info', _decode_beam_info),
0x337f9524: ('damage', _decode_damage),
0xf6f185d6: ('beam_sound', _decode_beam_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EmperorIngStage3StructA.py | 0.578329 | 0.283519 | EmperorIngStage3StructA.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class IngSpaceJumpGuardianStruct(BaseProperty):
taunt_chance: float = dataclasses.field(default=10.0)
attack_chance: float = dataclasses.field(default=90.0)
unknown_0x03698c10: float = dataclasses.field(default=33.29999923706055)
locomotion_speed: float = dataclasses.field(default=1.0)
unknown_0x3e370622: float = dataclasses.field(default=1500.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xa7\x7fb\x12') # 0xa77f6212
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_chance))
data.write(b'~\xaf\x8dp') # 0x7eaf8d70
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_chance))
data.write(b'\x03i\x8c\x10') # 0x3698c10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x03698c10))
data.write(b'\xfdF\xb8\\') # 0xfd46b85c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.locomotion_speed))
data.write(b'>7\x06"') # 0x3e370622
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3e370622))
@classmethod
def from_json(cls, data: dict):
return cls(
taunt_chance=data['taunt_chance'],
attack_chance=data['attack_chance'],
unknown_0x03698c10=data['unknown_0x03698c10'],
locomotion_speed=data['locomotion_speed'],
unknown_0x3e370622=data['unknown_0x3e370622'],
)
def to_json(self) -> dict:
return {
'taunt_chance': self.taunt_chance,
'attack_chance': self.attack_chance,
'unknown_0x03698c10': self.unknown_0x03698c10,
'locomotion_speed': self.locomotion_speed,
'unknown_0x3e370622': self.unknown_0x3e370622,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xa77f6212, 0x7eaf8d70, 0x3698c10, 0xfd46b85c, 0x3e370622)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[IngSpaceJumpGuardianStruct]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return IngSpaceJumpGuardianStruct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_taunt_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x03698c10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_locomotion_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3e370622(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]]] = {
0xa77f6212: ('taunt_chance', _decode_taunt_chance),
0x7eaf8d70: ('attack_chance', _decode_attack_chance),
0x3698c10: ('unknown_0x03698c10', _decode_unknown_0x03698c10),
0xfd46b85c: ('locomotion_speed', _decode_locomotion_speed),
0x3e370622: ('unknown_0x3e370622', _decode_unknown_0x3e370622),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/IngSpaceJumpGuardianStruct.py | 0.595375 | 0.302726 | IngSpaceJumpGuardianStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SpacePirateWeaponData(BaseProperty):
unknown_0x647670ac: int = dataclasses.field(default=0)
grenade_launcher: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0xa95a025b: int = dataclasses.field(default=3)
unknown_0x25f822c4: float = dataclasses.field(default=15.0)
unknown_0x765e3a20: float = dataclasses.field(default=50.0)
grenade_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=25.0)
unknown_0xed086ce0: float = dataclasses.field(default=0.4000000059604645)
unknown_0x00fc6646: float = dataclasses.field(default=20.0)
unknown_0xa7c8e63f: float = dataclasses.field(default=50.0)
unknown_0x454f16b1: int = dataclasses.field(default=2)
sound_grenade_bounce: int = dataclasses.field(default=0, metadata={'sound': True})
sound_grenade_explode: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x10') # 16 properties
data.write(b'dvp\xac') # 0x647670ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x647670ac))
data.write(b'\xa7\x9b\xb8.') # 0xa79bb82e
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_launcher))
data.write(b'\xa9Z\x02[') # 0xa95a025b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xa95a025b))
data.write(b'%\xf8"\xc4') # 0x25f822c4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x25f822c4))
data.write(b'v^: ') # 0x765e3a20
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x765e3a20))
data.write(b'\x14\xd1\xa3\xa8') # 0x14d1a3a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grenade_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 40.0, 'di_radius': 8.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\x00\xfcfF') # 0xfc6646
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x00fc6646))
data.write(b'\xa7\xc8\xe6?') # 0xa7c8e63f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa7c8e63f))
data.write(b'EO\x16\xb1') # 0x454f16b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x454f16b1))
data.write(b'%\x8c>\x1b') # 0x258c3e1b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_grenade_bounce))
data.write(b'\xafj\xad\x88') # 0xaf6aad88
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_grenade_explode))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x647670ac=data['unknown_0x647670ac'],
grenade_launcher=data['grenade_launcher'],
unknown_0xa95a025b=data['unknown_0xa95a025b'],
unknown_0x25f822c4=data['unknown_0x25f822c4'],
unknown_0x765e3a20=data['unknown_0x765e3a20'],
grenade_damage=DamageInfo.from_json(data['grenade_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_0x00fc6646=data['unknown_0x00fc6646'],
unknown_0xa7c8e63f=data['unknown_0xa7c8e63f'],
unknown_0x454f16b1=data['unknown_0x454f16b1'],
sound_grenade_bounce=data['sound_grenade_bounce'],
sound_grenade_explode=data['sound_grenade_explode'],
)
def to_json(self) -> dict:
return {
'unknown_0x647670ac': self.unknown_0x647670ac,
'grenade_launcher': self.grenade_launcher,
'unknown_0xa95a025b': self.unknown_0xa95a025b,
'unknown_0x25f822c4': self.unknown_0x25f822c4,
'unknown_0x765e3a20': self.unknown_0x765e3a20,
'grenade_damage': self.grenade_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_0x00fc6646': self.unknown_0x00fc6646,
'unknown_0xa7c8e63f': self.unknown_0xa7c8e63f,
'unknown_0x454f16b1': self.unknown_0x454f16b1,
'sound_grenade_bounce': self.sound_grenade_bounce,
'sound_grenade_explode': self.sound_grenade_explode,
}
def _dependencies_for_grenade_launcher(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_launcher)
def _dependencies_for_grenade_damage(self, asset_manager):
yield from self.grenade_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_sound_grenade_bounce(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_grenade_bounce)
def _dependencies_for_sound_grenade_explode(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_grenade_explode)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_grenade_launcher, "grenade_launcher", "AssetId"),
(self._dependencies_for_grenade_damage, "grenade_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_sound_grenade_bounce, "sound_grenade_bounce", "int"),
(self._dependencies_for_sound_grenade_explode, "sound_grenade_explode", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpacePirateWeaponData.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0x647670ac(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_grenade_launcher(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xa95a025b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x25f822c4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x765e3a20(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 40.0, 'di_radius': 8.0, 'di_knock_back_power': 10.0})
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_0x00fc6646(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa7c8e63f(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_sound_grenade_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_grenade_explode(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]]] = {
0x647670ac: ('unknown_0x647670ac', _decode_unknown_0x647670ac),
0xa79bb82e: ('grenade_launcher', _decode_grenade_launcher),
0xa95a025b: ('unknown_0xa95a025b', _decode_unknown_0xa95a025b),
0x25f822c4: ('unknown_0x25f822c4', _decode_unknown_0x25f822c4),
0x765e3a20: ('unknown_0x765e3a20', _decode_unknown_0x765e3a20),
0x14d1a3a8: ('grenade_damage', _decode_grenade_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),
0xfc6646: ('unknown_0x00fc6646', _decode_unknown_0x00fc6646),
0xa7c8e63f: ('unknown_0xa7c8e63f', _decode_unknown_0xa7c8e63f),
0x454f16b1: ('unknown_0x454f16b1', _decode_unknown_0x454f16b1),
0x258c3e1b: ('sound_grenade_bounce', _decode_sound_grenade_bounce),
0xaf6aad88: ('sound_grenade_explode', _decode_sound_grenade_explode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SpacePirateWeaponData.py | 0.503662 | 0.190705 | SpacePirateWeaponData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.Transform import Transform
@dataclasses.dataclass()
class EditorProperties(BaseProperty):
name: str = dataclasses.field(default='')
transform: Transform = dataclasses.field(default_factory=Transform)
active: bool = dataclasses.field(default=True)
unknown: int = dataclasses.field(default=3) # Flagset
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'INAM') # 0x494e414d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'XFRM') # 0x5846524d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.transform.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'ACTV') # 0x41435456
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'])\x8aC') # 0x5d298a43
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
transform=Transform.from_json(data['transform']),
active=data['active'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'transform': self.transform.to_json(),
'active': self.active,
'unknown': self.unknown,
}
def _dependencies_for_transform(self, asset_manager):
yield from self.transform.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_transform, "transform", "Transform"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EditorProperties.{field_name} ({field_type}): {e}"
)
def _decode_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_transform(data: typing.BinaryIO, property_size: int):
return Transform.from_stream(data, property_size)
def _decode_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x494e414d: ('name', _decode_name),
0x5846524d: ('transform', _decode_transform),
0x41435456: ('active', _decode_active),
0x5d298a43: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EditorProperties.py | 0.585812 | 0.330714 | EditorProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.WeaponVulnerability import WeaponVulnerability
@dataclasses.dataclass()
class DamageVulnerability(BaseProperty):
power: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
dark: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
light: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
annihilator: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
boost_ball: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
cannon_ball: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
screw_attack: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
bomb: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
power_bomb: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
missile: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
phazon: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
ai: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
poison_water: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
dark_water: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
lava: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
area_damage_hot: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
area_damage_cold: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
area_damage_dark: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
area_damage_light: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
power_charge: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
entangler: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
light_blast: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
sonic_boom: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
super_missle: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
black_hole: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
sunburst: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
imploder: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
weapon_vulnerability: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
normal_safe_zone: WeaponVulnerability = dataclasses.field(default_factory=WeaponVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1d') # 29 properties
data.write(b'\xac\x8b\xb2\xa7') # 0xac8bb2a7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.power.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb1\x9bml') # 0xb19b6d6c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00$D\xc6') # 0x2444c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.light.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6\xba\xcd\xe5') # 0xe6bacde5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.annihilator.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd9\x9c\x04\x00') # 0xd99c0400
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.boost_ball.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7\r\x8b\x8b') # 0xc70d8b8b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cannon_ball.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86o\x91\xbf') # 0x866f91bf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.screw_attack.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h\xae\x13\xa0') # 0x68ae13a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bomb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf0\xb2\xf4\xcf') # 0xf0b2f4cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.power_bomb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xef\xe8\xcb') # 0xefe8cb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.missile.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbbp\t?') # 0xbb70093f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phazon.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\xac"\x9f') # 0xbfac229f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ai.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'P\xdd\xe8\x91') # 0x50dde891
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.poison_water.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\xb5\xc6\x8b') # 0x97b5c68b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_water.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf4\xce\x8a\xcf') # 0xf4ce8acf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lava.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1dRX\x8d') # 0x1d52588d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage_hot.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xdd\xd5C') # 0x64ddd543
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage_cold.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'=b_\x10') # 0x3d625f10
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage_dark.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\x1b\x80\xe3') # 0x591b80e3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage_light.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4B\xb4\xa3') # 0xa442b4a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.power_charge.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*\x0f\x05$') # 0x2a0f0524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.entangler.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94\x9e<\x86') # 0x949e3c86
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.light_blast.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[\xa9\x91\xb1') # 0x5ba991b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sonic_boom.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'i$\xb8\xc1') # 0x6924b8c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.super_missle.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1a\xb7\x8b\xef') # 0x1ab78bef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.black_hole.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\xdc\xb7\xd4') # 0xfcdcb7d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sunburst.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1\x1f\xb0a') # 0x311fb061
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.imploder.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89\xd2]\xf4') # 0x89d25df4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weapon_vulnerability.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3V\xd3~') # 0x3356d37e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal_safe_zone.to_stream(data, default_override={'damage_multiplier': 0.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
power=WeaponVulnerability.from_json(data['power']),
dark=WeaponVulnerability.from_json(data['dark']),
light=WeaponVulnerability.from_json(data['light']),
annihilator=WeaponVulnerability.from_json(data['annihilator']),
boost_ball=WeaponVulnerability.from_json(data['boost_ball']),
cannon_ball=WeaponVulnerability.from_json(data['cannon_ball']),
screw_attack=WeaponVulnerability.from_json(data['screw_attack']),
bomb=WeaponVulnerability.from_json(data['bomb']),
power_bomb=WeaponVulnerability.from_json(data['power_bomb']),
missile=WeaponVulnerability.from_json(data['missile']),
phazon=WeaponVulnerability.from_json(data['phazon']),
ai=WeaponVulnerability.from_json(data['ai']),
poison_water=WeaponVulnerability.from_json(data['poison_water']),
dark_water=WeaponVulnerability.from_json(data['dark_water']),
lava=WeaponVulnerability.from_json(data['lava']),
area_damage_hot=WeaponVulnerability.from_json(data['area_damage_hot']),
area_damage_cold=WeaponVulnerability.from_json(data['area_damage_cold']),
area_damage_dark=WeaponVulnerability.from_json(data['area_damage_dark']),
area_damage_light=WeaponVulnerability.from_json(data['area_damage_light']),
power_charge=WeaponVulnerability.from_json(data['power_charge']),
entangler=WeaponVulnerability.from_json(data['entangler']),
light_blast=WeaponVulnerability.from_json(data['light_blast']),
sonic_boom=WeaponVulnerability.from_json(data['sonic_boom']),
super_missle=WeaponVulnerability.from_json(data['super_missle']),
black_hole=WeaponVulnerability.from_json(data['black_hole']),
sunburst=WeaponVulnerability.from_json(data['sunburst']),
imploder=WeaponVulnerability.from_json(data['imploder']),
weapon_vulnerability=WeaponVulnerability.from_json(data['weapon_vulnerability']),
normal_safe_zone=WeaponVulnerability.from_json(data['normal_safe_zone']),
)
def to_json(self) -> dict:
return {
'power': self.power.to_json(),
'dark': self.dark.to_json(),
'light': self.light.to_json(),
'annihilator': self.annihilator.to_json(),
'boost_ball': self.boost_ball.to_json(),
'cannon_ball': self.cannon_ball.to_json(),
'screw_attack': self.screw_attack.to_json(),
'bomb': self.bomb.to_json(),
'power_bomb': self.power_bomb.to_json(),
'missile': self.missile.to_json(),
'phazon': self.phazon.to_json(),
'ai': self.ai.to_json(),
'poison_water': self.poison_water.to_json(),
'dark_water': self.dark_water.to_json(),
'lava': self.lava.to_json(),
'area_damage_hot': self.area_damage_hot.to_json(),
'area_damage_cold': self.area_damage_cold.to_json(),
'area_damage_dark': self.area_damage_dark.to_json(),
'area_damage_light': self.area_damage_light.to_json(),
'power_charge': self.power_charge.to_json(),
'entangler': self.entangler.to_json(),
'light_blast': self.light_blast.to_json(),
'sonic_boom': self.sonic_boom.to_json(),
'super_missle': self.super_missle.to_json(),
'black_hole': self.black_hole.to_json(),
'sunburst': self.sunburst.to_json(),
'imploder': self.imploder.to_json(),
'weapon_vulnerability': self.weapon_vulnerability.to_json(),
'normal_safe_zone': self.normal_safe_zone.to_json(),
}
def _dependencies_for_power(self, asset_manager):
yield from self.power.dependencies_for(asset_manager)
def _dependencies_for_dark(self, asset_manager):
yield from self.dark.dependencies_for(asset_manager)
def _dependencies_for_light(self, asset_manager):
yield from self.light.dependencies_for(asset_manager)
def _dependencies_for_annihilator(self, asset_manager):
yield from self.annihilator.dependencies_for(asset_manager)
def _dependencies_for_boost_ball(self, asset_manager):
yield from self.boost_ball.dependencies_for(asset_manager)
def _dependencies_for_cannon_ball(self, asset_manager):
yield from self.cannon_ball.dependencies_for(asset_manager)
def _dependencies_for_screw_attack(self, asset_manager):
yield from self.screw_attack.dependencies_for(asset_manager)
def _dependencies_for_bomb(self, asset_manager):
yield from self.bomb.dependencies_for(asset_manager)
def _dependencies_for_power_bomb(self, asset_manager):
yield from self.power_bomb.dependencies_for(asset_manager)
def _dependencies_for_missile(self, asset_manager):
yield from self.missile.dependencies_for(asset_manager)
def _dependencies_for_phazon(self, asset_manager):
yield from self.phazon.dependencies_for(asset_manager)
def _dependencies_for_ai(self, asset_manager):
yield from self.ai.dependencies_for(asset_manager)
def _dependencies_for_poison_water(self, asset_manager):
yield from self.poison_water.dependencies_for(asset_manager)
def _dependencies_for_dark_water(self, asset_manager):
yield from self.dark_water.dependencies_for(asset_manager)
def _dependencies_for_lava(self, asset_manager):
yield from self.lava.dependencies_for(asset_manager)
def _dependencies_for_area_damage_hot(self, asset_manager):
yield from self.area_damage_hot.dependencies_for(asset_manager)
def _dependencies_for_area_damage_cold(self, asset_manager):
yield from self.area_damage_cold.dependencies_for(asset_manager)
def _dependencies_for_area_damage_dark(self, asset_manager):
yield from self.area_damage_dark.dependencies_for(asset_manager)
def _dependencies_for_area_damage_light(self, asset_manager):
yield from self.area_damage_light.dependencies_for(asset_manager)
def _dependencies_for_power_charge(self, asset_manager):
yield from self.power_charge.dependencies_for(asset_manager)
def _dependencies_for_entangler(self, asset_manager):
yield from self.entangler.dependencies_for(asset_manager)
def _dependencies_for_light_blast(self, asset_manager):
yield from self.light_blast.dependencies_for(asset_manager)
def _dependencies_for_sonic_boom(self, asset_manager):
yield from self.sonic_boom.dependencies_for(asset_manager)
def _dependencies_for_super_missle(self, asset_manager):
yield from self.super_missle.dependencies_for(asset_manager)
def _dependencies_for_black_hole(self, asset_manager):
yield from self.black_hole.dependencies_for(asset_manager)
def _dependencies_for_sunburst(self, asset_manager):
yield from self.sunburst.dependencies_for(asset_manager)
def _dependencies_for_imploder(self, asset_manager):
yield from self.imploder.dependencies_for(asset_manager)
def _dependencies_for_weapon_vulnerability(self, asset_manager):
yield from self.weapon_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_normal_safe_zone(self, asset_manager):
yield from self.normal_safe_zone.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_power, "power", "WeaponVulnerability"),
(self._dependencies_for_dark, "dark", "WeaponVulnerability"),
(self._dependencies_for_light, "light", "WeaponVulnerability"),
(self._dependencies_for_annihilator, "annihilator", "WeaponVulnerability"),
(self._dependencies_for_boost_ball, "boost_ball", "WeaponVulnerability"),
(self._dependencies_for_cannon_ball, "cannon_ball", "WeaponVulnerability"),
(self._dependencies_for_screw_attack, "screw_attack", "WeaponVulnerability"),
(self._dependencies_for_bomb, "bomb", "WeaponVulnerability"),
(self._dependencies_for_power_bomb, "power_bomb", "WeaponVulnerability"),
(self._dependencies_for_missile, "missile", "WeaponVulnerability"),
(self._dependencies_for_phazon, "phazon", "WeaponVulnerability"),
(self._dependencies_for_ai, "ai", "WeaponVulnerability"),
(self._dependencies_for_poison_water, "poison_water", "WeaponVulnerability"),
(self._dependencies_for_dark_water, "dark_water", "WeaponVulnerability"),
(self._dependencies_for_lava, "lava", "WeaponVulnerability"),
(self._dependencies_for_area_damage_hot, "area_damage_hot", "WeaponVulnerability"),
(self._dependencies_for_area_damage_cold, "area_damage_cold", "WeaponVulnerability"),
(self._dependencies_for_area_damage_dark, "area_damage_dark", "WeaponVulnerability"),
(self._dependencies_for_area_damage_light, "area_damage_light", "WeaponVulnerability"),
(self._dependencies_for_power_charge, "power_charge", "WeaponVulnerability"),
(self._dependencies_for_entangler, "entangler", "WeaponVulnerability"),
(self._dependencies_for_light_blast, "light_blast", "WeaponVulnerability"),
(self._dependencies_for_sonic_boom, "sonic_boom", "WeaponVulnerability"),
(self._dependencies_for_super_missle, "super_missle", "WeaponVulnerability"),
(self._dependencies_for_black_hole, "black_hole", "WeaponVulnerability"),
(self._dependencies_for_sunburst, "sunburst", "WeaponVulnerability"),
(self._dependencies_for_imploder, "imploder", "WeaponVulnerability"),
(self._dependencies_for_weapon_vulnerability, "weapon_vulnerability", "WeaponVulnerability"),
(self._dependencies_for_normal_safe_zone, "normal_safe_zone", "WeaponVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DamageVulnerability.{field_name} ({field_type}): {e}"
)
def _decode_power(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_dark(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_light(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_annihilator(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_boost_ball(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_cannon_ball(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_screw_attack(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_bomb(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_power_bomb(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_missile(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_phazon(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_ai(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_poison_water(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_dark_water(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_lava(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_area_damage_hot(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_area_damage_cold(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_area_damage_dark(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_area_damage_light(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_power_charge(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_entangler(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_light_blast(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_sonic_boom(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_super_missle(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_black_hole(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_sunburst(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_imploder(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size)
def _decode_weapon_vulnerability(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
def _decode_normal_safe_zone(data: typing.BinaryIO, property_size: int):
return WeaponVulnerability.from_stream(data, property_size, default_override={'damage_multiplier': 0.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xac8bb2a7: ('power', _decode_power),
0xb19b6d6c: ('dark', _decode_dark),
0x2444c6: ('light', _decode_light),
0xe6bacde5: ('annihilator', _decode_annihilator),
0xd99c0400: ('boost_ball', _decode_boost_ball),
0xc70d8b8b: ('cannon_ball', _decode_cannon_ball),
0x866f91bf: ('screw_attack', _decode_screw_attack),
0x68ae13a0: ('bomb', _decode_bomb),
0xf0b2f4cf: ('power_bomb', _decode_power_bomb),
0xefe8cb: ('missile', _decode_missile),
0xbb70093f: ('phazon', _decode_phazon),
0xbfac229f: ('ai', _decode_ai),
0x50dde891: ('poison_water', _decode_poison_water),
0x97b5c68b: ('dark_water', _decode_dark_water),
0xf4ce8acf: ('lava', _decode_lava),
0x1d52588d: ('area_damage_hot', _decode_area_damage_hot),
0x64ddd543: ('area_damage_cold', _decode_area_damage_cold),
0x3d625f10: ('area_damage_dark', _decode_area_damage_dark),
0x591b80e3: ('area_damage_light', _decode_area_damage_light),
0xa442b4a3: ('power_charge', _decode_power_charge),
0x2a0f0524: ('entangler', _decode_entangler),
0x949e3c86: ('light_blast', _decode_light_blast),
0x5ba991b1: ('sonic_boom', _decode_sonic_boom),
0x6924b8c1: ('super_missle', _decode_super_missle),
0x1ab78bef: ('black_hole', _decode_black_hole),
0xfcdcb7d4: ('sunburst', _decode_sunburst),
0x311fb061: ('imploder', _decode_imploder),
0x89d25df4: ('weapon_vulnerability', _decode_weapon_vulnerability),
0x3356d37e: ('normal_safe_zone', _decode_normal_safe_zone),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DamageVulnerability.py | 0.567937 | 0.2889 | DamageVulnerability.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct2(BaseProperty):
enabled: bool = dataclasses.field(default=False)
chance: float = dataclasses.field(default=0.0)
modifier: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b")\xc7}'") # 0x29c77d27
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enabled))
data.write(b'z{3\x0e') # 0x7a7b330e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chance))
data.write(b'\xed-To') # 0xed2d546f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.modifier))
@classmethod
def from_json(cls, data: dict):
return cls(
enabled=data['enabled'],
chance=data['chance'],
modifier=data['modifier'],
)
def to_json(self) -> dict:
return {
'enabled': self.enabled,
'chance': self.chance,
'modifier': self.modifier,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x29c77d27, 0x7a7b330e, 0xed2d546f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct2]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(27))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct2(
dec[2],
dec[5],
dec[8],
)
def _decode_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_modifier(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]]] = {
0x29c77d27: ('enabled', _decode_enabled),
0x7a7b330e: ('chance', _decode_chance),
0xed2d546f: ('modifier', _decode_modifier),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct2.py | 0.624752 | 0.332608 | UnknownStruct2.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.echoes as enums
@dataclasses.dataclass()
class VisorParameters(BaseProperty):
scan_through: bool = dataclasses.field(default=False)
visor_flags: enums.VisorFlags = dataclasses.field(default=enums.VisorFlags(15))
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xfe\x9d\xc2f') # 0xfe9dc266
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scan_through))
data.write(b'\xca\x19\xe8\xc6') # 0xca19e8c6
data.write(b'\x00\x04') # size
self.visor_flags.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
scan_through=data['scan_through'],
visor_flags=enums.VisorFlags.from_json(data['visor_flags']),
)
def to_json(self) -> dict:
return {
'scan_through': self.scan_through,
'visor_flags': self.visor_flags.to_json(),
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xfe9dc266, 0xca19e8c6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VisorParameters]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return VisorParameters(
dec[2],
enums.VisorFlags(dec[5]),
)
def _decode_scan_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_visor_flags(data: typing.BinaryIO, property_size: int):
return enums.VisorFlags.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfe9dc266: ('scan_through', _decode_scan_through),
0xca19e8c6: ('visor_flags', _decode_visor_flags),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/VisorParameters.py | 0.666605 | 0.305782 | VisorParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.ControllerActionStruct import ControllerActionStruct
@dataclasses.dataclass()
class ControlHintStruct(BaseProperty):
command: ControllerActionStruct = dataclasses.field(default_factory=ControllerActionStruct)
state: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'5\x9cz\xaf') # 0x359c7aaf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.command.to_stream(data, default_override={'command': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@cB*') # 0x4063422a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.state))
@classmethod
def from_json(cls, data: dict):
return cls(
command=ControllerActionStruct.from_json(data['command']),
state=data['state'],
)
def to_json(self) -> dict:
return {
'command': self.command.to_json(),
'state': self.state,
}
def _dependencies_for_command(self, asset_manager):
yield from self.command.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_command, "command", "ControllerActionStruct"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ControlHintStruct.{field_name} ({field_type}): {e}"
)
def _decode_command(data: typing.BinaryIO, property_size: int):
return ControllerActionStruct.from_stream(data, property_size, default_override={'command': 0})
def _decode_state(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]]] = {
0x359c7aaf: ('command', _decode_command),
0x4063422a: ('state', _decode_state),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/ControlHintStruct.py | 0.583203 | 0.270279 | ControlHintStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class BloggStruct(BaseProperty):
unknown_0x3e505ddb: int = dataclasses.field(default=0)
unknown_0x118f1e46: int = dataclasses.field(default=0)
unknown_0x6e603df2: float = dataclasses.field(default=0.0)
unknown_0x1e74f1ec: float = dataclasses.field(default=0.0)
unknown_0xecba9fb2: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'>P]\xdb') # 0x3e505ddb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3e505ddb))
data.write(b'\x11\x8f\x1eF') # 0x118f1e46
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x118f1e46))
data.write(b'n`=\xf2') # 0x6e603df2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6e603df2))
data.write(b'\x1et\xf1\xec') # 0x1e74f1ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1e74f1ec))
data.write(b'\xec\xba\x9f\xb2') # 0xecba9fb2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xecba9fb2))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x3e505ddb=data['unknown_0x3e505ddb'],
unknown_0x118f1e46=data['unknown_0x118f1e46'],
unknown_0x6e603df2=data['unknown_0x6e603df2'],
unknown_0x1e74f1ec=data['unknown_0x1e74f1ec'],
unknown_0xecba9fb2=data['unknown_0xecba9fb2'],
)
def to_json(self) -> dict:
return {
'unknown_0x3e505ddb': self.unknown_0x3e505ddb,
'unknown_0x118f1e46': self.unknown_0x118f1e46,
'unknown_0x6e603df2': self.unknown_0x6e603df2,
'unknown_0x1e74f1ec': self.unknown_0x1e74f1ec,
'unknown_0xecba9fb2': self.unknown_0xecba9fb2,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x3e505ddb, 0x118f1e46, 0x6e603df2, 0x1e74f1ec, 0xecba9fb2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BloggStruct]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return BloggStruct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_unknown_0x3e505ddb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x118f1e46(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6e603df2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1e74f1ec(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xecba9fb2(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]]] = {
0x3e505ddb: ('unknown_0x3e505ddb', _decode_unknown_0x3e505ddb),
0x118f1e46: ('unknown_0x118f1e46', _decode_unknown_0x118f1e46),
0x6e603df2: ('unknown_0x6e603df2', _decode_unknown_0x6e603df2),
0x1e74f1ec: ('unknown_0x1e74f1ec', _decode_unknown_0x1e74f1ec),
0xecba9fb2: ('unknown_0xecba9fb2', _decode_unknown_0xecba9fb2),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/BloggStruct.py | 0.609408 | 0.32449 | BloggStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EchoParameters import EchoParameters
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.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class PatternedAITypedef(BaseProperty):
mass: float = dataclasses.field(default=150.0)
speed: float = dataclasses.field(default=1.0)
turn_speed: float = dataclasses.field(default=120.0)
detection_range: float = dataclasses.field(default=100.0)
detection_height_range: float = dataclasses.field(default=0.0)
detection_angle: float = dataclasses.field(default=60.0)
min_attack_range: float = dataclasses.field(default=6.0)
max_attack_range: float = dataclasses.field(default=11.0)
average_attack_time: float = dataclasses.field(default=2.0)
attack_time_variation: float = dataclasses.field(default=1.0)
leash_radius: float = dataclasses.field(default=50.0)
player_leash_radius: float = dataclasses.field(default=25.0)
player_leash_time: float = dataclasses.field(default=5.0)
contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_wait_time: float = dataclasses.field(default=2.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
collision_radius: float = dataclasses.field(default=1.0)
collision_height: float = dataclasses.field(default=2.0)
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
step_up_height: float = dataclasses.field(default=0.10000000149011612)
unknown_0xe287d8dd: float = dataclasses.field(default=1000.0)
unknown_0x66cdc6e8: float = dataclasses.field(default=1000.0)
x_damage_delay: float = dataclasses.field(default=0.0)
sound_x_damage: int = dataclasses.field(default=0, metadata={'sound': True})
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
state_machine: AssetId = dataclasses.field(metadata={'asset_types': ['AFSM']}, default=default_asset_id)
state_machine2: AssetId = dataclasses.field(metadata={'asset_types': ['FSM2']}, default=default_asset_id)
unknown_0x87d22d43: float = dataclasses.field(default=0.10000000149011612)
unknown_0xf0790c1b: float = dataclasses.field(default=0.10000000149011612)
freeze_duration: float = dataclasses.field(default=2.0)
path_mesh_index: int = dataclasses.field(default=0)
gib_particles_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
gib_particles: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0xf35f5164: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
ice_gib_particles_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
ice_gib_particles: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_0x7344d6cd: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x562cf323: int = dataclasses.field(default=0, metadata={'sound': True})
sound_frozen: int = dataclasses.field(default=0, metadata={'sound': True})
knockback_rules: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
creature_size: int = dataclasses.field(default=0)
echo_parameters: EchoParameters = dataclasses.field(default_factory=EchoParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00+') # 43 properties
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'\x02\x0cx\xbb') # 0x20c78bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed))
data.write(b'\x8d\xb7~\xe4') # 0x8db77ee4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_range))
data.write(b'Q?\x04\xb8') # 0x513f04b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_height_range))
data.write(b'\x83\xdf\xc4\x0f') # 0x83dfc40f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_angle))
data.write(b'XCI\x16') # 0x58434916
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attack_range))
data.write(b'\xffw\xc9o') # 0xff77c96f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_range))
data.write(b'\xb0\xcf\xe0\x15') # 0xb0cfe015
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.average_attack_time))
data.write(b'\xc8\x0e2\x9b') # 0xc80e329b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_time_variation))
data.write(b'?\xaeG\xeb') # 0x3fae47eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.leash_radius))
data.write(b'\x13\xf0\xb1\x8f') # 0x13f0b18f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_leash_radius))
data.write(b'}Z\x04\x87') # 0x7d5a0487
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_leash_time))
data.write(b'\xd7VAn') # 0xd756416e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'\xe0\xcd\xc7\xe3') # 0xe0cdc7e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_wait_time))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data, default_override={'hi_knock_back_resistance': 2.0})
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'\x8aj\xb19') # 0x8a6ab139
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_radius))
data.write(b'0\x11\xb5\xdf') # 0x3011b5df
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_height))
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xd95Vt') # 0xd9355674
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.step_up_height))
data.write(b'\xe2\x87\xd8\xdd') # 0xe287d8dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe287d8dd))
data.write(b'f\xcd\xc6\xe8') # 0x66cdc6e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x66cdc6e8))
data.write(b'\x06\x1c\xbeb') # 0x61cbe62
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.x_damage_delay))
data.write(b'\x19\xf8C\x80') # 0x19f84380
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_x_damage))
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'UtA`') # 0x55744160
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.state_machine))
data.write(b'\xc1\xc7\xe2U') # 0xc1c7e255
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.state_machine2))
data.write(b'\x87\xd2-C') # 0x87d22d43
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x87d22d43))
data.write(b'\xf0y\x0c\x1b') # 0xf0790c1b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf0790c1b))
data.write(b'\xef;\xd8\xcf') # 0xef3bd8cf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.freeze_duration))
data.write(b'\x98\x16\x964') # 0x98169634
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.path_mesh_index))
data.write(b'H~\xf2W') # 0x487ef257
data.write(b'\x00\x0c') # size
self.gib_particles_offset.to_stream(data)
data.write(b'hO\x00\xc9') # 0x684f00c9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.gib_particles))
data.write(b'\xf3_Qd') # 0xf35f5164
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0xf35f5164))
data.write(b'\x13\x059\xa0') # 0x130539a0
data.write(b'\x00\x0c') # size
self.ice_gib_particles_offset.to_stream(data)
data.write(b'\xa8\xda\x929') # 0xa8da9239
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ice_gib_particles))
data.write(b'sD\xd6\xcd') # 0x7344d6cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x7344d6cd))
data.write(b'V,\xf3#') # 0x562cf323
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x562cf323))
data.write(b'\xcd\xd9\xf4\x1c') # 0xcdd9f41c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_frozen))
data.write(b'\x87\x01\x16R') # 0x87011652
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.knockback_rules))
data.write(b'K\xc4\xc4\xd9') # 0x4bc4c4d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.creature_size))
data.write(b'Dv\xbe\xd8') # 0x4476bed8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.echo_parameters.to_stream(data, default_override={'is_echo_emitter': True})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
mass=data['mass'],
speed=data['speed'],
turn_speed=data['turn_speed'],
detection_range=data['detection_range'],
detection_height_range=data['detection_height_range'],
detection_angle=data['detection_angle'],
min_attack_range=data['min_attack_range'],
max_attack_range=data['max_attack_range'],
average_attack_time=data['average_attack_time'],
attack_time_variation=data['attack_time_variation'],
leash_radius=data['leash_radius'],
player_leash_radius=data['player_leash_radius'],
player_leash_time=data['player_leash_time'],
contact_damage=DamageInfo.from_json(data['contact_damage']),
damage_wait_time=data['damage_wait_time'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
collision_radius=data['collision_radius'],
collision_height=data['collision_height'],
collision_offset=Vector.from_json(data['collision_offset']),
step_up_height=data['step_up_height'],
unknown_0xe287d8dd=data['unknown_0xe287d8dd'],
unknown_0x66cdc6e8=data['unknown_0x66cdc6e8'],
x_damage_delay=data['x_damage_delay'],
sound_x_damage=data['sound_x_damage'],
animation_information=AnimationParameters.from_json(data['animation_information']),
state_machine=data['state_machine'],
state_machine2=data['state_machine2'],
unknown_0x87d22d43=data['unknown_0x87d22d43'],
unknown_0xf0790c1b=data['unknown_0xf0790c1b'],
freeze_duration=data['freeze_duration'],
path_mesh_index=data['path_mesh_index'],
gib_particles_offset=Vector.from_json(data['gib_particles_offset']),
gib_particles=data['gib_particles'],
unknown_0xf35f5164=data['unknown_0xf35f5164'],
ice_gib_particles_offset=Vector.from_json(data['ice_gib_particles_offset']),
ice_gib_particles=data['ice_gib_particles'],
sound_0x7344d6cd=data['sound_0x7344d6cd'],
sound_0x562cf323=data['sound_0x562cf323'],
sound_frozen=data['sound_frozen'],
knockback_rules=data['knockback_rules'],
creature_size=data['creature_size'],
echo_parameters=EchoParameters.from_json(data['echo_parameters']),
)
def to_json(self) -> dict:
return {
'mass': self.mass,
'speed': self.speed,
'turn_speed': self.turn_speed,
'detection_range': self.detection_range,
'detection_height_range': self.detection_height_range,
'detection_angle': self.detection_angle,
'min_attack_range': self.min_attack_range,
'max_attack_range': self.max_attack_range,
'average_attack_time': self.average_attack_time,
'attack_time_variation': self.attack_time_variation,
'leash_radius': self.leash_radius,
'player_leash_radius': self.player_leash_radius,
'player_leash_time': self.player_leash_time,
'contact_damage': self.contact_damage.to_json(),
'damage_wait_time': self.damage_wait_time,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'collision_radius': self.collision_radius,
'collision_height': self.collision_height,
'collision_offset': self.collision_offset.to_json(),
'step_up_height': self.step_up_height,
'unknown_0xe287d8dd': self.unknown_0xe287d8dd,
'unknown_0x66cdc6e8': self.unknown_0x66cdc6e8,
'x_damage_delay': self.x_damage_delay,
'sound_x_damage': self.sound_x_damage,
'animation_information': self.animation_information.to_json(),
'state_machine': self.state_machine,
'state_machine2': self.state_machine2,
'unknown_0x87d22d43': self.unknown_0x87d22d43,
'unknown_0xf0790c1b': self.unknown_0xf0790c1b,
'freeze_duration': self.freeze_duration,
'path_mesh_index': self.path_mesh_index,
'gib_particles_offset': self.gib_particles_offset.to_json(),
'gib_particles': self.gib_particles,
'unknown_0xf35f5164': self.unknown_0xf35f5164,
'ice_gib_particles_offset': self.ice_gib_particles_offset.to_json(),
'ice_gib_particles': self.ice_gib_particles,
'sound_0x7344d6cd': self.sound_0x7344d6cd,
'sound_0x562cf323': self.sound_0x562cf323,
'sound_frozen': self.sound_frozen,
'knockback_rules': self.knockback_rules,
'creature_size': self.creature_size,
'echo_parameters': self.echo_parameters.to_json(),
}
def _dependencies_for_contact_damage(self, asset_manager):
yield from self.contact_damage.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_sound_x_damage(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_x_damage)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_state_machine(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.state_machine)
def _dependencies_for_state_machine2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.state_machine2)
def _dependencies_for_gib_particles(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.gib_particles)
def _dependencies_for_unknown_0xf35f5164(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0xf35f5164)
def _dependencies_for_ice_gib_particles(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ice_gib_particles)
def _dependencies_for_sound_0x7344d6cd(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x7344d6cd)
def _dependencies_for_sound_0x562cf323(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x562cf323)
def _dependencies_for_sound_frozen(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_frozen)
def _dependencies_for_knockback_rules(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.knockback_rules)
def _dependencies_for_echo_parameters(self, asset_manager):
yield from self.echo_parameters.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_contact_damage, "contact_damage", "DamageInfo"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_sound_x_damage, "sound_x_damage", "int"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_state_machine, "state_machine", "AssetId"),
(self._dependencies_for_state_machine2, "state_machine2", "AssetId"),
(self._dependencies_for_gib_particles, "gib_particles", "AssetId"),
(self._dependencies_for_unknown_0xf35f5164, "unknown_0xf35f5164", "AssetId"),
(self._dependencies_for_ice_gib_particles, "ice_gib_particles", "AssetId"),
(self._dependencies_for_sound_0x7344d6cd, "sound_0x7344d6cd", "int"),
(self._dependencies_for_sound_0x562cf323, "sound_0x562cf323", "int"),
(self._dependencies_for_sound_frozen, "sound_frozen", "int"),
(self._dependencies_for_knockback_rules, "knockback_rules", "AssetId"),
(self._dependencies_for_echo_parameters, "echo_parameters", "EchoParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PatternedAITypedef.{field_name} ({field_type}): {e}"
)
def _decode_mass(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_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_height_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_average_attack_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_time_variation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_leash_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_leash_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_leash_time(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)
def _decode_damage_wait_time(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, default_override={'hi_knock_back_resistance': 2.0})
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_collision_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_step_up_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe287d8dd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x66cdc6e8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_x_damage_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_x_damage(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_state_machine(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_state_machine2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x87d22d43(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf0790c1b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_freeze_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_path_mesh_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_gib_particles_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_gib_particles(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xf35f5164(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_ice_gib_particles_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_ice_gib_particles(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_0x7344d6cd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x562cf323(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_frozen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_knockback_rules(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_creature_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_echo_parameters(data: typing.BinaryIO, property_size: int):
return EchoParameters.from_stream(data, property_size, default_override={'is_echo_emitter': True})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x75dbb375: ('mass', _decode_mass),
0x6392404e: ('speed', _decode_speed),
0x20c78bb: ('turn_speed', _decode_turn_speed),
0x8db77ee4: ('detection_range', _decode_detection_range),
0x513f04b8: ('detection_height_range', _decode_detection_height_range),
0x83dfc40f: ('detection_angle', _decode_detection_angle),
0x58434916: ('min_attack_range', _decode_min_attack_range),
0xff77c96f: ('max_attack_range', _decode_max_attack_range),
0xb0cfe015: ('average_attack_time', _decode_average_attack_time),
0xc80e329b: ('attack_time_variation', _decode_attack_time_variation),
0x3fae47eb: ('leash_radius', _decode_leash_radius),
0x13f0b18f: ('player_leash_radius', _decode_player_leash_radius),
0x7d5a0487: ('player_leash_time', _decode_player_leash_time),
0xd756416e: ('contact_damage', _decode_contact_damage),
0xe0cdc7e3: ('damage_wait_time', _decode_damage_wait_time),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x8a6ab139: ('collision_radius', _decode_collision_radius),
0x3011b5df: ('collision_height', _decode_collision_height),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xd9355674: ('step_up_height', _decode_step_up_height),
0xe287d8dd: ('unknown_0xe287d8dd', _decode_unknown_0xe287d8dd),
0x66cdc6e8: ('unknown_0x66cdc6e8', _decode_unknown_0x66cdc6e8),
0x61cbe62: ('x_damage_delay', _decode_x_damage_delay),
0x19f84380: ('sound_x_damage', _decode_sound_x_damage),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x55744160: ('state_machine', _decode_state_machine),
0xc1c7e255: ('state_machine2', _decode_state_machine2),
0x87d22d43: ('unknown_0x87d22d43', _decode_unknown_0x87d22d43),
0xf0790c1b: ('unknown_0xf0790c1b', _decode_unknown_0xf0790c1b),
0xef3bd8cf: ('freeze_duration', _decode_freeze_duration),
0x98169634: ('path_mesh_index', _decode_path_mesh_index),
0x487ef257: ('gib_particles_offset', _decode_gib_particles_offset),
0x684f00c9: ('gib_particles', _decode_gib_particles),
0xf35f5164: ('unknown_0xf35f5164', _decode_unknown_0xf35f5164),
0x130539a0: ('ice_gib_particles_offset', _decode_ice_gib_particles_offset),
0xa8da9239: ('ice_gib_particles', _decode_ice_gib_particles),
0x7344d6cd: ('sound_0x7344d6cd', _decode_sound_0x7344d6cd),
0x562cf323: ('sound_0x562cf323', _decode_sound_0x562cf323),
0xcdd9f41c: ('sound_frozen', _decode_sound_frozen),
0x87011652: ('knockback_rules', _decode_knockback_rules),
0x4bc4c4d9: ('creature_size', _decode_creature_size),
0x4476bed8: ('echo_parameters', _decode_echo_parameters),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/PatternedAITypedef.py | 0.684053 | 0.230302 | PatternedAITypedef.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SurroundPan(BaseProperty):
pan: float = dataclasses.field(default=0.0)
surround_pan: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xdfCS\xa3') # 0xdf4353a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan))
data.write(b'H+\x88\xaa') # 0x482b88aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.surround_pan))
@classmethod
def from_json(cls, data: dict):
return cls(
pan=data['pan'],
surround_pan=data['surround_pan'],
)
def to_json(self) -> dict:
return {
'pan': self.pan,
'surround_pan': self.surround_pan,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xdf4353a3, 0x482b88aa)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SurroundPan]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return SurroundPan(
dec[2],
dec[5],
)
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_surround_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xdf4353a3: ('pan', _decode_pan),
0x482b88aa: ('surround_pan', _decode_surround_pan),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SurroundPan.py | 0.676086 | 0.310956 | SurroundPan.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
@dataclasses.dataclass()
class SplitterMainChassisData(BaseProperty):
unknown_0xcef5c2fe: int = dataclasses.field(default=124)
leg_stab_attack_interval: float = dataclasses.field(default=2.0)
unknown_0xf6047d40: float = dataclasses.field(default=2.5)
unknown_0x5130fd39: float = dataclasses.field(default=6.0)
leg_stab_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
min_dodge_interval: float = dataclasses.field(default=3.0)
dodge_chance: float = dataclasses.field(default=100.0)
deployment_speed: float = dataclasses.field(default=40.0)
scan_duration: float = dataclasses.field(default=3.0)
laser_sweep_interval: float = dataclasses.field(default=6.0)
unknown_0xb3ea58f8: float = dataclasses.field(default=30.0)
unknown_0x14ded881: float = dataclasses.field(default=60.0)
unknown_0x35eedd1c: float = dataclasses.field(default=20.0)
unknown_0x2dde6bfb: float = dataclasses.field(default=20.0)
unknown_0x8ae1ee93: float = dataclasses.field(default=60.0)
unknown_0x5027d1aa: float = dataclasses.field(default=20.0)
spin_attack_interval: float = dataclasses.field(default=6.0)
unknown_0xf65e430f: float = dataclasses.field(default=6.0)
unknown_0x43722555: float = dataclasses.field(default=1.5)
unknown_0x8935377c: float = dataclasses.field(default=10.0)
unknown_0x2e01b705: float = dataclasses.field(default=30.0)
unknown_0xd5f34476: int = dataclasses.field(default=4)
unknown_0x21296bdc: float = dataclasses.field(default=30.0)
spin_attack_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_alerted: int = dataclasses.field(default=0, metadata={'sound': True})
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
spin_attack_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1b') # 27 properties
data.write(b'\xce\xf5\xc2\xfe') # 0xcef5c2fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xcef5c2fe))
data.write(b'\xa8\xfd\xdb\xa0') # 0xa8fddba0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.leg_stab_attack_interval))
data.write(b'\xf6\x04}@') # 0xf6047d40
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf6047d40))
data.write(b'Q0\xfd9') # 0x5130fd39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5130fd39))
data.write(b'\xef\xac\xfaP') # 0xefacfa50
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.leg_stab_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.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'\x99\xa5Y9') # 0x99a55939
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_dodge_interval))
data.write(b'G\xbe2\x98') # 0x47be3298
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dodge_chance))
data.write(b'\xee\xadkM') # 0xeead6b4d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deployment_speed))
data.write(b'\xf8M\x8f\xda') # 0xf84d8fda
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scan_duration))
data.write(b'\x0f\xbaI+') # 0xfba492b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.laser_sweep_interval))
data.write(b'\xb3\xeaX\xf8') # 0xb3ea58f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb3ea58f8))
data.write(b'\x14\xde\xd8\x81') # 0x14ded881
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x14ded881))
data.write(b'5\xee\xdd\x1c') # 0x35eedd1c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x35eedd1c))
data.write(b'-\xdek\xfb') # 0x2dde6bfb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2dde6bfb))
data.write(b'\x8a\xe1\xee\x93') # 0x8ae1ee93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8ae1ee93))
data.write(b"P'\xd1\xaa") # 0x5027d1aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5027d1aa))
data.write(b'\xd8\x94\x06b') # 0xd8940662
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spin_attack_interval))
data.write(b'\xf6^C\x0f') # 0xf65e430f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf65e430f))
data.write(b'Cr%U') # 0x43722555
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x43722555))
data.write(b'\x8957|') # 0x8935377c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8935377c))
data.write(b'.\x01\xb7\x05') # 0x2e01b705
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2e01b705))
data.write(b'\xd5\xf3Dv') # 0xd5f34476
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd5f34476))
data.write(b'!)k\xdc') # 0x21296bdc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x21296bdc))
data.write(b'\xcf\xac\xffS') # 0xcfacff53
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spin_attack_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.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'\xa6\x1c*f') # 0xa61c2a66
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_alerted))
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'$\xe2<\xc5') # 0x24e23cc5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spin_attack_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xcef5c2fe=data['unknown_0xcef5c2fe'],
leg_stab_attack_interval=data['leg_stab_attack_interval'],
unknown_0xf6047d40=data['unknown_0xf6047d40'],
unknown_0x5130fd39=data['unknown_0x5130fd39'],
leg_stab_damage=DamageInfo.from_json(data['leg_stab_damage']),
min_dodge_interval=data['min_dodge_interval'],
dodge_chance=data['dodge_chance'],
deployment_speed=data['deployment_speed'],
scan_duration=data['scan_duration'],
laser_sweep_interval=data['laser_sweep_interval'],
unknown_0xb3ea58f8=data['unknown_0xb3ea58f8'],
unknown_0x14ded881=data['unknown_0x14ded881'],
unknown_0x35eedd1c=data['unknown_0x35eedd1c'],
unknown_0x2dde6bfb=data['unknown_0x2dde6bfb'],
unknown_0x8ae1ee93=data['unknown_0x8ae1ee93'],
unknown_0x5027d1aa=data['unknown_0x5027d1aa'],
spin_attack_interval=data['spin_attack_interval'],
unknown_0xf65e430f=data['unknown_0xf65e430f'],
unknown_0x43722555=data['unknown_0x43722555'],
unknown_0x8935377c=data['unknown_0x8935377c'],
unknown_0x2e01b705=data['unknown_0x2e01b705'],
unknown_0xd5f34476=data['unknown_0xd5f34476'],
unknown_0x21296bdc=data['unknown_0x21296bdc'],
spin_attack_damage=DamageInfo.from_json(data['spin_attack_damage']),
sound_alerted=data['sound_alerted'],
ing_possession_data=IngPossessionData.from_json(data['ing_possession_data']),
spin_attack_vulnerability=DamageVulnerability.from_json(data['spin_attack_vulnerability']),
)
def to_json(self) -> dict:
return {
'unknown_0xcef5c2fe': self.unknown_0xcef5c2fe,
'leg_stab_attack_interval': self.leg_stab_attack_interval,
'unknown_0xf6047d40': self.unknown_0xf6047d40,
'unknown_0x5130fd39': self.unknown_0x5130fd39,
'leg_stab_damage': self.leg_stab_damage.to_json(),
'min_dodge_interval': self.min_dodge_interval,
'dodge_chance': self.dodge_chance,
'deployment_speed': self.deployment_speed,
'scan_duration': self.scan_duration,
'laser_sweep_interval': self.laser_sweep_interval,
'unknown_0xb3ea58f8': self.unknown_0xb3ea58f8,
'unknown_0x14ded881': self.unknown_0x14ded881,
'unknown_0x35eedd1c': self.unknown_0x35eedd1c,
'unknown_0x2dde6bfb': self.unknown_0x2dde6bfb,
'unknown_0x8ae1ee93': self.unknown_0x8ae1ee93,
'unknown_0x5027d1aa': self.unknown_0x5027d1aa,
'spin_attack_interval': self.spin_attack_interval,
'unknown_0xf65e430f': self.unknown_0xf65e430f,
'unknown_0x43722555': self.unknown_0x43722555,
'unknown_0x8935377c': self.unknown_0x8935377c,
'unknown_0x2e01b705': self.unknown_0x2e01b705,
'unknown_0xd5f34476': self.unknown_0xd5f34476,
'unknown_0x21296bdc': self.unknown_0x21296bdc,
'spin_attack_damage': self.spin_attack_damage.to_json(),
'sound_alerted': self.sound_alerted,
'ing_possession_data': self.ing_possession_data.to_json(),
'spin_attack_vulnerability': self.spin_attack_vulnerability.to_json(),
}
def _dependencies_for_leg_stab_damage(self, asset_manager):
yield from self.leg_stab_damage.dependencies_for(asset_manager)
def _dependencies_for_spin_attack_damage(self, asset_manager):
yield from self.spin_attack_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_alerted(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_alerted)
def _dependencies_for_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def _dependencies_for_spin_attack_vulnerability(self, asset_manager):
yield from self.spin_attack_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_leg_stab_damage, "leg_stab_damage", "DamageInfo"),
(self._dependencies_for_spin_attack_damage, "spin_attack_damage", "DamageInfo"),
(self._dependencies_for_sound_alerted, "sound_alerted", "int"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
(self._dependencies_for_spin_attack_vulnerability, "spin_attack_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SplitterMainChassisData.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xcef5c2fe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_leg_stab_attack_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf6047d40(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5130fd39(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_leg_stab_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 5.0})
def _decode_min_dodge_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dodge_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deployment_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scan_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_laser_sweep_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb3ea58f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x14ded881(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x35eedd1c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2dde6bfb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8ae1ee93(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5027d1aa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spin_attack_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf65e430f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x43722555(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8935377c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2e01b705(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd5f34476(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x21296bdc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spin_attack_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 5.0})
def _decode_sound_alerted(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)
def _decode_spin_attack_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xcef5c2fe: ('unknown_0xcef5c2fe', _decode_unknown_0xcef5c2fe),
0xa8fddba0: ('leg_stab_attack_interval', _decode_leg_stab_attack_interval),
0xf6047d40: ('unknown_0xf6047d40', _decode_unknown_0xf6047d40),
0x5130fd39: ('unknown_0x5130fd39', _decode_unknown_0x5130fd39),
0xefacfa50: ('leg_stab_damage', _decode_leg_stab_damage),
0x99a55939: ('min_dodge_interval', _decode_min_dodge_interval),
0x47be3298: ('dodge_chance', _decode_dodge_chance),
0xeead6b4d: ('deployment_speed', _decode_deployment_speed),
0xf84d8fda: ('scan_duration', _decode_scan_duration),
0xfba492b: ('laser_sweep_interval', _decode_laser_sweep_interval),
0xb3ea58f8: ('unknown_0xb3ea58f8', _decode_unknown_0xb3ea58f8),
0x14ded881: ('unknown_0x14ded881', _decode_unknown_0x14ded881),
0x35eedd1c: ('unknown_0x35eedd1c', _decode_unknown_0x35eedd1c),
0x2dde6bfb: ('unknown_0x2dde6bfb', _decode_unknown_0x2dde6bfb),
0x8ae1ee93: ('unknown_0x8ae1ee93', _decode_unknown_0x8ae1ee93),
0x5027d1aa: ('unknown_0x5027d1aa', _decode_unknown_0x5027d1aa),
0xd8940662: ('spin_attack_interval', _decode_spin_attack_interval),
0xf65e430f: ('unknown_0xf65e430f', _decode_unknown_0xf65e430f),
0x43722555: ('unknown_0x43722555', _decode_unknown_0x43722555),
0x8935377c: ('unknown_0x8935377c', _decode_unknown_0x8935377c),
0x2e01b705: ('unknown_0x2e01b705', _decode_unknown_0x2e01b705),
0xd5f34476: ('unknown_0xd5f34476', _decode_unknown_0xd5f34476),
0x21296bdc: ('unknown_0x21296bdc', _decode_unknown_0x21296bdc),
0xcfacff53: ('spin_attack_damage', _decode_spin_attack_damage),
0xa61c2a66: ('sound_alerted', _decode_sound_alerted),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
0x24e23cc5: ('spin_attack_vulnerability', _decode_spin_attack_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SplitterMainChassisData.py | 0.555918 | 0.266685 | SplitterMainChassisData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScannableParameters(BaseProperty):
scannable_info0: AssetId = dataclasses.field(metadata={'asset_types': ['SCAN']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xb9N\x9b\xe7') # 0xb94e9be7
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.scannable_info0))
@classmethod
def from_json(cls, data: dict):
return cls(
scannable_info0=data['scannable_info0'],
)
def to_json(self) -> dict:
return {
'scannable_info0': self.scannable_info0,
}
def _dependencies_for_scannable_info0(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.scannable_info0)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_scannable_info0, "scannable_info0", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScannableParameters.{field_name} ({field_type}): {e}"
)
_FAST_FORMAT = None
_FAST_IDS = (0xb94e9be7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ScannableParameters]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return ScannableParameters(
dec[2],
)
def _decode_scannable_info0(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]]] = {
0xb94e9be7: ('scannable_info0', _decode_scannable_info0),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/ScannableParameters.py | 0.62223 | 0.261962 | ScannableParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct5(BaseProperty):
override: bool = dataclasses.field(default=False)
offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=1.0, z=1.0))
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x7f\xf8n\xe2') # 0x7ff86ee2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override))
data.write(b'FGpd') # 0x46477064
data.write(b'\x00\x0c') # size
self.offset.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
override=data['override'],
offset=Vector.from_json(data['offset']),
)
def to_json(self) -> dict:
return {
'override': self.override,
'offset': self.offset.to_json(),
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_override(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)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7ff86ee2: ('override', _decode_override),
0x46477064: ('offset', _decode_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct5.py | 0.671255 | 0.318949 | UnknownStruct5.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.UnknownStruct16 import UnknownStruct16
@dataclasses.dataclass()
class UnknownStruct17(BaseProperty):
unknown_0xb5af7831: float = dataclasses.field(default=-1.0)
unknown_0xac65eb7a: float = dataclasses.field(default=2.5)
unknown_0x4f3855a0: float = dataclasses.field(default=4.0)
unknown_0x08c0b02c: float = dataclasses.field(default=2.5)
unknown_0x695f68c7: float = dataclasses.field(default=4.0)
unknown_0xd061ff99: float = dataclasses.field(default=20.0)
pause_duration_min: float = dataclasses.field(default=1.5)
pause_duration_max: float = dataclasses.field(default=3.0)
chance_to_double_dash: float = dataclasses.field(default=0.0)
unknown_struct16: UnknownStruct16 = dataclasses.field(default_factory=UnknownStruct16)
unknown_0x3ff87a8c: bool = dataclasses.field(default=False)
unknown_0x49b9936d: bool = dataclasses.field(default=False)
unknown_0xc96b8223: bool = dataclasses.field(default=False)
unknown_0x53fdcb5b: bool = dataclasses.field(default=False)
unknown_0x0d7ef013: bool = dataclasses.field(default=False)
unknown_0xaa85c885: bool = dataclasses.field(default=False)
pause: float = dataclasses.field(default=0.0)
taunt: float = dataclasses.field(default=0.0)
look_around: bool = dataclasses.field(default=True)
melee_attack: float = dataclasses.field(default=0.0)
melee_dash: float = dataclasses.field(default=0.0)
scatter_shot: float = dataclasses.field(default=0.0)
unknown_0x94f48974: float = dataclasses.field(default=0.0)
dive_attack: float = dataclasses.field(default=0.0)
unknown_0xb2c1e4fa: bool = dataclasses.field(default=False)
unknown_0xf5cf3c0f: bool = dataclasses.field(default=True)
normal_missile: float = dataclasses.field(default=0.0)
missile_jump: float = dataclasses.field(default=0.0)
super_missile: float = dataclasses.field(default=0.0)
unknown_0xe63286eb: float = dataclasses.field(default=0.0)
unknown_0x4aae6186: float = dataclasses.field(default=0.0)
sweep_beam: float = dataclasses.field(default=0.0)
boost_ball: float = dataclasses.field(default=0.0)
unknown_0x2d7551e6: bool = dataclasses.field(default=False)
phazon_attack: float = dataclasses.field(default=0.0)
phazon_enrage: float = dataclasses.field(default=0.0)
unknown_0x911a2476: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00%') # 37 properties
data.write(b'\xb5\xafx1') # 0xb5af7831
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb5af7831))
data.write(b'\xace\xebz') # 0xac65eb7a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xac65eb7a))
data.write(b'O8U\xa0') # 0x4f3855a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4f3855a0))
data.write(b'\x08\xc0\xb0,') # 0x8c0b02c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x08c0b02c))
data.write(b'i_h\xc7') # 0x695f68c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x695f68c7))
data.write(b'\xd0a\xff\x99') # 0xd061ff99
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd061ff99))
data.write(b'\x97\xdb\xd4*') # 0x97dbd42a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause_duration_min))
data.write(b'q\xbb{\xcb') # 0x71bb7bcb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause_duration_max))
data.write(b'\xb7Qw\x8b') # 0xb751778b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chance_to_double_dash))
data.write(b'\xd6t\x03H') # 0xd6740348
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct16.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'?\xf8z\x8c') # 0x3ff87a8c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3ff87a8c))
data.write(b'I\xb9\x93m') # 0x49b9936d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x49b9936d))
data.write(b'\xc9k\x82#') # 0xc96b8223
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc96b8223))
data.write(b'S\xfd\xcb[') # 0x53fdcb5b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x53fdcb5b))
data.write(b'\r~\xf0\x13') # 0xd7ef013
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0d7ef013))
data.write(b'\xaa\x85\xc8\x85') # 0xaa85c885
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xaa85c885))
data.write(b'\x80\xf7\xe6\x05') # 0x80f7e605
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause))
data.write(b'G\x9fjO') # 0x479f6a4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt))
data.write(b'w\x87\x91\xf5') # 0x778791f5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.look_around))
data.write(b'\xceLFh') # 0xce4c4668
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.melee_attack))
data.write(b'YQ\xa0?') # 0x5951a03f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.melee_dash))
data.write(b'\x94aVQ') # 0x94615651
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scatter_shot))
data.write(b'\x94\xf4\x89t') # 0x94f48974
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x94f48974))
data.write(b'n@\xfbv') # 0x6e40fb76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dive_attack))
data.write(b'\xb2\xc1\xe4\xfa') # 0xb2c1e4fa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb2c1e4fa))
data.write(b'\xf5\xcf<\x0f') # 0xf5cf3c0f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf5cf3c0f))
data.write(b'hG\xef\xa7') # 0x6847efa7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_missile))
data.write(b'\x08?\xd6\x02') # 0x83fd602
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.missile_jump))
data.write(b'\xdb!@/') # 0xdb21402f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.super_missile))
data.write(b'\xe62\x86\xeb') # 0xe63286eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe63286eb))
data.write(b'J\xaea\x86') # 0x4aae6186
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4aae6186))
data.write(b'+\xd1\xc1[') # 0x2bd1c15b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.sweep_beam))
data.write(b'\xb56\x93\xfa') # 0xb53693fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_ball))
data.write(b'-uQ\xe6') # 0x2d7551e6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2d7551e6))
data.write(b'\x93\xa8v\xf3') # 0x93a876f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phazon_attack))
data.write(b'\xae\xa2(\xb9') # 0xaea228b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phazon_enrage))
data.write(b'\x91\x1a$v') # 0x911a2476
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x911a2476))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xb5af7831=data['unknown_0xb5af7831'],
unknown_0xac65eb7a=data['unknown_0xac65eb7a'],
unknown_0x4f3855a0=data['unknown_0x4f3855a0'],
unknown_0x08c0b02c=data['unknown_0x08c0b02c'],
unknown_0x695f68c7=data['unknown_0x695f68c7'],
unknown_0xd061ff99=data['unknown_0xd061ff99'],
pause_duration_min=data['pause_duration_min'],
pause_duration_max=data['pause_duration_max'],
chance_to_double_dash=data['chance_to_double_dash'],
unknown_struct16=UnknownStruct16.from_json(data['unknown_struct16']),
unknown_0x3ff87a8c=data['unknown_0x3ff87a8c'],
unknown_0x49b9936d=data['unknown_0x49b9936d'],
unknown_0xc96b8223=data['unknown_0xc96b8223'],
unknown_0x53fdcb5b=data['unknown_0x53fdcb5b'],
unknown_0x0d7ef013=data['unknown_0x0d7ef013'],
unknown_0xaa85c885=data['unknown_0xaa85c885'],
pause=data['pause'],
taunt=data['taunt'],
look_around=data['look_around'],
melee_attack=data['melee_attack'],
melee_dash=data['melee_dash'],
scatter_shot=data['scatter_shot'],
unknown_0x94f48974=data['unknown_0x94f48974'],
dive_attack=data['dive_attack'],
unknown_0xb2c1e4fa=data['unknown_0xb2c1e4fa'],
unknown_0xf5cf3c0f=data['unknown_0xf5cf3c0f'],
normal_missile=data['normal_missile'],
missile_jump=data['missile_jump'],
super_missile=data['super_missile'],
unknown_0xe63286eb=data['unknown_0xe63286eb'],
unknown_0x4aae6186=data['unknown_0x4aae6186'],
sweep_beam=data['sweep_beam'],
boost_ball=data['boost_ball'],
unknown_0x2d7551e6=data['unknown_0x2d7551e6'],
phazon_attack=data['phazon_attack'],
phazon_enrage=data['phazon_enrage'],
unknown_0x911a2476=data['unknown_0x911a2476'],
)
def to_json(self) -> dict:
return {
'unknown_0xb5af7831': self.unknown_0xb5af7831,
'unknown_0xac65eb7a': self.unknown_0xac65eb7a,
'unknown_0x4f3855a0': self.unknown_0x4f3855a0,
'unknown_0x08c0b02c': self.unknown_0x08c0b02c,
'unknown_0x695f68c7': self.unknown_0x695f68c7,
'unknown_0xd061ff99': self.unknown_0xd061ff99,
'pause_duration_min': self.pause_duration_min,
'pause_duration_max': self.pause_duration_max,
'chance_to_double_dash': self.chance_to_double_dash,
'unknown_struct16': self.unknown_struct16.to_json(),
'unknown_0x3ff87a8c': self.unknown_0x3ff87a8c,
'unknown_0x49b9936d': self.unknown_0x49b9936d,
'unknown_0xc96b8223': self.unknown_0xc96b8223,
'unknown_0x53fdcb5b': self.unknown_0x53fdcb5b,
'unknown_0x0d7ef013': self.unknown_0x0d7ef013,
'unknown_0xaa85c885': self.unknown_0xaa85c885,
'pause': self.pause,
'taunt': self.taunt,
'look_around': self.look_around,
'melee_attack': self.melee_attack,
'melee_dash': self.melee_dash,
'scatter_shot': self.scatter_shot,
'unknown_0x94f48974': self.unknown_0x94f48974,
'dive_attack': self.dive_attack,
'unknown_0xb2c1e4fa': self.unknown_0xb2c1e4fa,
'unknown_0xf5cf3c0f': self.unknown_0xf5cf3c0f,
'normal_missile': self.normal_missile,
'missile_jump': self.missile_jump,
'super_missile': self.super_missile,
'unknown_0xe63286eb': self.unknown_0xe63286eb,
'unknown_0x4aae6186': self.unknown_0x4aae6186,
'sweep_beam': self.sweep_beam,
'boost_ball': self.boost_ball,
'unknown_0x2d7551e6': self.unknown_0x2d7551e6,
'phazon_attack': self.phazon_attack,
'phazon_enrage': self.phazon_enrage,
'unknown_0x911a2476': self.unknown_0x911a2476,
}
def _dependencies_for_unknown_struct16(self, asset_manager):
yield from self.unknown_struct16.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unknown_struct16, "unknown_struct16", "UnknownStruct16"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct17.{field_name} ({field_type}): {e}"
)
def _decode_unknown_0xb5af7831(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xac65eb7a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4f3855a0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x08c0b02c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x695f68c7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd061ff99(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pause_duration_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pause_duration_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chance_to_double_dash(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct16(data: typing.BinaryIO, property_size: int):
return UnknownStruct16.from_stream(data, property_size)
def _decode_unknown_0x3ff87a8c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x49b9936d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xc96b8223(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x53fdcb5b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x0d7ef013(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xaa85c885(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_pause(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_taunt(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_around(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_melee_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_melee_dash(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scatter_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x94f48974(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dive_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb2c1e4fa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf5cf3c0f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_normal_missile(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_missile_jump(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_super_missile(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe63286eb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4aae6186(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sweep_beam(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_ball(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2d7551e6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_phazon_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phazon_enrage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x911a2476(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]]] = {
0xb5af7831: ('unknown_0xb5af7831', _decode_unknown_0xb5af7831),
0xac65eb7a: ('unknown_0xac65eb7a', _decode_unknown_0xac65eb7a),
0x4f3855a0: ('unknown_0x4f3855a0', _decode_unknown_0x4f3855a0),
0x8c0b02c: ('unknown_0x08c0b02c', _decode_unknown_0x08c0b02c),
0x695f68c7: ('unknown_0x695f68c7', _decode_unknown_0x695f68c7),
0xd061ff99: ('unknown_0xd061ff99', _decode_unknown_0xd061ff99),
0x97dbd42a: ('pause_duration_min', _decode_pause_duration_min),
0x71bb7bcb: ('pause_duration_max', _decode_pause_duration_max),
0xb751778b: ('chance_to_double_dash', _decode_chance_to_double_dash),
0xd6740348: ('unknown_struct16', _decode_unknown_struct16),
0x3ff87a8c: ('unknown_0x3ff87a8c', _decode_unknown_0x3ff87a8c),
0x49b9936d: ('unknown_0x49b9936d', _decode_unknown_0x49b9936d),
0xc96b8223: ('unknown_0xc96b8223', _decode_unknown_0xc96b8223),
0x53fdcb5b: ('unknown_0x53fdcb5b', _decode_unknown_0x53fdcb5b),
0xd7ef013: ('unknown_0x0d7ef013', _decode_unknown_0x0d7ef013),
0xaa85c885: ('unknown_0xaa85c885', _decode_unknown_0xaa85c885),
0x80f7e605: ('pause', _decode_pause),
0x479f6a4f: ('taunt', _decode_taunt),
0x778791f5: ('look_around', _decode_look_around),
0xce4c4668: ('melee_attack', _decode_melee_attack),
0x5951a03f: ('melee_dash', _decode_melee_dash),
0x94615651: ('scatter_shot', _decode_scatter_shot),
0x94f48974: ('unknown_0x94f48974', _decode_unknown_0x94f48974),
0x6e40fb76: ('dive_attack', _decode_dive_attack),
0xb2c1e4fa: ('unknown_0xb2c1e4fa', _decode_unknown_0xb2c1e4fa),
0xf5cf3c0f: ('unknown_0xf5cf3c0f', _decode_unknown_0xf5cf3c0f),
0x6847efa7: ('normal_missile', _decode_normal_missile),
0x83fd602: ('missile_jump', _decode_missile_jump),
0xdb21402f: ('super_missile', _decode_super_missile),
0xe63286eb: ('unknown_0xe63286eb', _decode_unknown_0xe63286eb),
0x4aae6186: ('unknown_0x4aae6186', _decode_unknown_0x4aae6186),
0x2bd1c15b: ('sweep_beam', _decode_sweep_beam),
0xb53693fa: ('boost_ball', _decode_boost_ball),
0x2d7551e6: ('unknown_0x2d7551e6', _decode_unknown_0x2d7551e6),
0x93a876f3: ('phazon_attack', _decode_phazon_attack),
0xaea228b9: ('phazon_enrage', _decode_phazon_enrage),
0x911a2476: ('unknown_0x911a2476', _decode_unknown_0x911a2476),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct17.py | 0.589126 | 0.200225 | UnknownStruct17.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct42(BaseProperty):
angle: float = dataclasses.field(default=20.0)
cloud_color1: Color = dataclasses.field(default_factory=lambda: Color(r=0.24705900251865387, g=0.0, b=0.0, a=0.0))
cloud_color2: Color = dataclasses.field(default_factory=lambda: Color(r=0.49803900718688965, g=0.09803900122642517, b=0.09803900122642517, a=0.0))
add_color1: Color = dataclasses.field(default_factory=lambda: Color(r=0.34902000427246094, g=0.0, b=0.0, a=0.0))
add_color2: Color = dataclasses.field(default_factory=lambda: Color(r=0.1490200012922287, g=0.0, b=0.0, a=0.0))
cloud_scale: float = dataclasses.field(default=10.0)
fade_off_size: float = dataclasses.field(default=5.0)
open_speed: float = dataclasses.field(default=4.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'8*\x19s') # 0x382a1973
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angle))
data.write(b'LA\xdc\xd4') # 0x4c41dcd4
data.write(b'\x00\x10') # size
self.cloud_color1.to_stream(data)
data.write(b'\xca\xd5\xaez') # 0xcad5ae7a
data.write(b'\x00\x10') # size
self.cloud_color2.to_stream(data)
data.write(b'\x1eR\x12N') # 0x1e52124e
data.write(b'\x00\x10') # size
self.add_color1.to_stream(data)
data.write(b'\x98\xc6`\xe0') # 0x98c660e0
data.write(b'\x00\x10') # size
self.add_color2.to_stream(data)
data.write(b'\x10\xc1\xde\xd2') # 0x10c1ded2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cloud_scale))
data.write(b'\xaeq\xa2*') # 0xae71a22a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_off_size))
data.write(b'N)\xc8Z') # 0x4e29c85a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.open_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
angle=data['angle'],
cloud_color1=Color.from_json(data['cloud_color1']),
cloud_color2=Color.from_json(data['cloud_color2']),
add_color1=Color.from_json(data['add_color1']),
add_color2=Color.from_json(data['add_color2']),
cloud_scale=data['cloud_scale'],
fade_off_size=data['fade_off_size'],
open_speed=data['open_speed'],
)
def to_json(self) -> dict:
return {
'angle': self.angle,
'cloud_color1': self.cloud_color1.to_json(),
'cloud_color2': self.cloud_color2.to_json(),
'add_color1': self.add_color1.to_json(),
'add_color2': self.add_color2.to_json(),
'cloud_scale': self.cloud_scale,
'fade_off_size': self.fade_off_size,
'open_speed': self.open_speed,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cloud_color1(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_cloud_color2(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_add_color1(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_add_color2(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_cloud_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_off_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_open_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]]] = {
0x382a1973: ('angle', _decode_angle),
0x4c41dcd4: ('cloud_color1', _decode_cloud_color1),
0xcad5ae7a: ('cloud_color2', _decode_cloud_color2),
0x1e52124e: ('add_color1', _decode_add_color1),
0x98c660e0: ('add_color2', _decode_add_color2),
0x10c1ded2: ('cloud_scale', _decode_cloud_scale),
0xae71a22a: ('fade_off_size', _decode_fade_off_size),
0x4e29c85a: ('open_speed', _decode_open_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct42.py | 0.719679 | 0.243941 | UnknownStruct42.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanInfoSecondaryModel(BaseProperty):
secondary_static_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
secondary_animated_model: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
secondary_model_locator: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x1fy!\xbc') # 0x1f7921bc
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.secondary_static_model))
data.write(b'\xcd\xd2\x02\xd1') # 0xcdd202d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_animated_model.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'>\xa2\xbe\xd8') # 0x3ea2bed8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.secondary_model_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
secondary_static_model=data['secondary_static_model'],
secondary_animated_model=AnimationParameters.from_json(data['secondary_animated_model']),
secondary_model_locator=data['secondary_model_locator'],
)
def to_json(self) -> dict:
return {
'secondary_static_model': self.secondary_static_model,
'secondary_animated_model': self.secondary_animated_model.to_json(),
'secondary_model_locator': self.secondary_model_locator,
}
def _dependencies_for_secondary_static_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.secondary_static_model)
def _dependencies_for_secondary_animated_model(self, asset_manager):
yield from self.secondary_animated_model.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_secondary_static_model, "secondary_static_model", "AssetId"),
(self._dependencies_for_secondary_animated_model, "secondary_animated_model", "AnimationParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScanInfoSecondaryModel.{field_name} ({field_type}): {e}"
)
def _decode_secondary_static_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_secondary_animated_model(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_secondary_model_locator(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]]] = {
0x1f7921bc: ('secondary_static_model', _decode_secondary_static_model),
0xcdd202d1: ('secondary_animated_model', _decode_secondary_animated_model),
0x3ea2bed8: ('secondary_model_locator', _decode_secondary_model_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/ScanInfoSecondaryModel.py | 0.608478 | 0.207074 | ScanInfoSecondaryModel.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MysteryFlyerData(BaseProperty):
shot_projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
shot_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
hover_speed: float = dataclasses.field(default=10.0)
hover_height: float = dataclasses.field(default=2.0)
separation_distance: float = dataclasses.field(default=5.0)
unknown: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'Q%;\xa3') # 0x51253ba3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shot_projectile))
data.write(b'\xce\xa3\x018') # 0xcea30138
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'\x84^\xf4\x89') # 0x845ef489
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_speed))
data.write(b'\xc7Y\x98\xaa') # 0xc75998aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_height))
data.write(b"\x01U\x9f'") # 0x1559f27
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_distance))
data.write(b'_?\xff\xd6') # 0x5f3fffd6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
shot_projectile=data['shot_projectile'],
shot_damage=DamageInfo.from_json(data['shot_damage']),
hover_speed=data['hover_speed'],
hover_height=data['hover_height'],
separation_distance=data['separation_distance'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'shot_projectile': self.shot_projectile,
'shot_damage': self.shot_damage.to_json(),
'hover_speed': self.hover_speed,
'hover_height': self.hover_height,
'separation_distance': self.separation_distance,
'unknown': self.unknown,
}
def _dependencies_for_shot_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shot_projectile)
def _dependencies_for_shot_damage(self, asset_manager):
yield from self.shot_damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_shot_projectile, "shot_projectile", "AssetId"),
(self._dependencies_for_shot_damage, "shot_damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MysteryFlyerData.{field_name} ({field_type}): {e}"
)
def _decode_shot_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_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_hover_speed(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_separation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x51253ba3: ('shot_projectile', _decode_shot_projectile),
0xcea30138: ('shot_damage', _decode_shot_damage),
0x845ef489: ('hover_speed', _decode_hover_speed),
0xc75998aa: ('hover_height', _decode_hover_height),
0x1559f27: ('separation_distance', _decode_separation_distance),
0x5f3fffd6: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/MysteryFlyerData.py | 0.59561 | 0.240864 | MysteryFlyerData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class GuiWidgetProperties(BaseProperty):
gui_label: str = dataclasses.field(default='')
controller_number: int = dataclasses.field(default=1)
is_locked: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b's\x93\x94\x07') # 0x73939407
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.gui_label.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'\xdb\x7fJ\xa2') # 0xdb7f4aa2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.controller_number))
data.write(b'\xde\xe70\xf5') # 0xdee730f5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_locked))
@classmethod
def from_json(cls, data: dict):
return cls(
gui_label=data['gui_label'],
controller_number=data['controller_number'],
is_locked=data['is_locked'],
)
def to_json(self) -> dict:
return {
'gui_label': self.gui_label,
'controller_number': self.controller_number,
'is_locked': self.is_locked,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_gui_label(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_controller_number(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_locked(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]]] = {
0x73939407: ('gui_label', _decode_gui_label),
0xdb7f4aa2: ('controller_number', _decode_controller_number),
0xdee730f5: ('is_locked', _decode_is_locked),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/GuiWidgetProperties.py | 0.591959 | 0.294678 | GuiWidgetProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.echoes as enums
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class LightParameters(BaseProperty):
cast_shadow: bool = dataclasses.field(default=True)
shadow_scale: float = dataclasses.field(default=1.0)
unknown_0xecda4163: int = dataclasses.field(default=0)
shadow_alpha: float = dataclasses.field(default=1.0)
max_shadow_height: float = dataclasses.field(default=20.0)
ambient_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
unknown_0xa71810e9: bool = dataclasses.field(default=True)
world_lighting_options: enums.WorldLightingOptions = dataclasses.field(default=enums.WorldLightingOptions.NormalWorldLighting)
light_recalculation: int = dataclasses.field(default=1) # Choice
lighting_position_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
num_dynamic_lights: int = dataclasses.field(default=4)
num_area_lights: int = dataclasses.field(default=4)
use_old_lighting: bool = dataclasses.field(default=False)
ignore_ambient_lighting: bool = dataclasses.field(default=False)
use_light_set: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\xcdc\x9bF') # 0xcd639b46
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.cast_shadow))
data.write(b'\x1d\x01\x1a9') # 0x1d011a39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_scale))
data.write(b'\xec\xdaAc') # 0xecda4163
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xecda4163))
data.write(b'>,\xd3\x8d') # 0x3e2cd38d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_alpha))
data.write(b'\x03(\xe3\x1b') # 0x328e31b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_shadow_height))
data.write(b'\xa3>[\x0e') # 0xa33e5b0e
data.write(b'\x00\x10') # size
self.ambient_color.to_stream(data)
data.write(b'\xa7\x18\x10\xe9') # 0xa71810e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa71810e9))
data.write(b'k^u\t') # 0x6b5e7509
data.write(b'\x00\x04') # size
self.world_lighting_options.to_stream(data)
data.write(b'b\x8ej\xc3') # 0x628e6ac3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.light_recalculation))
data.write(b'\xd1\x9d\xe7u') # 0xd19de775
data.write(b'\x00\x0c') # size
self.lighting_position_offset.to_stream(data)
data.write(b'\xca\xc1\xe7x') # 0xcac1e778
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_dynamic_lights))
data.write(b'g\xf4\xd3\xde') # 0x67f4d3de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_area_lights))
data.write(b'\xfbzz\xbb') # 0xfb7a7abb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_old_lighting))
data.write(b'a\xa9@\xd6') # 0x61a940d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_ambient_lighting))
data.write(b'\x1fq_\xd3') # 0x1f715fd3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.use_light_set))
@classmethod
def from_json(cls, data: dict):
return cls(
cast_shadow=data['cast_shadow'],
shadow_scale=data['shadow_scale'],
unknown_0xecda4163=data['unknown_0xecda4163'],
shadow_alpha=data['shadow_alpha'],
max_shadow_height=data['max_shadow_height'],
ambient_color=Color.from_json(data['ambient_color']),
unknown_0xa71810e9=data['unknown_0xa71810e9'],
world_lighting_options=enums.WorldLightingOptions.from_json(data['world_lighting_options']),
light_recalculation=data['light_recalculation'],
lighting_position_offset=Vector.from_json(data['lighting_position_offset']),
num_dynamic_lights=data['num_dynamic_lights'],
num_area_lights=data['num_area_lights'],
use_old_lighting=data['use_old_lighting'],
ignore_ambient_lighting=data['ignore_ambient_lighting'],
use_light_set=data['use_light_set'],
)
def to_json(self) -> dict:
return {
'cast_shadow': self.cast_shadow,
'shadow_scale': self.shadow_scale,
'unknown_0xecda4163': self.unknown_0xecda4163,
'shadow_alpha': self.shadow_alpha,
'max_shadow_height': self.max_shadow_height,
'ambient_color': self.ambient_color.to_json(),
'unknown_0xa71810e9': self.unknown_0xa71810e9,
'world_lighting_options': self.world_lighting_options.to_json(),
'light_recalculation': self.light_recalculation,
'lighting_position_offset': self.lighting_position_offset.to_json(),
'num_dynamic_lights': self.num_dynamic_lights,
'num_area_lights': self.num_area_lights,
'use_old_lighting': self.use_old_lighting,
'ignore_ambient_lighting': self.ignore_ambient_lighting,
'use_light_set': self.use_light_set,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_cast_shadow(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_shadow_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xecda4163(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_shadow_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_shadow_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0xa71810e9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_world_lighting_options(data: typing.BinaryIO, property_size: int):
return enums.WorldLightingOptions.from_stream(data)
def _decode_light_recalculation(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_lighting_position_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_num_dynamic_lights(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_num_area_lights(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_use_old_lighting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_ambient_lighting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_light_set(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]]] = {
0xcd639b46: ('cast_shadow', _decode_cast_shadow),
0x1d011a39: ('shadow_scale', _decode_shadow_scale),
0xecda4163: ('unknown_0xecda4163', _decode_unknown_0xecda4163),
0x3e2cd38d: ('shadow_alpha', _decode_shadow_alpha),
0x328e31b: ('max_shadow_height', _decode_max_shadow_height),
0xa33e5b0e: ('ambient_color', _decode_ambient_color),
0xa71810e9: ('unknown_0xa71810e9', _decode_unknown_0xa71810e9),
0x6b5e7509: ('world_lighting_options', _decode_world_lighting_options),
0x628e6ac3: ('light_recalculation', _decode_light_recalculation),
0xd19de775: ('lighting_position_offset', _decode_lighting_position_offset),
0xcac1e778: ('num_dynamic_lights', _decode_num_dynamic_lights),
0x67f4d3de: ('num_area_lights', _decode_num_area_lights),
0xfb7a7abb: ('use_old_lighting', _decode_use_old_lighting),
0x61a940d6: ('ignore_ambient_lighting', _decode_ignore_ambient_lighting),
0x1f715fd3: ('use_light_set', _decode_use_light_set),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/LightParameters.py | 0.636014 | 0.270601 | LightParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.ShockWaveInfo import ShockWaveInfo
@dataclasses.dataclass()
class UnknownStruct23(BaseProperty):
loop_duration: float = dataclasses.field(default=0.0)
destroy_percentage: int = dataclasses.field(default=0)
shock_wave_info: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xce\xe6\x87#') # 0xcee68723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.loop_duration))
data.write(b"\x01'Mn") # 0x1274d6e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.destroy_percentage))
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)
data.write(b'%\xafI\x0e') # 0x25af490e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
@classmethod
def from_json(cls, data: dict):
return cls(
loop_duration=data['loop_duration'],
destroy_percentage=data['destroy_percentage'],
shock_wave_info=ShockWaveInfo.from_json(data['shock_wave_info']),
sound=data['sound'],
)
def to_json(self) -> dict:
return {
'loop_duration': self.loop_duration,
'destroy_percentage': self.destroy_percentage,
'shock_wave_info': self.shock_wave_info.to_json(),
'sound': self.sound,
}
def _dependencies_for_shock_wave_info(self, asset_manager):
yield from self.shock_wave_info.dependencies_for(asset_manager)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_shock_wave_info, "shock_wave_info", "ShockWaveInfo"),
(self._dependencies_for_sound, "sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct23.{field_name} ({field_type}): {e}"
)
def _decode_loop_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_destroy_percentage(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)
def _decode_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]]] = {
0xcee68723: ('loop_duration', _decode_loop_duration),
0x1274d6e: ('destroy_percentage', _decode_destroy_percentage),
0x8f4787cb: ('shock_wave_info', _decode_shock_wave_info),
0x25af490e: ('sound', _decode_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct23.py | 0.597256 | 0.260019 | UnknownStruct23.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
@dataclasses.dataclass()
class UnknownStruct39(BaseProperty):
start_state: int = dataclasses.field(default=10)
explosion_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
min_height: float = dataclasses.field(default=4.0)
max_height: float = dataclasses.field(default=4.0)
min_down_height: float = dataclasses.field(default=4.0)
max_down_height: float = dataclasses.field(default=4.0)
separation_distance: float = dataclasses.field(default=5.0)
min_life_time: float = dataclasses.field(default=14.0)
max_life_time: float = dataclasses.field(default=16.0)
normal_knockback: float = dataclasses.field(default=20.0)
heavy_knockback: float = dataclasses.field(default=40.0)
knockback_decline: float = dataclasses.field(default=100.0)
is_dark_shredder: bool = dataclasses.field(default=False)
desired_distance: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0e') # 14 properties
data.write(b'F\xd8f\xd1') # 0x46d866d1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.start_state))
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'\xc6\xc4#,') # 0xc6c4232c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_height))
data.write(b'\x7f\xe2\xb8]') # 0x7fe2b85d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_height))
data.write(b'\x10\xbe\x8a\xd3') # 0x10be8ad3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_down_height))
data.write(b'C\x18\x927') # 0x43189237
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_down_height))
data.write(b"\x01U\x9f'") # 0x1559f27
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_distance))
data.write(b'\x07\xdc\xd4\x04') # 0x7dcd404
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_life_time))
data.write(b'V%oY') # 0x56256f59
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_life_time))
data.write(b'0a\x97l') # 0x3061976c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_knockback))
data.write(b'\x93\xa8\n\xa2') # 0x93a80aa2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.heavy_knockback))
data.write(b'Lk$!') # 0x4c6b2421
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.knockback_decline))
data.write(b'\xcf\xf9\x97\x1b') # 0xcff9971b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_dark_shredder))
data.write(b'`\xbe5\xa1') # 0x60be35a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.desired_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
start_state=data['start_state'],
explosion_damage=DamageInfo.from_json(data['explosion_damage']),
min_height=data['min_height'],
max_height=data['max_height'],
min_down_height=data['min_down_height'],
max_down_height=data['max_down_height'],
separation_distance=data['separation_distance'],
min_life_time=data['min_life_time'],
max_life_time=data['max_life_time'],
normal_knockback=data['normal_knockback'],
heavy_knockback=data['heavy_knockback'],
knockback_decline=data['knockback_decline'],
is_dark_shredder=data['is_dark_shredder'],
desired_distance=data['desired_distance'],
)
def to_json(self) -> dict:
return {
'start_state': self.start_state,
'explosion_damage': self.explosion_damage.to_json(),
'min_height': self.min_height,
'max_height': self.max_height,
'min_down_height': self.min_down_height,
'max_down_height': self.max_down_height,
'separation_distance': self.separation_distance,
'min_life_time': self.min_life_time,
'max_life_time': self.max_life_time,
'normal_knockback': self.normal_knockback,
'heavy_knockback': self.heavy_knockback,
'knockback_decline': self.knockback_decline,
'is_dark_shredder': self.is_dark_shredder,
'desired_distance': self.desired_distance,
}
def _dependencies_for_explosion_damage(self, asset_manager):
yield from self.explosion_damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_explosion_damage, "explosion_damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct39.{field_name} ({field_type}): {e}"
)
def _decode_start_state(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_explosion_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_min_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_down_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_down_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_separation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_normal_knockback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_heavy_knockback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_knockback_decline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_dark_shredder(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_desired_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]]] = {
0x46d866d1: ('start_state', _decode_start_state),
0xdeff74ea: ('explosion_damage', _decode_explosion_damage),
0xc6c4232c: ('min_height', _decode_min_height),
0x7fe2b85d: ('max_height', _decode_max_height),
0x10be8ad3: ('min_down_height', _decode_min_down_height),
0x43189237: ('max_down_height', _decode_max_down_height),
0x1559f27: ('separation_distance', _decode_separation_distance),
0x7dcd404: ('min_life_time', _decode_min_life_time),
0x56256f59: ('max_life_time', _decode_max_life_time),
0x3061976c: ('normal_knockback', _decode_normal_knockback),
0x93a80aa2: ('heavy_knockback', _decode_heavy_knockback),
0x4c6b2421: ('knockback_decline', _decode_knockback_decline),
0xcff9971b: ('is_dark_shredder', _decode_is_dark_shredder),
0x60be35a1: ('desired_distance', _decode_desired_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct39.py | 0.594316 | 0.234927 | UnknownStruct39.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class FlareDef(BaseProperty):
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
position: float = dataclasses.field(default=0.0)
scale: float = dataclasses.field(default=0.0)
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
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.texture))
data.write(b'\xcb\x99\xb4\xda') # 0xcb99b4da
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.position))
data.write(b',Q\xa6v') # 0x2c51a676
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scale))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
texture=data['texture'],
position=data['position'],
scale=data['scale'],
color=Color.from_json(data['color']),
)
def to_json(self) -> dict:
return {
'texture': self.texture,
'position': self.position,
'scale': self.scale,
'color': self.color.to_json(),
}
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_texture, "texture", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FlareDef.{field_name} ({field_type}): {e}"
)
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_position(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scale(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)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd1f65872: ('texture', _decode_texture),
0xcb99b4da: ('position', _decode_position),
0x2c51a676: ('scale', _decode_scale),
0x37c7d09d: ('color', _decode_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/FlareDef.py | 0.683314 | 0.25582 | FlareDef.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SplineType(BaseProperty):
type: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
@classmethod
def from_json(cls, data: dict):
return cls(
type=data['type'],
)
def to_json(self) -> dict:
return {
'type': self.type,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xf53dcdd6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SplineType]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return SplineType(
dec[2],
)
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]]] = {
0xf53dcdd6: ('type', _decode_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SplineType.py | 0.608478 | 0.295779 | SplineType.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct10(BaseProperty):
grenade_min_attack_interval: float = dataclasses.field(default=10.0)
unknown_0xb7994ea1: float = dataclasses.field(default=0.25)
grenade_attack_chance: float = dataclasses.field(default=80.0)
unknown_0x25f822c4: float = dataclasses.field(default=15.0)
unknown_0x765e3a20: float = dataclasses.field(default=50.0)
grenade_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=25.0)
unknown_0xed086ce0: float = dataclasses.field(default=0.4000000059604645)
unknown_0x00fc6646: float = dataclasses.field(default=20.0)
unknown_0xa7c8e63f: float = dataclasses.field(default=50.0)
unknown_0x454f16b1: int = dataclasses.field(default=0)
unknown_0x2d4706e8: float = dataclasses.field(default=8.0)
sound_grenade_bounce: int = dataclasses.field(default=0, metadata={'sound': True})
sound_grenade_explode: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x11') # 17 properties
data.write(b'tG\x9b\x13') # 0x74479b13
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_min_attack_interval))
data.write(b'\xb7\x99N\xa1') # 0xb7994ea1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb7994ea1))
data.write(b'\x9a\x86\xecM') # 0x9a86ec4d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_attack_chance))
data.write(b'%\xf8"\xc4') # 0x25f822c4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x25f822c4))
data.write(b'v^: ') # 0x765e3a20
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x765e3a20))
data.write(b'\x14\xd1\xa3\xa8') # 0x14d1a3a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grenade_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 50.0, 'di_radius': 10.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\x00\xfcfF') # 0xfc6646
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x00fc6646))
data.write(b'\xa7\xc8\xe6?') # 0xa7c8e63f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa7c8e63f))
data.write(b'EO\x16\xb1') # 0x454f16b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x454f16b1))
data.write(b'-G\x06\xe8') # 0x2d4706e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2d4706e8))
data.write(b'%\x8c>\x1b') # 0x258c3e1b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_grenade_bounce))
data.write(b'\xafj\xad\x88') # 0xaf6aad88
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_grenade_explode))
@classmethod
def from_json(cls, data: dict):
return cls(
grenade_min_attack_interval=data['grenade_min_attack_interval'],
unknown_0xb7994ea1=data['unknown_0xb7994ea1'],
grenade_attack_chance=data['grenade_attack_chance'],
unknown_0x25f822c4=data['unknown_0x25f822c4'],
unknown_0x765e3a20=data['unknown_0x765e3a20'],
grenade_damage=DamageInfo.from_json(data['grenade_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_0x00fc6646=data['unknown_0x00fc6646'],
unknown_0xa7c8e63f=data['unknown_0xa7c8e63f'],
unknown_0x454f16b1=data['unknown_0x454f16b1'],
unknown_0x2d4706e8=data['unknown_0x2d4706e8'],
sound_grenade_bounce=data['sound_grenade_bounce'],
sound_grenade_explode=data['sound_grenade_explode'],
)
def to_json(self) -> dict:
return {
'grenade_min_attack_interval': self.grenade_min_attack_interval,
'unknown_0xb7994ea1': self.unknown_0xb7994ea1,
'grenade_attack_chance': self.grenade_attack_chance,
'unknown_0x25f822c4': self.unknown_0x25f822c4,
'unknown_0x765e3a20': self.unknown_0x765e3a20,
'grenade_damage': self.grenade_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_0x00fc6646': self.unknown_0x00fc6646,
'unknown_0xa7c8e63f': self.unknown_0xa7c8e63f,
'unknown_0x454f16b1': self.unknown_0x454f16b1,
'unknown_0x2d4706e8': self.unknown_0x2d4706e8,
'sound_grenade_bounce': self.sound_grenade_bounce,
'sound_grenade_explode': self.sound_grenade_explode,
}
def _dependencies_for_grenade_damage(self, asset_manager):
yield from self.grenade_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_sound_grenade_bounce(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_grenade_bounce)
def _dependencies_for_sound_grenade_explode(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_grenade_explode)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_grenade_damage, "grenade_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_sound_grenade_bounce, "sound_grenade_bounce", "int"),
(self._dependencies_for_sound_grenade_explode, "sound_grenade_explode", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct10.{field_name} ({field_type}): {e}"
)
def _decode_grenade_min_attack_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb7994ea1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_attack_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x25f822c4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x765e3a20(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 50.0, 'di_radius': 10.0, 'di_knock_back_power': 10.0})
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_0x00fc6646(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa7c8e63f(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_0x2d4706e8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_grenade_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_grenade_explode(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]]] = {
0x74479b13: ('grenade_min_attack_interval', _decode_grenade_min_attack_interval),
0xb7994ea1: ('unknown_0xb7994ea1', _decode_unknown_0xb7994ea1),
0x9a86ec4d: ('grenade_attack_chance', _decode_grenade_attack_chance),
0x25f822c4: ('unknown_0x25f822c4', _decode_unknown_0x25f822c4),
0x765e3a20: ('unknown_0x765e3a20', _decode_unknown_0x765e3a20),
0x14d1a3a8: ('grenade_damage', _decode_grenade_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),
0xfc6646: ('unknown_0x00fc6646', _decode_unknown_0x00fc6646),
0xa7c8e63f: ('unknown_0xa7c8e63f', _decode_unknown_0xa7c8e63f),
0x454f16b1: ('unknown_0x454f16b1', _decode_unknown_0x454f16b1),
0x2d4706e8: ('unknown_0x2d4706e8', _decode_unknown_0x2d4706e8),
0x258c3e1b: ('sound_grenade_bounce', _decode_sound_grenade_bounce),
0xaf6aad88: ('sound_grenade_explode', _decode_sound_grenade_explode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct10.py | 0.540196 | 0.214794 | UnknownStruct10.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
@dataclasses.dataclass()
class UnknownStruct20(BaseProperty):
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
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)
@classmethod
def from_json(cls, data: dict):
return cls(
damage=DamageInfo.from_json(data['damage']),
)
def to_json(self) -> dict:
return {
'damage': self.damage.to_json(),
}
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_damage, "damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct20.{field_name} ({field_type}): {e}"
)
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]]] = {
0x337f9524: ('damage', _decode_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct20.py | 0.591015 | 0.279766 | UnknownStruct20.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct13(BaseProperty):
unknown: float = dataclasses.field(default=2.0)
min_attack_range: float = dataclasses.field(default=10.0)
max_attack_range: float = dataclasses.field(default=35.0)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
mold_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
mold_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_mold: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\xd2X\xec\t') # 0xd258ec09
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'XCI\x16') # 0x58434916
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attack_range))
data.write(b'\xffw\xc9o') # 0xff77c96f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_range))
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 40.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile))
data.write(b'Yy\xd9\xe1') # 0x5979d9e1
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mold_effect))
data.write(b'\x80t..') # 0x80742e2e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mold_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 0.08332999795675278})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5\xcf\xb8\xaf') # 0xf5cfb8af
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_mold.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
min_attack_range=data['min_attack_range'],
max_attack_range=data['max_attack_range'],
damage=DamageInfo.from_json(data['damage']),
projectile=data['projectile'],
mold_effect=data['mold_effect'],
mold_damage=DamageInfo.from_json(data['mold_damage']),
sound_mold=AudioPlaybackParms.from_json(data['sound_mold']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'min_attack_range': self.min_attack_range,
'max_attack_range': self.max_attack_range,
'damage': self.damage.to_json(),
'projectile': self.projectile,
'mold_effect': self.mold_effect,
'mold_damage': self.mold_damage.to_json(),
'sound_mold': self.sound_mold.to_json(),
}
def _dependencies_for_damage(self, asset_manager):
yield from self.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_mold_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.mold_effect)
def _dependencies_for_mold_damage(self, asset_manager):
yield from self.mold_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_mold(self, asset_manager):
yield from self.sound_mold.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_mold_effect, "mold_effect", "AssetId"),
(self._dependencies_for_mold_damage, "mold_damage", "DamageInfo"),
(self._dependencies_for_sound_mold, "sound_mold", "AudioPlaybackParms"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct13.{field_name} ({field_type}): {e}"
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 40.0, 'di_knock_back_power': 10.0})
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_mold_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_mold_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 0.08332999795675278})
def _decode_sound_mold(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd258ec09: ('unknown', _decode_unknown),
0x58434916: ('min_attack_range', _decode_min_attack_range),
0xff77c96f: ('max_attack_range', _decode_max_attack_range),
0x337f9524: ('damage', _decode_damage),
0xef485db9: ('projectile', _decode_projectile),
0x5979d9e1: ('mold_effect', _decode_mold_effect),
0x80742e2e: ('mold_damage', _decode_mold_damage),
0xf5cfb8af: ('sound_mold', _decode_sound_mold),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct13.py | 0.537041 | 0.200088 | UnknownStruct13.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PowerBombGuardianStageProperties(BaseProperty):
unknown_0x95e7a2c2: float = dataclasses.field(default=2.0)
unknown_0x76ba1c18: float = dataclasses.field(default=2.0)
unknown_0x3eb2de35: float = dataclasses.field(default=1.0)
unknown_0xe50d8dd2: float = dataclasses.field(default=1.0)
unknown_0x64d482d5: int = dataclasses.field(default=1)
unknown_0xc3e002ac: int = dataclasses.field(default=1)
unknown_0xbb4b6680: float = dataclasses.field(default=1.0)
unknown_0xd356c997: float = dataclasses.field(default=1.0)
double_shot_chance: float = dataclasses.field(default=0.5)
unknown_0x87cc8ba4: int = dataclasses.field(default=10)
unknown_0x6491357e: int = dataclasses.field(default=10)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\x95\xe7\xa2\xc2') # 0x95e7a2c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x95e7a2c2))
data.write(b'v\xba\x1c\x18') # 0x76ba1c18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76ba1c18))
data.write(b'>\xb2\xde5') # 0x3eb2de35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3eb2de35))
data.write(b'\xe5\r\x8d\xd2') # 0xe50d8dd2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe50d8dd2))
data.write(b'd\xd4\x82\xd5') # 0x64d482d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x64d482d5))
data.write(b'\xc3\xe0\x02\xac') # 0xc3e002ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc3e002ac))
data.write(b'\xbbKf\x80') # 0xbb4b6680
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbb4b6680))
data.write(b'\xd3V\xc9\x97') # 0xd356c997
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd356c997))
data.write(b'\xcaj\xc4:') # 0xca6ac43a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.double_shot_chance))
data.write(b'\x87\xcc\x8b\xa4') # 0x87cc8ba4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x87cc8ba4))
data.write(b'd\x915~') # 0x6491357e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6491357e))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x95e7a2c2=data['unknown_0x95e7a2c2'],
unknown_0x76ba1c18=data['unknown_0x76ba1c18'],
unknown_0x3eb2de35=data['unknown_0x3eb2de35'],
unknown_0xe50d8dd2=data['unknown_0xe50d8dd2'],
unknown_0x64d482d5=data['unknown_0x64d482d5'],
unknown_0xc3e002ac=data['unknown_0xc3e002ac'],
unknown_0xbb4b6680=data['unknown_0xbb4b6680'],
unknown_0xd356c997=data['unknown_0xd356c997'],
double_shot_chance=data['double_shot_chance'],
unknown_0x87cc8ba4=data['unknown_0x87cc8ba4'],
unknown_0x6491357e=data['unknown_0x6491357e'],
)
def to_json(self) -> dict:
return {
'unknown_0x95e7a2c2': self.unknown_0x95e7a2c2,
'unknown_0x76ba1c18': self.unknown_0x76ba1c18,
'unknown_0x3eb2de35': self.unknown_0x3eb2de35,
'unknown_0xe50d8dd2': self.unknown_0xe50d8dd2,
'unknown_0x64d482d5': self.unknown_0x64d482d5,
'unknown_0xc3e002ac': self.unknown_0xc3e002ac,
'unknown_0xbb4b6680': self.unknown_0xbb4b6680,
'unknown_0xd356c997': self.unknown_0xd356c997,
'double_shot_chance': self.double_shot_chance,
'unknown_0x87cc8ba4': self.unknown_0x87cc8ba4,
'unknown_0x6491357e': self.unknown_0x6491357e,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x95e7a2c2, 0x76ba1c18, 0x3eb2de35, 0xe50d8dd2, 0x64d482d5, 0xc3e002ac, 0xbb4b6680, 0xd356c997, 0xca6ac43a, 0x87cc8ba4, 0x6491357e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PowerBombGuardianStageProperties]:
if property_count != 11:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHlLHlLHfLHfLHfLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(110))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30]) != _FAST_IDS:
data.seek(before)
return None
return PowerBombGuardianStageProperties(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
)
def _decode_unknown_0x95e7a2c2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x76ba1c18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3eb2de35(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe50d8dd2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x64d482d5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc3e002ac(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xbb4b6680(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd356c997(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_double_shot_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x87cc8ba4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6491357e(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]]] = {
0x95e7a2c2: ('unknown_0x95e7a2c2', _decode_unknown_0x95e7a2c2),
0x76ba1c18: ('unknown_0x76ba1c18', _decode_unknown_0x76ba1c18),
0x3eb2de35: ('unknown_0x3eb2de35', _decode_unknown_0x3eb2de35),
0xe50d8dd2: ('unknown_0xe50d8dd2', _decode_unknown_0xe50d8dd2),
0x64d482d5: ('unknown_0x64d482d5', _decode_unknown_0x64d482d5),
0xc3e002ac: ('unknown_0xc3e002ac', _decode_unknown_0xc3e002ac),
0xbb4b6680: ('unknown_0xbb4b6680', _decode_unknown_0xbb4b6680),
0xd356c997: ('unknown_0xd356c997', _decode_unknown_0xd356c997),
0xca6ac43a: ('double_shot_chance', _decode_double_shot_chance),
0x87cc8ba4: ('unknown_0x87cc8ba4', _decode_unknown_0x87cc8ba4),
0x6491357e: ('unknown_0x6491357e', _decode_unknown_0x6491357e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/PowerBombGuardianStageProperties.py | 0.606498 | 0.252378 | PowerBombGuardianStageProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SandBossStructA(BaseProperty):
head_armor: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
armor_piece2: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
armor_piece3: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
armor_piece4: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
armor_piece5: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
armor_piece6: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
armor_piece7: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
tail_armor: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
sound_armor_impact: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x07\xd8\xccO') # 0x7d8cc4f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.head_armor))
data.write(b'\xae0\xae\x06') # 0xae30ae06
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.armor_piece2))
data.write(b'el}\xa3') # 0x656c7da3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.armor_piece3))
data.write(b'xiM\x1b') # 0x78694d1b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.armor_piece4))
data.write(b'\xb35\x9e\xbe') # 0xb3359ebe
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.armor_piece5))
data.write(b'5\xa1\xec\x10') # 0x35a1ec10
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.armor_piece6))
data.write(b'\xfe\xfd?\xb5') # 0xfefd3fb5
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.armor_piece7))
data.write(b'7\xe9\x9c#') # 0x37e99c23
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.tail_armor))
data.write(b'\xdc\xc2\xbf\x11') # 0xdcc2bf11
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.sound_armor_impact))
@classmethod
def from_json(cls, data: dict):
return cls(
head_armor=data['head_armor'],
armor_piece2=data['armor_piece2'],
armor_piece3=data['armor_piece3'],
armor_piece4=data['armor_piece4'],
armor_piece5=data['armor_piece5'],
armor_piece6=data['armor_piece6'],
armor_piece7=data['armor_piece7'],
tail_armor=data['tail_armor'],
sound_armor_impact=data['sound_armor_impact'],
)
def to_json(self) -> dict:
return {
'head_armor': self.head_armor,
'armor_piece2': self.armor_piece2,
'armor_piece3': self.armor_piece3,
'armor_piece4': self.armor_piece4,
'armor_piece5': self.armor_piece5,
'armor_piece6': self.armor_piece6,
'armor_piece7': self.armor_piece7,
'tail_armor': self.tail_armor,
'sound_armor_impact': self.sound_armor_impact,
}
def _dependencies_for_head_armor(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.head_armor)
def _dependencies_for_armor_piece2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.armor_piece2)
def _dependencies_for_armor_piece3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.armor_piece3)
def _dependencies_for_armor_piece4(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.armor_piece4)
def _dependencies_for_armor_piece5(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.armor_piece5)
def _dependencies_for_armor_piece6(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.armor_piece6)
def _dependencies_for_armor_piece7(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.armor_piece7)
def _dependencies_for_tail_armor(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.tail_armor)
def _dependencies_for_sound_armor_impact(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.sound_armor_impact)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_head_armor, "head_armor", "AssetId"),
(self._dependencies_for_armor_piece2, "armor_piece2", "AssetId"),
(self._dependencies_for_armor_piece3, "armor_piece3", "AssetId"),
(self._dependencies_for_armor_piece4, "armor_piece4", "AssetId"),
(self._dependencies_for_armor_piece5, "armor_piece5", "AssetId"),
(self._dependencies_for_armor_piece6, "armor_piece6", "AssetId"),
(self._dependencies_for_armor_piece7, "armor_piece7", "AssetId"),
(self._dependencies_for_tail_armor, "tail_armor", "AssetId"),
(self._dependencies_for_sound_armor_impact, "sound_armor_impact", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SandBossStructA.{field_name} ({field_type}): {e}"
)
_FAST_FORMAT = None
_FAST_IDS = (0x7d8cc4f, 0xae30ae06, 0x656c7da3, 0x78694d1b, 0xb3359ebe, 0x35a1ec10, 0xfefd3fb5, 0x37e99c23, 0xdcc2bf11)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SandBossStructA]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHLLHLLHLLHLLHLLHLLHLLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(90))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24]) != _FAST_IDS:
data.seek(before)
return None
return SandBossStructA(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_head_armor(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_armor_piece2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_armor_piece3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_armor_piece4(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_armor_piece5(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_armor_piece6(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_armor_piece7(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_tail_armor(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_armor_impact(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]]] = {
0x7d8cc4f: ('head_armor', _decode_head_armor),
0xae30ae06: ('armor_piece2', _decode_armor_piece2),
0x656c7da3: ('armor_piece3', _decode_armor_piece3),
0x78694d1b: ('armor_piece4', _decode_armor_piece4),
0xb3359ebe: ('armor_piece5', _decode_armor_piece5),
0x35a1ec10: ('armor_piece6', _decode_armor_piece6),
0xfefd3fb5: ('armor_piece7', _decode_armor_piece7),
0x37e99c23: ('tail_armor', _decode_tail_armor),
0xdcc2bf11: ('sound_armor_impact', _decode_sound_armor_impact),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SandBossStructA.py | 0.5794 | 0.160463 | SandBossStructA.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.echoes as enums
@dataclasses.dataclass()
class ConditionalTest(BaseProperty):
boolean: enums.Boolean = dataclasses.field(default=enums.Boolean.And)
player_item: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
amount_or_capacity: enums.AmountOrCapacity = dataclasses.field(default=enums.AmountOrCapacity.Amount)
condition: enums.Condition = dataclasses.field(default=enums.Condition.EqualTo)
value: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xde>@\xa3') # 0xde3e40a3
data.write(b'\x00\x04') # size
self.boolean.to_stream(data)
data.write(b'\xd3\xaf\x8dr') # 0xd3af8d72
data.write(b'\x00\x04') # size
self.player_item.to_stream(data)
data.write(b'\x03\xbd\xea\x98') # 0x3bdea98
data.write(b'\x00\x04') # size
self.amount_or_capacity.to_stream(data)
data.write(b'pr\x93d') # 0x70729364
data.write(b'\x00\x04') # size
self.condition.to_stream(data)
data.write(b'\x8d\xb99\x8a') # 0x8db9398a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.value))
@classmethod
def from_json(cls, data: dict):
return cls(
boolean=enums.Boolean.from_json(data['boolean']),
player_item=enums.PlayerItem.from_json(data['player_item']),
amount_or_capacity=enums.AmountOrCapacity.from_json(data['amount_or_capacity']),
condition=enums.Condition.from_json(data['condition']),
value=data['value'],
)
def to_json(self) -> dict:
return {
'boolean': self.boolean.to_json(),
'player_item': self.player_item.to_json(),
'amount_or_capacity': self.amount_or_capacity.to_json(),
'condition': self.condition.to_json(),
'value': self.value,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xde3e40a3, 0xd3af8d72, 0x3bdea98, 0x70729364, 0x8db9398a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ConditionalTest]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHLLHLLHLLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return ConditionalTest(
enums.Boolean(dec[2]),
enums.PlayerItem(dec[5]),
enums.AmountOrCapacity(dec[8]),
enums.Condition(dec[11]),
dec[14],
)
def _decode_boolean(data: typing.BinaryIO, property_size: int):
return enums.Boolean.from_stream(data)
def _decode_player_item(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_amount_or_capacity(data: typing.BinaryIO, property_size: int):
return enums.AmountOrCapacity.from_stream(data)
def _decode_condition(data: typing.BinaryIO, property_size: int):
return enums.Condition.from_stream(data)
def _decode_value(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]]] = {
0xde3e40a3: ('boolean', _decode_boolean),
0xd3af8d72: ('player_item', _decode_player_item),
0x3bdea98: ('amount_or_capacity', _decode_amount_or_capacity),
0x70729364: ('condition', _decode_condition),
0x8db9398a: ('value', _decode_value),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/ConditionalTest.py | 0.654343 | 0.276043 | ConditionalTest.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ShockWaveInfo(BaseProperty):
shock_wave_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
radius: float = dataclasses.field(default=0.0)
height: float = dataclasses.field(default=1.0)
unknown: float = dataclasses.field(default=0.5)
radial_velocity: float = dataclasses.field(default=1.0)
radial_velocity_acceleration: float = dataclasses.field(default=0.0)
visor_electric_effect: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
sound_visor_electric: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'6\x9f}\t') # 0x369f7d09
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shock_wave_effect))
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'\xc2\xbe\x03\r') # 0xc2be030d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.height))
data.write(b'\xcfl\x1d\xe9') # 0xcf6c1de9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'L\xd1E\x9b') # 0x4cd1459b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radial_velocity))
data.write(b'\nW\xb0\x9b') # 0xa57b09b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radial_velocity_acceleration))
data.write(b'\xbd2\x158') # 0xbd321538
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.visor_electric_effect))
data.write(b'X\xa4\x92\xef') # 0x58a492ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_visor_electric))
@classmethod
def from_json(cls, data: dict):
return cls(
shock_wave_effect=data['shock_wave_effect'],
damage=DamageInfo.from_json(data['damage']),
radius=data['radius'],
height=data['height'],
unknown=data['unknown'],
radial_velocity=data['radial_velocity'],
radial_velocity_acceleration=data['radial_velocity_acceleration'],
visor_electric_effect=data['visor_electric_effect'],
sound_visor_electric=data['sound_visor_electric'],
)
def to_json(self) -> dict:
return {
'shock_wave_effect': self.shock_wave_effect,
'damage': self.damage.to_json(),
'radius': self.radius,
'height': self.height,
'unknown': self.unknown,
'radial_velocity': self.radial_velocity,
'radial_velocity_acceleration': self.radial_velocity_acceleration,
'visor_electric_effect': self.visor_electric_effect,
'sound_visor_electric': self.sound_visor_electric,
}
def _dependencies_for_shock_wave_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shock_wave_effect)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def _dependencies_for_visor_electric_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.visor_electric_effect)
def _dependencies_for_sound_visor_electric(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_visor_electric)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_shock_wave_effect, "shock_wave_effect", "AssetId"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_visor_electric_effect, "visor_electric_effect", "AssetId"),
(self._dependencies_for_sound_visor_electric, "sound_visor_electric", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ShockWaveInfo.{field_name} ({field_type}): {e}"
)
def _decode_shock_wave_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
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_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radial_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radial_velocity_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visor_electric_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_visor_electric(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]]] = {
0x369f7d09: ('shock_wave_effect', _decode_shock_wave_effect),
0x337f9524: ('damage', _decode_damage),
0x78c507eb: ('radius', _decode_radius),
0xc2be030d: ('height', _decode_height),
0xcf6c1de9: ('unknown', _decode_unknown),
0x4cd1459b: ('radial_velocity', _decode_radial_velocity),
0xa57b09b: ('radial_velocity_acceleration', _decode_radial_velocity_acceleration),
0xbd321538: ('visor_electric_effect', _decode_visor_electric_effect),
0x58a492ef: ('sound_visor_electric', _decode_sound_visor_electric),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/ShockWaveInfo.py | 0.640861 | 0.261626 | ShockWaveInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class SpindleCameraStruct(BaseProperty):
interpolant_type: int = dataclasses.field(default=0)
interpolant_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'>\x9c\xf1@') # 0x3e9cf140
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.interpolant_type))
data.write(b'\x9aY\x8f\xa5') # 0x9a598fa5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.interpolant_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
interpolant_type=data['interpolant_type'],
interpolant_spline=Spline.from_json(data['interpolant_spline']),
)
def to_json(self) -> dict:
return {
'interpolant_type': self.interpolant_type,
'interpolant_spline': self.interpolant_spline.to_json(),
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_interpolant_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_interpolant_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]]] = {
0x3e9cf140: ('interpolant_type', _decode_interpolant_type),
0x9a598fa5: ('interpolant_spline', _decode_interpolant_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SpindleCameraStruct.py | 0.621656 | 0.266811 | SpindleCameraStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct33(BaseProperty):
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
bomb_stun_duration: float = dataclasses.field(default=5.0)
unknown_0x46aaced3: float = dataclasses.field(default=10.0)
max_speed: float = dataclasses.field(default=15.0)
max_wall_speed: float = dataclasses.field(default=7.0)
ball_pursuit_speed: float = dataclasses.field(default=25.0)
speed_modifier: float = dataclasses.field(default=2.0)
turn_speed: float = dataclasses.field(default=360.0)
blob_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
hit_normal_damage: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
hit_heavy_damage: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_idle: int = dataclasses.field(default=0, metadata={'sound': True})
sound_move: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0xb392943a: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x24ecc1e9: int = dataclasses.field(default=0, metadata={'sound': True})
sound_death: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x7569fdba: float = dataclasses.field(default=100.0)
unknown_0xd55938d2: float = dataclasses.field(default=0.20000000298023224)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x14') # 20 properties
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'X`\xe2K') # 0x5860e24b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_stun_duration))
data.write(b'F\xaa\xce\xd3') # 0x46aaced3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x46aaced3))
data.write(b'\x82\xdb\x0c\xbe') # 0x82db0cbe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_speed))
data.write(b'\xbe\xc6R\xae') # 0xbec652ae
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_wall_speed))
data.write(b'`\n\x86?') # 0x600a863f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ball_pursuit_speed))
data.write(b'8\x8eI\x02') # 0x388e4902
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed_modifier))
data.write(b'\x02\x0cx\xbb') # 0x20c78bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed))
data.write(b'#g\xf6\x89') # 0x2367f689
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.blob_effect))
data.write(b'\xd4s\x15\x8d') # 0xd473158d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.hit_normal_damage))
data.write(b'\xcc\xa2\x98\xb4') # 0xcca298b4
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.hit_heavy_damage))
data.write(b'\xb9\x9c\x80\xd3') # 0xb99c80d3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death))
data.write(b'\xaf8\x96\x8e') # 0xaf38968e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_idle))
data.write(b'l\x10\x18T') # 0x6c101854
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_move))
data.write(b'\xb3\x92\x94:') # 0xb392943a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xb392943a))
data.write(b'$\xec\xc1\xe9') # 0x24ecc1e9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x24ecc1e9))
data.write(b'\xe1`\xb5\x93') # 0xe160b593
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_death))
data.write(b'ui\xfd\xba') # 0x7569fdba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7569fdba))
data.write(b'\xd5Y8\xd2') # 0xd55938d2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd55938d2))
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)
@classmethod
def from_json(cls, data: dict):
return cls(
damage=DamageInfo.from_json(data['damage']),
bomb_stun_duration=data['bomb_stun_duration'],
unknown_0x46aaced3=data['unknown_0x46aaced3'],
max_speed=data['max_speed'],
max_wall_speed=data['max_wall_speed'],
ball_pursuit_speed=data['ball_pursuit_speed'],
speed_modifier=data['speed_modifier'],
turn_speed=data['turn_speed'],
blob_effect=data['blob_effect'],
hit_normal_damage=data['hit_normal_damage'],
hit_heavy_damage=data['hit_heavy_damage'],
death=data['death'],
sound_idle=data['sound_idle'],
sound_move=data['sound_move'],
sound_0xb392943a=data['sound_0xb392943a'],
sound_0x24ecc1e9=data['sound_0x24ecc1e9'],
sound_death=data['sound_death'],
unknown_0x7569fdba=data['unknown_0x7569fdba'],
unknown_0xd55938d2=data['unknown_0xd55938d2'],
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
)
def to_json(self) -> dict:
return {
'damage': self.damage.to_json(),
'bomb_stun_duration': self.bomb_stun_duration,
'unknown_0x46aaced3': self.unknown_0x46aaced3,
'max_speed': self.max_speed,
'max_wall_speed': self.max_wall_speed,
'ball_pursuit_speed': self.ball_pursuit_speed,
'speed_modifier': self.speed_modifier,
'turn_speed': self.turn_speed,
'blob_effect': self.blob_effect,
'hit_normal_damage': self.hit_normal_damage,
'hit_heavy_damage': self.hit_heavy_damage,
'death': self.death,
'sound_idle': self.sound_idle,
'sound_move': self.sound_move,
'sound_0xb392943a': self.sound_0xb392943a,
'sound_0x24ecc1e9': self.sound_0x24ecc1e9,
'sound_death': self.sound_death,
'unknown_0x7569fdba': self.unknown_0x7569fdba,
'unknown_0xd55938d2': self.unknown_0xd55938d2,
'vulnerability': self.vulnerability.to_json(),
}
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def _dependencies_for_blob_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.blob_effect)
def _dependencies_for_hit_normal_damage(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.hit_normal_damage)
def _dependencies_for_hit_heavy_damage(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.hit_heavy_damage)
def _dependencies_for_death(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death)
def _dependencies_for_sound_idle(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_idle)
def _dependencies_for_sound_move(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_move)
def _dependencies_for_sound_0xb392943a(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xb392943a)
def _dependencies_for_sound_0x24ecc1e9(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x24ecc1e9)
def _dependencies_for_sound_death(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_death)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_blob_effect, "blob_effect", "AssetId"),
(self._dependencies_for_hit_normal_damage, "hit_normal_damage", "AssetId"),
(self._dependencies_for_hit_heavy_damage, "hit_heavy_damage", "AssetId"),
(self._dependencies_for_death, "death", "AssetId"),
(self._dependencies_for_sound_idle, "sound_idle", "int"),
(self._dependencies_for_sound_move, "sound_move", "int"),
(self._dependencies_for_sound_0xb392943a, "sound_0xb392943a", "int"),
(self._dependencies_for_sound_0x24ecc1e9, "sound_0x24ecc1e9", "int"),
(self._dependencies_for_sound_death, "sound_death", "int"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct33.{field_name} ({field_type}): {e}"
)
def _decode_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_bomb_stun_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x46aaced3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_wall_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ball_pursuit_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed_modifier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_blob_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_hit_normal_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_hit_heavy_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_idle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_move(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0xb392943a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x24ecc1e9(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_unknown_0x7569fdba(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd55938d2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x337f9524: ('damage', _decode_damage),
0x5860e24b: ('bomb_stun_duration', _decode_bomb_stun_duration),
0x46aaced3: ('unknown_0x46aaced3', _decode_unknown_0x46aaced3),
0x82db0cbe: ('max_speed', _decode_max_speed),
0xbec652ae: ('max_wall_speed', _decode_max_wall_speed),
0x600a863f: ('ball_pursuit_speed', _decode_ball_pursuit_speed),
0x388e4902: ('speed_modifier', _decode_speed_modifier),
0x20c78bb: ('turn_speed', _decode_turn_speed),
0x2367f689: ('blob_effect', _decode_blob_effect),
0xd473158d: ('hit_normal_damage', _decode_hit_normal_damage),
0xcca298b4: ('hit_heavy_damage', _decode_hit_heavy_damage),
0xb99c80d3: ('death', _decode_death),
0xaf38968e: ('sound_idle', _decode_sound_idle),
0x6c101854: ('sound_move', _decode_sound_move),
0xb392943a: ('sound_0xb392943a', _decode_sound_0xb392943a),
0x24ecc1e9: ('sound_0x24ecc1e9', _decode_sound_0x24ecc1e9),
0xe160b593: ('sound_death', _decode_sound_death),
0x7569fdba: ('unknown_0x7569fdba', _decode_unknown_0x7569fdba),
0xd55938d2: ('unknown_0xd55938d2', _decode_unknown_0xd55938d2),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct33.py | 0.565299 | 0.209328 | UnknownStruct33.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class LayerInfo(BaseProperty):
motion_type: int = dataclasses.field(default=0)
unknown: float = dataclasses.field(default=0.0)
rotation: float = dataclasses.field(default=0.0)
amplitude: float = dataclasses.field(default=-0.0)
texture_scale: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xe9O~\x87') # 0xe94f7e87
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.motion_type))
data.write(b'<[\x0c\x98') # 0x3c5b0c98
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x91)T\xe6') # 0x912954e6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotation))
data.write(b'\x89\xe3\xd2\x94') # 0x89e3d294
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.amplitude))
data.write(b'\x08\x0ct\x99') # 0x80c7499
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.texture_scale))
@classmethod
def from_json(cls, data: dict):
return cls(
motion_type=data['motion_type'],
unknown=data['unknown'],
rotation=data['rotation'],
amplitude=data['amplitude'],
texture_scale=data['texture_scale'],
)
def to_json(self) -> dict:
return {
'motion_type': self.motion_type,
'unknown': self.unknown,
'rotation': self.rotation,
'amplitude': self.amplitude,
'texture_scale': self.texture_scale,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xe94f7e87, 0x3c5b0c98, 0x912954e6, 0x89e3d294, 0x80c7499)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[LayerInfo]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return LayerInfo(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_motion_type(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('>f', data.read(4))[0]
def _decode_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_amplitude(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_texture_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe94f7e87: ('motion_type', _decode_motion_type),
0x3c5b0c98: ('unknown', _decode_unknown),
0x912954e6: ('rotation', _decode_rotation),
0x89e3d294: ('amplitude', _decode_amplitude),
0x80c7499: ('texture_scale', _decode_texture_scale),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/LayerInfo.py | 0.658527 | 0.324864 | LayerInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class RotationSplines(BaseProperty):
x_rotation: Spline = dataclasses.field(default_factory=Spline)
y_rotation: Spline = dataclasses.field(default_factory=Spline)
z_rotation: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'i\xd8D}') # 0x69d8447d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd0#\x9f\x95') # 0xd0239f95
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc1^\xf5\xec') # 0xc15ef5ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_rotation=Spline.from_json(data['x_rotation']),
y_rotation=Spline.from_json(data['y_rotation']),
z_rotation=Spline.from_json(data['z_rotation']),
)
def to_json(self) -> dict:
return {
'x_rotation': self.x_rotation.to_json(),
'y_rotation': self.y_rotation.to_json(),
'z_rotation': self.z_rotation.to_json(),
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_x_rotation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_rotation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_rotation(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]]] = {
0x69d8447d: ('x_rotation', _decode_x_rotation),
0xd0239f95: ('y_rotation', _decode_y_rotation),
0xc15ef5ec: ('z_rotation', _decode_z_rotation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/RotationSplines.py | 0.695958 | 0.32985 | RotationSplines.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SwampBossStage1Struct(BaseProperty):
unknown_0x98106ee2: float = dataclasses.field(default=50.0)
unknown_0x95e7a2c2: float = dataclasses.field(default=1.0)
unknown_0x76ba1c18: float = dataclasses.field(default=3.0)
unknown_0xbb0ffdd6: int = dataclasses.field(default=3)
unknown_0x60b0ae31: int = dataclasses.field(default=3)
first_attack: int = dataclasses.field(default=0)
second_attack: int = dataclasses.field(default=0)
third_attack: int = dataclasses.field(default=0)
fourth_attack: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x98\x10n\xe2') # 0x98106ee2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x98106ee2))
data.write(b'\x95\xe7\xa2\xc2') # 0x95e7a2c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x95e7a2c2))
data.write(b'v\xba\x1c\x18') # 0x76ba1c18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76ba1c18))
data.write(b'\xbb\x0f\xfd\xd6') # 0xbb0ffdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xbb0ffdd6))
data.write(b'`\xb0\xae1') # 0x60b0ae31
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x60b0ae31))
data.write(b'\x9c\xfa\x9a\xcb') # 0x9cfa9acb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.first_attack))
data.write(b'\x18\x0f\x81\xdd') # 0x180f81dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.second_attack))
data.write(b'Ba|\xfd') # 0x42617cfd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.third_attack))
data.write(b'\xc3\x9f\x86N') # 0xc39f864e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fourth_attack))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x98106ee2=data['unknown_0x98106ee2'],
unknown_0x95e7a2c2=data['unknown_0x95e7a2c2'],
unknown_0x76ba1c18=data['unknown_0x76ba1c18'],
unknown_0xbb0ffdd6=data['unknown_0xbb0ffdd6'],
unknown_0x60b0ae31=data['unknown_0x60b0ae31'],
first_attack=data['first_attack'],
second_attack=data['second_attack'],
third_attack=data['third_attack'],
fourth_attack=data['fourth_attack'],
)
def to_json(self) -> dict:
return {
'unknown_0x98106ee2': self.unknown_0x98106ee2,
'unknown_0x95e7a2c2': self.unknown_0x95e7a2c2,
'unknown_0x76ba1c18': self.unknown_0x76ba1c18,
'unknown_0xbb0ffdd6': self.unknown_0xbb0ffdd6,
'unknown_0x60b0ae31': self.unknown_0x60b0ae31,
'first_attack': self.first_attack,
'second_attack': self.second_attack,
'third_attack': self.third_attack,
'fourth_attack': self.fourth_attack,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x98106ee2, 0x95e7a2c2, 0x76ba1c18, 0xbb0ffdd6, 0x60b0ae31, 0x9cfa9acb, 0x180f81dd, 0x42617cfd, 0xc39f864e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SwampBossStage1Struct]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHlLHlLHlLHlLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(90))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24]) != _FAST_IDS:
data.seek(before)
return None
return SwampBossStage1Struct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_unknown_0x98106ee2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x95e7a2c2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x76ba1c18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbb0ffdd6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x60b0ae31(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_first_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_second_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_third_attack(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fourth_attack(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]]] = {
0x98106ee2: ('unknown_0x98106ee2', _decode_unknown_0x98106ee2),
0x95e7a2c2: ('unknown_0x95e7a2c2', _decode_unknown_0x95e7a2c2),
0x76ba1c18: ('unknown_0x76ba1c18', _decode_unknown_0x76ba1c18),
0xbb0ffdd6: ('unknown_0xbb0ffdd6', _decode_unknown_0xbb0ffdd6),
0x60b0ae31: ('unknown_0x60b0ae31', _decode_unknown_0x60b0ae31),
0x9cfa9acb: ('first_attack', _decode_first_attack),
0x180f81dd: ('second_attack', _decode_second_attack),
0x42617cfd: ('third_attack', _decode_third_attack),
0xc39f864e: ('fourth_attack', _decode_fourth_attack),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SwampBossStage1Struct.py | 0.613121 | 0.269706 | SwampBossStage1Struct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.UnknownStruct2 import UnknownStruct2
@dataclasses.dataclass()
class EmperorIngStage3StructB(BaseProperty):
min_health_percentage: float = dataclasses.field(default=0.0)
unknown_0x95e7a2c2: float = dataclasses.field(default=0.0)
unknown_0x76ba1c18: float = dataclasses.field(default=0.0)
unknown_struct2_0x3826ec75: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0x93bf1106: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0xc4b88b80: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0x32c6dc77: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0xc6e7b293: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0x20746b56: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0x2ab44adb: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_struct2_0xe2e78a78: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\xdf\xeaF\xb3') # 0xdfea46b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_health_percentage))
data.write(b'\x95\xe7\xa2\xc2') # 0x95e7a2c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x95e7a2c2))
data.write(b'v\xba\x1c\x18') # 0x76ba1c18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76ba1c18))
data.write(b'8&\xecu') # 0x3826ec75
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0x3826ec75.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\xbf\x11\x06') # 0x93bf1106
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0x93bf1106.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xb8\x8b\x80') # 0xc4b88b80
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0xc4b88b80.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'2\xc6\xdcw') # 0x32c6dc77
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0x32c6dc77.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xe7\xb2\x93') # 0xc6e7b293
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0xc6e7b293.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' tkV') # 0x20746b56
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0x20746b56.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*\xb4J\xdb') # 0x2ab44adb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0x2ab44adb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2\xe7\x8ax') # 0xe2e78a78
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct2_0xe2e78a78.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
min_health_percentage=data['min_health_percentage'],
unknown_0x95e7a2c2=data['unknown_0x95e7a2c2'],
unknown_0x76ba1c18=data['unknown_0x76ba1c18'],
unknown_struct2_0x3826ec75=UnknownStruct2.from_json(data['unknown_struct2_0x3826ec75']),
unknown_struct2_0x93bf1106=UnknownStruct2.from_json(data['unknown_struct2_0x93bf1106']),
unknown_struct2_0xc4b88b80=UnknownStruct2.from_json(data['unknown_struct2_0xc4b88b80']),
unknown_struct2_0x32c6dc77=UnknownStruct2.from_json(data['unknown_struct2_0x32c6dc77']),
unknown_struct2_0xc6e7b293=UnknownStruct2.from_json(data['unknown_struct2_0xc6e7b293']),
unknown_struct2_0x20746b56=UnknownStruct2.from_json(data['unknown_struct2_0x20746b56']),
unknown_struct2_0x2ab44adb=UnknownStruct2.from_json(data['unknown_struct2_0x2ab44adb']),
unknown_struct2_0xe2e78a78=UnknownStruct2.from_json(data['unknown_struct2_0xe2e78a78']),
)
def to_json(self) -> dict:
return {
'min_health_percentage': self.min_health_percentage,
'unknown_0x95e7a2c2': self.unknown_0x95e7a2c2,
'unknown_0x76ba1c18': self.unknown_0x76ba1c18,
'unknown_struct2_0x3826ec75': self.unknown_struct2_0x3826ec75.to_json(),
'unknown_struct2_0x93bf1106': self.unknown_struct2_0x93bf1106.to_json(),
'unknown_struct2_0xc4b88b80': self.unknown_struct2_0xc4b88b80.to_json(),
'unknown_struct2_0x32c6dc77': self.unknown_struct2_0x32c6dc77.to_json(),
'unknown_struct2_0xc6e7b293': self.unknown_struct2_0xc6e7b293.to_json(),
'unknown_struct2_0x20746b56': self.unknown_struct2_0x20746b56.to_json(),
'unknown_struct2_0x2ab44adb': self.unknown_struct2_0x2ab44adb.to_json(),
'unknown_struct2_0xe2e78a78': self.unknown_struct2_0xe2e78a78.to_json(),
}
def _dependencies_for_unknown_struct2_0x3826ec75(self, asset_manager):
yield from self.unknown_struct2_0x3826ec75.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0x93bf1106(self, asset_manager):
yield from self.unknown_struct2_0x93bf1106.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0xc4b88b80(self, asset_manager):
yield from self.unknown_struct2_0xc4b88b80.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0x32c6dc77(self, asset_manager):
yield from self.unknown_struct2_0x32c6dc77.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0xc6e7b293(self, asset_manager):
yield from self.unknown_struct2_0xc6e7b293.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0x20746b56(self, asset_manager):
yield from self.unknown_struct2_0x20746b56.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0x2ab44adb(self, asset_manager):
yield from self.unknown_struct2_0x2ab44adb.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct2_0xe2e78a78(self, asset_manager):
yield from self.unknown_struct2_0xe2e78a78.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unknown_struct2_0x3826ec75, "unknown_struct2_0x3826ec75", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0x93bf1106, "unknown_struct2_0x93bf1106", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0xc4b88b80, "unknown_struct2_0xc4b88b80", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0x32c6dc77, "unknown_struct2_0x32c6dc77", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0xc6e7b293, "unknown_struct2_0xc6e7b293", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0x20746b56, "unknown_struct2_0x20746b56", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0x2ab44adb, "unknown_struct2_0x2ab44adb", "UnknownStruct2"),
(self._dependencies_for_unknown_struct2_0xe2e78a78, "unknown_struct2_0xe2e78a78", "UnknownStruct2"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage3StructB.{field_name} ({field_type}): {e}"
)
def _decode_min_health_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x95e7a2c2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x76ba1c18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct2_0x3826ec75(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0x93bf1106(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0xc4b88b80(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0x32c6dc77(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0xc6e7b293(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0x20746b56(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0x2ab44adb(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_struct2_0xe2e78a78(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xdfea46b3: ('min_health_percentage', _decode_min_health_percentage),
0x95e7a2c2: ('unknown_0x95e7a2c2', _decode_unknown_0x95e7a2c2),
0x76ba1c18: ('unknown_0x76ba1c18', _decode_unknown_0x76ba1c18),
0x3826ec75: ('unknown_struct2_0x3826ec75', _decode_unknown_struct2_0x3826ec75),
0x93bf1106: ('unknown_struct2_0x93bf1106', _decode_unknown_struct2_0x93bf1106),
0xc4b88b80: ('unknown_struct2_0xc4b88b80', _decode_unknown_struct2_0xc4b88b80),
0x32c6dc77: ('unknown_struct2_0x32c6dc77', _decode_unknown_struct2_0x32c6dc77),
0xc6e7b293: ('unknown_struct2_0xc6e7b293', _decode_unknown_struct2_0xc6e7b293),
0x20746b56: ('unknown_struct2_0x20746b56', _decode_unknown_struct2_0x20746b56),
0x2ab44adb: ('unknown_struct2_0x2ab44adb', _decode_unknown_struct2_0x2ab44adb),
0xe2e78a78: ('unknown_struct2_0xe2e78a78', _decode_unknown_struct2_0xe2e78a78),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EmperorIngStage3StructB.py | 0.512693 | 0.321167 | EmperorIngStage3StructB.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class HealthInfo(BaseProperty):
health: float = dataclasses.field(default=5.0)
hi_knock_back_resistance: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
data.write(b':-\x17\xe4') # 0x3a2d17e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hi_knock_back_resistance))
@classmethod
def from_json(cls, data: dict):
return cls(
health=data['health'],
hi_knock_back_resistance=data['hi_knock_back_resistance'],
)
def to_json(self) -> dict:
return {
'health': self.health,
'hi_knock_back_resistance': self.hi_knock_back_resistance,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xf0668919, 0x3a2d17e4)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HealthInfo]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return HealthInfo(
dec[2],
dec[5],
)
def _decode_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hi_knock_back_resistance(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]]] = {
0xf0668919: ('health', _decode_health),
0x3a2d17e4: ('hi_knock_back_resistance', _decode_hi_knock_back_resistance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/HealthInfo.py | 0.645455 | 0.302777 | HealthInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class PlasmaBeamInfo(BaseProperty):
unknown: int = dataclasses.field(default=0)
weapon_system: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
contact_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
pulse_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
beam_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
glow_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
length: float = dataclasses.field(default=10.0)
radius: float = dataclasses.field(default=0.10000000149011612)
expansion_speed: float = dataclasses.field(default=1.0)
life_time: float = dataclasses.field(default=10.0)
pulse_speed: float = dataclasses.field(default=10.0)
shutdown_time: float = dataclasses.field(default=1.0)
contact_effect_scale: float = dataclasses.field(default=1.0)
pulse_effect_scale: float = dataclasses.field(default=1.0)
travel_speed: float = dataclasses.field(default=150.0)
inner_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
outer_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
beam_streaks: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x12') # 18 properties
data.write(b'\xffq:\xad') # 0xff713aad
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'E\x9a\xe4\xa8') # 0x459ae4a8
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.weapon_system))
data.write(b'O8|I') # 0x4f387c49
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.contact_effect))
data.write(b'\xdd\xd5.:') # 0xddd52e3a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.pulse_effect))
data.write(b'\xc6\xf2)\xc6') # 0xc6f229c6
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.beam_texture))
data.write(b'\x8f\x1av\xc3') # 0x8f1a76c3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.glow_texture))
data.write(b'\xc2l)\x1c') # 0xc26c291c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.length))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\xecw=\x1d') # 0xec773d1d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.expansion_speed))
data.write(b'\xb0-\xe5U') # 0xb02de555
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.life_time))
data.write(b'Q\x80\x18\x1e') # 0x5180181e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pulse_speed))
data.write(b'r\xa9bR') # 0x72a96252
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shutdown_time))
data.write(b'\x85^\xd9\xb9') # 0x855ed9b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.contact_effect_scale))
data.write(b'\xb8e/\xe4') # 0xb8652fe4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pulse_effect_scale))
data.write(b'?\xed^R') # 0x3fed5e52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.travel_speed))
data.write(b'\x1a\xfb+s') # 0x1afb2b73
data.write(b'\x00\x10') # size
self.inner_color.to_stream(data)
data.write(b'\x9f\xd38\xfc') # 0x9fd338fc
data.write(b'\x00\x10') # size
self.outer_color.to_stream(data)
data.write(b'\xae\xb3\x1a\xf3') # 0xaeb31af3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.beam_streaks))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
weapon_system=data['weapon_system'],
contact_effect=data['contact_effect'],
pulse_effect=data['pulse_effect'],
beam_texture=data['beam_texture'],
glow_texture=data['glow_texture'],
length=data['length'],
radius=data['radius'],
expansion_speed=data['expansion_speed'],
life_time=data['life_time'],
pulse_speed=data['pulse_speed'],
shutdown_time=data['shutdown_time'],
contact_effect_scale=data['contact_effect_scale'],
pulse_effect_scale=data['pulse_effect_scale'],
travel_speed=data['travel_speed'],
inner_color=Color.from_json(data['inner_color']),
outer_color=Color.from_json(data['outer_color']),
beam_streaks=data['beam_streaks'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'weapon_system': self.weapon_system,
'contact_effect': self.contact_effect,
'pulse_effect': self.pulse_effect,
'beam_texture': self.beam_texture,
'glow_texture': self.glow_texture,
'length': self.length,
'radius': self.radius,
'expansion_speed': self.expansion_speed,
'life_time': self.life_time,
'pulse_speed': self.pulse_speed,
'shutdown_time': self.shutdown_time,
'contact_effect_scale': self.contact_effect_scale,
'pulse_effect_scale': self.pulse_effect_scale,
'travel_speed': self.travel_speed,
'inner_color': self.inner_color.to_json(),
'outer_color': self.outer_color.to_json(),
'beam_streaks': self.beam_streaks,
}
def _dependencies_for_weapon_system(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.weapon_system)
def _dependencies_for_contact_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.contact_effect)
def _dependencies_for_pulse_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.pulse_effect)
def _dependencies_for_beam_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.beam_texture)
def _dependencies_for_glow_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.glow_texture)
def _dependencies_for_beam_streaks(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.beam_streaks)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_weapon_system, "weapon_system", "AssetId"),
(self._dependencies_for_contact_effect, "contact_effect", "AssetId"),
(self._dependencies_for_pulse_effect, "pulse_effect", "AssetId"),
(self._dependencies_for_beam_texture, "beam_texture", "AssetId"),
(self._dependencies_for_glow_texture, "glow_texture", "AssetId"),
(self._dependencies_for_beam_streaks, "beam_streaks", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlasmaBeamInfo.{field_name} ({field_type}): {e}"
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_weapon_system(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_contact_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_pulse_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_beam_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_glow_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_length(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_expansion_speed(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_pulse_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shutdown_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_contact_effect_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pulse_effect_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_travel_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_inner_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_outer_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_beam_streaks(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]]] = {
0xff713aad: ('unknown', _decode_unknown),
0x459ae4a8: ('weapon_system', _decode_weapon_system),
0x4f387c49: ('contact_effect', _decode_contact_effect),
0xddd52e3a: ('pulse_effect', _decode_pulse_effect),
0xc6f229c6: ('beam_texture', _decode_beam_texture),
0x8f1a76c3: ('glow_texture', _decode_glow_texture),
0xc26c291c: ('length', _decode_length),
0x78c507eb: ('radius', _decode_radius),
0xec773d1d: ('expansion_speed', _decode_expansion_speed),
0xb02de555: ('life_time', _decode_life_time),
0x5180181e: ('pulse_speed', _decode_pulse_speed),
0x72a96252: ('shutdown_time', _decode_shutdown_time),
0x855ed9b9: ('contact_effect_scale', _decode_contact_effect_scale),
0xb8652fe4: ('pulse_effect_scale', _decode_pulse_effect_scale),
0x3fed5e52: ('travel_speed', _decode_travel_speed),
0x1afb2b73: ('inner_color', _decode_inner_color),
0x9fd338fc: ('outer_color', _decode_outer_color),
0xaeb31af3: ('beam_streaks', _decode_beam_streaks),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/PlasmaBeamInfo.py | 0.558568 | 0.214342 | PlasmaBeamInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class CameraHintStructC(BaseProperty):
override: bool = dataclasses.field(default=False)
angle: float = dataclasses.field(default=90.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x7f\xf8n\xe2') # 0x7ff86ee2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override))
data.write(b'8*\x19s') # 0x382a1973
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angle))
@classmethod
def from_json(cls, data: dict):
return cls(
override=data['override'],
angle=data['angle'],
)
def to_json(self) -> dict:
return {
'override': self.override,
'angle': self.angle,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x7ff86ee2, 0x382a1973)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraHintStructC]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return CameraHintStructC(
dec[2],
dec[5],
)
def _decode_override(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_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]]] = {
0x7ff86ee2: ('override', _decode_override),
0x382a1973: ('angle', _decode_angle),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/CameraHintStructC.py | 0.660939 | 0.307956 | CameraHintStructC.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class ControllerActionStruct(BaseProperty):
command: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x94\xbaW7') # 0x94ba5737
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.command))
@classmethod
def from_json(cls, data: dict):
return cls(
command=data['command'],
)
def to_json(self) -> dict:
return {
'command': self.command,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x94ba5737)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControllerActionStruct]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return ControllerActionStruct(
dec[2],
)
def _decode_command(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]]] = {
0x94ba5737: ('command', _decode_command),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/ControllerActionStruct.py | 0.602179 | 0.282152 | ControllerActionStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.echoes as enums
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class TriggerInfo(BaseProperty):
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
force_field: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
flags_trigger: enums.FlagsTrigger = dataclasses.field(default=enums.FlagsTrigger(30726))
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'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' \x92~\x9b') # 0x20927e9b
data.write(b'\x00\x0c') # size
self.force_field.to_stream(data)
data.write(b'\x82\x85\x9fF') # 0x82859f46
data.write(b'\x00\x04') # size
self.flags_trigger.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
damage=DamageInfo.from_json(data['damage']),
force_field=Vector.from_json(data['force_field']),
flags_trigger=enums.FlagsTrigger.from_json(data['flags_trigger']),
)
def to_json(self) -> dict:
return {
'damage': self.damage.to_json(),
'force_field': self.force_field.to_json(),
'flags_trigger': self.flags_trigger.to_json(),
}
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_damage, "damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TriggerInfo.{field_name} ({field_type}): {e}"
)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_force_field(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_flags_trigger(data: typing.BinaryIO, property_size: int):
return enums.FlagsTrigger.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x337f9524: ('damage', _decode_damage),
0x20927e9b: ('force_field', _decode_force_field),
0x82859f46: ('flags_trigger', _decode_flags_trigger),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/TriggerInfo.py | 0.621541 | 0.30319 | TriggerInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
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 UnknownStruct26(BaseProperty):
effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
portal_open_sound: int = dataclasses.field(default=0, metadata={'sound': True})
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xb6\x8cm\x96') # 0xb68c6d96
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.effect))
data.write(b'\x1af\xbe\xd7') # 0x1a66bed7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.portal_open_sound))
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': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\x98\x01*') # 0x1598012a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_info.to_stream(data, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
effect=data['effect'],
portal_open_sound=data['portal_open_sound'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
beam_info=PlasmaBeamInfo.from_json(data['beam_info']),
)
def to_json(self) -> dict:
return {
'effect': self.effect,
'portal_open_sound': self.portal_open_sound,
'projectile_damage': self.projectile_damage.to_json(),
'beam_info': self.beam_info.to_json(),
}
def _dependencies_for_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.effect)
def _dependencies_for_portal_open_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.portal_open_sound)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_beam_info(self, asset_manager):
yield from self.beam_info.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_effect, "effect", "AssetId"),
(self._dependencies_for_portal_open_sound, "portal_open_sound", "int"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
(self._dependencies_for_beam_info, "beam_info", "PlasmaBeamInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct26.{field_name} ({field_type}): {e}"
)
def _decode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_portal_open_sound(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': 20.0, 'di_knock_back_power': 10.0})
def _decode_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb68c6d96: ('effect', _decode_effect),
0x1a66bed7: ('portal_open_sound', _decode_portal_open_sound),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0x1598012a: ('beam_info', _decode_beam_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct26.py | 0.553023 | 0.226142 | UnknownStruct26.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct34(BaseProperty):
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
explosion: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
trail: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
mass: float = dataclasses.field(default=4.0)
unknown_0x417f4a91: float = dataclasses.field(default=0.5)
min_launch_speed: float = dataclasses.field(default=15.0)
max_launch_speed: float = dataclasses.field(default=20.0)
unknown_0xfbcdb101: int = dataclasses.field(default=5)
sound_bounce: int = dataclasses.field(default=0, metadata={'sound': True})
sound_explode: int = dataclasses.field(default=0, metadata={'sound': True})
max_turn_angle: float = dataclasses.field(default=30.0)
unknown_0x47f99fbc: float = dataclasses.field(default=2.0)
min_generation: int = dataclasses.field(default=0)
max_generation: int = dataclasses.field(default=3)
unknown_0xfbf8ea0a: float = dataclasses.field(default=40.0)
allow_lock_on: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x12') # 18 properties
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'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data, default_override={'di_weapon_type': 9, 'di_damage': 5.0, 'di_knock_back_power': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd8\xc6\xd1\\') # 0xd8c6d15c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.explosion))
data.write(b'\xb6\x8cm\x96') # 0xb68c6d96
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.effect))
data.write(b'\xcb\x0b\x91\x9b') # 0xcb0b919b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.trail))
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'P\xa1\x9b\x1f') # 0x50a19b1f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_launch_speed))
data.write(b'\xf7\x95\x1bf') # 0xf7951b66
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_launch_speed))
data.write(b'\xfb\xcd\xb1\x01') # 0xfbcdb101
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xfbcdb101))
data.write(b'gX\xbf\x01') # 0x6758bf01
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_bounce))
data.write(b'RJ\x80s') # 0x524a8073
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_explode))
data.write(b"P\xe4e'") # 0x50e46527
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_turn_angle))
data.write(b'G\xf9\x9f\xbc') # 0x47f99fbc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x47f99fbc))
data.write(b'\xdcZ\xf4\x1e') # 0xdc5af41e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.min_generation))
data.write(b'\x8d\xa3OC') # 0x8da34f43
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_generation))
data.write(b'\xfb\xf8\xea\n') # 0xfbf8ea0a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfbf8ea0a))
data.write(b'\x98\xd2\x1b"') # 0x98d21b22
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_lock_on))
@classmethod
def from_json(cls, data: dict):
return cls(
health=HealthInfo.from_json(data['health']),
damage=DamageInfo.from_json(data['damage']),
explosion=data['explosion'],
effect=data['effect'],
trail=data['trail'],
mass=data['mass'],
unknown_0x417f4a91=data['unknown_0x417f4a91'],
min_launch_speed=data['min_launch_speed'],
max_launch_speed=data['max_launch_speed'],
unknown_0xfbcdb101=data['unknown_0xfbcdb101'],
sound_bounce=data['sound_bounce'],
sound_explode=data['sound_explode'],
max_turn_angle=data['max_turn_angle'],
unknown_0x47f99fbc=data['unknown_0x47f99fbc'],
min_generation=data['min_generation'],
max_generation=data['max_generation'],
unknown_0xfbf8ea0a=data['unknown_0xfbf8ea0a'],
allow_lock_on=data['allow_lock_on'],
)
def to_json(self) -> dict:
return {
'health': self.health.to_json(),
'damage': self.damage.to_json(),
'explosion': self.explosion,
'effect': self.effect,
'trail': self.trail,
'mass': self.mass,
'unknown_0x417f4a91': self.unknown_0x417f4a91,
'min_launch_speed': self.min_launch_speed,
'max_launch_speed': self.max_launch_speed,
'unknown_0xfbcdb101': self.unknown_0xfbcdb101,
'sound_bounce': self.sound_bounce,
'sound_explode': self.sound_explode,
'max_turn_angle': self.max_turn_angle,
'unknown_0x47f99fbc': self.unknown_0x47f99fbc,
'min_generation': self.min_generation,
'max_generation': self.max_generation,
'unknown_0xfbf8ea0a': self.unknown_0xfbf8ea0a,
'allow_lock_on': self.allow_lock_on,
}
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def _dependencies_for_explosion(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.explosion)
def _dependencies_for_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.effect)
def _dependencies_for_trail(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.trail)
def _dependencies_for_sound_bounce(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_bounce)
def _dependencies_for_sound_explode(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_explode)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
(self._dependencies_for_explosion, "explosion", "AssetId"),
(self._dependencies_for_effect, "effect", "AssetId"),
(self._dependencies_for_trail, "trail", "AssetId"),
(self._dependencies_for_sound_bounce, "sound_bounce", "int"),
(self._dependencies_for_sound_explode, "sound_explode", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct34.{field_name} ({field_type}): {e}"
)
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 9, 'di_damage': 5.0, 'di_knock_back_power': 1.0})
def _decode_explosion(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_trail(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
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_min_launch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_launch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfbcdb101(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_explode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_turn_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x47f99fbc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_generation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_generation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xfbf8ea0a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_allow_lock_on(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]]] = {
0xcf90d15e: ('health', _decode_health),
0x337f9524: ('damage', _decode_damage),
0xd8c6d15c: ('explosion', _decode_explosion),
0xb68c6d96: ('effect', _decode_effect),
0xcb0b919b: ('trail', _decode_trail),
0x75dbb375: ('mass', _decode_mass),
0x417f4a91: ('unknown_0x417f4a91', _decode_unknown_0x417f4a91),
0x50a19b1f: ('min_launch_speed', _decode_min_launch_speed),
0xf7951b66: ('max_launch_speed', _decode_max_launch_speed),
0xfbcdb101: ('unknown_0xfbcdb101', _decode_unknown_0xfbcdb101),
0x6758bf01: ('sound_bounce', _decode_sound_bounce),
0x524a8073: ('sound_explode', _decode_sound_explode),
0x50e46527: ('max_turn_angle', _decode_max_turn_angle),
0x47f99fbc: ('unknown_0x47f99fbc', _decode_unknown_0x47f99fbc),
0xdc5af41e: ('min_generation', _decode_min_generation),
0x8da34f43: ('max_generation', _decode_max_generation),
0xfbf8ea0a: ('unknown_0xfbf8ea0a', _decode_unknown_0xfbf8ea0a),
0x98d21b22: ('allow_lock_on', _decode_allow_lock_on),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct34.py | 0.497803 | 0.221624 | UnknownStruct34.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct9(BaseProperty):
type: int = dataclasses.field(default=1)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
@classmethod
def from_json(cls, data: dict):
return cls(
type=data['type'],
)
def to_json(self) -> dict:
return {
'type': self.type,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xf53dcdd6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct9]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct9(
dec[2],
)
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]]] = {
0xf53dcdd6: ('type', _decode_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct9.py | 0.607896 | 0.28902 | UnknownStruct9.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightMotionSpline(BaseProperty):
motion_spline_path_loops: bool = dataclasses.field(default=False)
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
motion_spline_duration: float = dataclasses.field(default=10.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'=t\x06\xaf') # 0x3d7406af
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.motion_spline_path_loops))
data.write(b'I=j-') # 0x493d6a2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x1e/V') # 0xfd1e2f56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.motion_spline_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
motion_spline_path_loops=data['motion_spline_path_loops'],
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
motion_spline_duration=data['motion_spline_duration'],
)
def to_json(self) -> dict:
return {
'motion_spline_path_loops': self.motion_spline_path_loops,
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'motion_spline_duration': self.motion_spline_duration,
}
def _dependencies_for_motion_spline_type(self, asset_manager):
yield from self.motion_spline_type.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_motion_spline_type, "motion_spline_type", "SplineType"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DynamicLightMotionSpline.{field_name} ({field_type}): {e}"
)
def _decode_motion_spline_path_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_motion_spline_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x3d7406af: ('motion_spline_path_loops', _decode_motion_spline_path_loops),
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DynamicLightMotionSpline.py | 0.611266 | 0.255698 | DynamicLightMotionSpline.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class DigitalGuardianHeadStruct(BaseProperty):
first_shot_type: int = dataclasses.field(default=4)
projectile_telegraph_time: float = dataclasses.field(default=1.25)
projectile_attack_time: float = dataclasses.field(default=2.0)
unknown_0xfdfca535: float = dataclasses.field(default=25.0)
unknown_0xcd03632c: float = dataclasses.field(default=25.0)
unknown_0xf1548397: float = dataclasses.field(default=25.0)
unknown_0xf967e246: float = dataclasses.field(default=25.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xd2\x02\x88\xa4') # 0xd20288a4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.first_shot_type))
data.write(b'u\xdc\x92\xbc') # 0x75dc92bc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_telegraph_time))
data.write(b'\x9e\x1c?l') # 0x9e1c3f6c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_attack_time))
data.write(b'\xfd\xfc\xa55') # 0xfdfca535
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfdfca535))
data.write(b'\xcd\x03c,') # 0xcd03632c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcd03632c))
data.write(b'\xf1T\x83\x97') # 0xf1548397
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf1548397))
data.write(b'\xf9g\xe2F') # 0xf967e246
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf967e246))
@classmethod
def from_json(cls, data: dict):
return cls(
first_shot_type=data['first_shot_type'],
projectile_telegraph_time=data['projectile_telegraph_time'],
projectile_attack_time=data['projectile_attack_time'],
unknown_0xfdfca535=data['unknown_0xfdfca535'],
unknown_0xcd03632c=data['unknown_0xcd03632c'],
unknown_0xf1548397=data['unknown_0xf1548397'],
unknown_0xf967e246=data['unknown_0xf967e246'],
)
def to_json(self) -> dict:
return {
'first_shot_type': self.first_shot_type,
'projectile_telegraph_time': self.projectile_telegraph_time,
'projectile_attack_time': self.projectile_attack_time,
'unknown_0xfdfca535': self.unknown_0xfdfca535,
'unknown_0xcd03632c': self.unknown_0xcd03632c,
'unknown_0xf1548397': self.unknown_0xf1548397,
'unknown_0xf967e246': self.unknown_0xf967e246,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xd20288a4, 0x75dc92bc, 0x9e1c3f6c, 0xfdfca535, 0xcd03632c, 0xf1548397, 0xf967e246)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DigitalGuardianHeadStruct]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return DigitalGuardianHeadStruct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_first_shot_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_projectile_telegraph_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_attack_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfdfca535(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcd03632c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf1548397(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf967e246(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]]] = {
0xd20288a4: ('first_shot_type', _decode_first_shot_type),
0x75dc92bc: ('projectile_telegraph_time', _decode_projectile_telegraph_time),
0x9e1c3f6c: ('projectile_attack_time', _decode_projectile_attack_time),
0xfdfca535: ('unknown_0xfdfca535', _decode_unknown_0xfdfca535),
0xcd03632c: ('unknown_0xcd03632c', _decode_unknown_0xcd03632c),
0xf1548397: ('unknown_0xf1548397', _decode_unknown_0xf1548397),
0xf967e246: ('unknown_0xf967e246', _decode_unknown_0xf967e246),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DigitalGuardianHeadStruct.py | 0.593256 | 0.305866 | DigitalGuardianHeadStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
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.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EmperorIngStage3StructA import EmperorIngStage3StructA
from retro_data_structures.properties.echoes.archetypes.EmperorIngStage3StructB import EmperorIngStage3StructB
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.archetypes.ShockWaveInfo import ShockWaveInfo
from retro_data_structures.properties.echoes.archetypes.UnknownStruct26 import UnknownStruct26
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class EmperorIngStage3Data(BaseProperty):
taunt_frequency: float = dataclasses.field(default=0.0)
yellow_health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerable_time: float = dataclasses.field(default=0.0)
vulnerable_damage_threshold: float = dataclasses.field(default=0.0)
red_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
light_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
dark_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
melee_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info: DamageInfo = dataclasses.field(default_factory=DamageInfo)
jump_slide_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
ground_pound_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
emperor_ing_stage3_struct_a_0x98e311c1: EmperorIngStage3StructA = dataclasses.field(default_factory=EmperorIngStage3StructA)
emperor_ing_stage3_struct_a_0x93dae216: EmperorIngStage3StructA = dataclasses.field(default_factory=EmperorIngStage3StructA)
light_swarm_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
light_swarm_properties: BasicSwarmProperties = dataclasses.field(default_factory=BasicSwarmProperties)
light_swarm_death_sound: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
unknown_struct26: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
jump_attack_shock_wave_info: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
sound: int = dataclasses.field(default=0, metadata={'sound': True})
emperor_ing_stage3_struct_b_0xe843417f: EmperorIngStage3StructB = dataclasses.field(default_factory=EmperorIngStage3StructB)
emperor_ing_stage3_struct_b_0xd13bec3f: EmperorIngStage3StructB = dataclasses.field(default_factory=EmperorIngStage3StructB)
emperor_ing_stage3_struct_b_0xc61388ff: EmperorIngStage3StructB = dataclasses.field(default_factory=EmperorIngStage3StructB)
emperor_ing_stage3_struct_b_0xa3cab6bf: EmperorIngStage3StructB = dataclasses.field(default_factory=EmperorIngStage3StructB)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x19') # 25 properties
data.write(b'):\x0c\x19') # 0x293a0c19
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_frequency))
data.write(b'\x8a?v\x0c') # 0x8a3f760c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.yellow_health.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'i\xbc\\\xd4') # 0x69bc5cd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vulnerable_time))
data.write(b'\xb1\x10\xe59') # 0xb110e539
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vulnerable_damage_threshold))
data.write(b'\x8dp\xd6z') # 0x8d70d67a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.red_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89\xc1B\xf7') # 0x89c142f7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.light_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x88U\xc1\x18') # 0x8855c118
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9A`4') # 0xc9416034
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.melee_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14@\xd1R') # 0x1440d152
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xefX+\xd6') # 0xef582bd6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump_slide_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'G8\xc3!') # 0x4738c321
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ground_pound_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x98\xe3\x11\xc1') # 0x98e311c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.emperor_ing_stage3_struct_a_0x98e311c1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\xda\xe2\x16') # 0x93dae216
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.emperor_ing_stage3_struct_a_0x93dae216.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'O\x82\xb9\xe5') # 0x4f82b9e5
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.light_swarm_effect))
data.write(b'\x04>\x9c.') # 0x43e9c2e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.light_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'\x91\x00\x15\x08') # 0x91001508
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.light_swarm_death_sound.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x03U)S') # 0x3552953
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaf~03') # 0xaf7e3033
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xabN\xd4V') # 0xab4ed456
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump_attack_shock_wave_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x98_r\xfd') # 0x985f72fd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'\xe8CA\x7f') # 0xe843417f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.emperor_ing_stage3_struct_b_0xe843417f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1;\xec?') # 0xd13bec3f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.emperor_ing_stage3_struct_b_0xd13bec3f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\x13\x88\xff') # 0xc61388ff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.emperor_ing_stage3_struct_b_0xc61388ff.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa3\xca\xb6\xbf') # 0xa3cab6bf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.emperor_ing_stage3_struct_b_0xa3cab6bf.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
taunt_frequency=data['taunt_frequency'],
yellow_health=HealthInfo.from_json(data['yellow_health']),
health=HealthInfo.from_json(data['health']),
vulnerable_time=data['vulnerable_time'],
vulnerable_damage_threshold=data['vulnerable_damage_threshold'],
red_vulnerability=DamageVulnerability.from_json(data['red_vulnerability']),
light_vulnerability=DamageVulnerability.from_json(data['light_vulnerability']),
dark_vulnerability=DamageVulnerability.from_json(data['dark_vulnerability']),
melee_damage=DamageInfo.from_json(data['melee_damage']),
damage_info=DamageInfo.from_json(data['damage_info']),
jump_slide_damage=DamageInfo.from_json(data['jump_slide_damage']),
ground_pound_damage=DamageInfo.from_json(data['ground_pound_damage']),
emperor_ing_stage3_struct_a_0x98e311c1=EmperorIngStage3StructA.from_json(data['emperor_ing_stage3_struct_a_0x98e311c1']),
emperor_ing_stage3_struct_a_0x93dae216=EmperorIngStage3StructA.from_json(data['emperor_ing_stage3_struct_a_0x93dae216']),
light_swarm_effect=data['light_swarm_effect'],
light_swarm_properties=BasicSwarmProperties.from_json(data['light_swarm_properties']),
light_swarm_death_sound=AudioPlaybackParms.from_json(data['light_swarm_death_sound']),
audio_playback_parms=AudioPlaybackParms.from_json(data['audio_playback_parms']),
unknown_struct26=UnknownStruct26.from_json(data['unknown_struct26']),
jump_attack_shock_wave_info=ShockWaveInfo.from_json(data['jump_attack_shock_wave_info']),
sound=data['sound'],
emperor_ing_stage3_struct_b_0xe843417f=EmperorIngStage3StructB.from_json(data['emperor_ing_stage3_struct_b_0xe843417f']),
emperor_ing_stage3_struct_b_0xd13bec3f=EmperorIngStage3StructB.from_json(data['emperor_ing_stage3_struct_b_0xd13bec3f']),
emperor_ing_stage3_struct_b_0xc61388ff=EmperorIngStage3StructB.from_json(data['emperor_ing_stage3_struct_b_0xc61388ff']),
emperor_ing_stage3_struct_b_0xa3cab6bf=EmperorIngStage3StructB.from_json(data['emperor_ing_stage3_struct_b_0xa3cab6bf']),
)
def to_json(self) -> dict:
return {
'taunt_frequency': self.taunt_frequency,
'yellow_health': self.yellow_health.to_json(),
'health': self.health.to_json(),
'vulnerable_time': self.vulnerable_time,
'vulnerable_damage_threshold': self.vulnerable_damage_threshold,
'red_vulnerability': self.red_vulnerability.to_json(),
'light_vulnerability': self.light_vulnerability.to_json(),
'dark_vulnerability': self.dark_vulnerability.to_json(),
'melee_damage': self.melee_damage.to_json(),
'damage_info': self.damage_info.to_json(),
'jump_slide_damage': self.jump_slide_damage.to_json(),
'ground_pound_damage': self.ground_pound_damage.to_json(),
'emperor_ing_stage3_struct_a_0x98e311c1': self.emperor_ing_stage3_struct_a_0x98e311c1.to_json(),
'emperor_ing_stage3_struct_a_0x93dae216': self.emperor_ing_stage3_struct_a_0x93dae216.to_json(),
'light_swarm_effect': self.light_swarm_effect,
'light_swarm_properties': self.light_swarm_properties.to_json(),
'light_swarm_death_sound': self.light_swarm_death_sound.to_json(),
'audio_playback_parms': self.audio_playback_parms.to_json(),
'unknown_struct26': self.unknown_struct26.to_json(),
'jump_attack_shock_wave_info': self.jump_attack_shock_wave_info.to_json(),
'sound': self.sound,
'emperor_ing_stage3_struct_b_0xe843417f': self.emperor_ing_stage3_struct_b_0xe843417f.to_json(),
'emperor_ing_stage3_struct_b_0xd13bec3f': self.emperor_ing_stage3_struct_b_0xd13bec3f.to_json(),
'emperor_ing_stage3_struct_b_0xc61388ff': self.emperor_ing_stage3_struct_b_0xc61388ff.to_json(),
'emperor_ing_stage3_struct_b_0xa3cab6bf': self.emperor_ing_stage3_struct_b_0xa3cab6bf.to_json(),
}
def _dependencies_for_yellow_health(self, asset_manager):
yield from self.yellow_health.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_red_vulnerability(self, asset_manager):
yield from self.red_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_light_vulnerability(self, asset_manager):
yield from self.light_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_dark_vulnerability(self, asset_manager):
yield from self.dark_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_melee_damage(self, asset_manager):
yield from self.melee_damage.dependencies_for(asset_manager)
def _dependencies_for_damage_info(self, asset_manager):
yield from self.damage_info.dependencies_for(asset_manager)
def _dependencies_for_jump_slide_damage(self, asset_manager):
yield from self.jump_slide_damage.dependencies_for(asset_manager)
def _dependencies_for_ground_pound_damage(self, asset_manager):
yield from self.ground_pound_damage.dependencies_for(asset_manager)
def _dependencies_for_emperor_ing_stage3_struct_a_0x98e311c1(self, asset_manager):
yield from self.emperor_ing_stage3_struct_a_0x98e311c1.dependencies_for(asset_manager)
def _dependencies_for_emperor_ing_stage3_struct_a_0x93dae216(self, asset_manager):
yield from self.emperor_ing_stage3_struct_a_0x93dae216.dependencies_for(asset_manager)
def _dependencies_for_light_swarm_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.light_swarm_effect)
def _dependencies_for_light_swarm_properties(self, asset_manager):
yield from self.light_swarm_properties.dependencies_for(asset_manager)
def _dependencies_for_light_swarm_death_sound(self, asset_manager):
yield from self.light_swarm_death_sound.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms(self, asset_manager):
yield from self.audio_playback_parms.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct26(self, asset_manager):
yield from self.unknown_struct26.dependencies_for(asset_manager)
def _dependencies_for_jump_attack_shock_wave_info(self, asset_manager):
yield from self.jump_attack_shock_wave_info.dependencies_for(asset_manager)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def _dependencies_for_emperor_ing_stage3_struct_b_0xe843417f(self, asset_manager):
yield from self.emperor_ing_stage3_struct_b_0xe843417f.dependencies_for(asset_manager)
def _dependencies_for_emperor_ing_stage3_struct_b_0xd13bec3f(self, asset_manager):
yield from self.emperor_ing_stage3_struct_b_0xd13bec3f.dependencies_for(asset_manager)
def _dependencies_for_emperor_ing_stage3_struct_b_0xc61388ff(self, asset_manager):
yield from self.emperor_ing_stage3_struct_b_0xc61388ff.dependencies_for(asset_manager)
def _dependencies_for_emperor_ing_stage3_struct_b_0xa3cab6bf(self, asset_manager):
yield from self.emperor_ing_stage3_struct_b_0xa3cab6bf.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_yellow_health, "yellow_health", "HealthInfo"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_red_vulnerability, "red_vulnerability", "DamageVulnerability"),
(self._dependencies_for_light_vulnerability, "light_vulnerability", "DamageVulnerability"),
(self._dependencies_for_dark_vulnerability, "dark_vulnerability", "DamageVulnerability"),
(self._dependencies_for_melee_damage, "melee_damage", "DamageInfo"),
(self._dependencies_for_damage_info, "damage_info", "DamageInfo"),
(self._dependencies_for_jump_slide_damage, "jump_slide_damage", "DamageInfo"),
(self._dependencies_for_ground_pound_damage, "ground_pound_damage", "DamageInfo"),
(self._dependencies_for_emperor_ing_stage3_struct_a_0x98e311c1, "emperor_ing_stage3_struct_a_0x98e311c1", "EmperorIngStage3StructA"),
(self._dependencies_for_emperor_ing_stage3_struct_a_0x93dae216, "emperor_ing_stage3_struct_a_0x93dae216", "EmperorIngStage3StructA"),
(self._dependencies_for_light_swarm_effect, "light_swarm_effect", "AssetId"),
(self._dependencies_for_light_swarm_properties, "light_swarm_properties", "BasicSwarmProperties"),
(self._dependencies_for_light_swarm_death_sound, "light_swarm_death_sound", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms, "audio_playback_parms", "AudioPlaybackParms"),
(self._dependencies_for_unknown_struct26, "unknown_struct26", "UnknownStruct26"),
(self._dependencies_for_jump_attack_shock_wave_info, "jump_attack_shock_wave_info", "ShockWaveInfo"),
(self._dependencies_for_sound, "sound", "int"),
(self._dependencies_for_emperor_ing_stage3_struct_b_0xe843417f, "emperor_ing_stage3_struct_b_0xe843417f", "EmperorIngStage3StructB"),
(self._dependencies_for_emperor_ing_stage3_struct_b_0xd13bec3f, "emperor_ing_stage3_struct_b_0xd13bec3f", "EmperorIngStage3StructB"),
(self._dependencies_for_emperor_ing_stage3_struct_b_0xc61388ff, "emperor_ing_stage3_struct_b_0xc61388ff", "EmperorIngStage3StructB"),
(self._dependencies_for_emperor_ing_stage3_struct_b_0xa3cab6bf, "emperor_ing_stage3_struct_b_0xa3cab6bf", "EmperorIngStage3StructB"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage3Data.{field_name} ({field_type}): {e}"
)
def _decode_taunt_frequency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_yellow_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerable_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vulnerable_damage_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_red_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_light_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_dark_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_melee_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_damage_info(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_jump_slide_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_ground_pound_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_emperor_ing_stage3_struct_a_0x98e311c1(data: typing.BinaryIO, property_size: int):
return EmperorIngStage3StructA.from_stream(data, property_size)
def _decode_emperor_ing_stage3_struct_a_0x93dae216(data: typing.BinaryIO, property_size: int):
return EmperorIngStage3StructA.from_stream(data, property_size)
def _decode_light_swarm_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_light_swarm_properties(data: typing.BinaryIO, property_size: int):
return BasicSwarmProperties.from_stream(data, property_size)
def _decode_light_swarm_death_sound(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_unknown_struct26(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_jump_attack_shock_wave_info(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.from_stream(data, property_size)
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_emperor_ing_stage3_struct_b_0xe843417f(data: typing.BinaryIO, property_size: int):
return EmperorIngStage3StructB.from_stream(data, property_size)
def _decode_emperor_ing_stage3_struct_b_0xd13bec3f(data: typing.BinaryIO, property_size: int):
return EmperorIngStage3StructB.from_stream(data, property_size)
def _decode_emperor_ing_stage3_struct_b_0xc61388ff(data: typing.BinaryIO, property_size: int):
return EmperorIngStage3StructB.from_stream(data, property_size)
def _decode_emperor_ing_stage3_struct_b_0xa3cab6bf(data: typing.BinaryIO, property_size: int):
return EmperorIngStage3StructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x293a0c19: ('taunt_frequency', _decode_taunt_frequency),
0x8a3f760c: ('yellow_health', _decode_yellow_health),
0xcf90d15e: ('health', _decode_health),
0x69bc5cd4: ('vulnerable_time', _decode_vulnerable_time),
0xb110e539: ('vulnerable_damage_threshold', _decode_vulnerable_damage_threshold),
0x8d70d67a: ('red_vulnerability', _decode_red_vulnerability),
0x89c142f7: ('light_vulnerability', _decode_light_vulnerability),
0x8855c118: ('dark_vulnerability', _decode_dark_vulnerability),
0xc9416034: ('melee_damage', _decode_melee_damage),
0x1440d152: ('damage_info', _decode_damage_info),
0xef582bd6: ('jump_slide_damage', _decode_jump_slide_damage),
0x4738c321: ('ground_pound_damage', _decode_ground_pound_damage),
0x98e311c1: ('emperor_ing_stage3_struct_a_0x98e311c1', _decode_emperor_ing_stage3_struct_a_0x98e311c1),
0x93dae216: ('emperor_ing_stage3_struct_a_0x93dae216', _decode_emperor_ing_stage3_struct_a_0x93dae216),
0x4f82b9e5: ('light_swarm_effect', _decode_light_swarm_effect),
0x43e9c2e: ('light_swarm_properties', _decode_light_swarm_properties),
0x91001508: ('light_swarm_death_sound', _decode_light_swarm_death_sound),
0x3552953: ('audio_playback_parms', _decode_audio_playback_parms),
0xaf7e3033: ('unknown_struct26', _decode_unknown_struct26),
0xab4ed456: ('jump_attack_shock_wave_info', _decode_jump_attack_shock_wave_info),
0x985f72fd: ('sound', _decode_sound),
0xe843417f: ('emperor_ing_stage3_struct_b_0xe843417f', _decode_emperor_ing_stage3_struct_b_0xe843417f),
0xd13bec3f: ('emperor_ing_stage3_struct_b_0xd13bec3f', _decode_emperor_ing_stage3_struct_b_0xd13bec3f),
0xc61388ff: ('emperor_ing_stage3_struct_b_0xc61388ff', _decode_emperor_ing_stage3_struct_b_0xc61388ff),
0xa3cab6bf: ('emperor_ing_stage3_struct_b_0xa3cab6bf', _decode_emperor_ing_stage3_struct_b_0xa3cab6bf),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EmperorIngStage3Data.py | 0.532182 | 0.165391 | EmperorIngStage3Data.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightSpotlight(BaseProperty):
spotlight_angle: Spline = dataclasses.field(default_factory=Spline)
spotlight_angle_duration: float = dataclasses.field(default=0.0)
spotlight_angle_loops: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xfe\xec\xa0\xd6') # 0xfeeca0d6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spotlight_angle.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'y\xaay\x8b') # 0x79aa798b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spotlight_angle_duration))
data.write(b'/\xd0\x83\x00') # 0x2fd08300
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spotlight_angle_loops))
@classmethod
def from_json(cls, data: dict):
return cls(
spotlight_angle=Spline.from_json(data['spotlight_angle']),
spotlight_angle_duration=data['spotlight_angle_duration'],
spotlight_angle_loops=data['spotlight_angle_loops'],
)
def to_json(self) -> dict:
return {
'spotlight_angle': self.spotlight_angle.to_json(),
'spotlight_angle_duration': self.spotlight_angle_duration,
'spotlight_angle_loops': self.spotlight_angle_loops,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_spotlight_angle(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_spotlight_angle_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spotlight_angle_loops(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]]] = {
0xfeeca0d6: ('spotlight_angle', _decode_spotlight_angle),
0x79aa798b: ('spotlight_angle_duration', _decode_spotlight_angle_duration),
0x2fd08300: ('spotlight_angle_loops', _decode_spotlight_angle_loops),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DynamicLightSpotlight.py | 0.653459 | 0.336099 | DynamicLightSpotlight.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
from retro_data_structures.properties.echoes.archetypes.EmperorIngStage1TentacleData import EmperorIngStage1TentacleData
from retro_data_structures.properties.echoes.archetypes.UnknownStruct20 import UnknownStruct20
from retro_data_structures.properties.echoes.archetypes.UnknownStruct21 import UnknownStruct21
from retro_data_structures.properties.echoes.archetypes.UnknownStruct22 import UnknownStruct22
from retro_data_structures.properties.echoes.archetypes.UnknownStruct23 import UnknownStruct23
from retro_data_structures.properties.echoes.archetypes.UnknownStruct24 import UnknownStruct24
@dataclasses.dataclass()
class EmperorIngStage1Data(BaseProperty):
tentacle: EmperorIngStage1TentacleData = dataclasses.field(default_factory=EmperorIngStage1TentacleData)
unknown_struct20: UnknownStruct20 = dataclasses.field(default_factory=UnknownStruct20)
unknown_struct21: UnknownStruct21 = dataclasses.field(default_factory=UnknownStruct21)
unknown_struct22: UnknownStruct22 = dataclasses.field(default_factory=UnknownStruct22)
unknown_struct23: UnknownStruct23 = dataclasses.field(default_factory=UnknownStruct23)
unknown_struct24: UnknownStruct24 = dataclasses.field(default_factory=UnknownStruct24)
heart_exposed_time: float = dataclasses.field(default=0.0)
unknown_0x905938b8: float = dataclasses.field(default=0.0)
unknown_0xb826317a: float = dataclasses.field(default=0.0)
heart_damage_sound: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
turn_speed_accel: float = dataclasses.field(default=0.0)
max_turn_speed_normal: float = dataclasses.field(default=0.0)
max_turn_speed_melee: float = dataclasses.field(default=0.0)
unknown_0xe5a7c358: float = dataclasses.field(default=0.0)
vulnerability_change_sound: int = dataclasses.field(default=0, metadata={'sound': True})
taunt_frequency: float = dataclasses.field(default=0.0)
attack_interval_min: float = dataclasses.field(default=0.0)
attack_interval_max: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x12') # 18 properties
data.write(b'\xb3\xc69\x8f') # 0xb3c6398f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tentacle.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5\x9f\x9a`') # 0xf59f9a60
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct20.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\xcd\xa0\xb6') # 0xa1cda0b6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct21.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x85\xf3ds') # 0x85f36473
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct22.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\xbc\x04\xc4') # 0xb4bc04c4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct23.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8em \xec') # 0x8e6d20ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct24.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa5\x88\xaf\xd1') # 0xa588afd1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.heart_exposed_time))
data.write(b'\x90Y8\xb8') # 0x905938b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x905938b8))
data.write(b'\xb8&1z') # 0xb826317a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb826317a))
data.write(b'\x88##\x88') # 0x88232388
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.heart_damage_sound.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3j\xe5\xca') # 0xc36ae5ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed_accel))
data.write(b'\xd3\r\x9b\xb9') # 0xd30d9bb9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_turn_speed_normal))
data.write(b'\xb0,\xd3\x1f') # 0xb02cd31f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_turn_speed_melee))
data.write(b'\xe5\xa7\xc3X') # 0xe5a7c358
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe5a7c358))
data.write(b'\x935r@') # 0x93357240
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.vulnerability_change_sound))
data.write(b'):\x0c\x19') # 0x293a0c19
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_frequency))
data.write(b'1\xeb\xf8i') # 0x31ebf869
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_interval_min))
data.write(b'\xd7\x8bW\x88') # 0xd78b5788
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_interval_max))
@classmethod
def from_json(cls, data: dict):
return cls(
tentacle=EmperorIngStage1TentacleData.from_json(data['tentacle']),
unknown_struct20=UnknownStruct20.from_json(data['unknown_struct20']),
unknown_struct21=UnknownStruct21.from_json(data['unknown_struct21']),
unknown_struct22=UnknownStruct22.from_json(data['unknown_struct22']),
unknown_struct23=UnknownStruct23.from_json(data['unknown_struct23']),
unknown_struct24=UnknownStruct24.from_json(data['unknown_struct24']),
heart_exposed_time=data['heart_exposed_time'],
unknown_0x905938b8=data['unknown_0x905938b8'],
unknown_0xb826317a=data['unknown_0xb826317a'],
heart_damage_sound=AudioPlaybackParms.from_json(data['heart_damage_sound']),
turn_speed_accel=data['turn_speed_accel'],
max_turn_speed_normal=data['max_turn_speed_normal'],
max_turn_speed_melee=data['max_turn_speed_melee'],
unknown_0xe5a7c358=data['unknown_0xe5a7c358'],
vulnerability_change_sound=data['vulnerability_change_sound'],
taunt_frequency=data['taunt_frequency'],
attack_interval_min=data['attack_interval_min'],
attack_interval_max=data['attack_interval_max'],
)
def to_json(self) -> dict:
return {
'tentacle': self.tentacle.to_json(),
'unknown_struct20': self.unknown_struct20.to_json(),
'unknown_struct21': self.unknown_struct21.to_json(),
'unknown_struct22': self.unknown_struct22.to_json(),
'unknown_struct23': self.unknown_struct23.to_json(),
'unknown_struct24': self.unknown_struct24.to_json(),
'heart_exposed_time': self.heart_exposed_time,
'unknown_0x905938b8': self.unknown_0x905938b8,
'unknown_0xb826317a': self.unknown_0xb826317a,
'heart_damage_sound': self.heart_damage_sound.to_json(),
'turn_speed_accel': self.turn_speed_accel,
'max_turn_speed_normal': self.max_turn_speed_normal,
'max_turn_speed_melee': self.max_turn_speed_melee,
'unknown_0xe5a7c358': self.unknown_0xe5a7c358,
'vulnerability_change_sound': self.vulnerability_change_sound,
'taunt_frequency': self.taunt_frequency,
'attack_interval_min': self.attack_interval_min,
'attack_interval_max': self.attack_interval_max,
}
def _dependencies_for_tentacle(self, asset_manager):
yield from self.tentacle.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct20(self, asset_manager):
yield from self.unknown_struct20.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct21(self, asset_manager):
yield from self.unknown_struct21.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct22(self, asset_manager):
yield from self.unknown_struct22.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct23(self, asset_manager):
yield from self.unknown_struct23.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct24(self, asset_manager):
yield from self.unknown_struct24.dependencies_for(asset_manager)
def _dependencies_for_heart_damage_sound(self, asset_manager):
yield from self.heart_damage_sound.dependencies_for(asset_manager)
def _dependencies_for_vulnerability_change_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.vulnerability_change_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_tentacle, "tentacle", "EmperorIngStage1TentacleData"),
(self._dependencies_for_unknown_struct20, "unknown_struct20", "UnknownStruct20"),
(self._dependencies_for_unknown_struct21, "unknown_struct21", "UnknownStruct21"),
(self._dependencies_for_unknown_struct22, "unknown_struct22", "UnknownStruct22"),
(self._dependencies_for_unknown_struct23, "unknown_struct23", "UnknownStruct23"),
(self._dependencies_for_unknown_struct24, "unknown_struct24", "UnknownStruct24"),
(self._dependencies_for_heart_damage_sound, "heart_damage_sound", "AudioPlaybackParms"),
(self._dependencies_for_vulnerability_change_sound, "vulnerability_change_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage1Data.{field_name} ({field_type}): {e}"
)
def _decode_tentacle(data: typing.BinaryIO, property_size: int):
return EmperorIngStage1TentacleData.from_stream(data, property_size)
def _decode_unknown_struct20(data: typing.BinaryIO, property_size: int):
return UnknownStruct20.from_stream(data, property_size)
def _decode_unknown_struct21(data: typing.BinaryIO, property_size: int):
return UnknownStruct21.from_stream(data, property_size)
def _decode_unknown_struct22(data: typing.BinaryIO, property_size: int):
return UnknownStruct22.from_stream(data, property_size)
def _decode_unknown_struct23(data: typing.BinaryIO, property_size: int):
return UnknownStruct23.from_stream(data, property_size)
def _decode_unknown_struct24(data: typing.BinaryIO, property_size: int):
return UnknownStruct24.from_stream(data, property_size)
def _decode_heart_exposed_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x905938b8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb826317a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_heart_damage_sound(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_turn_speed_accel(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_turn_speed_normal(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_turn_speed_melee(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe5a7c358(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vulnerability_change_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_taunt_frequency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_interval_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_interval_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]]] = {
0xb3c6398f: ('tentacle', _decode_tentacle),
0xf59f9a60: ('unknown_struct20', _decode_unknown_struct20),
0xa1cda0b6: ('unknown_struct21', _decode_unknown_struct21),
0x85f36473: ('unknown_struct22', _decode_unknown_struct22),
0xb4bc04c4: ('unknown_struct23', _decode_unknown_struct23),
0x8e6d20ec: ('unknown_struct24', _decode_unknown_struct24),
0xa588afd1: ('heart_exposed_time', _decode_heart_exposed_time),
0x905938b8: ('unknown_0x905938b8', _decode_unknown_0x905938b8),
0xb826317a: ('unknown_0xb826317a', _decode_unknown_0xb826317a),
0x88232388: ('heart_damage_sound', _decode_heart_damage_sound),
0xc36ae5ca: ('turn_speed_accel', _decode_turn_speed_accel),
0xd30d9bb9: ('max_turn_speed_normal', _decode_max_turn_speed_normal),
0xb02cd31f: ('max_turn_speed_melee', _decode_max_turn_speed_melee),
0xe5a7c358: ('unknown_0xe5a7c358', _decode_unknown_0xe5a7c358),
0x93357240: ('vulnerability_change_sound', _decode_vulnerability_change_sound),
0x293a0c19: ('taunt_frequency', _decode_taunt_frequency),
0x31ebf869: ('attack_interval_min', _decode_attack_interval_min),
0xd78b5788: ('attack_interval_max', _decode_attack_interval_max),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/EmperorIngStage1Data.py | 0.513912 | 0.254023 | EmperorIngStage1Data.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class IngSpiderballGuardianStruct(BaseProperty):
min_patrol_speed: float = dataclasses.field(default=5.0)
max_patrol_speed: float = dataclasses.field(default=10.0)
linear_acceleration: float = dataclasses.field(default=7.0)
angular_speed: float = dataclasses.field(default=720.0)
unknown: float = dataclasses.field(default=40.0)
stunned_speed: float = dataclasses.field(default=2.0)
stunned_time: float = dataclasses.field(default=25.0)
max_charge_time: float = dataclasses.field(default=15.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\x17\xc5\xb6\x1d') # 0x17c5b61d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_patrol_speed))
data.write(b'\xb0\xf16d') # 0xb0f13664
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_patrol_speed))
data.write(b'\xaf\x9b\x05\xf4') # 0xaf9b05f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.linear_acceleration))
data.write(b'\xbc\xd73?') # 0xbcd7333f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angular_speed))
data.write(b'\xd1\xd9\xd8\xbd') # 0xd1d9d8bd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x8dY\x17\xd4') # 0x8d5917d4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stunned_speed))
data.write(b'\x81\x05\xec\xfd') # 0x8105ecfd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stunned_time))
data.write(b'\xe5\x06^\xa8') # 0xe5065ea8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_charge_time))
@classmethod
def from_json(cls, data: dict):
return cls(
min_patrol_speed=data['min_patrol_speed'],
max_patrol_speed=data['max_patrol_speed'],
linear_acceleration=data['linear_acceleration'],
angular_speed=data['angular_speed'],
unknown=data['unknown'],
stunned_speed=data['stunned_speed'],
stunned_time=data['stunned_time'],
max_charge_time=data['max_charge_time'],
)
def to_json(self) -> dict:
return {
'min_patrol_speed': self.min_patrol_speed,
'max_patrol_speed': self.max_patrol_speed,
'linear_acceleration': self.linear_acceleration,
'angular_speed': self.angular_speed,
'unknown': self.unknown,
'stunned_speed': self.stunned_speed,
'stunned_time': self.stunned_time,
'max_charge_time': self.max_charge_time,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0x17c5b61d, 0xb0f13664, 0xaf9b05f4, 0xbcd7333f, 0xd1d9d8bd, 0x8d5917d4, 0x8105ecfd, 0xe5065ea8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[IngSpiderballGuardianStruct]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(80))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21]) != _FAST_IDS:
data.seek(before)
return None
return IngSpiderballGuardianStruct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_min_patrol_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_patrol_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_linear_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_angular_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stunned_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stunned_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_charge_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]]] = {
0x17c5b61d: ('min_patrol_speed', _decode_min_patrol_speed),
0xb0f13664: ('max_patrol_speed', _decode_max_patrol_speed),
0xaf9b05f4: ('linear_acceleration', _decode_linear_acceleration),
0xbcd7333f: ('angular_speed', _decode_angular_speed),
0xd1d9d8bd: ('unknown', _decode_unknown),
0x8d5917d4: ('stunned_speed', _decode_stunned_speed),
0x8105ecfd: ('stunned_time', _decode_stunned_time),
0xe5065ea8: ('max_charge_time', _decode_max_charge_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/IngSpiderballGuardianStruct.py | 0.698227 | 0.280075 | IngSpiderballGuardianStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightIntensity(BaseProperty):
intensity: Spline = dataclasses.field(default_factory=Spline)
intensity_duration: float = dataclasses.field(default=0.0)
intensity_loops: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'#\x9d\r+') # 0x239d0d2b
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'\xc9\r\x88\x99') # 0xc90d8899
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.intensity_duration))
data.write(b'\xaeg\xe0P') # 0xae67e050
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.intensity_loops))
@classmethod
def from_json(cls, data: dict):
return cls(
intensity=Spline.from_json(data['intensity']),
intensity_duration=data['intensity_duration'],
intensity_loops=data['intensity_loops'],
)
def to_json(self) -> dict:
return {
'intensity': self.intensity.to_json(),
'intensity_duration': self.intensity_duration,
'intensity_loops': self.intensity_loops,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_intensity(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_intensity_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_intensity_loops(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]]] = {
0x239d0d2b: ('intensity', _decode_intensity),
0xc90d8899: ('intensity_duration', _decode_intensity_duration),
0xae67e050: ('intensity_loops', _decode_intensity_loops),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/DynamicLightIntensity.py | 0.733452 | 0.312527 | DynamicLightIntensity.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct11(BaseProperty):
shield_charge_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
shield_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0xc1d9dbc6: float = dataclasses.field(default=15.0)
unknown_0x927fc322: float = dataclasses.field(default=30.0)
shield_charge_speed: float = dataclasses.field(default=40.0)
shield_explode_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_shield_explode: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x6cb0da5a: float = dataclasses.field(default=50.0)
unknown_0xc3938663: float = dataclasses.field(default=1.5)
arm_shield_chance: float = dataclasses.field(default=50.0)
arm_shield_time: float = dataclasses.field(default=4.0)
unknown_0xe1b0efa0: float = dataclasses.field(default=1.0)
arm_shield_explode_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
shield_charge_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
arm_shield_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_0xbf3c59b6: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x78be3b8d: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x11') # 17 properties
data.write(b'M\xa4\xa8\x94') # 0x4da4a894
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shield_charge_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'\xd3O\x13#') # 0xd34f1323
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shield_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc1\xd9\xdb\xc6') # 0xc1d9dbc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc1d9dbc6))
data.write(b'\x92\x7f\xc3"') # 0x927fc322
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x927fc322))
data.write(b'qx$\xb4') # 0x717824b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shield_charge_speed))
data.write(b'\xa4\x1fu\xef') # 0xa41f75ef
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shield_explode_effect))
data.write(b'\xe6\xe9.s') # 0xe6e92e73
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_shield_explode))
data.write(b'l\xb0\xdaZ') # 0x6cb0da5a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6cb0da5a))
data.write(b'\xc3\x93\x86c') # 0xc3938663
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc3938663))
data.write(b'\x86\\\x10\x9c') # 0x865c109c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.arm_shield_chance))
data.write(b'\x8bH\xa2\xf8') # 0x8b48a2f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.arm_shield_time))
data.write(b'\xe1\xb0\xef\xa0') # 0xe1b0efa0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe1b0efa0))
data.write(b'\\\xa2\x06\xca') # 0x5ca206ca
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.arm_shield_explode_effect))
data.write(b'\xeb\xf6\x9c\xf0') # 0xebf69cf0
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shield_charge_effect))
data.write(b'J\xabN\x04') # 0x4aab4e04
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.arm_shield_effect))
data.write(b'\xbf<Y\xb6') # 0xbf3c59b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xbf3c59b6))
data.write(b'x\xbe;\x8d') # 0x78be3b8d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x78be3b8d))
@classmethod
def from_json(cls, data: dict):
return cls(
shield_charge_damage=DamageInfo.from_json(data['shield_charge_damage']),
shield_vulnerability=DamageVulnerability.from_json(data['shield_vulnerability']),
unknown_0xc1d9dbc6=data['unknown_0xc1d9dbc6'],
unknown_0x927fc322=data['unknown_0x927fc322'],
shield_charge_speed=data['shield_charge_speed'],
shield_explode_effect=data['shield_explode_effect'],
sound_shield_explode=data['sound_shield_explode'],
unknown_0x6cb0da5a=data['unknown_0x6cb0da5a'],
unknown_0xc3938663=data['unknown_0xc3938663'],
arm_shield_chance=data['arm_shield_chance'],
arm_shield_time=data['arm_shield_time'],
unknown_0xe1b0efa0=data['unknown_0xe1b0efa0'],
arm_shield_explode_effect=data['arm_shield_explode_effect'],
shield_charge_effect=data['shield_charge_effect'],
arm_shield_effect=data['arm_shield_effect'],
sound_0xbf3c59b6=data['sound_0xbf3c59b6'],
sound_0x78be3b8d=data['sound_0x78be3b8d'],
)
def to_json(self) -> dict:
return {
'shield_charge_damage': self.shield_charge_damage.to_json(),
'shield_vulnerability': self.shield_vulnerability.to_json(),
'unknown_0xc1d9dbc6': self.unknown_0xc1d9dbc6,
'unknown_0x927fc322': self.unknown_0x927fc322,
'shield_charge_speed': self.shield_charge_speed,
'shield_explode_effect': self.shield_explode_effect,
'sound_shield_explode': self.sound_shield_explode,
'unknown_0x6cb0da5a': self.unknown_0x6cb0da5a,
'unknown_0xc3938663': self.unknown_0xc3938663,
'arm_shield_chance': self.arm_shield_chance,
'arm_shield_time': self.arm_shield_time,
'unknown_0xe1b0efa0': self.unknown_0xe1b0efa0,
'arm_shield_explode_effect': self.arm_shield_explode_effect,
'shield_charge_effect': self.shield_charge_effect,
'arm_shield_effect': self.arm_shield_effect,
'sound_0xbf3c59b6': self.sound_0xbf3c59b6,
'sound_0x78be3b8d': self.sound_0x78be3b8d,
}
def _dependencies_for_shield_charge_damage(self, asset_manager):
yield from self.shield_charge_damage.dependencies_for(asset_manager)
def _dependencies_for_shield_vulnerability(self, asset_manager):
yield from self.shield_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_shield_explode_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shield_explode_effect)
def _dependencies_for_sound_shield_explode(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_shield_explode)
def _dependencies_for_arm_shield_explode_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.arm_shield_explode_effect)
def _dependencies_for_shield_charge_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shield_charge_effect)
def _dependencies_for_arm_shield_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.arm_shield_effect)
def _dependencies_for_sound_0xbf3c59b6(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xbf3c59b6)
def _dependencies_for_sound_0x78be3b8d(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x78be3b8d)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_shield_charge_damage, "shield_charge_damage", "DamageInfo"),
(self._dependencies_for_shield_vulnerability, "shield_vulnerability", "DamageVulnerability"),
(self._dependencies_for_shield_explode_effect, "shield_explode_effect", "AssetId"),
(self._dependencies_for_sound_shield_explode, "sound_shield_explode", "int"),
(self._dependencies_for_arm_shield_explode_effect, "arm_shield_explode_effect", "AssetId"),
(self._dependencies_for_shield_charge_effect, "shield_charge_effect", "AssetId"),
(self._dependencies_for_arm_shield_effect, "arm_shield_effect", "AssetId"),
(self._dependencies_for_sound_0xbf3c59b6, "sound_0xbf3c59b6", "int"),
(self._dependencies_for_sound_0x78be3b8d, "sound_0x78be3b8d", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct11.{field_name} ({field_type}): {e}"
)
def _decode_shield_charge_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_shield_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0xc1d9dbc6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x927fc322(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shield_charge_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shield_explode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_shield_explode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6cb0da5a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc3938663(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_arm_shield_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_arm_shield_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe1b0efa0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_arm_shield_explode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_shield_charge_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_arm_shield_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_0xbf3c59b6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x78be3b8d(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]]] = {
0x4da4a894: ('shield_charge_damage', _decode_shield_charge_damage),
0xd34f1323: ('shield_vulnerability', _decode_shield_vulnerability),
0xc1d9dbc6: ('unknown_0xc1d9dbc6', _decode_unknown_0xc1d9dbc6),
0x927fc322: ('unknown_0x927fc322', _decode_unknown_0x927fc322),
0x717824b4: ('shield_charge_speed', _decode_shield_charge_speed),
0xa41f75ef: ('shield_explode_effect', _decode_shield_explode_effect),
0xe6e92e73: ('sound_shield_explode', _decode_sound_shield_explode),
0x6cb0da5a: ('unknown_0x6cb0da5a', _decode_unknown_0x6cb0da5a),
0xc3938663: ('unknown_0xc3938663', _decode_unknown_0xc3938663),
0x865c109c: ('arm_shield_chance', _decode_arm_shield_chance),
0x8b48a2f8: ('arm_shield_time', _decode_arm_shield_time),
0xe1b0efa0: ('unknown_0xe1b0efa0', _decode_unknown_0xe1b0efa0),
0x5ca206ca: ('arm_shield_explode_effect', _decode_arm_shield_explode_effect),
0xebf69cf0: ('shield_charge_effect', _decode_shield_charge_effect),
0x4aab4e04: ('arm_shield_effect', _decode_arm_shield_effect),
0xbf3c59b6: ('sound_0xbf3c59b6', _decode_sound_0xbf3c59b6),
0x78be3b8d: ('sound_0x78be3b8d', _decode_sound_0x78be3b8d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct11.py | 0.52902 | 0.201479 | UnknownStruct11.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class IngPossessionData(BaseProperty):
is_an_encounter: bool = dataclasses.field(default=False)
unknown_0xb68c0aa3: bool = dataclasses.field(default=True)
ing_possessed_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
ing_possessed_skin_rules: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
dark_scan_info: AssetId = dataclasses.field(metadata={'asset_types': ['SCAN']}, default=default_asset_id)
ing_possessed_health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
ing_possessed_damage_multiplier: float = dataclasses.field(default=2.0)
unknown_0x2befc1bf: int = dataclasses.field(default=0)
ing_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x88\x8f\xa45') # 0x888fa435
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_an_encounter))
data.write(b'\xb6\x8c\n\xa3') # 0xb68c0aa3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb68c0aa3))
data.write(b'\xadT\xda\x11') # 0xad54da11
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ing_possessed_model))
data.write(b'\xf5\xc6c\x84') # 0xf5c66384
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ing_possessed_skin_rules))
data.write(b'5\xa9y.') # 0x35a9792e
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.dark_scan_info))
data.write(b'\x1d\x85-K') # 0x1d852d4b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_possessed_health.to_stream(data, default_override={'health': 150.0, 'hi_knock_back_resistance': 2.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'H~O\x9a') # 0x487e4f9a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ing_possessed_damage_multiplier))
data.write(b'+\xef\xc1\xbf') # 0x2befc1bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2befc1bf))
data.write(b'J\xee\xc0\x93') # 0x4aeec093
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
is_an_encounter=data['is_an_encounter'],
unknown_0xb68c0aa3=data['unknown_0xb68c0aa3'],
ing_possessed_model=data['ing_possessed_model'],
ing_possessed_skin_rules=data['ing_possessed_skin_rules'],
dark_scan_info=data['dark_scan_info'],
ing_possessed_health=HealthInfo.from_json(data['ing_possessed_health']),
ing_possessed_damage_multiplier=data['ing_possessed_damage_multiplier'],
unknown_0x2befc1bf=data['unknown_0x2befc1bf'],
ing_vulnerability=DamageVulnerability.from_json(data['ing_vulnerability']),
)
def to_json(self) -> dict:
return {
'is_an_encounter': self.is_an_encounter,
'unknown_0xb68c0aa3': self.unknown_0xb68c0aa3,
'ing_possessed_model': self.ing_possessed_model,
'ing_possessed_skin_rules': self.ing_possessed_skin_rules,
'dark_scan_info': self.dark_scan_info,
'ing_possessed_health': self.ing_possessed_health.to_json(),
'ing_possessed_damage_multiplier': self.ing_possessed_damage_multiplier,
'unknown_0x2befc1bf': self.unknown_0x2befc1bf,
'ing_vulnerability': self.ing_vulnerability.to_json(),
}
def _dependencies_for_ing_possessed_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ing_possessed_model)
def _dependencies_for_ing_possessed_skin_rules(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ing_possessed_skin_rules)
def _dependencies_for_dark_scan_info(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dark_scan_info)
def _dependencies_for_ing_possessed_health(self, asset_manager):
yield from self.ing_possessed_health.dependencies_for(asset_manager)
def _dependencies_for_ing_vulnerability(self, asset_manager):
yield from self.ing_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_ing_possessed_model, "ing_possessed_model", "AssetId"),
(self._dependencies_for_ing_possessed_skin_rules, "ing_possessed_skin_rules", "AssetId"),
(self._dependencies_for_dark_scan_info, "dark_scan_info", "AssetId"),
(self._dependencies_for_ing_possessed_health, "ing_possessed_health", "HealthInfo"),
(self._dependencies_for_ing_vulnerability, "ing_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IngPossessionData.{field_name} ({field_type}): {e}"
)
def _decode_is_an_encounter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb68c0aa3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ing_possessed_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_ing_possessed_skin_rules(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_dark_scan_info(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_ing_possessed_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size, default_override={'health': 150.0, 'hi_knock_back_resistance': 2.0})
def _decode_ing_possessed_damage_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2befc1bf(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_ing_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x888fa435: ('is_an_encounter', _decode_is_an_encounter),
0xb68c0aa3: ('unknown_0xb68c0aa3', _decode_unknown_0xb68c0aa3),
0xad54da11: ('ing_possessed_model', _decode_ing_possessed_model),
0xf5c66384: ('ing_possessed_skin_rules', _decode_ing_possessed_skin_rules),
0x35a9792e: ('dark_scan_info', _decode_dark_scan_info),
0x1d852d4b: ('ing_possessed_health', _decode_ing_possessed_health),
0x487e4f9a: ('ing_possessed_damage_multiplier', _decode_ing_possessed_damage_multiplier),
0x2befc1bf: ('unknown_0x2befc1bf', _decode_unknown_0x2befc1bf),
0x4aeec093: ('ing_vulnerability', _decode_ing_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/IngPossessionData.py | 0.576184 | 0.224331 | IngPossessionData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct4(BaseProperty):
behaviour_type: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xc1\xe7G\xad') # 0xc1e747ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.behaviour_type))
@classmethod
def from_json(cls, data: dict):
return cls(
behaviour_type=data['behaviour_type'],
)
def to_json(self) -> dict:
return {
'behaviour_type': self.behaviour_type,
}
def dependencies_for(self, asset_manager):
yield from []
_FAST_FORMAT = None
_FAST_IDS = (0xc1e747ad)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct4]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct4(
dec[2],
)
def _decode_behaviour_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]]] = {
0xc1e747ad: ('behaviour_type', _decode_behaviour_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct4.py | 0.594316 | 0.283362 | UnknownStruct4.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class CameraShakerData(BaseProperty):
flags_camera_shaker: int = dataclasses.field(default=16) # Flagset
attenuation_distance: float = dataclasses.field(default=5.0)
horizontal_motion: Spline = dataclasses.field(default_factory=Spline)
vertical_motion: Spline = dataclasses.field(default_factory=Spline)
forward_motion: Spline = dataclasses.field(default_factory=Spline)
duration: float = dataclasses.field(default=1.0)
audio_effect: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xc3\xe7\\_') # 0xc3e75c5f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_camera_shaker))
data.write(b'M(:\xc5') # 0x4d283ac5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attenuation_distance))
data.write(b'\xf1"\xcd\x97') # 0xf122cd97
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.horizontal_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b")'\xe5D") # 0x2927e544
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vertical_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|\xfaFx') # 0x7cfa4678
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forward_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'8\x8d.F') # 0x388d2e46
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.audio_effect))
@classmethod
def from_json(cls, data: dict):
return cls(
flags_camera_shaker=data['flags_camera_shaker'],
attenuation_distance=data['attenuation_distance'],
horizontal_motion=Spline.from_json(data['horizontal_motion']),
vertical_motion=Spline.from_json(data['vertical_motion']),
forward_motion=Spline.from_json(data['forward_motion']),
duration=data['duration'],
audio_effect=data['audio_effect'],
)
def to_json(self) -> dict:
return {
'flags_camera_shaker': self.flags_camera_shaker,
'attenuation_distance': self.attenuation_distance,
'horizontal_motion': self.horizontal_motion.to_json(),
'vertical_motion': self.vertical_motion.to_json(),
'forward_motion': self.forward_motion.to_json(),
'duration': self.duration,
'audio_effect': self.audio_effect,
}
def _dependencies_for_audio_effect(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.audio_effect)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_audio_effect, "audio_effect", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CameraShakerData.{field_name} ({field_type}): {e}"
)
def _decode_flags_camera_shaker(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_attenuation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horizontal_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_vertical_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_forward_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_audio_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]]] = {
0xc3e75c5f: ('flags_camera_shaker', _decode_flags_camera_shaker),
0x4d283ac5: ('attenuation_distance', _decode_attenuation_distance),
0xf122cd97: ('horizontal_motion', _decode_horizontal_motion),
0x2927e544: ('vertical_motion', _decode_vertical_motion),
0x7cfa4678: ('forward_motion', _decode_forward_motion),
0x8b51e23f: ('duration', _decode_duration),
0x388d2e46: ('audio_effect', _decode_audio_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/CameraShakerData.py | 0.635675 | 0.256262 | CameraShakerData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct38(BaseProperty):
range: float = dataclasses.field(default=20.0)
turn_rate: float = dataclasses.field(default=180.0)
sound_effect: int = dataclasses.field(default=0, metadata={'sound': True})
warp_scale: float = dataclasses.field(default=5.0)
repel_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=1.0, z=5.0))
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'6B\xa3\x98') # 0x3642a398
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.range))
data.write(b'\xe3M\xc7\x03') # 0xe34dc703
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_rate))
data.write(b'\x8d;\xa8\xae') # 0x8d3ba8ae
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_effect))
data.write(b'\xb9\x90\x98\xd9') # 0xb99098d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warp_scale))
data.write(b'\xb3%#$') # 0xb3252324
data.write(b'\x00\x0c') # size
self.repel_offset.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
range=data['range'],
turn_rate=data['turn_rate'],
sound_effect=data['sound_effect'],
warp_scale=data['warp_scale'],
repel_offset=Vector.from_json(data['repel_offset']),
)
def to_json(self) -> dict:
return {
'range': self.range,
'turn_rate': self.turn_rate,
'sound_effect': self.sound_effect,
'warp_scale': self.warp_scale,
'repel_offset': self.repel_offset.to_json(),
}
def _dependencies_for_sound_effect(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_effect)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_sound_effect, "sound_effect", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct38.{field_name} ({field_type}): {e}"
)
def _decode_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_warp_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_repel_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]]] = {
0x3642a398: ('range', _decode_range),
0xe34dc703: ('turn_rate', _decode_turn_rate),
0x8d3ba8ae: ('sound_effect', _decode_sound_effect),
0xb99098d9: ('warp_scale', _decode_warp_scale),
0xb3252324: ('repel_offset', _decode_repel_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct38.py | 0.678966 | 0.30905 | UnknownStruct38.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.IngSpaceJumpGuardianStruct import IngSpaceJumpGuardianStruct
from retro_data_structures.properties.echoes.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
from retro_data_structures.properties.echoes.archetypes.ShockWaveInfo import ShockWaveInfo
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 UnknownStruct32(BaseProperty):
ing_spot_blob_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound: int = dataclasses.field(default=0, metadata={'sound': True})
ing_space_jump_guardian_struct_0x5e1d1931: IngSpaceJumpGuardianStruct = dataclasses.field(default_factory=IngSpaceJumpGuardianStruct)
ing_space_jump_guardian_struct_0x6b08e2e5: IngSpaceJumpGuardianStruct = dataclasses.field(default_factory=IngSpaceJumpGuardianStruct)
ing_space_jump_guardian_struct_0xf223aa76: IngSpaceJumpGuardianStruct = dataclasses.field(default_factory=IngSpaceJumpGuardianStruct)
ing_space_jump_guardian_struct_0xd0db5f7a: IngSpaceJumpGuardianStruct = dataclasses.field(default_factory=IngSpaceJumpGuardianStruct)
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=5.0)
mini_portal_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_mini_portal: int = dataclasses.field(default=0, metadata={'sound': True})
mini_portal_projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
mini_portal_beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
shock_wave_info: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\r') # 13 properties
data.write(b'\xccZI\x18') # 0xcc5a4918
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ing_spot_blob_effect))
data.write(b'F\xe9\x02\xe8') # 0x46e902e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'^\x1d\x191') # 0x5e1d1931
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_space_jump_guardian_struct_0x5e1d1931.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k\x08\xe2\xe5') # 0x6b08e2e5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_space_jump_guardian_struct_0x6b08e2e5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf2#\xaav') # 0xf223aa76
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_space_jump_guardian_struct_0xf223aa76.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd0\xdb_z') # 0xd0db5f7a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_space_jump_guardian_struct_0xd0db5f7a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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'\xa9&\xf8\xa8') # 0xa926f8a8
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mini_portal_effect))
data.write(b'@Q\xfd\x1a') # 0x4051fd1a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_mini_portal))
data.write(b'BJm7') # 0x424a6d37
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mini_portal_projectile_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9c\x17\th') # 0x9c170968
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mini_portal_beam_info.to_stream(data, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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)
@classmethod
def from_json(cls, data: dict):
return cls(
ing_spot_blob_effect=data['ing_spot_blob_effect'],
sound=data['sound'],
ing_space_jump_guardian_struct_0x5e1d1931=IngSpaceJumpGuardianStruct.from_json(data['ing_space_jump_guardian_struct_0x5e1d1931']),
ing_space_jump_guardian_struct_0x6b08e2e5=IngSpaceJumpGuardianStruct.from_json(data['ing_space_jump_guardian_struct_0x6b08e2e5']),
ing_space_jump_guardian_struct_0xf223aa76=IngSpaceJumpGuardianStruct.from_json(data['ing_space_jump_guardian_struct_0xf223aa76']),
ing_space_jump_guardian_struct_0xd0db5f7a=IngSpaceJumpGuardianStruct.from_json(data['ing_space_jump_guardian_struct_0xd0db5f7a']),
light_color=Color.from_json(data['light_color']),
light_attenuation=data['light_attenuation'],
mini_portal_effect=data['mini_portal_effect'],
sound_mini_portal=data['sound_mini_portal'],
mini_portal_projectile_damage=DamageInfo.from_json(data['mini_portal_projectile_damage']),
mini_portal_beam_info=PlasmaBeamInfo.from_json(data['mini_portal_beam_info']),
shock_wave_info=ShockWaveInfo.from_json(data['shock_wave_info']),
)
def to_json(self) -> dict:
return {
'ing_spot_blob_effect': self.ing_spot_blob_effect,
'sound': self.sound,
'ing_space_jump_guardian_struct_0x5e1d1931': self.ing_space_jump_guardian_struct_0x5e1d1931.to_json(),
'ing_space_jump_guardian_struct_0x6b08e2e5': self.ing_space_jump_guardian_struct_0x6b08e2e5.to_json(),
'ing_space_jump_guardian_struct_0xf223aa76': self.ing_space_jump_guardian_struct_0xf223aa76.to_json(),
'ing_space_jump_guardian_struct_0xd0db5f7a': self.ing_space_jump_guardian_struct_0xd0db5f7a.to_json(),
'light_color': self.light_color.to_json(),
'light_attenuation': self.light_attenuation,
'mini_portal_effect': self.mini_portal_effect,
'sound_mini_portal': self.sound_mini_portal,
'mini_portal_projectile_damage': self.mini_portal_projectile_damage.to_json(),
'mini_portal_beam_info': self.mini_portal_beam_info.to_json(),
'shock_wave_info': self.shock_wave_info.to_json(),
}
def _dependencies_for_ing_spot_blob_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ing_spot_blob_effect)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def _dependencies_for_ing_space_jump_guardian_struct_0x5e1d1931(self, asset_manager):
yield from self.ing_space_jump_guardian_struct_0x5e1d1931.dependencies_for(asset_manager)
def _dependencies_for_ing_space_jump_guardian_struct_0x6b08e2e5(self, asset_manager):
yield from self.ing_space_jump_guardian_struct_0x6b08e2e5.dependencies_for(asset_manager)
def _dependencies_for_ing_space_jump_guardian_struct_0xf223aa76(self, asset_manager):
yield from self.ing_space_jump_guardian_struct_0xf223aa76.dependencies_for(asset_manager)
def _dependencies_for_ing_space_jump_guardian_struct_0xd0db5f7a(self, asset_manager):
yield from self.ing_space_jump_guardian_struct_0xd0db5f7a.dependencies_for(asset_manager)
def _dependencies_for_mini_portal_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.mini_portal_effect)
def _dependencies_for_sound_mini_portal(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_mini_portal)
def _dependencies_for_mini_portal_projectile_damage(self, asset_manager):
yield from self.mini_portal_projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_mini_portal_beam_info(self, asset_manager):
yield from self.mini_portal_beam_info.dependencies_for(asset_manager)
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_ing_spot_blob_effect, "ing_spot_blob_effect", "AssetId"),
(self._dependencies_for_sound, "sound", "int"),
(self._dependencies_for_ing_space_jump_guardian_struct_0x5e1d1931, "ing_space_jump_guardian_struct_0x5e1d1931", "IngSpaceJumpGuardianStruct"),
(self._dependencies_for_ing_space_jump_guardian_struct_0x6b08e2e5, "ing_space_jump_guardian_struct_0x6b08e2e5", "IngSpaceJumpGuardianStruct"),
(self._dependencies_for_ing_space_jump_guardian_struct_0xf223aa76, "ing_space_jump_guardian_struct_0xf223aa76", "IngSpaceJumpGuardianStruct"),
(self._dependencies_for_ing_space_jump_guardian_struct_0xd0db5f7a, "ing_space_jump_guardian_struct_0xd0db5f7a", "IngSpaceJumpGuardianStruct"),
(self._dependencies_for_mini_portal_effect, "mini_portal_effect", "AssetId"),
(self._dependencies_for_sound_mini_portal, "sound_mini_portal", "int"),
(self._dependencies_for_mini_portal_projectile_damage, "mini_portal_projectile_damage", "DamageInfo"),
(self._dependencies_for_mini_portal_beam_info, "mini_portal_beam_info", "PlasmaBeamInfo"),
(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 UnknownStruct32.{field_name} ({field_type}): {e}"
)
def _decode_ing_spot_blob_effect(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_ing_space_jump_guardian_struct_0x5e1d1931(data: typing.BinaryIO, property_size: int):
return IngSpaceJumpGuardianStruct.from_stream(data, property_size)
def _decode_ing_space_jump_guardian_struct_0x6b08e2e5(data: typing.BinaryIO, property_size: int):
return IngSpaceJumpGuardianStruct.from_stream(data, property_size)
def _decode_ing_space_jump_guardian_struct_0xf223aa76(data: typing.BinaryIO, property_size: int):
return IngSpaceJumpGuardianStruct.from_stream(data, property_size)
def _decode_ing_space_jump_guardian_struct_0xd0db5f7a(data: typing.BinaryIO, property_size: int):
return IngSpaceJumpGuardianStruct.from_stream(data, property_size)
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_mini_portal_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_mini_portal(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mini_portal_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
def _decode_mini_portal_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size, default_override={'length': 500.0, 'expansion_speed': 4.0, 'life_time': 1.0, 'pulse_speed': 20.0, 'shutdown_time': 0.25, 'pulse_effect_scale': 2.0, 'inner_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.49803900718688965), 'outer_color': Color(r=0.6000000238418579, g=0.6000000238418579, b=0.0, a=0.49803900718688965)})
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]]] = {
0xcc5a4918: ('ing_spot_blob_effect', _decode_ing_spot_blob_effect),
0x46e902e8: ('sound', _decode_sound),
0x5e1d1931: ('ing_space_jump_guardian_struct_0x5e1d1931', _decode_ing_space_jump_guardian_struct_0x5e1d1931),
0x6b08e2e5: ('ing_space_jump_guardian_struct_0x6b08e2e5', _decode_ing_space_jump_guardian_struct_0x6b08e2e5),
0xf223aa76: ('ing_space_jump_guardian_struct_0xf223aa76', _decode_ing_space_jump_guardian_struct_0xf223aa76),
0xd0db5f7a: ('ing_space_jump_guardian_struct_0xd0db5f7a', _decode_ing_space_jump_guardian_struct_0xd0db5f7a),
0xbd3efe7d: ('light_color', _decode_light_color),
0xd24b888f: ('light_attenuation', _decode_light_attenuation),
0xa926f8a8: ('mini_portal_effect', _decode_mini_portal_effect),
0x4051fd1a: ('sound_mini_portal', _decode_sound_mini_portal),
0x424a6d37: ('mini_portal_projectile_damage', _decode_mini_portal_projectile_damage),
0x9c170968: ('mini_portal_beam_info', _decode_mini_portal_beam_info),
0x8f4787cb: ('shock_wave_info', _decode_shock_wave_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct32.py | 0.511229 | 0.247862 | UnknownStruct32.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.Vector2f import Vector2f
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class SafeZoneStructA(BaseProperty):
enabled: bool = dataclasses.field(default=True)
mode: int = dataclasses.field(default=0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
near_far_plane: Vector2f = dataclasses.field(default_factory=Vector2f)
color_rate: float = dataclasses.field(default=0.0)
distance_rate: Vector2f = dataclasses.field(default_factory=Vector2f)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b")\xc7}'") # 0x29c77d27
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enabled))
data.write(b'\t\xadc\xde') # 0x9ad63de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.mode))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'e \x08\xda') # 0x652008da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.near_far_plane.to_stream(data, default_override={'x': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b")\xabG'") # 0x29ab4727
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.color_rate))
data.write(b'\xcc\x8e\x0f\x98') # 0xcc8e0f98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.distance_rate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
enabled=data['enabled'],
mode=data['mode'],
color=Color.from_json(data['color']),
near_far_plane=Vector2f.from_json(data['near_far_plane']),
color_rate=data['color_rate'],
distance_rate=Vector2f.from_json(data['distance_rate']),
)
def to_json(self) -> dict:
return {
'enabled': self.enabled,
'mode': self.mode,
'color': self.color.to_json(),
'near_far_plane': self.near_far_plane.to_json(),
'color_rate': self.color_rate,
'distance_rate': self.distance_rate.to_json(),
}
def _dependencies_for_near_far_plane(self, asset_manager):
yield from self.near_far_plane.dependencies_for(asset_manager)
def _dependencies_for_distance_rate(self, asset_manager):
yield from self.distance_rate.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_near_far_plane, "near_far_plane", "Vector2f"),
(self._dependencies_for_distance_rate, "distance_rate", "Vector2f"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SafeZoneStructA.{field_name} ({field_type}): {e}"
)
def _decode_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_near_far_plane(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size, default_override={'x': 1.0})
def _decode_color_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance_rate(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x29c77d27: ('enabled', _decode_enabled),
0x9ad63de: ('mode', _decode_mode),
0x37c7d09d: ('color', _decode_color),
0x652008da: ('near_far_plane', _decode_near_far_plane),
0x29ab4727: ('color_rate', _decode_color_rate),
0xcc8e0f98: ('distance_rate', _decode_distance_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SafeZoneStructA.py | 0.673406 | 0.34715 | SafeZoneStructA.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.AudioPlaybackParms import AudioPlaybackParms
@dataclasses.dataclass()
class UnknownStruct36(BaseProperty):
audio_playback_parms_0x4f904909: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x82e108de: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0xdf090545: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x3dd5b3cf: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0xf82231bb: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x009e3658: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x62bd75b1: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
unknown: float = dataclasses.field(default=10.0)
audio_playback_parms_0x32969cba: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
audio_playback_parms_0x597d2ac9: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'O\x90I\t') # 0x4f904909
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x4f904909.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82\xe1\x08\xde') # 0x82e108de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x82e108de.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\t\x05E') # 0xdf090545
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0xdf090545.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'=\xd5\xb3\xcf') # 0x3dd5b3cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x3dd5b3cf.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8"1\xbb') # 0xf82231bb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0xf82231bb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\x9e6X') # 0x9e3658
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x009e3658.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'b\xbdu\xb1') # 0x62bd75b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x62bd75b1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\x14\xba\xec') # 0x7714baec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'2\x96\x9c\xba') # 0x32969cba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x32969cba.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y}*\xc9') # 0x597d2ac9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.audio_playback_parms_0x597d2ac9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
audio_playback_parms_0x4f904909=AudioPlaybackParms.from_json(data['audio_playback_parms_0x4f904909']),
audio_playback_parms_0x82e108de=AudioPlaybackParms.from_json(data['audio_playback_parms_0x82e108de']),
audio_playback_parms_0xdf090545=AudioPlaybackParms.from_json(data['audio_playback_parms_0xdf090545']),
audio_playback_parms_0x3dd5b3cf=AudioPlaybackParms.from_json(data['audio_playback_parms_0x3dd5b3cf']),
audio_playback_parms_0xf82231bb=AudioPlaybackParms.from_json(data['audio_playback_parms_0xf82231bb']),
audio_playback_parms_0x009e3658=AudioPlaybackParms.from_json(data['audio_playback_parms_0x009e3658']),
audio_playback_parms_0x62bd75b1=AudioPlaybackParms.from_json(data['audio_playback_parms_0x62bd75b1']),
unknown=data['unknown'],
audio_playback_parms_0x32969cba=AudioPlaybackParms.from_json(data['audio_playback_parms_0x32969cba']),
audio_playback_parms_0x597d2ac9=AudioPlaybackParms.from_json(data['audio_playback_parms_0x597d2ac9']),
)
def to_json(self) -> dict:
return {
'audio_playback_parms_0x4f904909': self.audio_playback_parms_0x4f904909.to_json(),
'audio_playback_parms_0x82e108de': self.audio_playback_parms_0x82e108de.to_json(),
'audio_playback_parms_0xdf090545': self.audio_playback_parms_0xdf090545.to_json(),
'audio_playback_parms_0x3dd5b3cf': self.audio_playback_parms_0x3dd5b3cf.to_json(),
'audio_playback_parms_0xf82231bb': self.audio_playback_parms_0xf82231bb.to_json(),
'audio_playback_parms_0x009e3658': self.audio_playback_parms_0x009e3658.to_json(),
'audio_playback_parms_0x62bd75b1': self.audio_playback_parms_0x62bd75b1.to_json(),
'unknown': self.unknown,
'audio_playback_parms_0x32969cba': self.audio_playback_parms_0x32969cba.to_json(),
'audio_playback_parms_0x597d2ac9': self.audio_playback_parms_0x597d2ac9.to_json(),
}
def _dependencies_for_audio_playback_parms_0x4f904909(self, asset_manager):
yield from self.audio_playback_parms_0x4f904909.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x82e108de(self, asset_manager):
yield from self.audio_playback_parms_0x82e108de.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0xdf090545(self, asset_manager):
yield from self.audio_playback_parms_0xdf090545.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x3dd5b3cf(self, asset_manager):
yield from self.audio_playback_parms_0x3dd5b3cf.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0xf82231bb(self, asset_manager):
yield from self.audio_playback_parms_0xf82231bb.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x009e3658(self, asset_manager):
yield from self.audio_playback_parms_0x009e3658.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x62bd75b1(self, asset_manager):
yield from self.audio_playback_parms_0x62bd75b1.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x32969cba(self, asset_manager):
yield from self.audio_playback_parms_0x32969cba.dependencies_for(asset_manager)
def _dependencies_for_audio_playback_parms_0x597d2ac9(self, asset_manager):
yield from self.audio_playback_parms_0x597d2ac9.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_audio_playback_parms_0x4f904909, "audio_playback_parms_0x4f904909", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x82e108de, "audio_playback_parms_0x82e108de", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0xdf090545, "audio_playback_parms_0xdf090545", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x3dd5b3cf, "audio_playback_parms_0x3dd5b3cf", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0xf82231bb, "audio_playback_parms_0xf82231bb", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x009e3658, "audio_playback_parms_0x009e3658", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x62bd75b1, "audio_playback_parms_0x62bd75b1", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x32969cba, "audio_playback_parms_0x32969cba", "AudioPlaybackParms"),
(self._dependencies_for_audio_playback_parms_0x597d2ac9, "audio_playback_parms_0x597d2ac9", "AudioPlaybackParms"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct36.{field_name} ({field_type}): {e}"
)
def _decode_audio_playback_parms_0x4f904909(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x82e108de(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0xdf090545(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x3dd5b3cf(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0xf82231bb(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x009e3658(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x62bd75b1(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_audio_playback_parms_0x32969cba(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
def _decode_audio_playback_parms_0x597d2ac9(data: typing.BinaryIO, property_size: int):
return AudioPlaybackParms.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4f904909: ('audio_playback_parms_0x4f904909', _decode_audio_playback_parms_0x4f904909),
0x82e108de: ('audio_playback_parms_0x82e108de', _decode_audio_playback_parms_0x82e108de),
0xdf090545: ('audio_playback_parms_0xdf090545', _decode_audio_playback_parms_0xdf090545),
0x3dd5b3cf: ('audio_playback_parms_0x3dd5b3cf', _decode_audio_playback_parms_0x3dd5b3cf),
0xf82231bb: ('audio_playback_parms_0xf82231bb', _decode_audio_playback_parms_0xf82231bb),
0x9e3658: ('audio_playback_parms_0x009e3658', _decode_audio_playback_parms_0x009e3658),
0x62bd75b1: ('audio_playback_parms_0x62bd75b1', _decode_audio_playback_parms_0x62bd75b1),
0x7714baec: ('unknown', _decode_unknown),
0x32969cba: ('audio_playback_parms_0x32969cba', _decode_audio_playback_parms_0x32969cba),
0x597d2ac9: ('audio_playback_parms_0x597d2ac9', _decode_audio_playback_parms_0x597d2ac9),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct36.py | 0.468791 | 0.189577 | UnknownStruct36.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.SandBossStructA import SandBossStructA
from retro_data_structures.properties.echoes.archetypes.UnknownStruct40 import UnknownStruct40
from retro_data_structures.properties.echoes.archetypes.UnknownStruct41 import UnknownStruct41
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SandBossData(BaseProperty):
scannable_info1: AssetId = dataclasses.field(metadata={'asset_types': ['SCAN']}, default=default_asset_id)
command_index: int = dataclasses.field(default=0)
cracked_sphere1: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
cracked_sphere2: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
cracked_sphere3: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
snap_jaw_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
spit_out_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0xbf88fe4f: float = dataclasses.field(default=4.0)
unknown_0x74c702b3: float = dataclasses.field(default=1.0)
dark_beam_projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
dark_beam_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x2b42dddf: float = dataclasses.field(default=90.0)
unknown_0x1562e0d6: float = dataclasses.field(default=10.0)
unknown_0xd0db2574: float = dataclasses.field(default=100.0)
suck_air_time: float = dataclasses.field(default=7.0)
suck_morphball_range: float = dataclasses.field(default=30.0)
spit_morphball_time: float = dataclasses.field(default=5.0)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_struct40: UnknownStruct40 = dataclasses.field(default_factory=UnknownStruct40)
unknown_struct41: UnknownStruct41 = dataclasses.field(default_factory=UnknownStruct41)
sand_boss_struct_a_0x8b452a19: SandBossStructA = dataclasses.field(default_factory=SandBossStructA)
sand_boss_struct_a_0x0cf8c54c: SandBossStructA = dataclasses.field(default_factory=SandBossStructA)
model_with_tail_armor: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
skin_for_armored_tail: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
damage_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
stampede_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
suck_air_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1b') # 27 properties
data.write(b'r\x12HB') # 0x72124842
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.scannable_info1))
data.write(b'\xe3M|I') # 0xe34d7c49
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.command_index))
data.write(b'\xe4rb\xf5') # 0xe47262f5
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.cracked_sphere1))
data.write(b'b\xe6\x10[') # 0x62e6105b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.cracked_sphere2))
data.write(b'\xa9\xba\xc3\xfe') # 0xa9bac3fe
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.cracked_sphere3))
data.write(b'\x19\xc9\x1a\xaa') # 0x19c91aaa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.snap_jaw_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\x88\x93d') # 0x58889364
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spit_out_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x88\xfeO') # 0xbf88fe4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbf88fe4f))
data.write(b't\xc7\x02\xb3') # 0x74c702b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x74c702b3))
data.write(b'5\xee\x17]') # 0x35ee175d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.dark_beam_projectile))
data.write(b'\x94\xc2\x15\x0f') # 0x94c2150f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_beam_damage.to_stream(data, default_override={'di_weapon_type': 1, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+B\xdd\xdf') # 0x2b42dddf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2b42dddf))
data.write(b'\x15b\xe0\xd6') # 0x1562e0d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1562e0d6))
data.write(b'\xd0\xdb%t') # 0xd0db2574
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd0db2574))
data.write(b'\xf1\xae\xd4=') # 0xf1aed43d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.suck_air_time))
data.write(b'0U\xdd\x0e') # 0x3055dd0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.suck_morphball_range))
data.write(b'o\x13Ye') # 0x6f135965
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_morphball_time))
data.write(b'\xc4\x90\x86\xd9') # 0xc49086d9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'\x957\x1a2') # 0x95371a32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct40.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\x19\xe5a') # 0x7619e561
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct41.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8bE*\x19') # 0x8b452a19
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sand_boss_struct_a_0x8b452a19.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0c\xf8\xc5L') # 0xcf8c54c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sand_boss_struct_a_0x0cf8c54c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbb\xd8F\x81') # 0xbbd84681
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model_with_tail_armor))
data.write(b'\xdfm\xa1\xa2') # 0xdf6da1a2
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.skin_for_armored_tail))
data.write(b'\xb7\xec\xdc\xf9') # 0xb7ecdcf9
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'\x84N\xd7\x9c') # 0x844ed79c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.stampede_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w!\x01g') # 0x77210167
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.suck_air_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
scannable_info1=data['scannable_info1'],
command_index=data['command_index'],
cracked_sphere1=data['cracked_sphere1'],
cracked_sphere2=data['cracked_sphere2'],
cracked_sphere3=data['cracked_sphere3'],
snap_jaw_damage=DamageInfo.from_json(data['snap_jaw_damage']),
spit_out_damage=DamageInfo.from_json(data['spit_out_damage']),
unknown_0xbf88fe4f=data['unknown_0xbf88fe4f'],
unknown_0x74c702b3=data['unknown_0x74c702b3'],
dark_beam_projectile=data['dark_beam_projectile'],
dark_beam_damage=DamageInfo.from_json(data['dark_beam_damage']),
unknown_0x2b42dddf=data['unknown_0x2b42dddf'],
unknown_0x1562e0d6=data['unknown_0x1562e0d6'],
unknown_0xd0db2574=data['unknown_0xd0db2574'],
suck_air_time=data['suck_air_time'],
suck_morphball_range=data['suck_morphball_range'],
spit_morphball_time=data['spit_morphball_time'],
part=data['part'],
unknown_struct40=UnknownStruct40.from_json(data['unknown_struct40']),
unknown_struct41=UnknownStruct41.from_json(data['unknown_struct41']),
sand_boss_struct_a_0x8b452a19=SandBossStructA.from_json(data['sand_boss_struct_a_0x8b452a19']),
sand_boss_struct_a_0x0cf8c54c=SandBossStructA.from_json(data['sand_boss_struct_a_0x0cf8c54c']),
model_with_tail_armor=data['model_with_tail_armor'],
skin_for_armored_tail=data['skin_for_armored_tail'],
damage_vulnerability=DamageVulnerability.from_json(data['damage_vulnerability']),
stampede_vulnerability=DamageVulnerability.from_json(data['stampede_vulnerability']),
suck_air_vulnerability=DamageVulnerability.from_json(data['suck_air_vulnerability']),
)
def to_json(self) -> dict:
return {
'scannable_info1': self.scannable_info1,
'command_index': self.command_index,
'cracked_sphere1': self.cracked_sphere1,
'cracked_sphere2': self.cracked_sphere2,
'cracked_sphere3': self.cracked_sphere3,
'snap_jaw_damage': self.snap_jaw_damage.to_json(),
'spit_out_damage': self.spit_out_damage.to_json(),
'unknown_0xbf88fe4f': self.unknown_0xbf88fe4f,
'unknown_0x74c702b3': self.unknown_0x74c702b3,
'dark_beam_projectile': self.dark_beam_projectile,
'dark_beam_damage': self.dark_beam_damage.to_json(),
'unknown_0x2b42dddf': self.unknown_0x2b42dddf,
'unknown_0x1562e0d6': self.unknown_0x1562e0d6,
'unknown_0xd0db2574': self.unknown_0xd0db2574,
'suck_air_time': self.suck_air_time,
'suck_morphball_range': self.suck_morphball_range,
'spit_morphball_time': self.spit_morphball_time,
'part': self.part,
'unknown_struct40': self.unknown_struct40.to_json(),
'unknown_struct41': self.unknown_struct41.to_json(),
'sand_boss_struct_a_0x8b452a19': self.sand_boss_struct_a_0x8b452a19.to_json(),
'sand_boss_struct_a_0x0cf8c54c': self.sand_boss_struct_a_0x0cf8c54c.to_json(),
'model_with_tail_armor': self.model_with_tail_armor,
'skin_for_armored_tail': self.skin_for_armored_tail,
'damage_vulnerability': self.damage_vulnerability.to_json(),
'stampede_vulnerability': self.stampede_vulnerability.to_json(),
'suck_air_vulnerability': self.suck_air_vulnerability.to_json(),
}
def _dependencies_for_scannable_info1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.scannable_info1)
def _dependencies_for_cracked_sphere1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.cracked_sphere1)
def _dependencies_for_cracked_sphere2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.cracked_sphere2)
def _dependencies_for_cracked_sphere3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.cracked_sphere3)
def _dependencies_for_snap_jaw_damage(self, asset_manager):
yield from self.snap_jaw_damage.dependencies_for(asset_manager)
def _dependencies_for_spit_out_damage(self, asset_manager):
yield from self.spit_out_damage.dependencies_for(asset_manager)
def _dependencies_for_dark_beam_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dark_beam_projectile)
def _dependencies_for_dark_beam_damage(self, asset_manager):
yield from self.dark_beam_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_unknown_struct40(self, asset_manager):
yield from self.unknown_struct40.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct41(self, asset_manager):
yield from self.unknown_struct41.dependencies_for(asset_manager)
def _dependencies_for_sand_boss_struct_a_0x8b452a19(self, asset_manager):
yield from self.sand_boss_struct_a_0x8b452a19.dependencies_for(asset_manager)
def _dependencies_for_sand_boss_struct_a_0x0cf8c54c(self, asset_manager):
yield from self.sand_boss_struct_a_0x0cf8c54c.dependencies_for(asset_manager)
def _dependencies_for_model_with_tail_armor(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model_with_tail_armor)
def _dependencies_for_skin_for_armored_tail(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.skin_for_armored_tail)
def _dependencies_for_damage_vulnerability(self, asset_manager):
yield from self.damage_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_stampede_vulnerability(self, asset_manager):
yield from self.stampede_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_suck_air_vulnerability(self, asset_manager):
yield from self.suck_air_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_scannable_info1, "scannable_info1", "AssetId"),
(self._dependencies_for_cracked_sphere1, "cracked_sphere1", "AssetId"),
(self._dependencies_for_cracked_sphere2, "cracked_sphere2", "AssetId"),
(self._dependencies_for_cracked_sphere3, "cracked_sphere3", "AssetId"),
(self._dependencies_for_snap_jaw_damage, "snap_jaw_damage", "DamageInfo"),
(self._dependencies_for_spit_out_damage, "spit_out_damage", "DamageInfo"),
(self._dependencies_for_dark_beam_projectile, "dark_beam_projectile", "AssetId"),
(self._dependencies_for_dark_beam_damage, "dark_beam_damage", "DamageInfo"),
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_unknown_struct40, "unknown_struct40", "UnknownStruct40"),
(self._dependencies_for_unknown_struct41, "unknown_struct41", "UnknownStruct41"),
(self._dependencies_for_sand_boss_struct_a_0x8b452a19, "sand_boss_struct_a_0x8b452a19", "SandBossStructA"),
(self._dependencies_for_sand_boss_struct_a_0x0cf8c54c, "sand_boss_struct_a_0x0cf8c54c", "SandBossStructA"),
(self._dependencies_for_model_with_tail_armor, "model_with_tail_armor", "AssetId"),
(self._dependencies_for_skin_for_armored_tail, "skin_for_armored_tail", "AssetId"),
(self._dependencies_for_damage_vulnerability, "damage_vulnerability", "DamageVulnerability"),
(self._dependencies_for_stampede_vulnerability, "stampede_vulnerability", "DamageVulnerability"),
(self._dependencies_for_suck_air_vulnerability, "suck_air_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SandBossData.{field_name} ({field_type}): {e}"
)
def _decode_scannable_info1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_command_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_cracked_sphere1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_cracked_sphere2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_cracked_sphere3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_snap_jaw_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
def _decode_spit_out_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
def _decode_unknown_0xbf88fe4f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x74c702b3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dark_beam_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_dark_beam_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 1, 'di_damage': 20.0, 'di_knock_back_power': 10.0})
def _decode_unknown_0x2b42dddf(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1562e0d6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd0db2574(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_suck_air_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_suck_morphball_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_morphball_time(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_struct40(data: typing.BinaryIO, property_size: int):
return UnknownStruct40.from_stream(data, property_size)
def _decode_unknown_struct41(data: typing.BinaryIO, property_size: int):
return UnknownStruct41.from_stream(data, property_size)
def _decode_sand_boss_struct_a_0x8b452a19(data: typing.BinaryIO, property_size: int):
return SandBossStructA.from_stream(data, property_size)
def _decode_sand_boss_struct_a_0x0cf8c54c(data: typing.BinaryIO, property_size: int):
return SandBossStructA.from_stream(data, property_size)
def _decode_model_with_tail_armor(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_skin_for_armored_tail(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_damage_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_stampede_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_suck_air_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x72124842: ('scannable_info1', _decode_scannable_info1),
0xe34d7c49: ('command_index', _decode_command_index),
0xe47262f5: ('cracked_sphere1', _decode_cracked_sphere1),
0x62e6105b: ('cracked_sphere2', _decode_cracked_sphere2),
0xa9bac3fe: ('cracked_sphere3', _decode_cracked_sphere3),
0x19c91aaa: ('snap_jaw_damage', _decode_snap_jaw_damage),
0x58889364: ('spit_out_damage', _decode_spit_out_damage),
0xbf88fe4f: ('unknown_0xbf88fe4f', _decode_unknown_0xbf88fe4f),
0x74c702b3: ('unknown_0x74c702b3', _decode_unknown_0x74c702b3),
0x35ee175d: ('dark_beam_projectile', _decode_dark_beam_projectile),
0x94c2150f: ('dark_beam_damage', _decode_dark_beam_damage),
0x2b42dddf: ('unknown_0x2b42dddf', _decode_unknown_0x2b42dddf),
0x1562e0d6: ('unknown_0x1562e0d6', _decode_unknown_0x1562e0d6),
0xd0db2574: ('unknown_0xd0db2574', _decode_unknown_0xd0db2574),
0xf1aed43d: ('suck_air_time', _decode_suck_air_time),
0x3055dd0e: ('suck_morphball_range', _decode_suck_morphball_range),
0x6f135965: ('spit_morphball_time', _decode_spit_morphball_time),
0xc49086d9: ('part', _decode_part),
0x95371a32: ('unknown_struct40', _decode_unknown_struct40),
0x7619e561: ('unknown_struct41', _decode_unknown_struct41),
0x8b452a19: ('sand_boss_struct_a_0x8b452a19', _decode_sand_boss_struct_a_0x8b452a19),
0xcf8c54c: ('sand_boss_struct_a_0x0cf8c54c', _decode_sand_boss_struct_a_0x0cf8c54c),
0xbbd84681: ('model_with_tail_armor', _decode_model_with_tail_armor),
0xdf6da1a2: ('skin_for_armored_tail', _decode_skin_for_armored_tail),
0xb7ecdcf9: ('damage_vulnerability', _decode_damage_vulnerability),
0x844ed79c: ('stampede_vulnerability', _decode_stampede_vulnerability),
0x77210167: ('suck_air_vulnerability', _decode_suck_air_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/SandBossData.py | 0.554109 | 0.180413 | SandBossData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class TextProperties(BaseProperty):
text_bounding_width: int = dataclasses.field(default=1)
text_bounding_height: int = dataclasses.field(default=1)
line_spacing: float = dataclasses.field(default=100.0)
line_extra_space: int = dataclasses.field(default=0)
character_extra_space: int = dataclasses.field(default=0)
foreground_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
geometry_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
default_font: AssetId = dataclasses.field(metadata={'asset_types': ['FONT']}, default=default_asset_id)
unknown_0x18dd95cd: int = dataclasses.field(default=0)
unknown_0x42091548: int = dataclasses.field(default=0)
wrap_text: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\xeeR\x1d\xc6') # 0xee521dc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_bounding_width))
data.write(b'\xf2\xd3j\xbb') # 0xf2d36abb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_bounding_height))
data.write(b'\x1a\x99b\x92') # 0x1a996292
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.line_spacing))
data.write(b'\x05\xef\xf9\x13') # 0x5eff913
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.line_extra_space))
data.write(b'E\x83\t\x01') # 0x45830901
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.character_extra_space))
data.write(b'?9\xe65') # 0x3f39e635
data.write(b'\x00\x10') # size
self.foreground_color.to_stream(data)
data.write(b'`\xd7\x85i') # 0x60d78569
data.write(b'\x00\x10') # size
self.outline_color.to_stream(data)
data.write(b'Y\x08\xef9') # 0x5908ef39
data.write(b'\x00\x10') # size
self.geometry_color.to_stream(data)
data.write(b'\r\xb9\xf8\xb6') # 0xdb9f8b6
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.default_font))
data.write(b'\x18\xdd\x95\xcd') # 0x18dd95cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x18dd95cd))
data.write(b'B\t\x15H') # 0x42091548
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x42091548))
data.write(b'3\x05s\xe9') # 0x330573e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wrap_text))
@classmethod
def from_json(cls, data: dict):
return cls(
text_bounding_width=data['text_bounding_width'],
text_bounding_height=data['text_bounding_height'],
line_spacing=data['line_spacing'],
line_extra_space=data['line_extra_space'],
character_extra_space=data['character_extra_space'],
foreground_color=Color.from_json(data['foreground_color']),
outline_color=Color.from_json(data['outline_color']),
geometry_color=Color.from_json(data['geometry_color']),
default_font=data['default_font'],
unknown_0x18dd95cd=data['unknown_0x18dd95cd'],
unknown_0x42091548=data['unknown_0x42091548'],
wrap_text=data['wrap_text'],
)
def to_json(self) -> dict:
return {
'text_bounding_width': self.text_bounding_width,
'text_bounding_height': self.text_bounding_height,
'line_spacing': self.line_spacing,
'line_extra_space': self.line_extra_space,
'character_extra_space': self.character_extra_space,
'foreground_color': self.foreground_color.to_json(),
'outline_color': self.outline_color.to_json(),
'geometry_color': self.geometry_color.to_json(),
'default_font': self.default_font,
'unknown_0x18dd95cd': self.unknown_0x18dd95cd,
'unknown_0x42091548': self.unknown_0x42091548,
'wrap_text': self.wrap_text,
}
def _dependencies_for_default_font(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.default_font)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_default_font, "default_font", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TextProperties.{field_name} ({field_type}): {e}"
)
def _decode_text_bounding_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_text_bounding_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_line_spacing(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_line_extra_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_character_extra_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_foreground_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_geometry_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_default_font(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x18dd95cd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x42091548(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_wrap_text(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]]] = {
0xee521dc6: ('text_bounding_width', _decode_text_bounding_width),
0xf2d36abb: ('text_bounding_height', _decode_text_bounding_height),
0x1a996292: ('line_spacing', _decode_line_spacing),
0x5eff913: ('line_extra_space', _decode_line_extra_space),
0x45830901: ('character_extra_space', _decode_character_extra_space),
0x3f39e635: ('foreground_color', _decode_foreground_color),
0x60d78569: ('outline_color', _decode_outline_color),
0x5908ef39: ('geometry_color', _decode_geometry_color),
0xdb9f8b6: ('default_font', _decode_default_font),
0x18dd95cd: ('unknown_0x18dd95cd', _decode_unknown_0x18dd95cd),
0x42091548: ('unknown_0x42091548', _decode_unknown_0x42091548),
0x330573e9: ('wrap_text', _decode_wrap_text),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/TextProperties.py | 0.63114 | 0.173516 | TextProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct30(BaseProperty):
state_machine: AssetId = dataclasses.field(metadata={'asset_types': ['AFSM', 'FSM2']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
puddle_speed: float = dataclasses.field(default=20.0)
blob_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0xe8a6e174: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0x1ab2b090: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
puddle_death: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_ing_spot_idle: int = dataclasses.field(default=0, metadata={'sound': True})
sound_ing_spot_move: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0xb392943a: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x24ecc1e9: int = dataclasses.field(default=0, metadata={'sound': True})
sound_ing_spot_death: int = dataclasses.field(default=0, metadata={'sound': True})
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\r') # 13 properties
data.write(b'UtA`') # 0x55744160
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.state_machine))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data, default_override={'hi_knock_back_resistance': 2.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"\xc6\xc1d'") # 0xc6c16427
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.puddle_speed))
data.write(b'#g\xf6\x89') # 0x2367f689
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.blob_effect))
data.write(b'\xe8\xa6\xe1t') # 0xe8a6e174
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0xe8a6e174))
data.write(b'\x1a\xb2\xb0\x90') # 0x1ab2b090
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x1ab2b090))
data.write(b'\x1c\xcf\xa4\xba') # 0x1ccfa4ba
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.puddle_death))
data.write(b'L\xab0\xa9') # 0x4cab30a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_ing_spot_idle))
data.write(b'\x8f\x83\xbes') # 0x8f83be73
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_ing_spot_move))
data.write(b'\xb3\x92\x94:') # 0xb392943a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xb392943a))
data.write(b'$\xec\xc1\xe9') # 0x24ecc1e9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x24ecc1e9))
data.write(b'D\x89\x93^') # 0x4489935e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_ing_spot_death))
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)
@classmethod
def from_json(cls, data: dict):
return cls(
state_machine=data['state_machine'],
health=HealthInfo.from_json(data['health']),
puddle_speed=data['puddle_speed'],
blob_effect=data['blob_effect'],
part_0xe8a6e174=data['part_0xe8a6e174'],
part_0x1ab2b090=data['part_0x1ab2b090'],
puddle_death=data['puddle_death'],
sound_ing_spot_idle=data['sound_ing_spot_idle'],
sound_ing_spot_move=data['sound_ing_spot_move'],
sound_0xb392943a=data['sound_0xb392943a'],
sound_0x24ecc1e9=data['sound_0x24ecc1e9'],
sound_ing_spot_death=data['sound_ing_spot_death'],
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
)
def to_json(self) -> dict:
return {
'state_machine': self.state_machine,
'health': self.health.to_json(),
'puddle_speed': self.puddle_speed,
'blob_effect': self.blob_effect,
'part_0xe8a6e174': self.part_0xe8a6e174,
'part_0x1ab2b090': self.part_0x1ab2b090,
'puddle_death': self.puddle_death,
'sound_ing_spot_idle': self.sound_ing_spot_idle,
'sound_ing_spot_move': self.sound_ing_spot_move,
'sound_0xb392943a': self.sound_0xb392943a,
'sound_0x24ecc1e9': self.sound_0x24ecc1e9,
'sound_ing_spot_death': self.sound_ing_spot_death,
'vulnerability': self.vulnerability.to_json(),
}
def _dependencies_for_state_machine(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.state_machine)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_blob_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.blob_effect)
def _dependencies_for_part_0xe8a6e174(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0xe8a6e174)
def _dependencies_for_part_0x1ab2b090(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x1ab2b090)
def _dependencies_for_puddle_death(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.puddle_death)
def _dependencies_for_sound_ing_spot_idle(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_ing_spot_idle)
def _dependencies_for_sound_ing_spot_move(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_ing_spot_move)
def _dependencies_for_sound_0xb392943a(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xb392943a)
def _dependencies_for_sound_0x24ecc1e9(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x24ecc1e9)
def _dependencies_for_sound_ing_spot_death(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_ing_spot_death)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_state_machine, "state_machine", "AssetId"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_blob_effect, "blob_effect", "AssetId"),
(self._dependencies_for_part_0xe8a6e174, "part_0xe8a6e174", "AssetId"),
(self._dependencies_for_part_0x1ab2b090, "part_0x1ab2b090", "AssetId"),
(self._dependencies_for_puddle_death, "puddle_death", "AssetId"),
(self._dependencies_for_sound_ing_spot_idle, "sound_ing_spot_idle", "int"),
(self._dependencies_for_sound_ing_spot_move, "sound_ing_spot_move", "int"),
(self._dependencies_for_sound_0xb392943a, "sound_0xb392943a", "int"),
(self._dependencies_for_sound_0x24ecc1e9, "sound_0x24ecc1e9", "int"),
(self._dependencies_for_sound_ing_spot_death, "sound_ing_spot_death", "int"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for UnknownStruct30.{field_name} ({field_type}): {e}"
)
def _decode_state_machine(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, default_override={'hi_knock_back_resistance': 2.0})
def _decode_puddle_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_blob_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0xe8a6e174(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0x1ab2b090(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_puddle_death(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_ing_spot_idle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_ing_spot_move(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0xb392943a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x24ecc1e9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_ing_spot_death(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x55744160: ('state_machine', _decode_state_machine),
0xcf90d15e: ('health', _decode_health),
0xc6c16427: ('puddle_speed', _decode_puddle_speed),
0x2367f689: ('blob_effect', _decode_blob_effect),
0xe8a6e174: ('part_0xe8a6e174', _decode_part_0xe8a6e174),
0x1ab2b090: ('part_0x1ab2b090', _decode_part_0x1ab2b090),
0x1ccfa4ba: ('puddle_death', _decode_puddle_death),
0x4cab30a9: ('sound_ing_spot_idle', _decode_sound_ing_spot_idle),
0x8f83be73: ('sound_ing_spot_move', _decode_sound_ing_spot_move),
0xb392943a: ('sound_0xb392943a', _decode_sound_0xb392943a),
0x24ecc1e9: ('sound_0x24ecc1e9', _decode_sound_0x24ecc1e9),
0x4489935e: ('sound_ing_spot_death', _decode_sound_ing_spot_death),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/archetypes/UnknownStruct30.py | 0.54359 | 0.211519 | UnknownStruct30.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.