code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Splinter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_0x72edeb7d: float = dataclasses.field(default=0.0)
unknown_0xb8ed9ffa: float = dataclasses.field(default=5.0)
unknown_0x5e8d301b: float = dataclasses.field(default=18.0)
unknown_0xb98bb88f: float = dataclasses.field(default=1.0)
unknown_0x5feb176e: float = dataclasses.field(default=3.0)
unknown_0x726cd31d: int = dataclasses.field(default=1)
unknown_0x376e909f: int = dataclasses.field(default=2)
attack_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0xb63b810c: int = dataclasses.field(default=0)
unknown_0x6d752efc: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x0d6ab7b5: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
part_0x630d93a1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_info_0x4436a388: DamageInfo = dataclasses.field(default_factory=DamageInfo)
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
is_mega_splinter: bool = dataclasses.field(default=False)
wpsc: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage_info_0x02fd0913: DamageInfo = dataclasses.field(default_factory=DamageInfo)
part_0x496f191b: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x51be00d3: float = dataclasses.field(default=2.5)
unknown_0xb7deaf32: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPTR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Splinter.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x17') # 23 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'detection_range': 32.0, 'min_attack_range': 7.0, 'max_attack_range': 17.0, 'collision_radius': 0.5, 'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'r\xed\xeb}') # 0x72edeb7d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72edeb7d))
data.write(b'\xb8\xed\x9f\xfa') # 0xb8ed9ffa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb8ed9ffa))
data.write(b'^\x8d0\x1b') # 0x5e8d301b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5e8d301b))
data.write(b'\xb9\x8b\xb8\x8f') # 0xb98bb88f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb98bb88f))
data.write(b'_\xeb\x17n') # 0x5feb176e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5feb176e))
data.write(b'rl\xd3\x1d') # 0x726cd31d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x726cd31d))
data.write(b'7n\x90\x9f') # 0x376e909f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x376e909f))
data.write(b'f\xdc\xaa\xcb') # 0x66dcaacb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_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'\xb6;\x81\x0c') # 0xb63b810c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xb63b810c))
data.write(b'mu.\xfc') # 0x6d752efc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x6d752efc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\rj\xb7\xb5') # 0xd6ab7b5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x0d6ab7b5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c\r\x93\xa1') # 0x630d93a1
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x630d93a1))
data.write(b'D6\xa3\x88') # 0x4436a388
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x4436a388.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6\x17H\xed') # 0xe61748ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_possession_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'}\xc8/F') # 0x7dc82f46
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_mega_splinter))
data.write(b'BQ\x83Y') # 0x42518359
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.wpsc))
data.write(b'\x02\xfd\t\x13') # 0x2fd0913
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x02fd0913.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'Io\x19\x1b') # 0x496f191b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x496f191b))
data.write(b'Q\xbe\x00\xd3') # 0x51be00d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x51be00d3))
data.write(b'\xb7\xde\xaf2') # 0xb7deaf32
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb7deaf32))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_0x72edeb7d=data['unknown_0x72edeb7d'],
unknown_0xb8ed9ffa=data['unknown_0xb8ed9ffa'],
unknown_0x5e8d301b=data['unknown_0x5e8d301b'],
unknown_0xb98bb88f=data['unknown_0xb98bb88f'],
unknown_0x5feb176e=data['unknown_0x5feb176e'],
unknown_0x726cd31d=data['unknown_0x726cd31d'],
unknown_0x376e909f=data['unknown_0x376e909f'],
attack_damage=DamageInfo.from_json(data['attack_damage']),
unknown_0xb63b810c=data['unknown_0xb63b810c'],
unknown_0x6d752efc=AnimationParameters.from_json(data['unknown_0x6d752efc']),
unknown_0x0d6ab7b5=AnimationParameters.from_json(data['unknown_0x0d6ab7b5']),
part_0x630d93a1=data['part_0x630d93a1'],
damage_info_0x4436a388=DamageInfo.from_json(data['damage_info_0x4436a388']),
ing_possession_data=IngPossessionData.from_json(data['ing_possession_data']),
is_mega_splinter=data['is_mega_splinter'],
wpsc=data['wpsc'],
damage_info_0x02fd0913=DamageInfo.from_json(data['damage_info_0x02fd0913']),
part_0x496f191b=data['part_0x496f191b'],
unknown_0x51be00d3=data['unknown_0x51be00d3'],
unknown_0xb7deaf32=data['unknown_0xb7deaf32'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_0x72edeb7d': self.unknown_0x72edeb7d,
'unknown_0xb8ed9ffa': self.unknown_0xb8ed9ffa,
'unknown_0x5e8d301b': self.unknown_0x5e8d301b,
'unknown_0xb98bb88f': self.unknown_0xb98bb88f,
'unknown_0x5feb176e': self.unknown_0x5feb176e,
'unknown_0x726cd31d': self.unknown_0x726cd31d,
'unknown_0x376e909f': self.unknown_0x376e909f,
'attack_damage': self.attack_damage.to_json(),
'unknown_0xb63b810c': self.unknown_0xb63b810c,
'unknown_0x6d752efc': self.unknown_0x6d752efc.to_json(),
'unknown_0x0d6ab7b5': self.unknown_0x0d6ab7b5.to_json(),
'part_0x630d93a1': self.part_0x630d93a1,
'damage_info_0x4436a388': self.damage_info_0x4436a388.to_json(),
'ing_possession_data': self.ing_possession_data.to_json(),
'is_mega_splinter': self.is_mega_splinter,
'wpsc': self.wpsc,
'damage_info_0x02fd0913': self.damage_info_0x02fd0913.to_json(),
'part_0x496f191b': self.part_0x496f191b,
'unknown_0x51be00d3': self.unknown_0x51be00d3,
'unknown_0xb7deaf32': self.unknown_0xb7deaf32,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_attack_damage(self, asset_manager):
yield from self.attack_damage.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x6d752efc(self, asset_manager):
yield from self.unknown_0x6d752efc.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x0d6ab7b5(self, asset_manager):
yield from self.unknown_0x0d6ab7b5.dependencies_for(asset_manager)
def _dependencies_for_part_0x630d93a1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x630d93a1)
def _dependencies_for_damage_info_0x4436a388(self, asset_manager):
yield from self.damage_info_0x4436a388.dependencies_for(asset_manager)
def _dependencies_for_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def _dependencies_for_wpsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc)
def _dependencies_for_damage_info_0x02fd0913(self, asset_manager):
yield from self.damage_info_0x02fd0913.dependencies_for(asset_manager)
def _dependencies_for_part_0x496f191b(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x496f191b)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_attack_damage, "attack_damage", "DamageInfo"),
(self._dependencies_for_unknown_0x6d752efc, "unknown_0x6d752efc", "AnimationParameters"),
(self._dependencies_for_unknown_0x0d6ab7b5, "unknown_0x0d6ab7b5", "AnimationParameters"),
(self._dependencies_for_part_0x630d93a1, "part_0x630d93a1", "AssetId"),
(self._dependencies_for_damage_info_0x4436a388, "damage_info_0x4436a388", "DamageInfo"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
(self._dependencies_for_wpsc, "wpsc", "AssetId"),
(self._dependencies_for_damage_info_0x02fd0913, "damage_info_0x02fd0913", "DamageInfo"),
(self._dependencies_for_part_0x496f191b, "part_0x496f191b", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Splinter.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'detection_range': 32.0, 'min_attack_range': 7.0, 'max_attack_range': 17.0, 'collision_radius': 0.5, 'collision_height': 1.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_0x72edeb7d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb8ed9ffa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5e8d301b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb98bb88f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5feb176e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x726cd31d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x376e909f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_attack_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
def _decode_unknown_0xb63b810c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6d752efc(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x0d6ab7b5(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_part_0x630d93a1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_damage_info_0x4436a388(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_ing_possession_data(data: typing.BinaryIO, property_size: int):
return IngPossessionData.from_stream(data, property_size)
def _decode_is_mega_splinter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wpsc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_damage_info_0x02fd0913(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_part_0x496f191b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x51be00d3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb7deaf32(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x72edeb7d: ('unknown_0x72edeb7d', _decode_unknown_0x72edeb7d),
0xb8ed9ffa: ('unknown_0xb8ed9ffa', _decode_unknown_0xb8ed9ffa),
0x5e8d301b: ('unknown_0x5e8d301b', _decode_unknown_0x5e8d301b),
0xb98bb88f: ('unknown_0xb98bb88f', _decode_unknown_0xb98bb88f),
0x5feb176e: ('unknown_0x5feb176e', _decode_unknown_0x5feb176e),
0x726cd31d: ('unknown_0x726cd31d', _decode_unknown_0x726cd31d),
0x376e909f: ('unknown_0x376e909f', _decode_unknown_0x376e909f),
0x66dcaacb: ('attack_damage', _decode_attack_damage),
0xb63b810c: ('unknown_0xb63b810c', _decode_unknown_0xb63b810c),
0x6d752efc: ('unknown_0x6d752efc', _decode_unknown_0x6d752efc),
0xd6ab7b5: ('unknown_0x0d6ab7b5', _decode_unknown_0x0d6ab7b5),
0x630d93a1: ('part_0x630d93a1', _decode_part_0x630d93a1),
0x4436a388: ('damage_info_0x4436a388', _decode_damage_info_0x4436a388),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
0x7dc82f46: ('is_mega_splinter', _decode_is_mega_splinter),
0x42518359: ('wpsc', _decode_wpsc),
0x2fd0913: ('damage_info_0x02fd0913', _decode_damage_info_0x02fd0913),
0x496f191b: ('part_0x496f191b', _decode_part_0x496f191b),
0x51be00d3: ('unknown_0x51be00d3', _decode_unknown_0x51be00d3),
0xb7deaf32: ('unknown_0xb7deaf32', _decode_unknown_0xb7deaf32),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Splinter.py | 0.575111 | 0.25703 | Splinter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Kralee(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flavor: int = dataclasses.field(default=0) # Choice
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
waypoint_approach_distance: float = dataclasses.field(default=2.5)
visible_distance: float = dataclasses.field(default=2.5)
wall_turn_speed: float = dataclasses.field(default=360.0)
floor_turn_speed: float = dataclasses.field(default=180.0)
down_turn_speed: float = dataclasses.field(default=120.0)
unknown_0xd5c25506: float = dataclasses.field(default=0.4000000059604645)
projectile_bounds_multiplier: float = dataclasses.field(default=1.0)
collision_look_ahead: float = dataclasses.field(default=0.019999999552965164)
warp_in_time: float = dataclasses.field(default=1.0)
warp_out_time: float = dataclasses.field(default=1.0)
visible_time: float = dataclasses.field(default=0.0)
unknown_0x7bba36ff: float = dataclasses.field(default=0.0)
invisible_time: float = dataclasses.field(default=0.0)
unknown_0x4e4ae0e4: float = dataclasses.field(default=0.0)
warp_attack_radius: float = dataclasses.field(default=2.5)
warp_attack_knockback: float = dataclasses.field(default=10.0)
warp_attack_damage: float = dataclasses.field(default=10.0)
anim_speed_scalar: float = dataclasses.field(default=1.0)
max_audible_distance: float = dataclasses.field(default=50.0)
warp_in_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
warp_out_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
warp_in_sound: int = dataclasses.field(default=0, metadata={'sound': True})
warp_out_sound: int = dataclasses.field(default=0, metadata={'sound': True})
initially_paused: bool = dataclasses.field(default=False)
initially_invisible: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'KRAL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'Kralee.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1d') # 29 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbesrJ') # 0xbe73724a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flavor))
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 25.0, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'collision_height': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\xa7%0\xe8') # 0xa72530e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_distance))
data.write(b'\xacG\xc6(') # 0xac47c628
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_turn_speed))
data.write(b'\x8eO{)') # 0x8e4f7b29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_turn_speed))
data.write(b'=<\x1bv') # 0x3d3c1b76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.down_turn_speed))
data.write(b'\xd5\xc2U\x06') # 0xd5c25506
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd5c25506))
data.write(b't.\xab ') # 0x742eab20
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_bounds_multiplier))
data.write(b'\x80\xa8\x19\t') # 0x80a81909
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_look_ahead))
data.write(b'\xedj\x93S') # 0xed6a9353
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warp_in_time))
data.write(b'\x031S\xa0') # 0x33153a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warp_out_time))
data.write(b'W\x04\x89|') # 0x5704897c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_time))
data.write(b'{\xba6\xff') # 0x7bba36ff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7bba36ff))
data.write(b'\xbb\xd4\xb1\x0c') # 0xbbd4b10c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.invisible_time))
data.write(b'NJ\xe0\xe4') # 0x4e4ae0e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4e4ae0e4))
data.write(b'\xadi\xac2') # 0xad69ac32
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warp_attack_radius))
data.write(b'\xc7\xd2\xed\xe8') # 0xc7d2ede8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warp_attack_knockback))
data.write(b'\xb1\xa2c5') # 0xb1a26335
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warp_attack_damage))
data.write(b'\x85\x90H;') # 0x8590483b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.anim_speed_scalar))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'5\x1d\xbcs') # 0x351dbc73
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.warp_in_particle_effect))
data.write(b'-r\xba{') # 0x2d72ba7b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.warp_out_particle_effect))
data.write(b'\x80\xb5\x83$') # 0x80b58324
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.warp_in_sound))
data.write(b'\xa4\xef{B') # 0xa4ef7b42
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.warp_out_sound))
data.write(b'\xc3\xccC\x7f') # 0xc3cc437f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.initially_paused))
data.write(b's\x8d\x1c\x80') # 0x738d1c80
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.initially_invisible))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flavor=data['flavor'],
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
waypoint_approach_distance=data['waypoint_approach_distance'],
visible_distance=data['visible_distance'],
wall_turn_speed=data['wall_turn_speed'],
floor_turn_speed=data['floor_turn_speed'],
down_turn_speed=data['down_turn_speed'],
unknown_0xd5c25506=data['unknown_0xd5c25506'],
projectile_bounds_multiplier=data['projectile_bounds_multiplier'],
collision_look_ahead=data['collision_look_ahead'],
warp_in_time=data['warp_in_time'],
warp_out_time=data['warp_out_time'],
visible_time=data['visible_time'],
unknown_0x7bba36ff=data['unknown_0x7bba36ff'],
invisible_time=data['invisible_time'],
unknown_0x4e4ae0e4=data['unknown_0x4e4ae0e4'],
warp_attack_radius=data['warp_attack_radius'],
warp_attack_knockback=data['warp_attack_knockback'],
warp_attack_damage=data['warp_attack_damage'],
anim_speed_scalar=data['anim_speed_scalar'],
max_audible_distance=data['max_audible_distance'],
warp_in_particle_effect=data['warp_in_particle_effect'],
warp_out_particle_effect=data['warp_out_particle_effect'],
warp_in_sound=data['warp_in_sound'],
warp_out_sound=data['warp_out_sound'],
initially_paused=data['initially_paused'],
initially_invisible=data['initially_invisible'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flavor': self.flavor,
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'waypoint_approach_distance': self.waypoint_approach_distance,
'visible_distance': self.visible_distance,
'wall_turn_speed': self.wall_turn_speed,
'floor_turn_speed': self.floor_turn_speed,
'down_turn_speed': self.down_turn_speed,
'unknown_0xd5c25506': self.unknown_0xd5c25506,
'projectile_bounds_multiplier': self.projectile_bounds_multiplier,
'collision_look_ahead': self.collision_look_ahead,
'warp_in_time': self.warp_in_time,
'warp_out_time': self.warp_out_time,
'visible_time': self.visible_time,
'unknown_0x7bba36ff': self.unknown_0x7bba36ff,
'invisible_time': self.invisible_time,
'unknown_0x4e4ae0e4': self.unknown_0x4e4ae0e4,
'warp_attack_radius': self.warp_attack_radius,
'warp_attack_knockback': self.warp_attack_knockback,
'warp_attack_damage': self.warp_attack_damage,
'anim_speed_scalar': self.anim_speed_scalar,
'max_audible_distance': self.max_audible_distance,
'warp_in_particle_effect': self.warp_in_particle_effect,
'warp_out_particle_effect': self.warp_out_particle_effect,
'warp_in_sound': self.warp_in_sound,
'warp_out_sound': self.warp_out_sound,
'initially_paused': self.initially_paused,
'initially_invisible': self.initially_invisible,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_warp_in_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.warp_in_particle_effect)
def _dependencies_for_warp_out_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.warp_out_particle_effect)
def _dependencies_for_warp_in_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.warp_in_sound)
def _dependencies_for_warp_out_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.warp_out_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_warp_in_particle_effect, "warp_in_particle_effect", "AssetId"),
(self._dependencies_for_warp_out_particle_effect, "warp_out_particle_effect", "AssetId"),
(self._dependencies_for_warp_in_sound, "warp_in_sound", "int"),
(self._dependencies_for_warp_out_sound, "warp_out_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Kralee.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flavor(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'collision_height': 5.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_waypoint_approach_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_floor_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_down_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd5c25506(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_bounds_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_look_ahead(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warp_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warp_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visible_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7bba36ff(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_invisible_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4e4ae0e4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warp_attack_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warp_attack_knockback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warp_attack_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_anim_speed_scalar(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warp_in_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_warp_out_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_warp_in_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_warp_out_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_initially_paused(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_initially_invisible(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbe73724a: ('flavor', _decode_flavor),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0xa72530e8: ('visible_distance', _decode_visible_distance),
0xac47c628: ('wall_turn_speed', _decode_wall_turn_speed),
0x8e4f7b29: ('floor_turn_speed', _decode_floor_turn_speed),
0x3d3c1b76: ('down_turn_speed', _decode_down_turn_speed),
0xd5c25506: ('unknown_0xd5c25506', _decode_unknown_0xd5c25506),
0x742eab20: ('projectile_bounds_multiplier', _decode_projectile_bounds_multiplier),
0x80a81909: ('collision_look_ahead', _decode_collision_look_ahead),
0xed6a9353: ('warp_in_time', _decode_warp_in_time),
0x33153a0: ('warp_out_time', _decode_warp_out_time),
0x5704897c: ('visible_time', _decode_visible_time),
0x7bba36ff: ('unknown_0x7bba36ff', _decode_unknown_0x7bba36ff),
0xbbd4b10c: ('invisible_time', _decode_invisible_time),
0x4e4ae0e4: ('unknown_0x4e4ae0e4', _decode_unknown_0x4e4ae0e4),
0xad69ac32: ('warp_attack_radius', _decode_warp_attack_radius),
0xc7d2ede8: ('warp_attack_knockback', _decode_warp_attack_knockback),
0xb1a26335: ('warp_attack_damage', _decode_warp_attack_damage),
0x8590483b: ('anim_speed_scalar', _decode_anim_speed_scalar),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x351dbc73: ('warp_in_particle_effect', _decode_warp_in_particle_effect),
0x2d72ba7b: ('warp_out_particle_effect', _decode_warp_out_particle_effect),
0x80b58324: ('warp_in_sound', _decode_warp_in_sound),
0xa4ef7b42: ('warp_out_sound', _decode_warp_out_sound),
0xc3cc437f: ('initially_paused', _decode_initially_paused),
0x738d1c80: ('initially_invisible', _decode_initially_invisible),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Kralee.py | 0.621541 | 0.277892 | Kralee.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TBallTransitionResources import TBallTransitionResources
from retro_data_structures.properties.echoes.archetypes.TGunResources import TGunResources
from retro_data_structures.properties.echoes.archetypes.TweakPlayerRes.AutoMapperIcons import AutoMapperIcons
from retro_data_structures.properties.echoes.archetypes.TweakPlayerRes.MapScreenIcons import MapScreenIcons
@dataclasses.dataclass()
class TweakPlayerRes(BaseObjectType):
instance_name: str = dataclasses.field(default='')
auto_mapper_icons: AutoMapperIcons = dataclasses.field(default_factory=AutoMapperIcons)
map_screen_icons: MapScreenIcons = dataclasses.field(default_factory=MapScreenIcons)
ball_transition_resources: TBallTransitionResources = dataclasses.field(default_factory=TBallTransitionResources)
cinematic_resources: TGunResources = dataclasses.field(default_factory=TGunResources)
unknown: float = dataclasses.field(default=-0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWPR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'5wA\xe0') # 0x357741e0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.auto_mapper_icons.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\r^\x02\xa0') # 0xd5e02a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.map_screen_icons.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\x98R\xba") # 0x279852ba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ball_transition_resources.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'^c\x06\x08') # 0x5e630608
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cinematic_resources.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xad\x9d\x19') # 0x36ad9d19
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
instance_name=data['instance_name'],
auto_mapper_icons=AutoMapperIcons.from_json(data['auto_mapper_icons']),
map_screen_icons=MapScreenIcons.from_json(data['map_screen_icons']),
ball_transition_resources=TBallTransitionResources.from_json(data['ball_transition_resources']),
cinematic_resources=TGunResources.from_json(data['cinematic_resources']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'auto_mapper_icons': self.auto_mapper_icons.to_json(),
'map_screen_icons': self.map_screen_icons.to_json(),
'ball_transition_resources': self.ball_transition_resources.to_json(),
'cinematic_resources': self.cinematic_resources.to_json(),
'unknown': self.unknown,
}
def _dependencies_for_auto_mapper_icons(self, asset_manager):
yield from self.auto_mapper_icons.dependencies_for(asset_manager)
def _dependencies_for_map_screen_icons(self, asset_manager):
yield from self.map_screen_icons.dependencies_for(asset_manager)
def _dependencies_for_ball_transition_resources(self, asset_manager):
yield from self.ball_transition_resources.dependencies_for(asset_manager)
def _dependencies_for_cinematic_resources(self, asset_manager):
yield from self.cinematic_resources.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_auto_mapper_icons, "auto_mapper_icons", "AutoMapperIcons"),
(self._dependencies_for_map_screen_icons, "map_screen_icons", "MapScreenIcons"),
(self._dependencies_for_ball_transition_resources, "ball_transition_resources", "TBallTransitionResources"),
(self._dependencies_for_cinematic_resources, "cinematic_resources", "TGunResources"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakPlayerRes.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_auto_mapper_icons(data: typing.BinaryIO, property_size: int):
return AutoMapperIcons.from_stream(data, property_size)
def _decode_map_screen_icons(data: typing.BinaryIO, property_size: int):
return MapScreenIcons.from_stream(data, property_size)
def _decode_ball_transition_resources(data: typing.BinaryIO, property_size: int):
return TBallTransitionResources.from_stream(data, property_size)
def _decode_cinematic_resources(data: typing.BinaryIO, property_size: int):
return TGunResources.from_stream(data, property_size)
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]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0x357741e0: ('auto_mapper_icons', _decode_auto_mapper_icons),
0xd5e02a0: ('map_screen_icons', _decode_map_screen_icons),
0x279852ba: ('ball_transition_resources', _decode_ball_transition_resources),
0x5e630608: ('cinematic_resources', _decode_cinematic_resources),
0x36ad9d19: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakPlayerRes.py | 0.571288 | 0.207938 | TweakPlayerRes.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class SpankWeed(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown: bool = dataclasses.field(default=True)
wake_up_radius: float = dataclasses.field(default=60.0)
search_radius: float = dataclasses.field(default=30.0)
attack_radius: float = dataclasses.field(default=15.0)
hurt_sleep_delay: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPNK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SpankWeed.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'damage_wait_time': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\xdc\x87}') # 0x5cdc877d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x83Z\xdc\xa1') # 0x835adca1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wake_up_radius))
data.write(b'\xed\x9b\xf5\xa3') # 0xed9bf5a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_radius))
data.write(b'|\x11\xb9\x95') # 0x7c11b995
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_radius))
data.write(b'\x9bZGD') # 0x9b5a4744
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurt_sleep_delay))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown=data['unknown'],
wake_up_radius=data['wake_up_radius'],
search_radius=data['search_radius'],
attack_radius=data['attack_radius'],
hurt_sleep_delay=data['hurt_sleep_delay'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown': self.unknown,
'wake_up_radius': self.wake_up_radius,
'search_radius': self.search_radius,
'attack_radius': self.attack_radius,
'hurt_sleep_delay': self.hurt_sleep_delay,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpankWeed.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'damage_wait_time': 1.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wake_up_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_search_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurt_sleep_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x5cdc877d: ('unknown', _decode_unknown),
0x835adca1: ('wake_up_radius', _decode_wake_up_radius),
0xed9bf5a3: ('search_radius', _decode_search_radius),
0x7c11b995: ('attack_radius', _decode_attack_radius),
0x9b5a4744: ('hurt_sleep_delay', _decode_hurt_sleep_delay),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SpankWeed.py | 0.616936 | 0.375191 | SpankWeed.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.GuiWidgetProperties import GuiWidgetProperties
@dataclasses.dataclass()
class GuiSlider(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_widget_properties: GuiWidgetProperties = dataclasses.field(default_factory=GuiWidgetProperties)
min_value: float = dataclasses.field(default=0.0)
max_value: float = dataclasses.field(default=255.0)
increment: float = dataclasses.field(default=1.0)
slide_speed: float = dataclasses.field(default=1.0)
slide_sound: int = dataclasses.field(default=0, metadata={'sound': True})
slide_sound_volume: int = dataclasses.field(default=127)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GSLD'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptGui.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xce\xfa\x1e') # 0x91cefa1e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gui_widget_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b',\xcb\xbd\xfe') # 0x2ccbbdfe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_value))
data.write(b'l\x84\xc5\x88') # 0x6c84c588
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_value))
data.write(b'\x8ah\xdbR') # 0x8a68db52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.increment))
data.write(b'\xed\xb6\x06+') # 0xedb6062b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_speed))
data.write(b'\xd1XsK') # 0xd158734b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.slide_sound))
data.write(b' \xdd\xb6a') # 0x20ddb661
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.slide_sound_volume))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
gui_widget_properties=GuiWidgetProperties.from_json(data['gui_widget_properties']),
min_value=data['min_value'],
max_value=data['max_value'],
increment=data['increment'],
slide_speed=data['slide_speed'],
slide_sound=data['slide_sound'],
slide_sound_volume=data['slide_sound_volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_widget_properties': self.gui_widget_properties.to_json(),
'min_value': self.min_value,
'max_value': self.max_value,
'increment': self.increment,
'slide_speed': self.slide_speed,
'slide_sound': self.slide_sound,
'slide_sound_volume': self.slide_sound_volume,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_gui_widget_properties(self, asset_manager):
yield from self.gui_widget_properties.dependencies_for(asset_manager)
def _dependencies_for_slide_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.slide_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_gui_widget_properties, "gui_widget_properties", "GuiWidgetProperties"),
(self._dependencies_for_slide_sound, "slide_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for GuiSlider.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_gui_widget_properties(data: typing.BinaryIO, property_size: int):
return GuiWidgetProperties.from_stream(data, property_size)
def _decode_min_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_increment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_slide_sound_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x91cefa1e: ('gui_widget_properties', _decode_gui_widget_properties),
0x2ccbbdfe: ('min_value', _decode_min_value),
0x6c84c588: ('max_value', _decode_max_value),
0x8a68db52: ('increment', _decode_increment),
0xedb6062b: ('slide_speed', _decode_slide_speed),
0xd158734b: ('slide_sound', _decode_slide_sound),
0x20ddb661: ('slide_sound_volume', _decode_slide_sound_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/GuiSlider.py | 0.590661 | 0.235196 | GuiSlider.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class HUDHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
hud_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_0x6078a651: float = dataclasses.field(default=15.0)
unknown_0xf00bb6bb: float = dataclasses.field(default=16.0)
icon_scale: float = dataclasses.field(default=1.0)
animation_time: float = dataclasses.field(default=0.0)
animation_frames: int = dataclasses.field(default=0)
unknown_0xd993f97b: int = dataclasses.field(default=15)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'HHNT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd8\x04G\xe0') # 0xd80447e0
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.hud_texture))
data.write(b'`x\xa6Q') # 0x6078a651
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6078a651))
data.write(b'\xf0\x0b\xb6\xbb') # 0xf00bb6bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf00bb6bb))
data.write(b'\x1a\xd2G\xa1') # 0x1ad247a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.icon_scale))
data.write(b'*S$Z') # 0x2a53245a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.animation_time))
data.write(b'n\x88\xd6\xad') # 0x6e88d6ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation_frames))
data.write(b'\xd9\x93\xf9{') # 0xd993f97b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd993f97b))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
hud_texture=data['hud_texture'],
unknown_0x6078a651=data['unknown_0x6078a651'],
unknown_0xf00bb6bb=data['unknown_0xf00bb6bb'],
icon_scale=data['icon_scale'],
animation_time=data['animation_time'],
animation_frames=data['animation_frames'],
unknown_0xd993f97b=data['unknown_0xd993f97b'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'hud_texture': self.hud_texture,
'unknown_0x6078a651': self.unknown_0x6078a651,
'unknown_0xf00bb6bb': self.unknown_0xf00bb6bb,
'icon_scale': self.icon_scale,
'animation_time': self.animation_time,
'animation_frames': self.animation_frames,
'unknown_0xd993f97b': self.unknown_0xd993f97b,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_hud_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.hud_texture)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_hud_texture, "hud_texture", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for HUDHint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_hud_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x6078a651(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf00bb6bb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_icon_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation_frames(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd993f97b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd80447e0: ('hud_texture', _decode_hud_texture),
0x6078a651: ('unknown_0x6078a651', _decode_unknown_0x6078a651),
0xf00bb6bb: ('unknown_0xf00bb6bb', _decode_unknown_0xf00bb6bb),
0x1ad247a1: ('icon_scale', _decode_icon_scale),
0x2a53245a: ('animation_time', _decode_animation_time),
0x6e88d6ad: ('animation_frames', _decode_animation_frames),
0xd993f97b: ('unknown_0xd993f97b', _decode_unknown_0xd993f97b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/HUDHint.py | 0.62498 | 0.254683 | HUDHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AdvancedCounter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
initial_count: int = dataclasses.field(default=0)
max_count: int = dataclasses.field(default=10)
auto_reset: bool = dataclasses.field(default=False)
counter_condition1: int = dataclasses.field(default=1)
counter_condition2: int = dataclasses.field(default=2)
counter_condition3: int = dataclasses.field(default=3)
counter_condition4: int = dataclasses.field(default=4)
counter_condition5: int = dataclasses.field(default=5)
counter_condition6: int = dataclasses.field(default=6)
counter_condition7: int = dataclasses.field(default=7)
counter_condition8: int = dataclasses.field(default=8)
counter_condition9: int = dataclasses.field(default=9)
counter_condition10: int = dataclasses.field(default=10)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ACNT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x17\x9ao') # 0xfd179a6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_count))
data.write(b'[\x85\x15\x89') # 0x5b851589
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_count))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'\x16(\xf2:') # 0x1628f23a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition1))
data.write(b'\x04\x9d]\xd4') # 0x49d5dd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition2))
data.write(b'\xbc!:\xb1') # 0xbc213ab1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition3))
data.write(b'!\xf6\x02\x08') # 0x21f60208
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition4))
data.write(b'\x99Jem') # 0x994a656d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition5))
data.write(b'\x8b\xff\xca\x83') # 0x8bffca83
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition6))
data.write(b'3C\xad\xe6') # 0x3343ade6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition7))
data.write(b'k \xbd\xb0') # 0x6b20bdb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition8))
data.write(b'\xd3\x9c\xda\xd5') # 0xd39cdad5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition9))
data.write(b'\x92\x15\xe8\x13') # 0x9215e813
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition10))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
initial_count=data['initial_count'],
max_count=data['max_count'],
auto_reset=data['auto_reset'],
counter_condition1=data['counter_condition1'],
counter_condition2=data['counter_condition2'],
counter_condition3=data['counter_condition3'],
counter_condition4=data['counter_condition4'],
counter_condition5=data['counter_condition5'],
counter_condition6=data['counter_condition6'],
counter_condition7=data['counter_condition7'],
counter_condition8=data['counter_condition8'],
counter_condition9=data['counter_condition9'],
counter_condition10=data['counter_condition10'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'initial_count': self.initial_count,
'max_count': self.max_count,
'auto_reset': self.auto_reset,
'counter_condition1': self.counter_condition1,
'counter_condition2': self.counter_condition2,
'counter_condition3': self.counter_condition3,
'counter_condition4': self.counter_condition4,
'counter_condition5': self.counter_condition5,
'counter_condition6': self.counter_condition6,
'counter_condition7': self.counter_condition7,
'counter_condition8': self.counter_condition8,
'counter_condition9': self.counter_condition9,
'counter_condition10': self.counter_condition10,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AdvancedCounter.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_initial_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_auto_reset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_counter_condition1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfd179a6f: ('initial_count', _decode_initial_count),
0x5b851589: ('max_count', _decode_max_count),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0x1628f23a: ('counter_condition1', _decode_counter_condition1),
0x49d5dd4: ('counter_condition2', _decode_counter_condition2),
0xbc213ab1: ('counter_condition3', _decode_counter_condition3),
0x21f60208: ('counter_condition4', _decode_counter_condition4),
0x994a656d: ('counter_condition5', _decode_counter_condition5),
0x8bffca83: ('counter_condition6', _decode_counter_condition6),
0x3343ade6: ('counter_condition7', _decode_counter_condition7),
0x6b20bdb0: ('counter_condition8', _decode_counter_condition8),
0xd39cdad5: ('counter_condition9', _decode_counter_condition9),
0x9215e813: ('counter_condition10', _decode_counter_condition10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AdvancedCounter.py | 0.556279 | 0.307293 | AdvancedCounter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class SporbTop(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPBT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Sporb.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SporbTop.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SporbTop.py | 0.655115 | 0.344251 | SporbTop.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.echoes as enums
from retro_data_structures.properties.echoes.archetypes.ScanInfoSecondaryModel import ScanInfoSecondaryModel
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 ScannableObjectInfo(BaseObjectType):
string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
scan_speed: enums.ScanSpeed = dataclasses.field(default=enums.ScanSpeed.Normal)
critical: bool = dataclasses.field(default=False)
unknown_0x1733b1ec: bool = dataclasses.field(default=False)
unknown_0x53336141: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
model_initial_pitch: float = dataclasses.field(default=0.0)
model_initial_yaw: float = dataclasses.field(default=0.0)
model_scale: float = dataclasses.field(default=1.0)
static_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animated_model: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x58f9fe99: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
secondary_model0: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model1: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model2: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model3: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model4: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model5: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model6: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model7: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
secondary_model8: ScanInfoSecondaryModel = dataclasses.field(default_factory=ScanInfoSecondaryModel)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'SNFO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x14') # 20 properties
data.write(b'/[d#') # 0x2f5b6423
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.string))
data.write(b'\xc3\x08\xa3"') # 0xc308a322
data.write(b'\x00\x04') # size
self.scan_speed.to_stream(data)
data.write(b'{qH\x14') # 0x7b714814
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.critical))
data.write(b'\x173\xb1\xec') # 0x1733b1ec
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x1733b1ec))
data.write(b'S3aA') # 0x53336141
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x53336141))
data.write(b'=\xe0\xbad') # 0x3de0ba64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.model_initial_pitch))
data.write(b'*\xddf(') # 0x2add6628
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.model_initial_yaw))
data.write(b'\xd0\xc1Pf') # 0xd0c15066
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.model_scale))
data.write(b'\xb7\xad\xc4\x18') # 0xb7adc418
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.static_model))
data.write(b'\x15iN\xe1') # 0x15694ee1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'X\xf9\xfe\x99') # 0x58f9fe99
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x58f9fe99.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c[J:') # 0x1c5b4a3a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x87(\xa0\xee') # 0x8728a0ee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1\xcd\x99\xd3') # 0xf1cd99d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'j\xbes\x07') # 0x6abe7307
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\x07\xeb\xa9') # 0x1c07eba9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x87t\x01}') # 0x8774017d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1\x918@') # 0xf1913840
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'j\xe2\xd2\x94') # 0x6ae2d294
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\xe2\t\x1c') # 0x1ce2091c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.secondary_model8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
string=data['string'],
scan_speed=enums.ScanSpeed.from_json(data['scan_speed']),
critical=data['critical'],
unknown_0x1733b1ec=data['unknown_0x1733b1ec'],
unknown_0x53336141=data['unknown_0x53336141'],
model_initial_pitch=data['model_initial_pitch'],
model_initial_yaw=data['model_initial_yaw'],
model_scale=data['model_scale'],
static_model=data['static_model'],
animated_model=AnimationParameters.from_json(data['animated_model']),
unknown_0x58f9fe99=AnimationParameters.from_json(data['unknown_0x58f9fe99']),
secondary_model0=ScanInfoSecondaryModel.from_json(data['secondary_model0']),
secondary_model1=ScanInfoSecondaryModel.from_json(data['secondary_model1']),
secondary_model2=ScanInfoSecondaryModel.from_json(data['secondary_model2']),
secondary_model3=ScanInfoSecondaryModel.from_json(data['secondary_model3']),
secondary_model4=ScanInfoSecondaryModel.from_json(data['secondary_model4']),
secondary_model5=ScanInfoSecondaryModel.from_json(data['secondary_model5']),
secondary_model6=ScanInfoSecondaryModel.from_json(data['secondary_model6']),
secondary_model7=ScanInfoSecondaryModel.from_json(data['secondary_model7']),
secondary_model8=ScanInfoSecondaryModel.from_json(data['secondary_model8']),
)
def to_json(self) -> dict:
return {
'string': self.string,
'scan_speed': self.scan_speed.to_json(),
'critical': self.critical,
'unknown_0x1733b1ec': self.unknown_0x1733b1ec,
'unknown_0x53336141': self.unknown_0x53336141,
'model_initial_pitch': self.model_initial_pitch,
'model_initial_yaw': self.model_initial_yaw,
'model_scale': self.model_scale,
'static_model': self.static_model,
'animated_model': self.animated_model.to_json(),
'unknown_0x58f9fe99': self.unknown_0x58f9fe99.to_json(),
'secondary_model0': self.secondary_model0.to_json(),
'secondary_model1': self.secondary_model1.to_json(),
'secondary_model2': self.secondary_model2.to_json(),
'secondary_model3': self.secondary_model3.to_json(),
'secondary_model4': self.secondary_model4.to_json(),
'secondary_model5': self.secondary_model5.to_json(),
'secondary_model6': self.secondary_model6.to_json(),
'secondary_model7': self.secondary_model7.to_json(),
'secondary_model8': self.secondary_model8.to_json(),
}
def _dependencies_for_string(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.string)
def _dependencies_for_unknown_0x53336141(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x53336141)
def _dependencies_for_static_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.static_model)
def _dependencies_for_animated_model(self, asset_manager):
yield from self.animated_model.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x58f9fe99(self, asset_manager):
yield from self.unknown_0x58f9fe99.dependencies_for(asset_manager)
def _dependencies_for_secondary_model0(self, asset_manager):
yield from self.secondary_model0.dependencies_for(asset_manager)
def _dependencies_for_secondary_model1(self, asset_manager):
yield from self.secondary_model1.dependencies_for(asset_manager)
def _dependencies_for_secondary_model2(self, asset_manager):
yield from self.secondary_model2.dependencies_for(asset_manager)
def _dependencies_for_secondary_model3(self, asset_manager):
yield from self.secondary_model3.dependencies_for(asset_manager)
def _dependencies_for_secondary_model4(self, asset_manager):
yield from self.secondary_model4.dependencies_for(asset_manager)
def _dependencies_for_secondary_model5(self, asset_manager):
yield from self.secondary_model5.dependencies_for(asset_manager)
def _dependencies_for_secondary_model6(self, asset_manager):
yield from self.secondary_model6.dependencies_for(asset_manager)
def _dependencies_for_secondary_model7(self, asset_manager):
yield from self.secondary_model7.dependencies_for(asset_manager)
def _dependencies_for_secondary_model8(self, asset_manager):
yield from self.secondary_model8.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_string, "string", "AssetId"),
(self._dependencies_for_unknown_0x53336141, "unknown_0x53336141", "AssetId"),
(self._dependencies_for_static_model, "static_model", "AssetId"),
(self._dependencies_for_animated_model, "animated_model", "AnimationParameters"),
(self._dependencies_for_unknown_0x58f9fe99, "unknown_0x58f9fe99", "AnimationParameters"),
(self._dependencies_for_secondary_model0, "secondary_model0", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model1, "secondary_model1", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model2, "secondary_model2", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model3, "secondary_model3", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model4, "secondary_model4", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model5, "secondary_model5", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model6, "secondary_model6", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model7, "secondary_model7", "ScanInfoSecondaryModel"),
(self._dependencies_for_secondary_model8, "secondary_model8", "ScanInfoSecondaryModel"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScannableObjectInfo.{field_name} ({field_type}): {e}"
)
def _decode_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_scan_speed(data: typing.BinaryIO, property_size: int):
return enums.ScanSpeed.from_stream(data)
def _decode_critical(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x1733b1ec(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x53336141(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_model_initial_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model_initial_yaw(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_static_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_animated_model(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x58f9fe99(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_secondary_model0(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model1(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model2(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model3(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model4(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model5(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model6(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model7(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
def _decode_secondary_model8(data: typing.BinaryIO, property_size: int):
return ScanInfoSecondaryModel.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f5b6423: ('string', _decode_string),
0xc308a322: ('scan_speed', _decode_scan_speed),
0x7b714814: ('critical', _decode_critical),
0x1733b1ec: ('unknown_0x1733b1ec', _decode_unknown_0x1733b1ec),
0x53336141: ('unknown_0x53336141', _decode_unknown_0x53336141),
0x3de0ba64: ('model_initial_pitch', _decode_model_initial_pitch),
0x2add6628: ('model_initial_yaw', _decode_model_initial_yaw),
0xd0c15066: ('model_scale', _decode_model_scale),
0xb7adc418: ('static_model', _decode_static_model),
0x15694ee1: ('animated_model', _decode_animated_model),
0x58f9fe99: ('unknown_0x58f9fe99', _decode_unknown_0x58f9fe99),
0x1c5b4a3a: ('secondary_model0', _decode_secondary_model0),
0x8728a0ee: ('secondary_model1', _decode_secondary_model1),
0xf1cd99d3: ('secondary_model2', _decode_secondary_model2),
0x6abe7307: ('secondary_model3', _decode_secondary_model3),
0x1c07eba9: ('secondary_model4', _decode_secondary_model4),
0x8774017d: ('secondary_model5', _decode_secondary_model5),
0xf1913840: ('secondary_model6', _decode_secondary_model6),
0x6ae2d294: ('secondary_model7', _decode_secondary_model7),
0x1ce2091c: ('secondary_model8', _decode_secondary_model8),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ScannableObjectInfo.py | 0.574992 | 0.190988 | ScannableObjectInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class Parasite(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flavor: int = dataclasses.field(default=0)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
telegraph_distance: float = dataclasses.field(default=10.0)
waypoint_approach_distance: float = dataclasses.field(default=2.5)
wall_turn_speed: float = dataclasses.field(default=360.0)
floor_turn_speed: float = dataclasses.field(default=180.0)
down_turn_speed: float = dataclasses.field(default=120.0)
stuck_time: float = dataclasses.field(default=0.20000000298023224)
unknown_0xd5c25506: float = dataclasses.field(default=0.4000000059604645)
behavior_influence_radius: float = dataclasses.field(default=6.0)
separation_distance: float = dataclasses.field(default=2.5999999046325684)
separation_priority: float = dataclasses.field(default=1.0)
alignment_priority: float = dataclasses.field(default=0.800000011920929)
unknown_0x61959f0d: float = dataclasses.field(default=0.699999988079071)
path_following_priority: float = dataclasses.field(default=0.8999999761581421)
forward_moving_priority: float = dataclasses.field(default=0.20000000298023224)
player_avoidance_distance: float = dataclasses.field(default=1.2999999523162842)
player_avoidance_priority: float = dataclasses.field(default=0.20000000298023224)
parasite_visible_distance: float = dataclasses.field(default=40.0)
initially_paused: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PARA'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'Parasite.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x16') # 22 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbesrJ') # 0xbe73724a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flavor))
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 25.0, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'collision_height': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x84X\xb0\x03') # 0x8458b003
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.telegraph_distance))
data.write(b's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\xacG\xc6(') # 0xac47c628
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_turn_speed))
data.write(b'\x8eO{)') # 0x8e4f7b29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_turn_speed))
data.write(b'=<\x1bv') # 0x3d3c1b76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.down_turn_speed))
data.write(b'\x0e~6\x98') # 0xe7e3698
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stuck_time))
data.write(b'\xd5\xc2U\x06') # 0xd5c25506
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd5c25506))
data.write(b'(\x03a\xaa') # 0x280361aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.behavior_influence_radius))
data.write(b"\x01U\x9f'") # 0x1559f27
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_distance))
data.write(b'\xd2\x93\xeb\xc4') # 0xd293ebc4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_priority))
data.write(b'HA\xf1\xde') # 0x4841f1de
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alignment_priority))
data.write(b'a\x95\x9f\r') # 0x61959f0d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61959f0d))
data.write(b'\xae\x11\xf9u') # 0xae11f975
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.path_following_priority))
data.write(b'^jT\xb8') # 0x5e6a54b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_moving_priority))
data.write(b'\x95j\x12H') # 0x956a1248
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_avoidance_distance))
data.write(b'F\xacf\xab') # 0x46ac66ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_avoidance_priority))
data.write(b'N\xee\xc7\x85') # 0x4eeec785
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.parasite_visible_distance))
data.write(b'\xc3\xccC\x7f') # 0xc3cc437f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.initially_paused))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flavor=data['flavor'],
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
telegraph_distance=data['telegraph_distance'],
waypoint_approach_distance=data['waypoint_approach_distance'],
wall_turn_speed=data['wall_turn_speed'],
floor_turn_speed=data['floor_turn_speed'],
down_turn_speed=data['down_turn_speed'],
stuck_time=data['stuck_time'],
unknown_0xd5c25506=data['unknown_0xd5c25506'],
behavior_influence_radius=data['behavior_influence_radius'],
separation_distance=data['separation_distance'],
separation_priority=data['separation_priority'],
alignment_priority=data['alignment_priority'],
unknown_0x61959f0d=data['unknown_0x61959f0d'],
path_following_priority=data['path_following_priority'],
forward_moving_priority=data['forward_moving_priority'],
player_avoidance_distance=data['player_avoidance_distance'],
player_avoidance_priority=data['player_avoidance_priority'],
parasite_visible_distance=data['parasite_visible_distance'],
initially_paused=data['initially_paused'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flavor': self.flavor,
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'telegraph_distance': self.telegraph_distance,
'waypoint_approach_distance': self.waypoint_approach_distance,
'wall_turn_speed': self.wall_turn_speed,
'floor_turn_speed': self.floor_turn_speed,
'down_turn_speed': self.down_turn_speed,
'stuck_time': self.stuck_time,
'unknown_0xd5c25506': self.unknown_0xd5c25506,
'behavior_influence_radius': self.behavior_influence_radius,
'separation_distance': self.separation_distance,
'separation_priority': self.separation_priority,
'alignment_priority': self.alignment_priority,
'unknown_0x61959f0d': self.unknown_0x61959f0d,
'path_following_priority': self.path_following_priority,
'forward_moving_priority': self.forward_moving_priority,
'player_avoidance_distance': self.player_avoidance_distance,
'player_avoidance_priority': self.player_avoidance_priority,
'parasite_visible_distance': self.parasite_visible_distance,
'initially_paused': self.initially_paused,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Parasite.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flavor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'collision_height': 5.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_telegraph_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_waypoint_approach_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_floor_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_down_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stuck_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd5c25506(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_behavior_influence_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_separation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_separation_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alignment_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x61959f0d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_path_following_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_forward_moving_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_avoidance_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_avoidance_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_parasite_visible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initially_paused(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbe73724a: ('flavor', _decode_flavor),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x8458b003: ('telegraph_distance', _decode_telegraph_distance),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0xac47c628: ('wall_turn_speed', _decode_wall_turn_speed),
0x8e4f7b29: ('floor_turn_speed', _decode_floor_turn_speed),
0x3d3c1b76: ('down_turn_speed', _decode_down_turn_speed),
0xe7e3698: ('stuck_time', _decode_stuck_time),
0xd5c25506: ('unknown_0xd5c25506', _decode_unknown_0xd5c25506),
0x280361aa: ('behavior_influence_radius', _decode_behavior_influence_radius),
0x1559f27: ('separation_distance', _decode_separation_distance),
0xd293ebc4: ('separation_priority', _decode_separation_priority),
0x4841f1de: ('alignment_priority', _decode_alignment_priority),
0x61959f0d: ('unknown_0x61959f0d', _decode_unknown_0x61959f0d),
0xae11f975: ('path_following_priority', _decode_path_following_priority),
0x5e6a54b8: ('forward_moving_priority', _decode_forward_moving_priority),
0x956a1248: ('player_avoidance_distance', _decode_player_avoidance_distance),
0x46ac66ab: ('player_avoidance_priority', _decode_player_avoidance_priority),
0x4eeec785: ('parasite_visible_distance', _decode_parasite_visible_distance),
0xc3cc437f: ('initially_paused', _decode_initially_paused),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Parasite.py | 0.626467 | 0.297142 | Parasite.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Timer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=5.0)
random_adjust: float = dataclasses.field(default=0.0)
auto_reset: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TIMR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
data.write(b':\xd3\x9b1') # 0x3ad39b31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_adjust))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
time=data['time'],
random_adjust=data['random_adjust'],
auto_reset=data['auto_reset'],
auto_start=data['auto_start'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
'random_adjust': self.random_adjust,
'auto_reset': self.auto_reset,
'auto_start': self.auto_start,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Timer.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_adjust(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_reset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44335aff: ('time', _decode_time),
0x3ad39b31: ('random_adjust', _decode_random_adjust),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0x3217dff8: ('auto_start', _decode_auto_start),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Timer.py | 0.602763 | 0.358746 | Timer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class DestructibleBarrier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0xcd4f7e71: int = dataclasses.field(default=2)
unknown_0xa7f551f7: int = dataclasses.field(default=5)
unknown_0x609c6240: int = dataclasses.field(default=1)
chunk_size: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.5, y=0.20000000298023224, z=1.0))
left_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
center_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
right_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x396660b4: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x48e25884: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
base_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x1eb90d06: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x9d852dfe: int = dataclasses.field(default=4)
unknown_0x982d7fa8: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x2e11003d: int = dataclasses.field(default=4)
unknown_0x5371ac0d: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x409d1b7c: int = dataclasses.field(default=1)
unknown_0x4e749cb5: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x92485dfa: int = dataclasses.field(default=1)
unknown_0x6e4a9d27: int = dataclasses.field(default=0)
unknown_0xbc2381a6: int = dataclasses.field(default=0)
unknown_0x6575a3d5: int = dataclasses.field(default=0)
unknown_0xc91b0946: int = dataclasses.field(default=0)
unknown_0x4b2d5a37: int = dataclasses.field(default=0)
unknown_0x605847b9: float = dataclasses.field(default=50.0)
unknown_0xcd9c67fe: float = dataclasses.field(default=10.0)
unknown_0x0af428b4: float = dataclasses.field(default=10.0)
unknown_0x4d3109e3: bool = dataclasses.field(default=False)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DBAR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['DestructibleBarrier.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1f') # 31 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcdO~q') # 0xcd4f7e71
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xcd4f7e71))
data.write(b'\xa7\xf5Q\xf7') # 0xa7f551f7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xa7f551f7))
data.write(b'`\x9cb@') # 0x609c6240
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x609c6240))
data.write(b'\xb2\x9e\x15\x9e') # 0xb29e159e
data.write(b'\x00\x0c') # size
self.chunk_size.to_stream(data)
data.write(b'\x01J\x0c6') # 0x14a0c36
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.left_model))
data.write(b'\x90\xf5\\]') # 0x90f55c5d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.center_model))
data.write(b'\xe1\x97SU') # 0xe1975355
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.right_model))
data.write(b'9f`\xb4') # 0x396660b4
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x396660b4))
data.write(b'H\xe2X\x84') # 0x48e25884
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x48e25884))
data.write(b'\xf1\xab\xb2\xc7') # 0xf1abb2c7
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.base_model))
data.write(b'\x1e\xb9\r\x06') # 0x1eb90d06
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x1eb90d06))
data.write(b'\x9d\x85-\xfe') # 0x9d852dfe
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x9d852dfe))
data.write(b'\x98-\x7f\xa8') # 0x982d7fa8
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x982d7fa8))
data.write(b'.\x11\x00=') # 0x2e11003d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2e11003d))
data.write(b'Sq\xac\r') # 0x5371ac0d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x5371ac0d))
data.write(b'@\x9d\x1b|') # 0x409d1b7c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x409d1b7c))
data.write(b'Nt\x9c\xb5') # 0x4e749cb5
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x4e749cb5))
data.write(b'\x92H]\xfa') # 0x92485dfa
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x92485dfa))
data.write(b"nJ\x9d'") # 0x6e4a9d27
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6e4a9d27))
data.write(b'\xbc#\x81\xa6') # 0xbc2381a6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xbc2381a6))
data.write(b'eu\xa3\xd5') # 0x6575a3d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6575a3d5))
data.write(b'\xc9\x1b\tF') # 0xc91b0946
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc91b0946))
data.write(b'K-Z7') # 0x4b2d5a37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x4b2d5a37))
data.write(b'`XG\xb9') # 0x605847b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x605847b9))
data.write(b'\xcd\x9cg\xfe') # 0xcd9c67fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcd9c67fe))
data.write(b'\n\xf4(\xb4') # 0xaf428b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0af428b4))
data.write(b'M1\t\xe3') # 0x4d3109e3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4d3109e3))
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'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_0xcd4f7e71=data['unknown_0xcd4f7e71'],
unknown_0xa7f551f7=data['unknown_0xa7f551f7'],
unknown_0x609c6240=data['unknown_0x609c6240'],
chunk_size=Vector.from_json(data['chunk_size']),
left_model=data['left_model'],
center_model=data['center_model'],
right_model=data['right_model'],
unknown_0x396660b4=data['unknown_0x396660b4'],
unknown_0x48e25884=data['unknown_0x48e25884'],
base_model=data['base_model'],
unknown_0x1eb90d06=data['unknown_0x1eb90d06'],
unknown_0x9d852dfe=data['unknown_0x9d852dfe'],
unknown_0x982d7fa8=data['unknown_0x982d7fa8'],
unknown_0x2e11003d=data['unknown_0x2e11003d'],
unknown_0x5371ac0d=data['unknown_0x5371ac0d'],
unknown_0x409d1b7c=data['unknown_0x409d1b7c'],
unknown_0x4e749cb5=data['unknown_0x4e749cb5'],
unknown_0x92485dfa=data['unknown_0x92485dfa'],
unknown_0x6e4a9d27=data['unknown_0x6e4a9d27'],
unknown_0xbc2381a6=data['unknown_0xbc2381a6'],
unknown_0x6575a3d5=data['unknown_0x6575a3d5'],
unknown_0xc91b0946=data['unknown_0xc91b0946'],
unknown_0x4b2d5a37=data['unknown_0x4b2d5a37'],
unknown_0x605847b9=data['unknown_0x605847b9'],
unknown_0xcd9c67fe=data['unknown_0xcd9c67fe'],
unknown_0x0af428b4=data['unknown_0x0af428b4'],
unknown_0x4d3109e3=data['unknown_0x4d3109e3'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0xcd4f7e71': self.unknown_0xcd4f7e71,
'unknown_0xa7f551f7': self.unknown_0xa7f551f7,
'unknown_0x609c6240': self.unknown_0x609c6240,
'chunk_size': self.chunk_size.to_json(),
'left_model': self.left_model,
'center_model': self.center_model,
'right_model': self.right_model,
'unknown_0x396660b4': self.unknown_0x396660b4,
'unknown_0x48e25884': self.unknown_0x48e25884,
'base_model': self.base_model,
'unknown_0x1eb90d06': self.unknown_0x1eb90d06,
'unknown_0x9d852dfe': self.unknown_0x9d852dfe,
'unknown_0x982d7fa8': self.unknown_0x982d7fa8,
'unknown_0x2e11003d': self.unknown_0x2e11003d,
'unknown_0x5371ac0d': self.unknown_0x5371ac0d,
'unknown_0x409d1b7c': self.unknown_0x409d1b7c,
'unknown_0x4e749cb5': self.unknown_0x4e749cb5,
'unknown_0x92485dfa': self.unknown_0x92485dfa,
'unknown_0x6e4a9d27': self.unknown_0x6e4a9d27,
'unknown_0xbc2381a6': self.unknown_0xbc2381a6,
'unknown_0x6575a3d5': self.unknown_0x6575a3d5,
'unknown_0xc91b0946': self.unknown_0xc91b0946,
'unknown_0x4b2d5a37': self.unknown_0x4b2d5a37,
'unknown_0x605847b9': self.unknown_0x605847b9,
'unknown_0xcd9c67fe': self.unknown_0xcd9c67fe,
'unknown_0x0af428b4': self.unknown_0x0af428b4,
'unknown_0x4d3109e3': self.unknown_0x4d3109e3,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_left_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.left_model)
def _dependencies_for_center_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.center_model)
def _dependencies_for_right_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.right_model)
def _dependencies_for_unknown_0x396660b4(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x396660b4)
def _dependencies_for_unknown_0x48e25884(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x48e25884)
def _dependencies_for_base_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.base_model)
def _dependencies_for_unknown_0x1eb90d06(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x1eb90d06)
def _dependencies_for_unknown_0x982d7fa8(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x982d7fa8)
def _dependencies_for_unknown_0x5371ac0d(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x5371ac0d)
def _dependencies_for_unknown_0x4e749cb5(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x4e749cb5)
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_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_left_model, "left_model", "AssetId"),
(self._dependencies_for_center_model, "center_model", "AssetId"),
(self._dependencies_for_right_model, "right_model", "AssetId"),
(self._dependencies_for_unknown_0x396660b4, "unknown_0x396660b4", "AssetId"),
(self._dependencies_for_unknown_0x48e25884, "unknown_0x48e25884", "AssetId"),
(self._dependencies_for_base_model, "base_model", "AssetId"),
(self._dependencies_for_unknown_0x1eb90d06, "unknown_0x1eb90d06", "AssetId"),
(self._dependencies_for_unknown_0x982d7fa8, "unknown_0x982d7fa8", "AssetId"),
(self._dependencies_for_unknown_0x5371ac0d, "unknown_0x5371ac0d", "AssetId"),
(self._dependencies_for_unknown_0x4e749cb5, "unknown_0x4e749cb5", "AssetId"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DestructibleBarrier.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0xcd4f7e71(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xa7f551f7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x609c6240(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_chunk_size(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_left_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_center_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_right_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x396660b4(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x48e25884(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_base_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x1eb90d06(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x9d852dfe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x982d7fa8(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x2e11003d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x5371ac0d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x409d1b7c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x4e749cb5(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x92485dfa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6e4a9d27(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xbc2381a6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6575a3d5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc91b0946(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x4b2d5a37(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x605847b9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcd9c67fe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0af428b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4d3109e3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[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_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcd4f7e71: ('unknown_0xcd4f7e71', _decode_unknown_0xcd4f7e71),
0xa7f551f7: ('unknown_0xa7f551f7', _decode_unknown_0xa7f551f7),
0x609c6240: ('unknown_0x609c6240', _decode_unknown_0x609c6240),
0xb29e159e: ('chunk_size', _decode_chunk_size),
0x14a0c36: ('left_model', _decode_left_model),
0x90f55c5d: ('center_model', _decode_center_model),
0xe1975355: ('right_model', _decode_right_model),
0x396660b4: ('unknown_0x396660b4', _decode_unknown_0x396660b4),
0x48e25884: ('unknown_0x48e25884', _decode_unknown_0x48e25884),
0xf1abb2c7: ('base_model', _decode_base_model),
0x1eb90d06: ('unknown_0x1eb90d06', _decode_unknown_0x1eb90d06),
0x9d852dfe: ('unknown_0x9d852dfe', _decode_unknown_0x9d852dfe),
0x982d7fa8: ('unknown_0x982d7fa8', _decode_unknown_0x982d7fa8),
0x2e11003d: ('unknown_0x2e11003d', _decode_unknown_0x2e11003d),
0x5371ac0d: ('unknown_0x5371ac0d', _decode_unknown_0x5371ac0d),
0x409d1b7c: ('unknown_0x409d1b7c', _decode_unknown_0x409d1b7c),
0x4e749cb5: ('unknown_0x4e749cb5', _decode_unknown_0x4e749cb5),
0x92485dfa: ('unknown_0x92485dfa', _decode_unknown_0x92485dfa),
0x6e4a9d27: ('unknown_0x6e4a9d27', _decode_unknown_0x6e4a9d27),
0xbc2381a6: ('unknown_0xbc2381a6', _decode_unknown_0xbc2381a6),
0x6575a3d5: ('unknown_0x6575a3d5', _decode_unknown_0x6575a3d5),
0xc91b0946: ('unknown_0xc91b0946', _decode_unknown_0xc91b0946),
0x4b2d5a37: ('unknown_0x4b2d5a37', _decode_unknown_0x4b2d5a37),
0x605847b9: ('unknown_0x605847b9', _decode_unknown_0x605847b9),
0xcd9c67fe: ('unknown_0xcd9c67fe', _decode_unknown_0xcd9c67fe),
0xaf428b4: ('unknown_0x0af428b4', _decode_unknown_0x0af428b4),
0x4d3109e3: ('unknown_0x4d3109e3', _decode_unknown_0x4d3109e3),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DestructibleBarrier.py | 0.603932 | 0.176228 | DestructibleBarrier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Spinner(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
forward_speed: float = dataclasses.field(default=0.0)
backward_speed: float = dataclasses.field(default=0.0)
unknown_0x449dd059: float = dataclasses.field(default=0.0)
unknown_0xfc849759: float = dataclasses.field(default=0.0)
shot_spinner: bool = dataclasses.field(default=False)
allow_wrap: bool = dataclasses.field(default=False)
no_backward: bool = dataclasses.field(default=False)
spline_control: bool = dataclasses.field(default=True)
loop_sound: int = dataclasses.field(default=0, metadata={'sound': True})
start_sound: int = dataclasses.field(default=0, metadata={'sound': True})
stop_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPIN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdeOjv') # 0xde4f6a76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_speed))
data.write(b'T\xe1Z<') # 0x54e15a3c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.backward_speed))
data.write(b'D\x9d\xd0Y') # 0x449dd059
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x449dd059))
data.write(b'\xfc\x84\x97Y') # 0xfc849759
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfc849759))
data.write(b'PP\x1e\x17') # 0x50501e17
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.shot_spinner))
data.write(b'9\x83\xcb\xa7') # 0x3983cba7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_wrap))
data.write(b'\xf1\xc8\xa0\xae') # 0xf1c8a0ae
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_backward))
data.write(b'\xe8\xf0\xa1\xce') # 0xe8f0a1ce
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spline_control))
data.write(b'\x8bf\xec\xa2') # 0x8b66eca2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.loop_sound))
data.write(b'R\xed\xd1k') # 0x52edd16b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.start_sound))
data.write(b'\xe8\x8e}A') # 0xe88e7d41
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.stop_sound))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
forward_speed=data['forward_speed'],
backward_speed=data['backward_speed'],
unknown_0x449dd059=data['unknown_0x449dd059'],
unknown_0xfc849759=data['unknown_0xfc849759'],
shot_spinner=data['shot_spinner'],
allow_wrap=data['allow_wrap'],
no_backward=data['no_backward'],
spline_control=data['spline_control'],
loop_sound=data['loop_sound'],
start_sound=data['start_sound'],
stop_sound=data['stop_sound'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'forward_speed': self.forward_speed,
'backward_speed': self.backward_speed,
'unknown_0x449dd059': self.unknown_0x449dd059,
'unknown_0xfc849759': self.unknown_0xfc849759,
'shot_spinner': self.shot_spinner,
'allow_wrap': self.allow_wrap,
'no_backward': self.no_backward,
'spline_control': self.spline_control,
'loop_sound': self.loop_sound,
'start_sound': self.start_sound,
'stop_sound': self.stop_sound,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_loop_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.loop_sound)
def _dependencies_for_start_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.start_sound)
def _dependencies_for_stop_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.stop_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_loop_sound, "loop_sound", "int"),
(self._dependencies_for_start_sound, "start_sound", "int"),
(self._dependencies_for_stop_sound, "stop_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Spinner.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_forward_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_backward_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x449dd059(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfc849759(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shot_spinner(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_wrap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_no_backward(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_spline_control(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_start_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_stop_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xde4f6a76: ('forward_speed', _decode_forward_speed),
0x54e15a3c: ('backward_speed', _decode_backward_speed),
0x449dd059: ('unknown_0x449dd059', _decode_unknown_0x449dd059),
0xfc849759: ('unknown_0xfc849759', _decode_unknown_0xfc849759),
0x50501e17: ('shot_spinner', _decode_shot_spinner),
0x3983cba7: ('allow_wrap', _decode_allow_wrap),
0xf1c8a0ae: ('no_backward', _decode_no_backward),
0xe8f0a1ce: ('spline_control', _decode_spline_control),
0x8b66eca2: ('loop_sound', _decode_loop_sound),
0x52edd16b: ('start_sound', _decode_start_sound),
0xe88e7d41: ('stop_sound', _decode_stop_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Spinner.py | 0.590897 | 0.310538 | Spinner.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TweakGui.HudColorTypedef import HudColorTypedef
from retro_data_structures.properties.echoes.archetypes.TweakGui.VisorColorSchemeTypedef import VisorColorSchemeTypedef
from retro_data_structures.properties.echoes.archetypes.TweakGuiColors.HUDColorsTypedef import HUDColorsTypedef
from retro_data_structures.properties.echoes.archetypes.TweakGuiColors.Misc import Misc
from retro_data_structures.properties.echoes.archetypes.TweakGuiColors.Multiplayer import Multiplayer
from retro_data_structures.properties.echoes.archetypes.TweakGuiColors.TurretHudTypedef import TurretHudTypedef
@dataclasses.dataclass()
class TweakGuiColors(BaseObjectType):
instance_name: str = dataclasses.field(default='')
hud_colors: HUDColorsTypedef = dataclasses.field(default_factory=HUDColorsTypedef)
misc: Misc = dataclasses.field(default_factory=Misc)
multiplayer: Multiplayer = dataclasses.field(default_factory=Multiplayer)
combat_hud_color_scheme: VisorColorSchemeTypedef = dataclasses.field(default_factory=VisorColorSchemeTypedef)
echo_hud_color_scheme: VisorColorSchemeTypedef = dataclasses.field(default_factory=VisorColorSchemeTypedef)
scan_hud_color_scheme: VisorColorSchemeTypedef = dataclasses.field(default_factory=VisorColorSchemeTypedef)
dark_hud_color_scheme: VisorColorSchemeTypedef = dataclasses.field(default_factory=VisorColorSchemeTypedef)
ball_hud_color_scheme: VisorColorSchemeTypedef = dataclasses.field(default_factory=VisorColorSchemeTypedef)
combat_hud: HudColorTypedef = dataclasses.field(default_factory=HudColorTypedef)
scan_hud: HudColorTypedef = dataclasses.field(default_factory=HudColorTypedef)
x_ray_hud: HudColorTypedef = dataclasses.field(default_factory=HudColorTypedef)
thermal_hud: HudColorTypedef = dataclasses.field(default_factory=HudColorTypedef)
ball_hud: HudColorTypedef = dataclasses.field(default_factory=HudColorTypedef)
turret_hud: TurretHudTypedef = dataclasses.field(default_factory=TurretHudTypedef)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWGC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcbsw$') # 0xcb737724
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.hud_colors.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'gV\xd4\xde') # 0x6756d4de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.misc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'iv\x13\xe9') # 0x697613e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multiplayer.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'g\xc7\x00U') # 0x67c70055
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.combat_hud_color_scheme.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'b\xe0\xa0\x8f') # 0x62e0a08f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.echo_hud_color_scheme.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x80\xbe\xcdn') # 0x80becd6e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_hud_color_scheme.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'}\xe4\xb2\x97') # 0x7de4b297
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_hud_color_scheme.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\x18\x17b') # 0xc0181762
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ball_hud_color_scheme.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\xd7\xa4\x0f') # 0x45d7a40f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.combat_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'YKD\xcf') # 0x594b44cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8f^\xbe\xb9') # 0x8f5ebeb9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_ray_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1+\x1eY') # 0xf12b1e59
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.thermal_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\xcdcs') # 0x58cd6373
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ball_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xde\x13\x90\x81') # 0xde139081
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.turret_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
instance_name=data['instance_name'],
hud_colors=HUDColorsTypedef.from_json(data['hud_colors']),
misc=Misc.from_json(data['misc']),
multiplayer=Multiplayer.from_json(data['multiplayer']),
combat_hud_color_scheme=VisorColorSchemeTypedef.from_json(data['combat_hud_color_scheme']),
echo_hud_color_scheme=VisorColorSchemeTypedef.from_json(data['echo_hud_color_scheme']),
scan_hud_color_scheme=VisorColorSchemeTypedef.from_json(data['scan_hud_color_scheme']),
dark_hud_color_scheme=VisorColorSchemeTypedef.from_json(data['dark_hud_color_scheme']),
ball_hud_color_scheme=VisorColorSchemeTypedef.from_json(data['ball_hud_color_scheme']),
combat_hud=HudColorTypedef.from_json(data['combat_hud']),
scan_hud=HudColorTypedef.from_json(data['scan_hud']),
x_ray_hud=HudColorTypedef.from_json(data['x_ray_hud']),
thermal_hud=HudColorTypedef.from_json(data['thermal_hud']),
ball_hud=HudColorTypedef.from_json(data['ball_hud']),
turret_hud=TurretHudTypedef.from_json(data['turret_hud']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'hud_colors': self.hud_colors.to_json(),
'misc': self.misc.to_json(),
'multiplayer': self.multiplayer.to_json(),
'combat_hud_color_scheme': self.combat_hud_color_scheme.to_json(),
'echo_hud_color_scheme': self.echo_hud_color_scheme.to_json(),
'scan_hud_color_scheme': self.scan_hud_color_scheme.to_json(),
'dark_hud_color_scheme': self.dark_hud_color_scheme.to_json(),
'ball_hud_color_scheme': self.ball_hud_color_scheme.to_json(),
'combat_hud': self.combat_hud.to_json(),
'scan_hud': self.scan_hud.to_json(),
'x_ray_hud': self.x_ray_hud.to_json(),
'thermal_hud': self.thermal_hud.to_json(),
'ball_hud': self.ball_hud.to_json(),
'turret_hud': self.turret_hud.to_json(),
}
def _dependencies_for_hud_colors(self, asset_manager):
yield from self.hud_colors.dependencies_for(asset_manager)
def _dependencies_for_misc(self, asset_manager):
yield from self.misc.dependencies_for(asset_manager)
def _dependencies_for_multiplayer(self, asset_manager):
yield from self.multiplayer.dependencies_for(asset_manager)
def _dependencies_for_combat_hud_color_scheme(self, asset_manager):
yield from self.combat_hud_color_scheme.dependencies_for(asset_manager)
def _dependencies_for_echo_hud_color_scheme(self, asset_manager):
yield from self.echo_hud_color_scheme.dependencies_for(asset_manager)
def _dependencies_for_scan_hud_color_scheme(self, asset_manager):
yield from self.scan_hud_color_scheme.dependencies_for(asset_manager)
def _dependencies_for_dark_hud_color_scheme(self, asset_manager):
yield from self.dark_hud_color_scheme.dependencies_for(asset_manager)
def _dependencies_for_ball_hud_color_scheme(self, asset_manager):
yield from self.ball_hud_color_scheme.dependencies_for(asset_manager)
def _dependencies_for_combat_hud(self, asset_manager):
yield from self.combat_hud.dependencies_for(asset_manager)
def _dependencies_for_scan_hud(self, asset_manager):
yield from self.scan_hud.dependencies_for(asset_manager)
def _dependencies_for_x_ray_hud(self, asset_manager):
yield from self.x_ray_hud.dependencies_for(asset_manager)
def _dependencies_for_thermal_hud(self, asset_manager):
yield from self.thermal_hud.dependencies_for(asset_manager)
def _dependencies_for_ball_hud(self, asset_manager):
yield from self.ball_hud.dependencies_for(asset_manager)
def _dependencies_for_turret_hud(self, asset_manager):
yield from self.turret_hud.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_hud_colors, "hud_colors", "HUDColorsTypedef"),
(self._dependencies_for_misc, "misc", "Misc"),
(self._dependencies_for_multiplayer, "multiplayer", "Multiplayer"),
(self._dependencies_for_combat_hud_color_scheme, "combat_hud_color_scheme", "VisorColorSchemeTypedef"),
(self._dependencies_for_echo_hud_color_scheme, "echo_hud_color_scheme", "VisorColorSchemeTypedef"),
(self._dependencies_for_scan_hud_color_scheme, "scan_hud_color_scheme", "VisorColorSchemeTypedef"),
(self._dependencies_for_dark_hud_color_scheme, "dark_hud_color_scheme", "VisorColorSchemeTypedef"),
(self._dependencies_for_ball_hud_color_scheme, "ball_hud_color_scheme", "VisorColorSchemeTypedef"),
(self._dependencies_for_combat_hud, "combat_hud", "HudColorTypedef"),
(self._dependencies_for_scan_hud, "scan_hud", "HudColorTypedef"),
(self._dependencies_for_x_ray_hud, "x_ray_hud", "HudColorTypedef"),
(self._dependencies_for_thermal_hud, "thermal_hud", "HudColorTypedef"),
(self._dependencies_for_ball_hud, "ball_hud", "HudColorTypedef"),
(self._dependencies_for_turret_hud, "turret_hud", "TurretHudTypedef"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakGuiColors.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_hud_colors(data: typing.BinaryIO, property_size: int):
return HUDColorsTypedef.from_stream(data, property_size)
def _decode_misc(data: typing.BinaryIO, property_size: int):
return Misc.from_stream(data, property_size)
def _decode_multiplayer(data: typing.BinaryIO, property_size: int):
return Multiplayer.from_stream(data, property_size)
def _decode_combat_hud_color_scheme(data: typing.BinaryIO, property_size: int):
return VisorColorSchemeTypedef.from_stream(data, property_size)
def _decode_echo_hud_color_scheme(data: typing.BinaryIO, property_size: int):
return VisorColorSchemeTypedef.from_stream(data, property_size)
def _decode_scan_hud_color_scheme(data: typing.BinaryIO, property_size: int):
return VisorColorSchemeTypedef.from_stream(data, property_size)
def _decode_dark_hud_color_scheme(data: typing.BinaryIO, property_size: int):
return VisorColorSchemeTypedef.from_stream(data, property_size)
def _decode_ball_hud_color_scheme(data: typing.BinaryIO, property_size: int):
return VisorColorSchemeTypedef.from_stream(data, property_size)
def _decode_combat_hud(data: typing.BinaryIO, property_size: int):
return HudColorTypedef.from_stream(data, property_size)
def _decode_scan_hud(data: typing.BinaryIO, property_size: int):
return HudColorTypedef.from_stream(data, property_size)
def _decode_x_ray_hud(data: typing.BinaryIO, property_size: int):
return HudColorTypedef.from_stream(data, property_size)
def _decode_thermal_hud(data: typing.BinaryIO, property_size: int):
return HudColorTypedef.from_stream(data, property_size)
def _decode_ball_hud(data: typing.BinaryIO, property_size: int):
return HudColorTypedef.from_stream(data, property_size)
def _decode_turret_hud(data: typing.BinaryIO, property_size: int):
return TurretHudTypedef.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0xcb737724: ('hud_colors', _decode_hud_colors),
0x6756d4de: ('misc', _decode_misc),
0x697613e9: ('multiplayer', _decode_multiplayer),
0x67c70055: ('combat_hud_color_scheme', _decode_combat_hud_color_scheme),
0x62e0a08f: ('echo_hud_color_scheme', _decode_echo_hud_color_scheme),
0x80becd6e: ('scan_hud_color_scheme', _decode_scan_hud_color_scheme),
0x7de4b297: ('dark_hud_color_scheme', _decode_dark_hud_color_scheme),
0xc0181762: ('ball_hud_color_scheme', _decode_ball_hud_color_scheme),
0x45d7a40f: ('combat_hud', _decode_combat_hud),
0x594b44cf: ('scan_hud', _decode_scan_hud),
0x8f5ebeb9: ('x_ray_hud', _decode_x_ray_hud),
0xf12b1e59: ('thermal_hud', _decode_thermal_hud),
0x58cd6373: ('ball_hud', _decode_ball_hud),
0xde139081: ('turret_hud', _decode_turret_hud),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakGuiColors.py | 0.527317 | 0.262406 | TweakGuiColors.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class AtomicBeta(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
beam_effect: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC', 'WPSC']}, default=default_asset_id)
beam: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
beam_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
contact_fx: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
beam_fade_time: float = dataclasses.field(default=1.0)
beam_radius: float = dataclasses.field(default=0.10000000149011612)
hover_speed: float = dataclasses.field(default=3.0)
frozen_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
normal_rotate_speed: float = dataclasses.field(default=1.5)
charging_rotate_speed: float = dataclasses.field(default=5.0)
speed_change_rate: float = dataclasses.field(default=1.0)
sound_0x14038b71: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x16a435cb: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x67edefc2: int = dataclasses.field(default=0, metadata={'sound': True})
damage_delay: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ATMB'
@classmethod
def modules(cls) -> typing.List[str]:
return ['AtomicBeta.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x12') # 18 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05C\x9a\x08') # 0x5439a08
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.beam_effect))
data.write(b',\xbf\x98\x9b') # 0x2cbf989b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.beam))
data.write(b'\x13\xe3\x0eM') # 0x13e30e4d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2q\xea\xf5') # 0xc271eaf5
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.contact_fx))
data.write(b'\x18\t?\xa8') # 0x18093fa8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_fade_time))
data.write(b'\xcb\n\xf0u') # 0xcb0af075
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_radius))
data.write(b'\x84^\xf4\x89') # 0x845ef489
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_speed))
data.write(b'A\x198\xaa') # 0x411938aa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.frozen_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xce\x18\x93\xcc') # 0xce1893cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_rotate_speed))
data.write(b'jE=\x89') # 0x6a453d89
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.charging_rotate_speed))
data.write(b'\xac *]') # 0xac202a5d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed_change_rate))
data.write(b'\x14\x03\x8bq') # 0x14038b71
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x14038b71))
data.write(b'\x16\xa45\xcb') # 0x16a435cb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x16a435cb))
data.write(b'g\xed\xef\xc2') # 0x67edefc2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x67edefc2))
data.write(b'\x8fO\xb7\x9d') # 0x8f4fb79d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_delay))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
beam_effect=data['beam_effect'],
beam=data['beam'],
beam_damage=DamageInfo.from_json(data['beam_damage']),
contact_fx=data['contact_fx'],
beam_fade_time=data['beam_fade_time'],
beam_radius=data['beam_radius'],
hover_speed=data['hover_speed'],
frozen_vulnerability=DamageVulnerability.from_json(data['frozen_vulnerability']),
normal_rotate_speed=data['normal_rotate_speed'],
charging_rotate_speed=data['charging_rotate_speed'],
speed_change_rate=data['speed_change_rate'],
sound_0x14038b71=data['sound_0x14038b71'],
sound_0x16a435cb=data['sound_0x16a435cb'],
sound_0x67edefc2=data['sound_0x67edefc2'],
damage_delay=data['damage_delay'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'beam_effect': self.beam_effect,
'beam': self.beam,
'beam_damage': self.beam_damage.to_json(),
'contact_fx': self.contact_fx,
'beam_fade_time': self.beam_fade_time,
'beam_radius': self.beam_radius,
'hover_speed': self.hover_speed,
'frozen_vulnerability': self.frozen_vulnerability.to_json(),
'normal_rotate_speed': self.normal_rotate_speed,
'charging_rotate_speed': self.charging_rotate_speed,
'speed_change_rate': self.speed_change_rate,
'sound_0x14038b71': self.sound_0x14038b71,
'sound_0x16a435cb': self.sound_0x16a435cb,
'sound_0x67edefc2': self.sound_0x67edefc2,
'damage_delay': self.damage_delay,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_beam_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.beam_effect)
def _dependencies_for_beam(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.beam)
def _dependencies_for_beam_damage(self, asset_manager):
yield from self.beam_damage.dependencies_for(asset_manager)
def _dependencies_for_contact_fx(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.contact_fx)
def _dependencies_for_frozen_vulnerability(self, asset_manager):
yield from self.frozen_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_sound_0x14038b71(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x14038b71)
def _dependencies_for_sound_0x16a435cb(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x16a435cb)
def _dependencies_for_sound_0x67edefc2(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x67edefc2)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_beam_effect, "beam_effect", "AssetId"),
(self._dependencies_for_beam, "beam", "AssetId"),
(self._dependencies_for_beam_damage, "beam_damage", "DamageInfo"),
(self._dependencies_for_contact_fx, "contact_fx", "AssetId"),
(self._dependencies_for_frozen_vulnerability, "frozen_vulnerability", "DamageVulnerability"),
(self._dependencies_for_sound_0x14038b71, "sound_0x14038b71", "int"),
(self._dependencies_for_sound_0x16a435cb, "sound_0x16a435cb", "int"),
(self._dependencies_for_sound_0x67edefc2, "sound_0x67edefc2", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AtomicBeta.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_beam_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_beam(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_beam_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_contact_fx(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_beam_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hover_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_frozen_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_normal_rotate_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_charging_rotate_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed_change_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_0x14038b71(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x16a435cb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x67edefc2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_damage_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x5439a08: ('beam_effect', _decode_beam_effect),
0x2cbf989b: ('beam', _decode_beam),
0x13e30e4d: ('beam_damage', _decode_beam_damage),
0xc271eaf5: ('contact_fx', _decode_contact_fx),
0x18093fa8: ('beam_fade_time', _decode_beam_fade_time),
0xcb0af075: ('beam_radius', _decode_beam_radius),
0x845ef489: ('hover_speed', _decode_hover_speed),
0x411938aa: ('frozen_vulnerability', _decode_frozen_vulnerability),
0xce1893cc: ('normal_rotate_speed', _decode_normal_rotate_speed),
0x6a453d89: ('charging_rotate_speed', _decode_charging_rotate_speed),
0xac202a5d: ('speed_change_rate', _decode_speed_change_rate),
0x14038b71: ('sound_0x14038b71', _decode_sound_0x14038b71),
0x16a435cb: ('sound_0x16a435cb', _decode_sound_0x16a435cb),
0x67edefc2: ('sound_0x67edefc2', _decode_sound_0x67edefc2),
0x8f4fb79d: ('damage_delay', _decode_damage_delay),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AtomicBeta.py | 0.563018 | 0.252349 | AtomicBeta.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RoomAcoustics(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
room_volume: int = dataclasses.field(default=117)
priority: int = dataclasses.field(default=1) # Choice
reverb_hi_enabled: bool = dataclasses.field(default=False)
unknown_0x3263c26e: bool = dataclasses.field(default=False)
reverb_hi_time: float = dataclasses.field(default=0.0)
reverb_hi_pre_delay: float = dataclasses.field(default=0.0)
reverb_hi_damping: float = dataclasses.field(default=0.0)
reverb_hi_coloration: float = dataclasses.field(default=0.0)
reverb_hi_cross_talk: float = dataclasses.field(default=0.0)
reverb_hi_mix: float = dataclasses.field(default=0.0)
chorus_enabled: bool = dataclasses.field(default=False)
chorus_base_delay: float = dataclasses.field(default=0.0)
chorus_variation: float = dataclasses.field(default=0.0)
chorus_period: float = dataclasses.field(default=0.0)
reverb_std_enabled: bool = dataclasses.field(default=False)
unknown_0x4a5bbf90: bool = dataclasses.field(default=False)
reverb_std_time: float = dataclasses.field(default=0.0)
reverb_std_pre_delay: float = dataclasses.field(default=0.0)
reverb_std_damping: float = dataclasses.field(default=0.0)
reverb_std_coloration: float = dataclasses.field(default=0.0)
reverb_std_mix: float = dataclasses.field(default=0.0)
delay_enabled: bool = dataclasses.field(default=False)
delay0: int = dataclasses.field(default=0)
delay1: int = dataclasses.field(default=0)
delay2: int = dataclasses.field(default=0)
delay_feedback0: int = dataclasses.field(default=0)
delay_feedback1: int = dataclasses.field(default=0)
delay_feedback2: int = dataclasses.field(default=0)
delay_output0: int = dataclasses.field(default=0)
delay_output1: int = dataclasses.field(default=0)
delay_output2: int = dataclasses.field(default=0)
unknown_0xcf45711c: int = dataclasses.field(default=32000)
unknown_0x626d1e9b: int = dataclasses.field(default=0)
unknown_0x7d8ee273: bool = dataclasses.field(default=False)
unknown_0x83378e6a: float = dataclasses.field(default=0.0)
unknown_0xf549d269: float = dataclasses.field(default=0.0)
unknown_0x11fdae16: float = dataclasses.field(default=0.0)
unknown_0xa3c439c1: float = dataclasses.field(default=0.0)
unknown_0x2dc70efe: float = dataclasses.field(default=0.0)
unknown_0xe2bd3706: float = dataclasses.field(default=0.0)
unknown_0x5e29cef8: float = dataclasses.field(default=0.0)
unknown_0x35ae9f10: float = dataclasses.field(default=0.0)
bitcrusher_enabled: bool = dataclasses.field(default=False)
unknown_0xf51a1d6a: int = dataclasses.field(default=0)
bitcrusher_gain: float = dataclasses.field(default=0.0)
bitcrusher_bit_depth: int = dataclasses.field(default=0)
unknown_0x58096e0b: float = dataclasses.field(default=1.0)
phaser_enabled: bool = dataclasses.field(default=False)
phaser_frequency: float = dataclasses.field(default=0.0)
phaser_feedback: float = dataclasses.field(default=0.0)
phaser_invert: float = dataclasses.field(default=0.0)
phaser_mix: float = dataclasses.field(default=0.0)
phaser_sweep: float = dataclasses.field(default=200.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RMAC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x006') # 54 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbd\x9e\xa2f') # 0xbd9ea266
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.room_volume))
data.write(b'\x86\xcf#\xf4') # 0x86cf23f4
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.priority))
data.write(b'\xa0\x03`\xcc') # 0xa00360cc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reverb_hi_enabled))
data.write(b'2c\xc2n') # 0x3263c26e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3263c26e))
data.write(b'\xc5\x86\x80a') # 0xc5868061
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_hi_time))
data.write(b'\xc6\xf5\x002') # 0xc6f50032
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_hi_pre_delay))
data.write(b'\xcb\xa5U]') # 0xcba5555d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_hi_damping))
data.write(b's\x19\xcfP') # 0x7319cf50
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_hi_coloration))
data.write(b'=\xc3\xf1o') # 0x3dc3f16f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_hi_cross_talk))
data.write(b'\xd5Q\x8bl') # 0xd5518b6c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_hi_mix))
data.write(b'&\x99|\xcb') # 0x26997ccb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.chorus_enabled))
data.write(b'\x12\x1b\xdf\xad') # 0x121bdfad
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chorus_base_delay))
data.write(b'\xe8yk\xce') # 0xe8796bce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chorus_variation))
data.write(b'$\xbb\xd5\xe4') # 0x24bbd5e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chorus_period))
data.write(b'\xff1c\x1b') # 0xff31631b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reverb_std_enabled))
data.write(b'J[\xbf\x90') # 0x4a5bbf90
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4a5bbf90))
data.write(b'\x96bI\x8a') # 0x9662498a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_std_time))
data.write(b'\x91\x85]b') # 0x91855d62
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_std_pre_delay))
data.write(b'\xd3M )') # 0xd34d2029
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_std_damping))
data.write(b'\xdcx\xe8=') # 0xdc78e83d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_std_coloration))
data.write(b'\x82\x0bP\x9e') # 0x820b509e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverb_std_mix))
data.write(b'\xe9\xa3`1') # 0xe9a36031
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.delay_enabled))
data.write(b'b\xc4\x94W') # 0x62c49457
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay0))
data.write(b'\xdax\xf32') # 0xda78f332
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay1))
data.write(b'\xc8\xcd\\\xdc') # 0xc8cd5cdc
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay2))
data.write(b'|\x14\xff\x17') # 0x7c14ff17
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay_feedback0))
data.write(b'\xc4\xa8\x98r') # 0xc4a89872
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay_feedback1))
data.write(b'\xd6\x1d7\x9c') # 0xd61d379c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay_feedback2))
data.write(b'\x9fu\x98\x7f') # 0x9f75987f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay_output0))
data.write(b"'\xc9\xff\x1a") # 0x27c9ff1a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay_output1))
data.write(b'5|P\xf4') # 0x357c50f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.delay_output2))
data.write(b'\xcfEq\x1c') # 0xcf45711c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xcf45711c))
data.write(b'bm\x1e\x9b') # 0x626d1e9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x626d1e9b))
data.write(b'}\x8e\xe2s') # 0x7d8ee273
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7d8ee273))
data.write(b'\x837\x8ej') # 0x83378e6a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x83378e6a))
data.write(b'\xf5I\xd2i') # 0xf549d269
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf549d269))
data.write(b'\x11\xfd\xae\x16') # 0x11fdae16
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x11fdae16))
data.write(b'\xa3\xc49\xc1') # 0xa3c439c1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa3c439c1))
data.write(b'-\xc7\x0e\xfe') # 0x2dc70efe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2dc70efe))
data.write(b'\xe2\xbd7\x06') # 0xe2bd3706
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe2bd3706))
data.write(b'^)\xce\xf8') # 0x5e29cef8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5e29cef8))
data.write(b'5\xae\x9f\x10') # 0x35ae9f10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x35ae9f10))
data.write(b'>\x8d\x86\x94') # 0x3e8d8694
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.bitcrusher_enabled))
data.write(b'\xf5\x1a\x1dj') # 0xf51a1d6a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xf51a1d6a))
data.write(b'\xbb\x1a\x0f4') # 0xbb1a0f34
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bitcrusher_gain))
data.write(b'\xeb\x00\x909') # 0xeb009039
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.bitcrusher_bit_depth))
data.write(b'X\tn\x0b') # 0x58096e0b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x58096e0b))
data.write(b'=\x8c\xad\x84') # 0x3d8cad84
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.phaser_enabled))
data.write(b'#\xc3@\xf6') # 0x23c340f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phaser_frequency))
data.write(b'\x1eZR\xb8') # 0x1e5a52b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phaser_feedback))
data.write(b'\x1di\xbe\xc4') # 0x1d69bec4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phaser_invert))
data.write(b'$S\x8cJ') # 0x24538c4a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phaser_mix))
data.write(b'\xd58\x81\x16') # 0xd5388116
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.phaser_sweep))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
room_volume=data['room_volume'],
priority=data['priority'],
reverb_hi_enabled=data['reverb_hi_enabled'],
unknown_0x3263c26e=data['unknown_0x3263c26e'],
reverb_hi_time=data['reverb_hi_time'],
reverb_hi_pre_delay=data['reverb_hi_pre_delay'],
reverb_hi_damping=data['reverb_hi_damping'],
reverb_hi_coloration=data['reverb_hi_coloration'],
reverb_hi_cross_talk=data['reverb_hi_cross_talk'],
reverb_hi_mix=data['reverb_hi_mix'],
chorus_enabled=data['chorus_enabled'],
chorus_base_delay=data['chorus_base_delay'],
chorus_variation=data['chorus_variation'],
chorus_period=data['chorus_period'],
reverb_std_enabled=data['reverb_std_enabled'],
unknown_0x4a5bbf90=data['unknown_0x4a5bbf90'],
reverb_std_time=data['reverb_std_time'],
reverb_std_pre_delay=data['reverb_std_pre_delay'],
reverb_std_damping=data['reverb_std_damping'],
reverb_std_coloration=data['reverb_std_coloration'],
reverb_std_mix=data['reverb_std_mix'],
delay_enabled=data['delay_enabled'],
delay0=data['delay0'],
delay1=data['delay1'],
delay2=data['delay2'],
delay_feedback0=data['delay_feedback0'],
delay_feedback1=data['delay_feedback1'],
delay_feedback2=data['delay_feedback2'],
delay_output0=data['delay_output0'],
delay_output1=data['delay_output1'],
delay_output2=data['delay_output2'],
unknown_0xcf45711c=data['unknown_0xcf45711c'],
unknown_0x626d1e9b=data['unknown_0x626d1e9b'],
unknown_0x7d8ee273=data['unknown_0x7d8ee273'],
unknown_0x83378e6a=data['unknown_0x83378e6a'],
unknown_0xf549d269=data['unknown_0xf549d269'],
unknown_0x11fdae16=data['unknown_0x11fdae16'],
unknown_0xa3c439c1=data['unknown_0xa3c439c1'],
unknown_0x2dc70efe=data['unknown_0x2dc70efe'],
unknown_0xe2bd3706=data['unknown_0xe2bd3706'],
unknown_0x5e29cef8=data['unknown_0x5e29cef8'],
unknown_0x35ae9f10=data['unknown_0x35ae9f10'],
bitcrusher_enabled=data['bitcrusher_enabled'],
unknown_0xf51a1d6a=data['unknown_0xf51a1d6a'],
bitcrusher_gain=data['bitcrusher_gain'],
bitcrusher_bit_depth=data['bitcrusher_bit_depth'],
unknown_0x58096e0b=data['unknown_0x58096e0b'],
phaser_enabled=data['phaser_enabled'],
phaser_frequency=data['phaser_frequency'],
phaser_feedback=data['phaser_feedback'],
phaser_invert=data['phaser_invert'],
phaser_mix=data['phaser_mix'],
phaser_sweep=data['phaser_sweep'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'room_volume': self.room_volume,
'priority': self.priority,
'reverb_hi_enabled': self.reverb_hi_enabled,
'unknown_0x3263c26e': self.unknown_0x3263c26e,
'reverb_hi_time': self.reverb_hi_time,
'reverb_hi_pre_delay': self.reverb_hi_pre_delay,
'reverb_hi_damping': self.reverb_hi_damping,
'reverb_hi_coloration': self.reverb_hi_coloration,
'reverb_hi_cross_talk': self.reverb_hi_cross_talk,
'reverb_hi_mix': self.reverb_hi_mix,
'chorus_enabled': self.chorus_enabled,
'chorus_base_delay': self.chorus_base_delay,
'chorus_variation': self.chorus_variation,
'chorus_period': self.chorus_period,
'reverb_std_enabled': self.reverb_std_enabled,
'unknown_0x4a5bbf90': self.unknown_0x4a5bbf90,
'reverb_std_time': self.reverb_std_time,
'reverb_std_pre_delay': self.reverb_std_pre_delay,
'reverb_std_damping': self.reverb_std_damping,
'reverb_std_coloration': self.reverb_std_coloration,
'reverb_std_mix': self.reverb_std_mix,
'delay_enabled': self.delay_enabled,
'delay0': self.delay0,
'delay1': self.delay1,
'delay2': self.delay2,
'delay_feedback0': self.delay_feedback0,
'delay_feedback1': self.delay_feedback1,
'delay_feedback2': self.delay_feedback2,
'delay_output0': self.delay_output0,
'delay_output1': self.delay_output1,
'delay_output2': self.delay_output2,
'unknown_0xcf45711c': self.unknown_0xcf45711c,
'unknown_0x626d1e9b': self.unknown_0x626d1e9b,
'unknown_0x7d8ee273': self.unknown_0x7d8ee273,
'unknown_0x83378e6a': self.unknown_0x83378e6a,
'unknown_0xf549d269': self.unknown_0xf549d269,
'unknown_0x11fdae16': self.unknown_0x11fdae16,
'unknown_0xa3c439c1': self.unknown_0xa3c439c1,
'unknown_0x2dc70efe': self.unknown_0x2dc70efe,
'unknown_0xe2bd3706': self.unknown_0xe2bd3706,
'unknown_0x5e29cef8': self.unknown_0x5e29cef8,
'unknown_0x35ae9f10': self.unknown_0x35ae9f10,
'bitcrusher_enabled': self.bitcrusher_enabled,
'unknown_0xf51a1d6a': self.unknown_0xf51a1d6a,
'bitcrusher_gain': self.bitcrusher_gain,
'bitcrusher_bit_depth': self.bitcrusher_bit_depth,
'unknown_0x58096e0b': self.unknown_0x58096e0b,
'phaser_enabled': self.phaser_enabled,
'phaser_frequency': self.phaser_frequency,
'phaser_feedback': self.phaser_feedback,
'phaser_invert': self.phaser_invert,
'phaser_mix': self.phaser_mix,
'phaser_sweep': self.phaser_sweep,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for RoomAcoustics.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_room_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_reverb_hi_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x3263c26e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_reverb_hi_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_hi_pre_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_hi_damping(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_hi_coloration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_hi_cross_talk(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_hi_mix(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chorus_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_chorus_base_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chorus_variation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chorus_period(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_std_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4a5bbf90(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_reverb_std_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_std_pre_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_std_damping(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_std_coloration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverb_std_mix(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delay0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay_feedback0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay_feedback1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay_feedback2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay_output0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay_output1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_delay_output2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xcf45711c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x626d1e9b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7d8ee273(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x83378e6a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf549d269(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x11fdae16(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa3c439c1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2dc70efe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe2bd3706(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5e29cef8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x35ae9f10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bitcrusher_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf51a1d6a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_bitcrusher_gain(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bitcrusher_bit_depth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x58096e0b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phaser_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_phaser_frequency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phaser_feedback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phaser_invert(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phaser_mix(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phaser_sweep(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbd9ea266: ('room_volume', _decode_room_volume),
0x86cf23f4: ('priority', _decode_priority),
0xa00360cc: ('reverb_hi_enabled', _decode_reverb_hi_enabled),
0x3263c26e: ('unknown_0x3263c26e', _decode_unknown_0x3263c26e),
0xc5868061: ('reverb_hi_time', _decode_reverb_hi_time),
0xc6f50032: ('reverb_hi_pre_delay', _decode_reverb_hi_pre_delay),
0xcba5555d: ('reverb_hi_damping', _decode_reverb_hi_damping),
0x7319cf50: ('reverb_hi_coloration', _decode_reverb_hi_coloration),
0x3dc3f16f: ('reverb_hi_cross_talk', _decode_reverb_hi_cross_talk),
0xd5518b6c: ('reverb_hi_mix', _decode_reverb_hi_mix),
0x26997ccb: ('chorus_enabled', _decode_chorus_enabled),
0x121bdfad: ('chorus_base_delay', _decode_chorus_base_delay),
0xe8796bce: ('chorus_variation', _decode_chorus_variation),
0x24bbd5e4: ('chorus_period', _decode_chorus_period),
0xff31631b: ('reverb_std_enabled', _decode_reverb_std_enabled),
0x4a5bbf90: ('unknown_0x4a5bbf90', _decode_unknown_0x4a5bbf90),
0x9662498a: ('reverb_std_time', _decode_reverb_std_time),
0x91855d62: ('reverb_std_pre_delay', _decode_reverb_std_pre_delay),
0xd34d2029: ('reverb_std_damping', _decode_reverb_std_damping),
0xdc78e83d: ('reverb_std_coloration', _decode_reverb_std_coloration),
0x820b509e: ('reverb_std_mix', _decode_reverb_std_mix),
0xe9a36031: ('delay_enabled', _decode_delay_enabled),
0x62c49457: ('delay0', _decode_delay0),
0xda78f332: ('delay1', _decode_delay1),
0xc8cd5cdc: ('delay2', _decode_delay2),
0x7c14ff17: ('delay_feedback0', _decode_delay_feedback0),
0xc4a89872: ('delay_feedback1', _decode_delay_feedback1),
0xd61d379c: ('delay_feedback2', _decode_delay_feedback2),
0x9f75987f: ('delay_output0', _decode_delay_output0),
0x27c9ff1a: ('delay_output1', _decode_delay_output1),
0x357c50f4: ('delay_output2', _decode_delay_output2),
0xcf45711c: ('unknown_0xcf45711c', _decode_unknown_0xcf45711c),
0x626d1e9b: ('unknown_0x626d1e9b', _decode_unknown_0x626d1e9b),
0x7d8ee273: ('unknown_0x7d8ee273', _decode_unknown_0x7d8ee273),
0x83378e6a: ('unknown_0x83378e6a', _decode_unknown_0x83378e6a),
0xf549d269: ('unknown_0xf549d269', _decode_unknown_0xf549d269),
0x11fdae16: ('unknown_0x11fdae16', _decode_unknown_0x11fdae16),
0xa3c439c1: ('unknown_0xa3c439c1', _decode_unknown_0xa3c439c1),
0x2dc70efe: ('unknown_0x2dc70efe', _decode_unknown_0x2dc70efe),
0xe2bd3706: ('unknown_0xe2bd3706', _decode_unknown_0xe2bd3706),
0x5e29cef8: ('unknown_0x5e29cef8', _decode_unknown_0x5e29cef8),
0x35ae9f10: ('unknown_0x35ae9f10', _decode_unknown_0x35ae9f10),
0x3e8d8694: ('bitcrusher_enabled', _decode_bitcrusher_enabled),
0xf51a1d6a: ('unknown_0xf51a1d6a', _decode_unknown_0xf51a1d6a),
0xbb1a0f34: ('bitcrusher_gain', _decode_bitcrusher_gain),
0xeb009039: ('bitcrusher_bit_depth', _decode_bitcrusher_bit_depth),
0x58096e0b: ('unknown_0x58096e0b', _decode_unknown_0x58096e0b),
0x3d8cad84: ('phaser_enabled', _decode_phaser_enabled),
0x23c340f6: ('phaser_frequency', _decode_phaser_frequency),
0x1e5a52b8: ('phaser_feedback', _decode_phaser_feedback),
0x1d69bec4: ('phaser_invert', _decode_phaser_invert),
0x24538c4a: ('phaser_mix', _decode_phaser_mix),
0xd5388116: ('phaser_sweep', _decode_phaser_sweep),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/RoomAcoustics.py | 0.670177 | 0.251912 | RoomAcoustics.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class HUDMemo(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
display_time: float = dataclasses.field(default=3.0)
clear_window: bool = dataclasses.field(default=True)
player1: bool = dataclasses.field(default=True)
player2: bool = dataclasses.field(default=True)
player3: bool = dataclasses.field(default=True)
player4: bool = dataclasses.field(default=True)
type_out: bool = dataclasses.field(default=True)
use_originator: bool = dataclasses.field(default=False)
display_type: int = dataclasses.field(default=0)
string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MEMO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1a&\xc1\xcc') # 0x1a26c1cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.display_time))
data.write(b'\x84\xe2Io') # 0x84e2496f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.clear_window))
data.write(b'\xa8\xfa\xdf\xa5') # 0xa8fadfa5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player1))
data.write(b'\xefZ\xa5u') # 0xef5aa575
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player2))
data.write(b'\xd2:\x8c\xc5') # 0xd23a8cc5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player3))
data.write(b'`\x1aP\xd5') # 0x601a50d5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player4))
data.write(b'\xaf\xd0\x15\x8e') # 0xafd0158e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.type_out))
data.write(b'\xbdo{\x11') # 0xbd6f7b11
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_originator))
data.write(b'J\xb3\xb9[') # 0x4ab3b95b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.display_type))
data.write(b'\x91\x82%\x0c') # 0x9182250c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.string))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
display_time=data['display_time'],
clear_window=data['clear_window'],
player1=data['player1'],
player2=data['player2'],
player3=data['player3'],
player4=data['player4'],
type_out=data['type_out'],
use_originator=data['use_originator'],
display_type=data['display_type'],
string=data['string'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'display_time': self.display_time,
'clear_window': self.clear_window,
'player1': self.player1,
'player2': self.player2,
'player3': self.player3,
'player4': self.player4,
'type_out': self.type_out,
'use_originator': self.use_originator,
'display_type': self.display_type,
'string': self.string,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_string(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.string)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_string, "string", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for HUDMemo.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_display_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_clear_window(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_type_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_originator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_display_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x1a26c1cc: ('display_time', _decode_display_time),
0x84e2496f: ('clear_window', _decode_clear_window),
0xa8fadfa5: ('player1', _decode_player1),
0xef5aa575: ('player2', _decode_player2),
0xd23a8cc5: ('player3', _decode_player3),
0x601a50d5: ('player4', _decode_player4),
0xafd0158e: ('type_out', _decode_type_out),
0xbd6f7b11: ('use_originator', _decode_use_originator),
0x4ab3b95b: ('display_type', _decode_display_type),
0x9182250c: ('string', _decode_string),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/HUDMemo.py | 0.581184 | 0.291882 | HUDMemo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.ShockWaveInfo import ShockWaveInfo
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 ElitePirate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
melee_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
max_melee_range: float = dataclasses.field(default=9.0)
min_shockwave_range: float = dataclasses.field(default=9.0)
max_shockwave_range: float = dataclasses.field(default=35.0)
min_rocket_range: float = dataclasses.field(default=15.0)
max_rocket_range: float = dataclasses.field(default=80.0)
unknown_0x5236c2b6: float = dataclasses.field(default=50.0)
unknown_0x01eaab17: float = dataclasses.field(default=50.0)
shielded_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
shielded_skin_rules: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
dark_shield: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
dark_shield_sound: int = dataclasses.field(default=0, metadata={'sound': True})
dark_shield_pop: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
light_shield: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
light_shield_sound: int = dataclasses.field(default=0, metadata={'sound': True})
light_shield_pop: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
taunt_interval: float = dataclasses.field(default=8.0)
taunt_variance: float = dataclasses.field(default=3.0)
single_shock_wave_info: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
double_shock_wave_info: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
unknown_0x28b39197: float = dataclasses.field(default=1.0)
unknown_0xe27de71b: float = dataclasses.field(default=1.0)
unknown_0x665e7ace: float = dataclasses.field(default=1.0)
unknown_0xacd4d06d: float = dataclasses.field(default=2.0)
rocket: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
rocket_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x624222f8: int = dataclasses.field(default=2)
unknown_0x31e43a1c: int = dataclasses.field(default=4)
repeated_attack_chance: float = dataclasses.field(default=0.10000000149011612)
energy_absorb_duration: float = dataclasses.field(default=3.0)
unknown_0xe47334ae: float = dataclasses.field(default=1.0)
unknown_0x3dad897b: float = dataclasses.field(default=50.0)
always_ff_0x06cf4324: int = dataclasses.field(default=0)
always_ff_0x23f5e1ee: int = dataclasses.field(default=0)
rocket_launcher_actor_info: ActorParameters = dataclasses.field(default_factory=ActorParameters)
rocket_launcher_anim_info: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x7e6e0d38: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
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})
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'EPRT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ElitePirate.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00+') # 43 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'average_attack_time': 3.5, 'attack_time_variation': 2.0, 'creature_size': 2})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\x98s\xa1\xc1') # 0x9873a1c1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_melee_range))
data.write(b'(\t\\\xe6') # 0x28095ce6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_shockwave_range))
data.write(b'i\x1ec`') # 0x691e6360
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_shockwave_range))
data.write(b'\xe6)\x9f\xac') # 0xe6299fac
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_rocket_range))
data.write(b'A\x1d\x1f\xd5') # 0x411d1fd5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_rocket_range))
data.write(b'R6\xc2\xb6') # 0x5236c2b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5236c2b6))
data.write(b'\x01\xea\xab\x17') # 0x1eaab17
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x01eaab17))
data.write(b'\x00\xae\x9ca') # 0xae9c61
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shielded_model))
data.write(b'\xac\xda\xe4\x08') # 0xacdae408
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shielded_skin_rules))
data.write(b'\xaaH-\x8d') # 0xaa482d8d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.dark_shield))
data.write(b'\xee\xaf\x03\xc4') # 0xeeaf03c4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.dark_shield_sound))
data.write(b'\xafO\xaet') # 0xaf4fae74
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.dark_shield_pop))
data.write(b'd\xa1\xf5X') # 0x64a1f558
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.light_shield))
data.write(b'\xbf\x10st') # 0xbf107374
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.light_shield_sound))
data.write(b'\xb4:L\xaa') # 0xb43a4caa
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.light_shield_pop))
data.write(b'a\xc4\xc0\xea') # 0x61c4c0ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_interval))
data.write(b'\xf8-\x12r') # 0xf82d1272
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_variance))
data.write(b'\xb2\xeb\xbf\xc6') # 0xb2ebbfc6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.single_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'\t%\r\xb2') # 0x9250db2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.double_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'(\xb3\x91\x97') # 0x28b39197
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x28b39197))
data.write(b'\xe2}\xe7\x1b') # 0xe27de71b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe27de71b))
data.write(b'f^z\xce') # 0x665e7ace
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x665e7ace))
data.write(b'\xac\xd4\xd0m') # 0xacd4d06d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xacd4d06d))
data.write(b'\xf1\x99\xf5S') # 0xf199f553
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.rocket))
data.write(b'@c\xd4\\') # 0x4063d45c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rocket_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 10.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'bB"\xf8') # 0x624222f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x624222f8))
data.write(b'1\xe4:\x1c') # 0x31e43a1c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x31e43a1c))
data.write(b'\xd6F\x91\x19') # 0xd6469119
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.repeated_attack_chance))
data.write(b'm\x14%\xd8') # 0x6d1425d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.energy_absorb_duration))
data.write(b'\xe4s4\xae') # 0xe47334ae
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe47334ae))
data.write(b'=\xad\x89{') # 0x3dad897b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3dad897b))
data.write(b'\x06\xcfC$') # 0x6cf4324
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.always_ff_0x06cf4324))
data.write(b'#\xf5\xe1\xee') # 0x23f5e1ee
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.always_ff_0x23f5e1ee))
data.write(b'b\xc7D\xcd') # 0x62c744cd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rocket_launcher_actor_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9+H\x1d') # 0xb92b481d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rocket_launcher_anim_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\r8') # 0x7e6e0d38
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7e6e0d38.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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))
data.write(b'\xe6\x17H\xed') # 0xe61748ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_possession_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
melee_damage=DamageInfo.from_json(data['melee_damage']),
max_melee_range=data['max_melee_range'],
min_shockwave_range=data['min_shockwave_range'],
max_shockwave_range=data['max_shockwave_range'],
min_rocket_range=data['min_rocket_range'],
max_rocket_range=data['max_rocket_range'],
unknown_0x5236c2b6=data['unknown_0x5236c2b6'],
unknown_0x01eaab17=data['unknown_0x01eaab17'],
shielded_model=data['shielded_model'],
shielded_skin_rules=data['shielded_skin_rules'],
dark_shield=data['dark_shield'],
dark_shield_sound=data['dark_shield_sound'],
dark_shield_pop=data['dark_shield_pop'],
light_shield=data['light_shield'],
light_shield_sound=data['light_shield_sound'],
light_shield_pop=data['light_shield_pop'],
taunt_interval=data['taunt_interval'],
taunt_variance=data['taunt_variance'],
single_shock_wave_info=ShockWaveInfo.from_json(data['single_shock_wave_info']),
double_shock_wave_info=ShockWaveInfo.from_json(data['double_shock_wave_info']),
unknown_0x28b39197=data['unknown_0x28b39197'],
unknown_0xe27de71b=data['unknown_0xe27de71b'],
unknown_0x665e7ace=data['unknown_0x665e7ace'],
unknown_0xacd4d06d=data['unknown_0xacd4d06d'],
rocket=data['rocket'],
rocket_damage=DamageInfo.from_json(data['rocket_damage']),
unknown_0x624222f8=data['unknown_0x624222f8'],
unknown_0x31e43a1c=data['unknown_0x31e43a1c'],
repeated_attack_chance=data['repeated_attack_chance'],
energy_absorb_duration=data['energy_absorb_duration'],
unknown_0xe47334ae=data['unknown_0xe47334ae'],
unknown_0x3dad897b=data['unknown_0x3dad897b'],
always_ff_0x06cf4324=data['always_ff_0x06cf4324'],
always_ff_0x23f5e1ee=data['always_ff_0x23f5e1ee'],
rocket_launcher_actor_info=ActorParameters.from_json(data['rocket_launcher_actor_info']),
rocket_launcher_anim_info=AnimationParameters.from_json(data['rocket_launcher_anim_info']),
unknown_0x7e6e0d38=AnimationParameters.from_json(data['unknown_0x7e6e0d38']),
visor_electric_effect=data['visor_electric_effect'],
sound_visor_electric=data['sound_visor_electric'],
ing_possession_data=IngPossessionData.from_json(data['ing_possession_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'melee_damage': self.melee_damage.to_json(),
'max_melee_range': self.max_melee_range,
'min_shockwave_range': self.min_shockwave_range,
'max_shockwave_range': self.max_shockwave_range,
'min_rocket_range': self.min_rocket_range,
'max_rocket_range': self.max_rocket_range,
'unknown_0x5236c2b6': self.unknown_0x5236c2b6,
'unknown_0x01eaab17': self.unknown_0x01eaab17,
'shielded_model': self.shielded_model,
'shielded_skin_rules': self.shielded_skin_rules,
'dark_shield': self.dark_shield,
'dark_shield_sound': self.dark_shield_sound,
'dark_shield_pop': self.dark_shield_pop,
'light_shield': self.light_shield,
'light_shield_sound': self.light_shield_sound,
'light_shield_pop': self.light_shield_pop,
'taunt_interval': self.taunt_interval,
'taunt_variance': self.taunt_variance,
'single_shock_wave_info': self.single_shock_wave_info.to_json(),
'double_shock_wave_info': self.double_shock_wave_info.to_json(),
'unknown_0x28b39197': self.unknown_0x28b39197,
'unknown_0xe27de71b': self.unknown_0xe27de71b,
'unknown_0x665e7ace': self.unknown_0x665e7ace,
'unknown_0xacd4d06d': self.unknown_0xacd4d06d,
'rocket': self.rocket,
'rocket_damage': self.rocket_damage.to_json(),
'unknown_0x624222f8': self.unknown_0x624222f8,
'unknown_0x31e43a1c': self.unknown_0x31e43a1c,
'repeated_attack_chance': self.repeated_attack_chance,
'energy_absorb_duration': self.energy_absorb_duration,
'unknown_0xe47334ae': self.unknown_0xe47334ae,
'unknown_0x3dad897b': self.unknown_0x3dad897b,
'always_ff_0x06cf4324': self.always_ff_0x06cf4324,
'always_ff_0x23f5e1ee': self.always_ff_0x23f5e1ee,
'rocket_launcher_actor_info': self.rocket_launcher_actor_info.to_json(),
'rocket_launcher_anim_info': self.rocket_launcher_anim_info.to_json(),
'unknown_0x7e6e0d38': self.unknown_0x7e6e0d38.to_json(),
'visor_electric_effect': self.visor_electric_effect,
'sound_visor_electric': self.sound_visor_electric,
'ing_possession_data': self.ing_possession_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_melee_damage(self, asset_manager):
yield from self.melee_damage.dependencies_for(asset_manager)
def _dependencies_for_shielded_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shielded_model)
def _dependencies_for_shielded_skin_rules(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shielded_skin_rules)
def _dependencies_for_dark_shield(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dark_shield)
def _dependencies_for_dark_shield_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.dark_shield_sound)
def _dependencies_for_dark_shield_pop(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dark_shield_pop)
def _dependencies_for_light_shield(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.light_shield)
def _dependencies_for_light_shield_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.light_shield_sound)
def _dependencies_for_light_shield_pop(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.light_shield_pop)
def _dependencies_for_single_shock_wave_info(self, asset_manager):
yield from self.single_shock_wave_info.dependencies_for(asset_manager)
def _dependencies_for_double_shock_wave_info(self, asset_manager):
yield from self.double_shock_wave_info.dependencies_for(asset_manager)
def _dependencies_for_rocket(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.rocket)
def _dependencies_for_rocket_damage(self, asset_manager):
yield from self.rocket_damage.dependencies_for(asset_manager)
def _dependencies_for_rocket_launcher_actor_info(self, asset_manager):
yield from self.rocket_launcher_actor_info.dependencies_for(asset_manager)
def _dependencies_for_rocket_launcher_anim_info(self, asset_manager):
yield from self.rocket_launcher_anim_info.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x7e6e0d38(self, asset_manager):
yield from self.unknown_0x7e6e0d38.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_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_melee_damage, "melee_damage", "DamageInfo"),
(self._dependencies_for_shielded_model, "shielded_model", "AssetId"),
(self._dependencies_for_shielded_skin_rules, "shielded_skin_rules", "AssetId"),
(self._dependencies_for_dark_shield, "dark_shield", "AssetId"),
(self._dependencies_for_dark_shield_sound, "dark_shield_sound", "int"),
(self._dependencies_for_dark_shield_pop, "dark_shield_pop", "AssetId"),
(self._dependencies_for_light_shield, "light_shield", "AssetId"),
(self._dependencies_for_light_shield_sound, "light_shield_sound", "int"),
(self._dependencies_for_light_shield_pop, "light_shield_pop", "AssetId"),
(self._dependencies_for_single_shock_wave_info, "single_shock_wave_info", "ShockWaveInfo"),
(self._dependencies_for_double_shock_wave_info, "double_shock_wave_info", "ShockWaveInfo"),
(self._dependencies_for_rocket, "rocket", "AssetId"),
(self._dependencies_for_rocket_damage, "rocket_damage", "DamageInfo"),
(self._dependencies_for_rocket_launcher_actor_info, "rocket_launcher_actor_info", "ActorParameters"),
(self._dependencies_for_rocket_launcher_anim_info, "rocket_launcher_anim_info", "AnimationParameters"),
(self._dependencies_for_unknown_0x7e6e0d38, "unknown_0x7e6e0d38", "AnimationParameters"),
(self._dependencies_for_visor_electric_effect, "visor_electric_effect", "AssetId"),
(self._dependencies_for_sound_visor_electric, "sound_visor_electric", "int"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ElitePirate.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'average_attack_time': 3.5, 'attack_time_variation': 2.0, 'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_melee_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_max_melee_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_shockwave_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_shockwave_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_rocket_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_rocket_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5236c2b6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x01eaab17(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shielded_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_shielded_skin_rules(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_dark_shield(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_dark_shield_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dark_shield_pop(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_light_shield(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_light_shield_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_light_shield_pop(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_taunt_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_taunt_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_single_shock_wave_info(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.from_stream(data, property_size)
def _decode_double_shock_wave_info(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.from_stream(data, property_size)
def _decode_unknown_0x28b39197(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe27de71b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x665e7ace(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xacd4d06d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rocket(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_rocket_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': 5.0})
def _decode_unknown_0x624222f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x31e43a1c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_repeated_attack_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_energy_absorb_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe47334ae(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3dad897b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_always_ff_0x06cf4324(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_always_ff_0x23f5e1ee(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_rocket_launcher_actor_info(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_rocket_launcher_anim_info(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x7e6e0d38(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
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]
def _decode_ing_possession_data(data: typing.BinaryIO, property_size: int):
return IngPossessionData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc9416034: ('melee_damage', _decode_melee_damage),
0x9873a1c1: ('max_melee_range', _decode_max_melee_range),
0x28095ce6: ('min_shockwave_range', _decode_min_shockwave_range),
0x691e6360: ('max_shockwave_range', _decode_max_shockwave_range),
0xe6299fac: ('min_rocket_range', _decode_min_rocket_range),
0x411d1fd5: ('max_rocket_range', _decode_max_rocket_range),
0x5236c2b6: ('unknown_0x5236c2b6', _decode_unknown_0x5236c2b6),
0x1eaab17: ('unknown_0x01eaab17', _decode_unknown_0x01eaab17),
0xae9c61: ('shielded_model', _decode_shielded_model),
0xacdae408: ('shielded_skin_rules', _decode_shielded_skin_rules),
0xaa482d8d: ('dark_shield', _decode_dark_shield),
0xeeaf03c4: ('dark_shield_sound', _decode_dark_shield_sound),
0xaf4fae74: ('dark_shield_pop', _decode_dark_shield_pop),
0x64a1f558: ('light_shield', _decode_light_shield),
0xbf107374: ('light_shield_sound', _decode_light_shield_sound),
0xb43a4caa: ('light_shield_pop', _decode_light_shield_pop),
0x61c4c0ea: ('taunt_interval', _decode_taunt_interval),
0xf82d1272: ('taunt_variance', _decode_taunt_variance),
0xb2ebbfc6: ('single_shock_wave_info', _decode_single_shock_wave_info),
0x9250db2: ('double_shock_wave_info', _decode_double_shock_wave_info),
0x28b39197: ('unknown_0x28b39197', _decode_unknown_0x28b39197),
0xe27de71b: ('unknown_0xe27de71b', _decode_unknown_0xe27de71b),
0x665e7ace: ('unknown_0x665e7ace', _decode_unknown_0x665e7ace),
0xacd4d06d: ('unknown_0xacd4d06d', _decode_unknown_0xacd4d06d),
0xf199f553: ('rocket', _decode_rocket),
0x4063d45c: ('rocket_damage', _decode_rocket_damage),
0x624222f8: ('unknown_0x624222f8', _decode_unknown_0x624222f8),
0x31e43a1c: ('unknown_0x31e43a1c', _decode_unknown_0x31e43a1c),
0xd6469119: ('repeated_attack_chance', _decode_repeated_attack_chance),
0x6d1425d8: ('energy_absorb_duration', _decode_energy_absorb_duration),
0xe47334ae: ('unknown_0xe47334ae', _decode_unknown_0xe47334ae),
0x3dad897b: ('unknown_0x3dad897b', _decode_unknown_0x3dad897b),
0x6cf4324: ('always_ff_0x06cf4324', _decode_always_ff_0x06cf4324),
0x23f5e1ee: ('always_ff_0x23f5e1ee', _decode_always_ff_0x23f5e1ee),
0x62c744cd: ('rocket_launcher_actor_info', _decode_rocket_launcher_actor_info),
0xb92b481d: ('rocket_launcher_anim_info', _decode_rocket_launcher_anim_info),
0x7e6e0d38: ('unknown_0x7e6e0d38', _decode_unknown_0x7e6e0d38),
0xbd321538: ('visor_electric_effect', _decode_visor_electric_effect),
0x58a492ef: ('sound_visor_electric', _decode_sound_visor_electric),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ElitePirate.py | 0.645902 | 0.166811 | ElitePirate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.Vector2f import Vector2f
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class DistanceFog(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
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)
force_settings: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DFOG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\t\xadc\xde') # 0x9ad63de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.mode))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'e \x08\xda') # 0x652008da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.near_far_plane.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b")\xabG'") # 0x29ab4727
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.color_rate))
data.write(b'\xcc\x8e\x0f\x98') # 0xcc8e0f98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.distance_rate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5\x93[g') # 0xc5935b67
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_settings))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
mode=data['mode'],
color=Color.from_json(data['color']),
near_far_plane=Vector2f.from_json(data['near_far_plane']),
color_rate=data['color_rate'],
distance_rate=Vector2f.from_json(data['distance_rate']),
force_settings=data['force_settings'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'mode': self.mode,
'color': self.color.to_json(),
'near_far_plane': self.near_far_plane.to_json(),
'color_rate': self.color_rate,
'distance_rate': self.distance_rate.to_json(),
'force_settings': self.force_settings,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
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_editor_properties, "editor_properties", "EditorProperties"),
(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 DistanceFog.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_near_far_plane(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
def _decode_color_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance_rate(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
def _decode_force_settings(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x9ad63de: ('mode', _decode_mode),
0x37c7d09d: ('color', _decode_color),
0x652008da: ('near_far_plane', _decode_near_far_plane),
0x29ab4727: ('color_rate', _decode_color_rate),
0xcc8e0f98: ('distance_rate', _decode_distance_rate),
0xc5935b67: ('force_settings', _decode_force_settings),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DistanceFog.py | 0.640299 | 0.408513 | DistanceFog.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CameraBlurKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
blur_type: int = dataclasses.field(default=0)
blur_radius: float = dataclasses.field(default=0.0)
which_filter_group: int = dataclasses.field(default=0)
interpolate_in_time: float = dataclasses.field(default=0.0)
interpolate_out_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BLUR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe95\x91H') # 0xe9359148
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blur_type))
data.write(b'on\xb1\xf4') # 0x6f6eb1f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.blur_radius))
data.write(b'?\xdcK.') # 0x3fdc4b2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_filter_group))
data.write(b'\xab\xd4\x1a6') # 0xabd41a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_in_time))
data.write(b'>\xafx\xfe') # 0x3eaf78fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
blur_type=data['blur_type'],
blur_radius=data['blur_radius'],
which_filter_group=data['which_filter_group'],
interpolate_in_time=data['interpolate_in_time'],
interpolate_out_time=data['interpolate_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'blur_type': self.blur_type,
'blur_radius': self.blur_radius,
'which_filter_group': self.which_filter_group,
'interpolate_in_time': self.interpolate_in_time,
'interpolate_out_time': self.interpolate_out_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CameraBlurKeyframe.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_blur_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_blur_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_which_filter_group(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_interpolate_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_interpolate_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe9359148: ('blur_type', _decode_blur_type),
0x6f6eb1f4: ('blur_radius', _decode_blur_radius),
0x3fdc4b2e: ('which_filter_group', _decode_which_filter_group),
0xabd41a36: ('interpolate_in_time', _decode_interpolate_in_time),
0x3eaf78fe: ('interpolate_out_time', _decode_interpolate_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CameraBlurKeyframe.py | 0.609873 | 0.37299 | CameraBlurKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.archetypes.VisorParameters import VisorParameters
@dataclasses.dataclass()
class DamageableTrigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
orbitable: bool = dataclasses.field(default=False)
enable_seeker_lock_on: bool = dataclasses.field(default=False)
invulnerable: bool = dataclasses.field(default=False)
visor: VisorParameters = dataclasses.field(default_factory=VisorParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DTRG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'pKSi') # 0x704b5369
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orbitable))
data.write(b']\xfdx ') # 0x5dfd7820
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_seeker_lock_on))
data.write(b'fR\xbd\xd7') # 0x6652bdd7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.invulnerable))
data.write(b'\x05\xad%\x0e') # 0x5ad250e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.visor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
orbitable=data['orbitable'],
enable_seeker_lock_on=data['enable_seeker_lock_on'],
invulnerable=data['invulnerable'],
visor=VisorParameters.from_json(data['visor']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'orbitable': self.orbitable,
'enable_seeker_lock_on': self.enable_seeker_lock_on,
'invulnerable': self.invulnerable,
'visor': self.visor.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_visor(self, asset_manager):
yield from self.visor.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_visor, "visor", "VisorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DamageableTrigger.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_orbitable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_seeker_lock_on(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_invulnerable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_visor(data: typing.BinaryIO, property_size: int):
return VisorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x704b5369: ('orbitable', _decode_orbitable),
0x5dfd7820: ('enable_seeker_lock_on', _decode_enable_seeker_lock_on),
0x6652bdd7: ('invulnerable', _decode_invulnerable),
0x5ad250e: ('visor', _decode_visor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DamageableTrigger.py | 0.555435 | 0.355299 | DamageableTrigger.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class GuiPlayerJoinManager(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GPJN'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptGui.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for GuiPlayerJoinManager.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/GuiPlayerJoinManager.py | 0.593138 | 0.348507 | GuiPlayerJoinManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TweakGui.Completion import Completion
from retro_data_structures.properties.echoes.archetypes.TweakGui.Credits import Credits
from retro_data_structures.properties.echoes.archetypes.TweakGui.DarkVisor import DarkVisor
from retro_data_structures.properties.echoes.archetypes.TweakGui.EchoVisor import EchoVisor
from retro_data_structures.properties.echoes.archetypes.TweakGui.LogBook import LogBook
from retro_data_structures.properties.echoes.archetypes.TweakGui.Misc import Misc
from retro_data_structures.properties.echoes.archetypes.TweakGui.MovieVolumes import MovieVolumes
from retro_data_structures.properties.echoes.archetypes.TweakGui.ScanVisor import ScanVisor
from retro_data_structures.properties.echoes.archetypes.TweakGui.ScannableObjectDownloadTimes import ScannableObjectDownloadTimes
@dataclasses.dataclass()
class TweakGui(BaseObjectType):
instance_name: str = dataclasses.field(default='')
misc: Misc = dataclasses.field(default_factory=Misc)
scannable_object_download_times: ScannableObjectDownloadTimes = dataclasses.field(default_factory=ScannableObjectDownloadTimes)
unknown: DarkVisor = dataclasses.field(default_factory=DarkVisor)
echo_visor: EchoVisor = dataclasses.field(default_factory=EchoVisor)
scan_visor: ScanVisor = dataclasses.field(default_factory=ScanVisor)
log_book: LogBook = dataclasses.field(default_factory=LogBook)
credits: Credits = dataclasses.field(default_factory=Credits)
completion: Completion = dataclasses.field(default_factory=Completion)
movie_volumes: MovieVolumes = dataclasses.field(default_factory=MovieVolumes)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWGU'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd4_vc') # 0xd45f7663
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.misc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x80\xb1>`') # 0x80b13e60
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scannable_object_download_times.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10*\xa3\x8d') # 0x102aa38d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+i\x8eE') # 0x2b698e45
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.echo_visor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@\xff\xb3\xc4') # 0x40ffb3c4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_visor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\xb8\xa7j') # 0x97b8a76a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.log_book.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w94\x16') # 0x77393416
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.credits.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x02\x14\x98\x92') # 0x2149892
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.completion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf6\x1e\x92') # 0xa4f61e92
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.movie_volumes.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
instance_name=data['instance_name'],
misc=Misc.from_json(data['misc']),
scannable_object_download_times=ScannableObjectDownloadTimes.from_json(data['scannable_object_download_times']),
unknown=DarkVisor.from_json(data['unknown']),
echo_visor=EchoVisor.from_json(data['echo_visor']),
scan_visor=ScanVisor.from_json(data['scan_visor']),
log_book=LogBook.from_json(data['log_book']),
credits=Credits.from_json(data['credits']),
completion=Completion.from_json(data['completion']),
movie_volumes=MovieVolumes.from_json(data['movie_volumes']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'misc': self.misc.to_json(),
'scannable_object_download_times': self.scannable_object_download_times.to_json(),
'unknown': self.unknown.to_json(),
'echo_visor': self.echo_visor.to_json(),
'scan_visor': self.scan_visor.to_json(),
'log_book': self.log_book.to_json(),
'credits': self.credits.to_json(),
'completion': self.completion.to_json(),
'movie_volumes': self.movie_volumes.to_json(),
}
def _dependencies_for_misc(self, asset_manager):
yield from self.misc.dependencies_for(asset_manager)
def _dependencies_for_scannable_object_download_times(self, asset_manager):
yield from self.scannable_object_download_times.dependencies_for(asset_manager)
def _dependencies_for_unknown(self, asset_manager):
yield from self.unknown.dependencies_for(asset_manager)
def _dependencies_for_echo_visor(self, asset_manager):
yield from self.echo_visor.dependencies_for(asset_manager)
def _dependencies_for_scan_visor(self, asset_manager):
yield from self.scan_visor.dependencies_for(asset_manager)
def _dependencies_for_log_book(self, asset_manager):
yield from self.log_book.dependencies_for(asset_manager)
def _dependencies_for_credits(self, asset_manager):
yield from self.credits.dependencies_for(asset_manager)
def _dependencies_for_completion(self, asset_manager):
yield from self.completion.dependencies_for(asset_manager)
def _dependencies_for_movie_volumes(self, asset_manager):
yield from self.movie_volumes.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_misc, "misc", "Misc"),
(self._dependencies_for_scannable_object_download_times, "scannable_object_download_times", "ScannableObjectDownloadTimes"),
(self._dependencies_for_unknown, "unknown", "DarkVisor"),
(self._dependencies_for_echo_visor, "echo_visor", "EchoVisor"),
(self._dependencies_for_scan_visor, "scan_visor", "ScanVisor"),
(self._dependencies_for_log_book, "log_book", "LogBook"),
(self._dependencies_for_credits, "credits", "Credits"),
(self._dependencies_for_completion, "completion", "Completion"),
(self._dependencies_for_movie_volumes, "movie_volumes", "MovieVolumes"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakGui.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_misc(data: typing.BinaryIO, property_size: int):
return Misc.from_stream(data, property_size)
def _decode_scannable_object_download_times(data: typing.BinaryIO, property_size: int):
return ScannableObjectDownloadTimes.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return DarkVisor.from_stream(data, property_size)
def _decode_echo_visor(data: typing.BinaryIO, property_size: int):
return EchoVisor.from_stream(data, property_size)
def _decode_scan_visor(data: typing.BinaryIO, property_size: int):
return ScanVisor.from_stream(data, property_size)
def _decode_log_book(data: typing.BinaryIO, property_size: int):
return LogBook.from_stream(data, property_size)
def _decode_credits(data: typing.BinaryIO, property_size: int):
return Credits.from_stream(data, property_size)
def _decode_completion(data: typing.BinaryIO, property_size: int):
return Completion.from_stream(data, property_size)
def _decode_movie_volumes(data: typing.BinaryIO, property_size: int):
return MovieVolumes.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0xd45f7663: ('misc', _decode_misc),
0x80b13e60: ('scannable_object_download_times', _decode_scannable_object_download_times),
0x102aa38d: ('unknown', _decode_unknown),
0x2b698e45: ('echo_visor', _decode_echo_visor),
0x40ffb3c4: ('scan_visor', _decode_scan_visor),
0x97b8a76a: ('log_book', _decode_log_book),
0x77393416: ('credits', _decode_credits),
0x2149892: ('completion', _decode_completion),
0xa4f61e92: ('movie_volumes', _decode_movie_volumes),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakGui.py | 0.47926 | 0.293373 | TweakGui.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class MemoryRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: bool = dataclasses.field(default=False)
delayed_action: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
data.write(b'\xa9\x05\xcc\xf0') # 0xa905ccf0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.delayed_action))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
one_shot=data['one_shot'],
delayed_action=data['delayed_action'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
'delayed_action': self.delayed_action,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MemoryRelay.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delayed_action(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xead7b7bb: ('one_shot', _decode_one_shot),
0xa905ccf0: ('delayed_action', _decode_delayed_action),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/MemoryRelay.py | 0.622115 | 0.345105 | MemoryRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
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.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Metaree(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
radius_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
drop_height: float = dataclasses.field(default=3.0)
unknown: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
attack_speed: float = dataclasses.field(default=5.0)
drop_delay: float = dataclasses.field(default=0.0)
halt_delay: float = dataclasses.field(default=0.0)
launch_speed: float = dataclasses.field(default=0.0)
turn_sound: AudioPlaybackParms = dataclasses.field(default_factory=AudioPlaybackParms)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MREE'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Metaree.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'detection_range': 10.0, 'max_attack_range': 30.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x08mX\xdd') # 0x86d58dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.radius_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 5.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'8\xa5Vo') # 0x38a5566f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drop_height))
data.write(b'\xa2\x87\x07}') # 0xa287077d
data.write(b'\x00\x0c') # size
self.unknown.to_stream(data)
data.write(b'l\n+\xc8') # 0x6c0a2bc8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_speed))
data.write(b'\x00\x97\xf2\x82') # 0x97f282
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drop_delay))
data.write(b'\xe4\xe8\x08\xc9') # 0xe4e808c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.halt_delay))
data.write(b'18\x1a\x17') # 0x31381a17
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.launch_speed))
data.write(b'\xea\x11\xd1\xfa') # 0xea11d1fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.turn_sound.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
radius_damage=DamageInfo.from_json(data['radius_damage']),
drop_height=data['drop_height'],
unknown=Vector.from_json(data['unknown']),
attack_speed=data['attack_speed'],
drop_delay=data['drop_delay'],
halt_delay=data['halt_delay'],
launch_speed=data['launch_speed'],
turn_sound=AudioPlaybackParms.from_json(data['turn_sound']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'radius_damage': self.radius_damage.to_json(),
'drop_height': self.drop_height,
'unknown': self.unknown.to_json(),
'attack_speed': self.attack_speed,
'drop_delay': self.drop_delay,
'halt_delay': self.halt_delay,
'launch_speed': self.launch_speed,
'turn_sound': self.turn_sound.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_radius_damage(self, asset_manager):
yield from self.radius_damage.dependencies_for(asset_manager)
def _dependencies_for_turn_sound(self, asset_manager):
yield from self.turn_sound.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_radius_damage, "radius_damage", "DamageInfo"),
(self._dependencies_for_turn_sound, "turn_sound", "AudioPlaybackParms"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Metaree.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'detection_range': 10.0, 'max_attack_range': 30.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_radius_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0, 'di_knock_back_power': 5.0})
def _decode_drop_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 Vector.from_stream(data)
def _decode_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drop_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_halt_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_launch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_sound(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x86d58dd: ('radius_damage', _decode_radius_damage),
0x38a5566f: ('drop_height', _decode_drop_height),
0xa287077d: ('unknown', _decode_unknown),
0x6c0a2bc8: ('attack_speed', _decode_attack_speed),
0x97f282: ('drop_delay', _decode_drop_delay),
0xe4e808c9: ('halt_delay', _decode_halt_delay),
0x31381a17: ('launch_speed', _decode_launch_speed),
0xea11d1fa: ('turn_sound', _decode_turn_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Metaree.py | 0.578686 | 0.333015 | Metaree.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.EmperorIngStage1Data import EmperorIngStage1Data
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class EmperorIngStage1(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
data: EmperorIngStage1Data = dataclasses.field(default_factory=EmperorIngStage1Data)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'EMS1'
@classmethod
def modules(cls) -> typing.List[str]:
return ['EmperorIngStage1.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'creature_size': 2})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\x1eI;') # 0x4a1e493b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
data=EmperorIngStage1Data.from_json(data['data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'data': self.data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_data(self, asset_manager):
yield from self.data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_data, "data", "EmperorIngStage1Data"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage1.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_data(data: typing.BinaryIO, property_size: int):
return EmperorIngStage1Data.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x4a1e493b: ('data', _decode_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/EmperorIngStage1.py | 0.598312 | 0.361841 | EmperorIngStage1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TeamAI(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
max_team_size: int = dataclasses.field(default=20)
max_melee_attackers: int = dataclasses.field(default=2)
max_ranged_attackers: int = dataclasses.field(default=2)
unknown_0x9fa9c457: int = dataclasses.field(default=30)
unknown_0x54cd2755: int = dataclasses.field(default=1)
unknown_0xc36ed15c: int = dataclasses.field(default=1)
team_formation: int = dataclasses.field(default=0)
unknown_0xd3ad55b6: float = dataclasses.field(default=0.0)
unknown_0x8d00b839: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TMAI'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf7\xe5\x18') # 0xbf37e518
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_team_size))
data.write(b'\xce\xbe\xe4\xab') # 0xcebee4ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_melee_attackers))
data.write(b'uU\xc1\xea') # 0x7555c1ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_ranged_attackers))
data.write(b'\x9f\xa9\xc4W') # 0x9fa9c457
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x9fa9c457))
data.write(b"T\xcd'U") # 0x54cd2755
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x54cd2755))
data.write(b'\xc3n\xd1\\') # 0xc36ed15c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc36ed15c))
data.write(b'7\xa2\x03v') # 0x37a20376
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.team_formation))
data.write(b'\xd3\xadU\xb6') # 0xd3ad55b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd3ad55b6))
data.write(b'\x8d\x00\xb89') # 0x8d00b839
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8d00b839))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
max_team_size=data['max_team_size'],
max_melee_attackers=data['max_melee_attackers'],
max_ranged_attackers=data['max_ranged_attackers'],
unknown_0x9fa9c457=data['unknown_0x9fa9c457'],
unknown_0x54cd2755=data['unknown_0x54cd2755'],
unknown_0xc36ed15c=data['unknown_0xc36ed15c'],
team_formation=data['team_formation'],
unknown_0xd3ad55b6=data['unknown_0xd3ad55b6'],
unknown_0x8d00b839=data['unknown_0x8d00b839'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'max_team_size': self.max_team_size,
'max_melee_attackers': self.max_melee_attackers,
'max_ranged_attackers': self.max_ranged_attackers,
'unknown_0x9fa9c457': self.unknown_0x9fa9c457,
'unknown_0x54cd2755': self.unknown_0x54cd2755,
'unknown_0xc36ed15c': self.unknown_0xc36ed15c,
'team_formation': self.team_formation,
'unknown_0xd3ad55b6': self.unknown_0xd3ad55b6,
'unknown_0x8d00b839': self.unknown_0x8d00b839,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TeamAI.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_max_team_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_melee_attackers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_ranged_attackers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x9fa9c457(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x54cd2755(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc36ed15c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_team_formation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd3ad55b6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8d00b839(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbf37e518: ('max_team_size', _decode_max_team_size),
0xcebee4ab: ('max_melee_attackers', _decode_max_melee_attackers),
0x7555c1ea: ('max_ranged_attackers', _decode_max_ranged_attackers),
0x9fa9c457: ('unknown_0x9fa9c457', _decode_unknown_0x9fa9c457),
0x54cd2755: ('unknown_0x54cd2755', _decode_unknown_0x54cd2755),
0xc36ed15c: ('unknown_0xc36ed15c', _decode_unknown_0xc36ed15c),
0x37a20376: ('team_formation', _decode_team_formation),
0xd3ad55b6: ('unknown_0xd3ad55b6', _decode_unknown_0xd3ad55b6),
0x8d00b839: ('unknown_0x8d00b839', _decode_unknown_0x8d00b839),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TeamAI.py | 0.580947 | 0.282444 | TeamAI.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class Tryclops(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
attract_force: float = dataclasses.field(default=20.0)
attract_angle: float = dataclasses.field(default=45.0)
attract_distance: float = dataclasses.field(default=4.0)
shot_force: float = dataclasses.field(default=20.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TRYC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Tryclops.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'min_attack_range': 0.0, 'player_leash_radius': 10.0, 'collision_radius': 0.6000000238418579, 'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb1?\xc5x') # 0xb13fc578
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attract_force))
data.write(b'\x86\x8b\x85\xe4') # 0x868b85e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attract_angle))
data.write(b'G\xc6\xbb\x1d') # 0x47c6bb1d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attract_distance))
data.write(b'&\x08}#') # 0x26087d23
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shot_force))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
attract_force=data['attract_force'],
attract_angle=data['attract_angle'],
attract_distance=data['attract_distance'],
shot_force=data['shot_force'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'attract_force': self.attract_force,
'attract_angle': self.attract_angle,
'attract_distance': self.attract_distance,
'shot_force': self.shot_force,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Tryclops.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'min_attack_range': 0.0, 'player_leash_radius': 10.0, 'collision_radius': 0.6000000238418579, 'collision_height': 1.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_attract_force(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attract_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attract_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shot_force(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb13fc578: ('attract_force', _decode_attract_force),
0x868b85e4: ('attract_angle', _decode_attract_angle),
0x47c6bb1d: ('attract_distance', _decode_attract_distance),
0x26087d23: ('shot_force', _decode_shot_force),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Tryclops.py | 0.650911 | 0.36625 | Tryclops.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EchoParameters import EchoParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Actor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
mass: float = dataclasses.field(default=1.0)
gravity: float = dataclasses.field(default=0.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
echo_information: EchoParameters = dataclasses.field(default_factory=EchoParameters)
is_loop: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
is_solid: bool = dataclasses.field(default=True)
is_camera_through: bool = dataclasses.field(default=False)
is_scan_through: bool = dataclasses.field(default=False)
render_texture_set: int = dataclasses.field(default=0)
draws_shadow: bool = dataclasses.field(default=False)
scale_animation: bool = dataclasses.field(default=False)
ai_shoot_through: bool = dataclasses.field(default=False)
random_animation_offset: float = dataclasses.field(default=0.0)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ACTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x17') # 23 properties
num_properties_written = 23
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.collision_model))
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19+\x0ep') # 0x192b0e70
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.echo_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'xY\xb5 ') # 0x7859b520
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_camera_through))
if self.is_scan_through != default_override.get('is_scan_through', False):
num_properties_written += 1
data.write(b'*\xff\xd6\xfe') # 0x2affd6fe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_scan_through))
data.write(b'2\xfa\xb9~') # 0x32fab97e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_texture_set))
data.write(b'\x97htF') # 0x97687446
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.draws_shadow))
data.write(b'&\x1e\x92\xa4') # 0x261e92a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scale_animation))
data.write(b"\xcc'\xf8'") # 0xcc27f827
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ai_shoot_through))
data.write(b'\xbfi\xc0>') # 0xbf69c03e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_animation_offset))
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile))
data.write(b'U;\x139') # 0x553b1339
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_damage.to_stream(data, default_override={'di_weapon_type': 11})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
mass=data['mass'],
gravity=data['gravity'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
model=data['model'],
collision_model=data['collision_model'],
animation_information=AnimationParameters.from_json(data['animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
echo_information=EchoParameters.from_json(data['echo_information']),
is_loop=data['is_loop'],
immovable=data['immovable'],
is_solid=data['is_solid'],
is_camera_through=data['is_camera_through'],
is_scan_through=data['is_scan_through'],
render_texture_set=data['render_texture_set'],
draws_shadow=data['draws_shadow'],
scale_animation=data['scale_animation'],
ai_shoot_through=data['ai_shoot_through'],
random_animation_offset=data['random_animation_offset'],
projectile=data['projectile'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'mass': self.mass,
'gravity': self.gravity,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'animation_information': self.animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'echo_information': self.echo_information.to_json(),
'is_loop': self.is_loop,
'immovable': self.immovable,
'is_solid': self.is_solid,
'is_camera_through': self.is_camera_through,
'is_scan_through': self.is_scan_through,
'render_texture_set': self.render_texture_set,
'draws_shadow': self.draws_shadow,
'scale_animation': self.scale_animation,
'ai_shoot_through': self.ai_shoot_through,
'random_animation_offset': self.random_animation_offset,
'projectile': self.projectile,
'projectile_damage': self.projectile_damage.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_collision_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.collision_model)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_echo_information(self, asset_manager):
yield from self.echo_information.dependencies_for(asset_manager)
def _dependencies_for_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_collision_model, "collision_model", "AssetId"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_echo_information, "echo_information", "EchoParameters"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Actor.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_echo_information(data: typing.BinaryIO, property_size: int):
return EchoParameters.from_stream(data, property_size)
def _decode_is_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_camera_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_scan_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_draws_shadow(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ai_shoot_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_random_animation_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">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})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x75dbb375: ('mass', _decode_mass),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0x192b0e70: ('echo_information', _decode_echo_information),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x1e32523e: ('immovable', _decode_immovable),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x7859b520: ('is_camera_through', _decode_is_camera_through),
0x2affd6fe: ('is_scan_through', _decode_is_scan_through),
0x32fab97e: ('render_texture_set', _decode_render_texture_set),
0x97687446: ('draws_shadow', _decode_draws_shadow),
0x261e92a4: ('scale_animation', _decode_scale_animation),
0xcc27f827: ('ai_shoot_through', _decode_ai_shoot_through),
0xbf69c03e: ('random_animation_offset', _decode_random_animation_offset),
0xef485db9: ('projectile', _decode_projectile),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Actor.py | 0.57332 | 0.22642 | Actor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class PlayerActor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
mass: float = dataclasses.field(default=1.0)
gravity: float = dataclasses.field(default=0.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
no_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
is_loop: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
is_solid: bool = dataclasses.field(default=True)
flags_player_actor: int = dataclasses.field(default=4) # Flagset
render_gun_override: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PLAC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptPlayerActor.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0f') # 15 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@^R\x86') # 0x405e5286
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.no_model))
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'3Py\x98') # 0x33507998
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_player_actor))
data.write(b'\xb6\x83(@') # 0xb6832840
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_gun_override))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
mass=data['mass'],
gravity=data['gravity'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
no_model=data['no_model'],
animation_information=AnimationParameters.from_json(data['animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
is_loop=data['is_loop'],
immovable=data['immovable'],
is_solid=data['is_solid'],
flags_player_actor=data['flags_player_actor'],
render_gun_override=data['render_gun_override'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'mass': self.mass,
'gravity': self.gravity,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'no_model': self.no_model,
'animation_information': self.animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'is_loop': self.is_loop,
'immovable': self.immovable,
'is_solid': self.is_solid,
'flags_player_actor': self.flags_player_actor,
'render_gun_override': self.render_gun_override,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_no_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.no_model)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_no_model, "no_model", "AssetId"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlayerActor.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_no_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_is_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flags_player_actor(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_render_gun_override(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x75dbb375: ('mass', _decode_mass),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x405e5286: ('no_model', _decode_no_model),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x1e32523e: ('immovable', _decode_immovable),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x33507998: ('flags_player_actor', _decode_flags_player_actor),
0xb6832840: ('render_gun_override', _decode_render_gun_override),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PlayerActor.py | 0.562297 | 0.305438 | PlayerActor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct32 import UnknownStruct32
@dataclasses.dataclass()
class IngSpaceJumpGuardian(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct32: UnknownStruct32 = dataclasses.field(default_factory=UnknownStruct32)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ISJG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['GeomBlobV2.rel', 'Ing.rel', 'IngSpaceJumpGuardian.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0, 'min_attack_range': 0.0, 'creature_size': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\x83z\xb3') # 0xf9837ab3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct32.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct32=UnknownStruct32.from_json(data['unknown_struct32']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct32': self.unknown_struct32.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct32(self, asset_manager):
yield from self.unknown_struct32.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_unknown_struct32, "unknown_struct32", "UnknownStruct32"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IngSpaceJumpGuardian.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'turn_speed': 360.0, 'min_attack_range': 0.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct32(data: typing.BinaryIO, property_size: int):
return UnknownStruct32.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xf9837ab3: ('unknown_struct32', _decode_unknown_struct32),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/IngSpaceJumpGuardian.py | 0.670716 | 0.308568 | IngSpaceJumpGuardian.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class FlyingPirate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
search_radius: float = dataclasses.field(default=20.0)
hearing_radius: float = dataclasses.field(default=20.0)
unknown_0x20daf45e: int = dataclasses.field(default=0)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_projectile: int = dataclasses.field(default=0, metadata={'sound': True})
missile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
missile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
wpsc: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
hurl_recover_time: float = dataclasses.field(default=0.800000011920929)
hover_height: float = dataclasses.field(default=4.0)
part_0x6475fc6f: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
rocket_pack_explosion_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
spiral_chance: float = dataclasses.field(default=20.0)
minimum_missile_time: float = dataclasses.field(default=10.0)
unknown_0xb9bb2f64: float = dataclasses.field(default=10.0)
flight_thrust: float = dataclasses.field(default=1000.0)
sound_impact: int = dataclasses.field(default=0, metadata={'sound': True})
sound_spiral: int = dataclasses.field(default=0, metadata={'sound': True})
land_chance: float = dataclasses.field(default=25.0)
unknown_0x71587b45: float = dataclasses.field(default=0.10000000149011612)
unknown_0x7903312e: float = dataclasses.field(default=0.05000000074505806)
part_0x317212ab: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0xbc113d7b: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0x738bbbaa: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_hurled: int = dataclasses.field(default=0, metadata={'sound': True})
sound_death: int = dataclasses.field(default=0, metadata={'sound': True})
double_attack_chance: float = dataclasses.field(default=25.0)
unknown_0x3427d27f: float = dataclasses.field(default=25.0)
stop_homing_range: float = dataclasses.field(default=8.0)
unknown_0xccf05648: float = dataclasses.field(default=2.25)
unknown_0x2a90f9a9: float = dataclasses.field(default=3.0)
unknown_0x9ca8f357: float = dataclasses.field(default=-0.10000000149011612)
unknown_0x7ac85cb6: float = dataclasses.field(default=-0.23000000417232513)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FPRT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['FlyingPirate.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00%') # 37 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0, 'detection_angle': 90.0, 'min_attack_range': 15.0, 'max_attack_range': 40.0, 'average_attack_time': 1.0, 'attack_time_variation': 0.5, 'damage_wait_time': 3.0, 'collision_height': 6.0, 'step_up_height': 0.30000001192092896})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\x9b\xf5\xa3') # 0xed9bf5a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_radius))
data.write(b'\xediH\x8f') # 0xed69488f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hearing_radius))
data.write(b' \xda\xf4^') # 0x20daf45e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x20daf45e))
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile))
data.write(b'U;\x139') # 0x553b1339
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_damage.to_stream(data, default_override={'di_weapon_type': 9, 'di_damage': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xc2v\x05') # 0xeac27605
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_projectile))
data.write(b'\xca)H\x11') # 0xca294811
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.missile))
data.write(b'%\x8c\xfbM') # 0x258cfb4d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.missile_damage.to_stream(data, default_override={'di_weapon_type': 9, 'di_damage': 10.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'\x1dQ\x0cl') # 0x1d510c6c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.wpsc))
data.write(b'\x96\xfe\xb7]') # 0x96feb75d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_recover_time))
data.write(b'\xc7Y\x98\xaa') # 0xc75998aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_height))
data.write(b'du\xfco') # 0x6475fc6f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x6475fc6f))
data.write(b"%d\xee'") # 0x2564ee27
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rocket_pack_explosion_damage.to_stream(data, default_override={'di_weapon_type': 9, 'di_damage': 20.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'\xdf\x88`}') # 0xdf88607d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spiral_chance))
data.write(b'\x8f\xff\x07\xe9') # 0x8fff07e9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_missile_time))
data.write(b'\xb9\xbb/d') # 0xb9bb2f64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb9bb2f64))
data.write(b'\x8e\xe7\xf4@') # 0x8ee7f440
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flight_thrust))
data.write(b'\x1b\xb1n\xa5') # 0x1bb16ea5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_impact))
data.write(b'\x0f\xf5\xab\x8f') # 0xff5ab8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_spiral))
data.write(b'\x87\xb2\xbcZ') # 0x87b2bc5a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.land_chance))
data.write(b'qX{E') # 0x71587b45
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x71587b45))
data.write(b'y\x031.') # 0x7903312e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7903312e))
data.write(b'1r\x12\xab') # 0x317212ab
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x317212ab))
data.write(b'\xbc\x11={') # 0xbc113d7b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0xbc113d7b))
data.write(b's\x8b\xbb\xaa') # 0x738bbbaa
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x738bbbaa))
data.write(b';\xb3z\x8f') # 0x3bb37a8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_hurled))
data.write(b'\xe1`\xb5\x93') # 0xe160b593
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_death))
data.write(b'\x96m\x11\xf3') # 0x966d11f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.double_attack_chance))
data.write(b"4'\xd2\x7f") # 0x3427d27f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3427d27f))
data.write(b'\x05:\xe4\xa7') # 0x53ae4a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stop_homing_range))
data.write(b'\xcc\xf0VH') # 0xccf05648
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xccf05648))
data.write(b'*\x90\xf9\xa9') # 0x2a90f9a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2a90f9a9))
data.write(b'\x9c\xa8\xf3W') # 0x9ca8f357
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9ca8f357))
data.write(b'z\xc8\\\xb6') # 0x7ac85cb6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7ac85cb6))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
search_radius=data['search_radius'],
hearing_radius=data['hearing_radius'],
unknown_0x20daf45e=data['unknown_0x20daf45e'],
projectile=data['projectile'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
sound_projectile=data['sound_projectile'],
missile=data['missile'],
missile_damage=DamageInfo.from_json(data['missile_damage']),
wpsc=data['wpsc'],
hurl_recover_time=data['hurl_recover_time'],
hover_height=data['hover_height'],
part_0x6475fc6f=data['part_0x6475fc6f'],
rocket_pack_explosion_damage=DamageInfo.from_json(data['rocket_pack_explosion_damage']),
spiral_chance=data['spiral_chance'],
minimum_missile_time=data['minimum_missile_time'],
unknown_0xb9bb2f64=data['unknown_0xb9bb2f64'],
flight_thrust=data['flight_thrust'],
sound_impact=data['sound_impact'],
sound_spiral=data['sound_spiral'],
land_chance=data['land_chance'],
unknown_0x71587b45=data['unknown_0x71587b45'],
unknown_0x7903312e=data['unknown_0x7903312e'],
part_0x317212ab=data['part_0x317212ab'],
part_0xbc113d7b=data['part_0xbc113d7b'],
part_0x738bbbaa=data['part_0x738bbbaa'],
sound_hurled=data['sound_hurled'],
sound_death=data['sound_death'],
double_attack_chance=data['double_attack_chance'],
unknown_0x3427d27f=data['unknown_0x3427d27f'],
stop_homing_range=data['stop_homing_range'],
unknown_0xccf05648=data['unknown_0xccf05648'],
unknown_0x2a90f9a9=data['unknown_0x2a90f9a9'],
unknown_0x9ca8f357=data['unknown_0x9ca8f357'],
unknown_0x7ac85cb6=data['unknown_0x7ac85cb6'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'search_radius': self.search_radius,
'hearing_radius': self.hearing_radius,
'unknown_0x20daf45e': self.unknown_0x20daf45e,
'projectile': self.projectile,
'projectile_damage': self.projectile_damage.to_json(),
'sound_projectile': self.sound_projectile,
'missile': self.missile,
'missile_damage': self.missile_damage.to_json(),
'wpsc': self.wpsc,
'hurl_recover_time': self.hurl_recover_time,
'hover_height': self.hover_height,
'part_0x6475fc6f': self.part_0x6475fc6f,
'rocket_pack_explosion_damage': self.rocket_pack_explosion_damage.to_json(),
'spiral_chance': self.spiral_chance,
'minimum_missile_time': self.minimum_missile_time,
'unknown_0xb9bb2f64': self.unknown_0xb9bb2f64,
'flight_thrust': self.flight_thrust,
'sound_impact': self.sound_impact,
'sound_spiral': self.sound_spiral,
'land_chance': self.land_chance,
'unknown_0x71587b45': self.unknown_0x71587b45,
'unknown_0x7903312e': self.unknown_0x7903312e,
'part_0x317212ab': self.part_0x317212ab,
'part_0xbc113d7b': self.part_0xbc113d7b,
'part_0x738bbbaa': self.part_0x738bbbaa,
'sound_hurled': self.sound_hurled,
'sound_death': self.sound_death,
'double_attack_chance': self.double_attack_chance,
'unknown_0x3427d27f': self.unknown_0x3427d27f,
'stop_homing_range': self.stop_homing_range,
'unknown_0xccf05648': self.unknown_0xccf05648,
'unknown_0x2a90f9a9': self.unknown_0x2a90f9a9,
'unknown_0x9ca8f357': self.unknown_0x9ca8f357,
'unknown_0x7ac85cb6': self.unknown_0x7ac85cb6,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_projectile(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_projectile)
def _dependencies_for_missile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.missile)
def _dependencies_for_missile_damage(self, asset_manager):
yield from self.missile_damage.dependencies_for(asset_manager)
def _dependencies_for_wpsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc)
def _dependencies_for_part_0x6475fc6f(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x6475fc6f)
def _dependencies_for_rocket_pack_explosion_damage(self, asset_manager):
yield from self.rocket_pack_explosion_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_impact(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_impact)
def _dependencies_for_sound_spiral(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_spiral)
def _dependencies_for_part_0x317212ab(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x317212ab)
def _dependencies_for_part_0xbc113d7b(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0xbc113d7b)
def _dependencies_for_part_0x738bbbaa(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x738bbbaa)
def _dependencies_for_sound_hurled(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_hurled)
def _dependencies_for_sound_death(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_death)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
(self._dependencies_for_sound_projectile, "sound_projectile", "int"),
(self._dependencies_for_missile, "missile", "AssetId"),
(self._dependencies_for_missile_damage, "missile_damage", "DamageInfo"),
(self._dependencies_for_wpsc, "wpsc", "AssetId"),
(self._dependencies_for_part_0x6475fc6f, "part_0x6475fc6f", "AssetId"),
(self._dependencies_for_rocket_pack_explosion_damage, "rocket_pack_explosion_damage", "DamageInfo"),
(self._dependencies_for_sound_impact, "sound_impact", "int"),
(self._dependencies_for_sound_spiral, "sound_spiral", "int"),
(self._dependencies_for_part_0x317212ab, "part_0x317212ab", "AssetId"),
(self._dependencies_for_part_0xbc113d7b, "part_0xbc113d7b", "AssetId"),
(self._dependencies_for_part_0x738bbbaa, "part_0x738bbbaa", "AssetId"),
(self._dependencies_for_sound_hurled, "sound_hurled", "int"),
(self._dependencies_for_sound_death, "sound_death", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FlyingPirate.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'turn_speed': 360.0, 'detection_angle': 90.0, 'min_attack_range': 15.0, 'max_attack_range': 40.0, 'average_attack_time': 1.0, 'attack_time_variation': 0.5, 'damage_wait_time': 3.0, 'collision_height': 6.0, 'step_up_height': 0.30000001192092896})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_search_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hearing_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x20daf45e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 9, 'di_damage': 5.0})
def _decode_sound_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_missile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_missile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 9, 'di_damage': 10.0, 'di_radius': 5.0})
def _decode_wpsc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_hurl_recover_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hover_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part_0x6475fc6f(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_rocket_pack_explosion_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 9, 'di_damage': 20.0, 'di_radius': 10.0, 'di_knock_back_power': 10.0})
def _decode_spiral_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_missile_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb9bb2f64(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_thrust(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_impact(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_spiral(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_land_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x71587b45(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7903312e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part_0x317212ab(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0xbc113d7b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0x738bbbaa(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_hurled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_death(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_double_attack_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3427d27f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stop_homing_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xccf05648(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2a90f9a9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9ca8f357(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7ac85cb6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xed9bf5a3: ('search_radius', _decode_search_radius),
0xed69488f: ('hearing_radius', _decode_hearing_radius),
0x20daf45e: ('unknown_0x20daf45e', _decode_unknown_0x20daf45e),
0xef485db9: ('projectile', _decode_projectile),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0xeac27605: ('sound_projectile', _decode_sound_projectile),
0xca294811: ('missile', _decode_missile),
0x258cfb4d: ('missile_damage', _decode_missile_damage),
0x1d510c6c: ('wpsc', _decode_wpsc),
0x96feb75d: ('hurl_recover_time', _decode_hurl_recover_time),
0xc75998aa: ('hover_height', _decode_hover_height),
0x6475fc6f: ('part_0x6475fc6f', _decode_part_0x6475fc6f),
0x2564ee27: ('rocket_pack_explosion_damage', _decode_rocket_pack_explosion_damage),
0xdf88607d: ('spiral_chance', _decode_spiral_chance),
0x8fff07e9: ('minimum_missile_time', _decode_minimum_missile_time),
0xb9bb2f64: ('unknown_0xb9bb2f64', _decode_unknown_0xb9bb2f64),
0x8ee7f440: ('flight_thrust', _decode_flight_thrust),
0x1bb16ea5: ('sound_impact', _decode_sound_impact),
0xff5ab8f: ('sound_spiral', _decode_sound_spiral),
0x87b2bc5a: ('land_chance', _decode_land_chance),
0x71587b45: ('unknown_0x71587b45', _decode_unknown_0x71587b45),
0x7903312e: ('unknown_0x7903312e', _decode_unknown_0x7903312e),
0x317212ab: ('part_0x317212ab', _decode_part_0x317212ab),
0xbc113d7b: ('part_0xbc113d7b', _decode_part_0xbc113d7b),
0x738bbbaa: ('part_0x738bbbaa', _decode_part_0x738bbbaa),
0x3bb37a8f: ('sound_hurled', _decode_sound_hurled),
0xe160b593: ('sound_death', _decode_sound_death),
0x966d11f3: ('double_attack_chance', _decode_double_attack_chance),
0x3427d27f: ('unknown_0x3427d27f', _decode_unknown_0x3427d27f),
0x53ae4a7: ('stop_homing_range', _decode_stop_homing_range),
0xccf05648: ('unknown_0xccf05648', _decode_unknown_0xccf05648),
0x2a90f9a9: ('unknown_0x2a90f9a9', _decode_unknown_0x2a90f9a9),
0x9ca8f357: ('unknown_0x9ca8f357', _decode_unknown_0x9ca8f357),
0x7ac85cb6: ('unknown_0x7ac85cb6', _decode_unknown_0x7ac85cb6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/FlyingPirate.py | 0.637595 | 0.205037 | FlyingPirate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.BasicSwarmProperties import BasicSwarmProperties
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class BacteriaSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
basic_swarm_properties: BasicSwarmProperties = dataclasses.field(default_factory=BasicSwarmProperties)
unknown_0x4a85a2da: float = dataclasses.field(default=1.0)
containment_priority: float = dataclasses.field(default=1.0)
bacteria_patrol_speed: float = dataclasses.field(default=0.10000000149011612)
unknown_0x7de56d56: float = dataclasses.field(default=0.5)
unknown_0x39098c47: float = dataclasses.field(default=0.20000000298023224)
bacteria_acceleration: float = dataclasses.field(default=0.009999999776482582)
bacteria_deceleration: float = dataclasses.field(default=0.009999999776482582)
patrol_turn_speed: float = dataclasses.field(default=180.0)
unknown_0xbdcdb9c0: float = dataclasses.field(default=1440.0)
bacteria_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
bacteria_patrol_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
bacteria_player_pursuit_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=0.0, b=0.0, a=0.0))
color_change_time: float = dataclasses.field(default=0.5)
patrol_sound: int = dataclasses.field(default=0, metadata={'sound': True})
pursuit_sound: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0xad4ce8f3: float = dataclasses.field(default=0.5)
unknown_0xa9d6d9d9: float = dataclasses.field(default=0.5)
patrol_sound_weight: float = dataclasses.field(default=0.5)
unknown_0x90f8e29f: float = dataclasses.field(default=0.5)
unknown_0x4b47b178: float = dataclasses.field(default=0.5)
pursuit_sound_weight: float = dataclasses.field(default=0.5)
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)
bacteria_scan_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
spawn_instantly: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BSWM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['BacteriaSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00 ') # 32 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'\xe1\xecsF') # 0xe1ec7346
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.basic_swarm_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\x85\xa2\xda') # 0x4a85a2da
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4a85a2da))
data.write(b'\x7f\xf1F\x9e') # 0x7ff1469e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.containment_priority))
data.write(b'\xf8\x7f\xd6\xa9') # 0xf87fd6a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bacteria_patrol_speed))
data.write(b'}\xe5mV') # 0x7de56d56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7de56d56))
data.write(b'9\t\x8cG') # 0x39098c47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x39098c47))
data.write(b'\xfb\xa2\xa5>') # 0xfba2a53e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bacteria_acceleration))
data.write(b'\\\x9d V') # 0x5c9d2056
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bacteria_deceleration))
data.write(b'w\x1a\x90\xe6') # 0x771a90e6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.patrol_turn_speed))
data.write(b'\xbd\xcd\xb9\xc0') # 0xbdcdb9c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbdcdb9c0))
data.write(b'#\x01)J') # 0x2301294a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.bacteria_particle_effect))
data.write(b'\xac*Fz') # 0xac2a467a
data.write(b'\x00\x10') # size
self.bacteria_patrol_color.to_stream(data)
data.write(b'm\\\x1c\x94') # 0x6d5c1c94
data.write(b'\x00\x10') # size
self.bacteria_player_pursuit_color.to_stream(data)
data.write(b'1\x1b\x07P') # 0x311b0750
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.color_change_time))
data.write(b'J\xb2Bu') # 0x4ab24275
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.patrol_sound))
data.write(b'\xfe>{\xbf') # 0xfe3e7bbf
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.pursuit_sound))
data.write(b'\xadL\xe8\xf3') # 0xad4ce8f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xad4ce8f3))
data.write(b'\xa9\xd6\xd9\xd9') # 0xa9d6d9d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa9d6d9d9))
data.write(b'\x9f\xe2S\xa5') # 0x9fe253a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.patrol_sound_weight))
data.write(b'\x90\xf8\xe2\x9f') # 0x90f8e29f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x90f8e29f))
data.write(b'KG\xb1x') # 0x4b47b178
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4b47b178))
data.write(b'\xe6x\xeb\xcf') # 0xe678ebcf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pursuit_sound_weight))
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'uz\x1c4') # 0x757a1c34
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.bacteria_scan_model))
data.write(b'\xc5\xbc^\xd0') # 0xc5bc5ed0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spawn_instantly))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
animation_information=AnimationParameters.from_json(data['animation_information']),
active=data['active'],
basic_swarm_properties=BasicSwarmProperties.from_json(data['basic_swarm_properties']),
unknown_0x4a85a2da=data['unknown_0x4a85a2da'],
containment_priority=data['containment_priority'],
bacteria_patrol_speed=data['bacteria_patrol_speed'],
unknown_0x7de56d56=data['unknown_0x7de56d56'],
unknown_0x39098c47=data['unknown_0x39098c47'],
bacteria_acceleration=data['bacteria_acceleration'],
bacteria_deceleration=data['bacteria_deceleration'],
patrol_turn_speed=data['patrol_turn_speed'],
unknown_0xbdcdb9c0=data['unknown_0xbdcdb9c0'],
bacteria_particle_effect=data['bacteria_particle_effect'],
bacteria_patrol_color=Color.from_json(data['bacteria_patrol_color']),
bacteria_player_pursuit_color=Color.from_json(data['bacteria_player_pursuit_color']),
color_change_time=data['color_change_time'],
patrol_sound=data['patrol_sound'],
pursuit_sound=data['pursuit_sound'],
unknown_0xad4ce8f3=data['unknown_0xad4ce8f3'],
unknown_0xa9d6d9d9=data['unknown_0xa9d6d9d9'],
patrol_sound_weight=data['patrol_sound_weight'],
unknown_0x90f8e29f=data['unknown_0x90f8e29f'],
unknown_0x4b47b178=data['unknown_0x4b47b178'],
pursuit_sound_weight=data['pursuit_sound_weight'],
unknown_0xd2986c43=data['unknown_0xd2986c43'],
max_audible_distance=data['max_audible_distance'],
min_volume=data['min_volume'],
max_volume=data['max_volume'],
bacteria_scan_model=data['bacteria_scan_model'],
spawn_instantly=data['spawn_instantly'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'animation_information': self.animation_information.to_json(),
'active': self.active,
'basic_swarm_properties': self.basic_swarm_properties.to_json(),
'unknown_0x4a85a2da': self.unknown_0x4a85a2da,
'containment_priority': self.containment_priority,
'bacteria_patrol_speed': self.bacteria_patrol_speed,
'unknown_0x7de56d56': self.unknown_0x7de56d56,
'unknown_0x39098c47': self.unknown_0x39098c47,
'bacteria_acceleration': self.bacteria_acceleration,
'bacteria_deceleration': self.bacteria_deceleration,
'patrol_turn_speed': self.patrol_turn_speed,
'unknown_0xbdcdb9c0': self.unknown_0xbdcdb9c0,
'bacteria_particle_effect': self.bacteria_particle_effect,
'bacteria_patrol_color': self.bacteria_patrol_color.to_json(),
'bacteria_player_pursuit_color': self.bacteria_player_pursuit_color.to_json(),
'color_change_time': self.color_change_time,
'patrol_sound': self.patrol_sound,
'pursuit_sound': self.pursuit_sound,
'unknown_0xad4ce8f3': self.unknown_0xad4ce8f3,
'unknown_0xa9d6d9d9': self.unknown_0xa9d6d9d9,
'patrol_sound_weight': self.patrol_sound_weight,
'unknown_0x90f8e29f': self.unknown_0x90f8e29f,
'unknown_0x4b47b178': self.unknown_0x4b47b178,
'pursuit_sound_weight': self.pursuit_sound_weight,
'unknown_0xd2986c43': self.unknown_0xd2986c43,
'max_audible_distance': self.max_audible_distance,
'min_volume': self.min_volume,
'max_volume': self.max_volume,
'bacteria_scan_model': self.bacteria_scan_model,
'spawn_instantly': self.spawn_instantly,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_basic_swarm_properties(self, asset_manager):
yield from self.basic_swarm_properties.dependencies_for(asset_manager)
def _dependencies_for_bacteria_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.bacteria_particle_effect)
def _dependencies_for_patrol_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.patrol_sound)
def _dependencies_for_pursuit_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.pursuit_sound)
def _dependencies_for_bacteria_scan_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.bacteria_scan_model)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_basic_swarm_properties, "basic_swarm_properties", "BasicSwarmProperties"),
(self._dependencies_for_bacteria_particle_effect, "bacteria_particle_effect", "AssetId"),
(self._dependencies_for_patrol_sound, "patrol_sound", "int"),
(self._dependencies_for_pursuit_sound, "pursuit_sound", "int"),
(self._dependencies_for_bacteria_scan_model, "bacteria_scan_model", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for BacteriaSwarm.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_basic_swarm_properties(data: typing.BinaryIO, property_size: int):
return BasicSwarmProperties.from_stream(data, property_size)
def _decode_unknown_0x4a85a2da(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_containment_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bacteria_patrol_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7de56d56(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x39098c47(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bacteria_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bacteria_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_patrol_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbdcdb9c0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bacteria_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_bacteria_patrol_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_bacteria_player_pursuit_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_color_change_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_patrol_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_pursuit_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xad4ce8f3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa9d6d9d9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_patrol_sound_weight(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x90f8e29f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4b47b178(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pursuit_sound_weight(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', 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_bacteria_scan_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_spawn_instantly(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xc6bb2f45: ('active', _decode_active),
0xe1ec7346: ('basic_swarm_properties', _decode_basic_swarm_properties),
0x4a85a2da: ('unknown_0x4a85a2da', _decode_unknown_0x4a85a2da),
0x7ff1469e: ('containment_priority', _decode_containment_priority),
0xf87fd6a9: ('bacteria_patrol_speed', _decode_bacteria_patrol_speed),
0x7de56d56: ('unknown_0x7de56d56', _decode_unknown_0x7de56d56),
0x39098c47: ('unknown_0x39098c47', _decode_unknown_0x39098c47),
0xfba2a53e: ('bacteria_acceleration', _decode_bacteria_acceleration),
0x5c9d2056: ('bacteria_deceleration', _decode_bacteria_deceleration),
0x771a90e6: ('patrol_turn_speed', _decode_patrol_turn_speed),
0xbdcdb9c0: ('unknown_0xbdcdb9c0', _decode_unknown_0xbdcdb9c0),
0x2301294a: ('bacteria_particle_effect', _decode_bacteria_particle_effect),
0xac2a467a: ('bacteria_patrol_color', _decode_bacteria_patrol_color),
0x6d5c1c94: ('bacteria_player_pursuit_color', _decode_bacteria_player_pursuit_color),
0x311b0750: ('color_change_time', _decode_color_change_time),
0x4ab24275: ('patrol_sound', _decode_patrol_sound),
0xfe3e7bbf: ('pursuit_sound', _decode_pursuit_sound),
0xad4ce8f3: ('unknown_0xad4ce8f3', _decode_unknown_0xad4ce8f3),
0xa9d6d9d9: ('unknown_0xa9d6d9d9', _decode_unknown_0xa9d6d9d9),
0x9fe253a5: ('patrol_sound_weight', _decode_patrol_sound_weight),
0x90f8e29f: ('unknown_0x90f8e29f', _decode_unknown_0x90f8e29f),
0x4b47b178: ('unknown_0x4b47b178', _decode_unknown_0x4b47b178),
0xe678ebcf: ('pursuit_sound_weight', _decode_pursuit_sound_weight),
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),
0x757a1c34: ('bacteria_scan_model', _decode_bacteria_scan_model),
0xc5bc5ed0: ('spawn_instantly', _decode_spawn_instantly),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/BacteriaSwarm.py | 0.631253 | 0.220668 | BacteriaSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SkyRipple(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SKRP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SkyRipple.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SkyRipple.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SkyRipple.py | 0.643441 | 0.356531 | SkyRipple.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.LightParameters import LightParameters
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class Effect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART', 'ELSC', 'SRSC', 'SPSC', 'SWHC']}, default=default_asset_id)
unknown_0x3df5a489: bool = dataclasses.field(default=False)
restart_on_activate: bool = dataclasses.field(default=False)
unknown_0xee538174: bool = dataclasses.field(default=False)
unknown_0xa94b0efd: float = dataclasses.field(default=5.0)
unknown_0x93756968: float = dataclasses.field(default=0.5)
unknown_0x0b94597d: float = dataclasses.field(default=0.20000000298023224)
unknown_0xd0e8a496: float = dataclasses.field(default=0.10000000149011612)
unknown_0xa8bb6c61: bool = dataclasses.field(default=False)
unknown_0x7589d549: float = dataclasses.field(default=20.0)
unknown_0xa7d7d767: float = dataclasses.field(default=30.0)
unknown_0xfe69615c: float = dataclasses.field(default=0.0)
unknown_0x88d914a6: bool = dataclasses.field(default=True)
visible_in_dark: bool = dataclasses.field(default=True)
visible_in_echo: bool = dataclasses.field(default=True)
unknown_0x6714021c: bool = dataclasses.field(default=False)
unknown_0xbe931927: bool = dataclasses.field(default=False)
render_order: int = dataclasses.field(default=0)
lighting: LightParameters = dataclasses.field(default_factory=LightParameters)
motion_spline_path_loops: bool = dataclasses.field(default=False)
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
motion_spline_duration: float = dataclasses.field(default=10.0)
unknown_0x73e63382: bool = dataclasses.field(default=False)
unknown_0x608ecac5: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'EFCT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1a') # 26 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\nG\x9do') # 0xa479d6f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle_effect))
data.write(b'=\xf5\xa4\x89') # 0x3df5a489
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3df5a489))
data.write(b'\xa4\xb9\x98O') # 0xa4b9984f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.restart_on_activate))
data.write(b'\xeeS\x81t') # 0xee538174
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xee538174))
data.write(b'\xa9K\x0e\xfd') # 0xa94b0efd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa94b0efd))
data.write(b'\x93uih') # 0x93756968
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x93756968))
data.write(b'\x0b\x94Y}') # 0xb94597d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0b94597d))
data.write(b'\xd0\xe8\xa4\x96') # 0xd0e8a496
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd0e8a496))
data.write(b'\xa8\xbbla') # 0xa8bb6c61
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa8bb6c61))
data.write(b'u\x89\xd5I') # 0x7589d549
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7589d549))
data.write(b'\xa7\xd7\xd7g') # 0xa7d7d767
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa7d7d767))
data.write(b'\xfeia\\') # 0xfe69615c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfe69615c))
data.write(b'\x88\xd9\x14\xa6') # 0x88d914a6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x88d914a6))
data.write(b'\xc2\x02\x8c\xc2') # 0xc2028cc2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.visible_in_dark))
data.write(b'\xce\xfa\x1aH') # 0xcefa1a48
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.visible_in_echo))
data.write(b'g\x14\x02\x1c') # 0x6714021c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x6714021c))
data.write(b"\xbe\x93\x19'") # 0xbe931927
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbe931927))
data.write(b'/\xa4\xe5\xd7') # 0x2fa4e5d7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_order))
data.write(b'\xb0(\xdb\x0e') # 0xb028db0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'=t\x06\xaf') # 0x3d7406af
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.motion_spline_path_loops))
data.write(b'I=j-') # 0x493d6a2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x1e/V') # 0xfd1e2f56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.motion_spline_duration))
data.write(b's\xe63\x82') # 0x73e63382
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x73e63382))
data.write(b'`\x8e\xca\xc5') # 0x608ecac5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x608ecac5))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
particle_effect=data['particle_effect'],
unknown_0x3df5a489=data['unknown_0x3df5a489'],
restart_on_activate=data['restart_on_activate'],
unknown_0xee538174=data['unknown_0xee538174'],
unknown_0xa94b0efd=data['unknown_0xa94b0efd'],
unknown_0x93756968=data['unknown_0x93756968'],
unknown_0x0b94597d=data['unknown_0x0b94597d'],
unknown_0xd0e8a496=data['unknown_0xd0e8a496'],
unknown_0xa8bb6c61=data['unknown_0xa8bb6c61'],
unknown_0x7589d549=data['unknown_0x7589d549'],
unknown_0xa7d7d767=data['unknown_0xa7d7d767'],
unknown_0xfe69615c=data['unknown_0xfe69615c'],
unknown_0x88d914a6=data['unknown_0x88d914a6'],
visible_in_dark=data['visible_in_dark'],
visible_in_echo=data['visible_in_echo'],
unknown_0x6714021c=data['unknown_0x6714021c'],
unknown_0xbe931927=data['unknown_0xbe931927'],
render_order=data['render_order'],
lighting=LightParameters.from_json(data['lighting']),
motion_spline_path_loops=data['motion_spline_path_loops'],
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
motion_spline_duration=data['motion_spline_duration'],
unknown_0x73e63382=data['unknown_0x73e63382'],
unknown_0x608ecac5=data['unknown_0x608ecac5'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'particle_effect': self.particle_effect,
'unknown_0x3df5a489': self.unknown_0x3df5a489,
'restart_on_activate': self.restart_on_activate,
'unknown_0xee538174': self.unknown_0xee538174,
'unknown_0xa94b0efd': self.unknown_0xa94b0efd,
'unknown_0x93756968': self.unknown_0x93756968,
'unknown_0x0b94597d': self.unknown_0x0b94597d,
'unknown_0xd0e8a496': self.unknown_0xd0e8a496,
'unknown_0xa8bb6c61': self.unknown_0xa8bb6c61,
'unknown_0x7589d549': self.unknown_0x7589d549,
'unknown_0xa7d7d767': self.unknown_0xa7d7d767,
'unknown_0xfe69615c': self.unknown_0xfe69615c,
'unknown_0x88d914a6': self.unknown_0x88d914a6,
'visible_in_dark': self.visible_in_dark,
'visible_in_echo': self.visible_in_echo,
'unknown_0x6714021c': self.unknown_0x6714021c,
'unknown_0xbe931927': self.unknown_0xbe931927,
'render_order': self.render_order,
'lighting': self.lighting.to_json(),
'motion_spline_path_loops': self.motion_spline_path_loops,
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'motion_spline_duration': self.motion_spline_duration,
'unknown_0x73e63382': self.unknown_0x73e63382,
'unknown_0x608ecac5': self.unknown_0x608ecac5,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_effect)
def _dependencies_for_lighting(self, asset_manager):
yield from self.lighting.dependencies_for(asset_manager)
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_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_particle_effect, "particle_effect", "AssetId"),
(self._dependencies_for_lighting, "lighting", "LightParameters"),
(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 Effect.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x3df5a489(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_restart_on_activate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xee538174(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa94b0efd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x93756968(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0b94597d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd0e8a496(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa8bb6c61(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7589d549(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa7d7d767(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfe69615c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x88d914a6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_visible_in_dark(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_visible_in_echo(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x6714021c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbe931927(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_order(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightParameters.from_stream(data, property_size)
def _decode_motion_spline_path_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_motion_spline_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x73e63382(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x608ecac5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa479d6f: ('particle_effect', _decode_particle_effect),
0x3df5a489: ('unknown_0x3df5a489', _decode_unknown_0x3df5a489),
0xa4b9984f: ('restart_on_activate', _decode_restart_on_activate),
0xee538174: ('unknown_0xee538174', _decode_unknown_0xee538174),
0xa94b0efd: ('unknown_0xa94b0efd', _decode_unknown_0xa94b0efd),
0x93756968: ('unknown_0x93756968', _decode_unknown_0x93756968),
0xb94597d: ('unknown_0x0b94597d', _decode_unknown_0x0b94597d),
0xd0e8a496: ('unknown_0xd0e8a496', _decode_unknown_0xd0e8a496),
0xa8bb6c61: ('unknown_0xa8bb6c61', _decode_unknown_0xa8bb6c61),
0x7589d549: ('unknown_0x7589d549', _decode_unknown_0x7589d549),
0xa7d7d767: ('unknown_0xa7d7d767', _decode_unknown_0xa7d7d767),
0xfe69615c: ('unknown_0xfe69615c', _decode_unknown_0xfe69615c),
0x88d914a6: ('unknown_0x88d914a6', _decode_unknown_0x88d914a6),
0xc2028cc2: ('visible_in_dark', _decode_visible_in_dark),
0xcefa1a48: ('visible_in_echo', _decode_visible_in_echo),
0x6714021c: ('unknown_0x6714021c', _decode_unknown_0x6714021c),
0xbe931927: ('unknown_0xbe931927', _decode_unknown_0xbe931927),
0x2fa4e5d7: ('render_order', _decode_render_order),
0xb028db0e: ('lighting', _decode_lighting),
0x3d7406af: ('motion_spline_path_loops', _decode_motion_spline_path_loops),
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
0x73e63382: ('unknown_0x73e63382', _decode_unknown_0x73e63382),
0x608ecac5: ('unknown_0x608ecac5', _decode_unknown_0x608ecac5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Effect.py | 0.592549 | 0.259216 | Effect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class EnvFxDensityController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
density: float = dataclasses.field(default=0.5)
fade_speed: int = dataclasses.field(default=500)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FXDC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xe5\xfe\x9f') # 0x64e5fe9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.density))
data.write(b'e\xa8#\xb4') # 0x65a823b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fade_speed))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
density=data['density'],
fade_speed=data['fade_speed'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'density': self.density,
'fade_speed': self.fade_speed,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EnvFxDensityController.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x64e5fe9f: ('density', _decode_density),
0x65a823b4: ('fade_speed', _decode_fade_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/EnvFxDensityController.py | 0.64579 | 0.343479 | EnvFxDensityController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class ColorModulate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
color_a: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
color_b: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
blend_mode: int = dataclasses.field(default=0)
time_a2_b: float = dataclasses.field(default=1.0)
time_b2_a: float = dataclasses.field(default=1.0)
do_reverse: bool = dataclasses.field(default=False)
reset_target_when_done: bool = dataclasses.field(default=False)
depth_compare: bool = dataclasses.field(default=True)
depth_update: bool = dataclasses.field(default=True)
depth_backwards: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
update_time: bool = dataclasses.field(default=True)
loop_forever: bool = dataclasses.field(default=False)
external_time: bool = dataclasses.field(default=False)
copy_model_color_to_color_a: bool = dataclasses.field(default=False)
control_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CLRM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x11') # 17 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd6\xa3\xd2o') # 0xd6a3d26f
data.write(b'\x00\x10') # size
self.color_a.to_stream(data)
data.write(b'P7\xa0\xc1') # 0x5037a0c1
data.write(b'\x00\x10') # size
self.color_b.to_stream(data)
data.write(b'\x94\xf06\\') # 0x94f0365c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blend_mode))
data.write(b'\x1a\xfa\\H') # 0x1afa5c48
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_a2_b))
data.write(b'\x12\xe1)\x05') # 0x12e12905
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_b2_a))
data.write(b'\xce\xc5$K') # 0xcec5244b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.do_reverse))
data.write(b'\x81\xfc\x97\x9c') # 0x81fc979c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reset_target_when_done))
data.write(b'\x94\xc0\x1b\x0c') # 0x94c01b0c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_compare))
data.write(b'\xae\xd2ZQ') # 0xaed25a51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_update))
data.write(b'5\xdcC\xd0') # 0x35dc43d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_backwards))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b':\x7fY\xf7') # 0x3a7f59f7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.update_time))
data.write(b'\x08\xbbs\xc5') # 0x8bb73c5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_forever))
data.write(b'~7\x9a\xe8') # 0x7e379ae8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.external_time))
data.write(b't\x08\x1e\x94') # 0x74081e94
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.copy_model_color_to_color_a))
data.write(b'\x15V\x7f\xe7') # 0x15567fe7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
color_a=Color.from_json(data['color_a']),
color_b=Color.from_json(data['color_b']),
blend_mode=data['blend_mode'],
time_a2_b=data['time_a2_b'],
time_b2_a=data['time_b2_a'],
do_reverse=data['do_reverse'],
reset_target_when_done=data['reset_target_when_done'],
depth_compare=data['depth_compare'],
depth_update=data['depth_update'],
depth_backwards=data['depth_backwards'],
auto_start=data['auto_start'],
update_time=data['update_time'],
loop_forever=data['loop_forever'],
external_time=data['external_time'],
copy_model_color_to_color_a=data['copy_model_color_to_color_a'],
control_spline=Spline.from_json(data['control_spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'color_a': self.color_a.to_json(),
'color_b': self.color_b.to_json(),
'blend_mode': self.blend_mode,
'time_a2_b': self.time_a2_b,
'time_b2_a': self.time_b2_a,
'do_reverse': self.do_reverse,
'reset_target_when_done': self.reset_target_when_done,
'depth_compare': self.depth_compare,
'depth_update': self.depth_update,
'depth_backwards': self.depth_backwards,
'auto_start': self.auto_start,
'update_time': self.update_time,
'loop_forever': self.loop_forever,
'external_time': self.external_time,
'copy_model_color_to_color_a': self.copy_model_color_to_color_a,
'control_spline': self.control_spline.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ColorModulate.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_color_a(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_color_b(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_time_a2_b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_b2_a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_do_reverse(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_reset_target_when_done(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_compare(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_update(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_backwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_update_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_forever(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_external_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_copy_model_color_to_color_a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd6a3d26f: ('color_a', _decode_color_a),
0x5037a0c1: ('color_b', _decode_color_b),
0x94f0365c: ('blend_mode', _decode_blend_mode),
0x1afa5c48: ('time_a2_b', _decode_time_a2_b),
0x12e12905: ('time_b2_a', _decode_time_b2_a),
0xcec5244b: ('do_reverse', _decode_do_reverse),
0x81fc979c: ('reset_target_when_done', _decode_reset_target_when_done),
0x94c01b0c: ('depth_compare', _decode_depth_compare),
0xaed25a51: ('depth_update', _decode_depth_update),
0x35dc43d0: ('depth_backwards', _decode_depth_backwards),
0x3217dff8: ('auto_start', _decode_auto_start),
0x3a7f59f7: ('update_time', _decode_update_time),
0x8bb73c5: ('loop_forever', _decode_loop_forever),
0x7e379ae8: ('external_time', _decode_external_time),
0x74081e94: ('copy_model_color_to_color_a', _decode_copy_model_color_to_color_a),
0x15567fe7: ('control_spline', _decode_control_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ColorModulate.py | 0.572484 | 0.276077 | ColorModulate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class GunTurretTop(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
power_up_time: float = dataclasses.field(default=0.5)
power_down_time: float = dataclasses.field(default=0.5)
part_0xbf87e353: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0xaf6e671a: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
always_ff_0x67c8a8f4: int = dataclasses.field(default=0)
always_ff_0x68d8b844: int = dataclasses.field(default=0)
light_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
sound_0xe4aeeba4: int = dataclasses.field(default=0, metadata={'sound': True})
sound_0x5d9ed447: int = dataclasses.field(default=0, metadata={'sound': True})
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GNTT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['GunTurret.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\xc1\xd0C') # 0x3bc1d043
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.power_up_time))
data.write(b'\x83\x8au\xa4') # 0x838a75a4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.power_down_time))
data.write(b'\xbf\x87\xe3S') # 0xbf87e353
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0xbf87e353))
data.write(b'\xafng\x1a') # 0xaf6e671a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0xaf6e671a))
data.write(b'g\xc8\xa8\xf4') # 0x67c8a8f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.always_ff_0x67c8a8f4))
data.write(b'h\xd8\xb8D') # 0x68d8b844
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.always_ff_0x68d8b844))
data.write(b'\xbd>\xfe}') # 0xbd3efe7d
data.write(b'\x00\x10') # size
self.light_color.to_stream(data)
data.write(b'\xe4\xae\xeb\xa4') # 0xe4aeeba4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0xe4aeeba4))
data.write(b']\x9e\xd4G') # 0x5d9ed447
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_0x5d9ed447))
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
power_up_time=data['power_up_time'],
power_down_time=data['power_down_time'],
part_0xbf87e353=data['part_0xbf87e353'],
part_0xaf6e671a=data['part_0xaf6e671a'],
always_ff_0x67c8a8f4=data['always_ff_0x67c8a8f4'],
always_ff_0x68d8b844=data['always_ff_0x68d8b844'],
light_color=Color.from_json(data['light_color']),
sound_0xe4aeeba4=data['sound_0xe4aeeba4'],
sound_0x5d9ed447=data['sound_0x5d9ed447'],
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'power_up_time': self.power_up_time,
'power_down_time': self.power_down_time,
'part_0xbf87e353': self.part_0xbf87e353,
'part_0xaf6e671a': self.part_0xaf6e671a,
'always_ff_0x67c8a8f4': self.always_ff_0x67c8a8f4,
'always_ff_0x68d8b844': self.always_ff_0x68d8b844,
'light_color': self.light_color.to_json(),
'sound_0xe4aeeba4': self.sound_0xe4aeeba4,
'sound_0x5d9ed447': self.sound_0x5d9ed447,
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_part_0xbf87e353(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0xbf87e353)
def _dependencies_for_part_0xaf6e671a(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0xaf6e671a)
def _dependencies_for_sound_0xe4aeeba4(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0xe4aeeba4)
def _dependencies_for_sound_0x5d9ed447(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_0x5d9ed447)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_part_0xbf87e353, "part_0xbf87e353", "AssetId"),
(self._dependencies_for_part_0xaf6e671a, "part_0xaf6e671a", "AssetId"),
(self._dependencies_for_sound_0xe4aeeba4, "sound_0xe4aeeba4", "int"),
(self._dependencies_for_sound_0x5d9ed447, "sound_0x5d9ed447", "int"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for GunTurretTop.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_power_up_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_power_down_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part_0xbf87e353(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part_0xaf6e671a(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_always_ff_0x67c8a8f4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_always_ff_0x68d8b844(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_light_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_sound_0xe4aeeba4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_0x5d9ed447(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3bc1d043: ('power_up_time', _decode_power_up_time),
0x838a75a4: ('power_down_time', _decode_power_down_time),
0xbf87e353: ('part_0xbf87e353', _decode_part_0xbf87e353),
0xaf6e671a: ('part_0xaf6e671a', _decode_part_0xaf6e671a),
0x67c8a8f4: ('always_ff_0x67c8a8f4', _decode_always_ff_0x67c8a8f4),
0x68d8b844: ('always_ff_0x68d8b844', _decode_always_ff_0x68d8b844),
0xbd3efe7d: ('light_color', _decode_light_color),
0xe4aeeba4: ('sound_0xe4aeeba4', _decode_sound_0xe4aeeba4),
0x5d9ed447: ('sound_0x5d9ed447', _decode_sound_0x5d9ed447),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/GunTurretTop.py | 0.547948 | 0.270592 | GunTurretTop.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SporbNeedle(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
initial_speed: float = dataclasses.field(default=60.0)
mass: float = dataclasses.field(default=1.0)
attack_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
fuse_time: float = dataclasses.field(default=1.5)
trail_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
explosion_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
launch_sound: int = dataclasses.field(default=0, metadata={'sound': True})
flight_sound: int = dataclasses.field(default=0, metadata={'sound': True})
hit_player_sound: int = dataclasses.field(default=0, metadata={'sound': True})
collision_sound: int = dataclasses.field(default=0, metadata={'sound': True})
explosion_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPBN'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Sporb.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'\xcb\x14\xd9|') # 0xcb14d97c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_speed))
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'f\xdc\xaa\xcb') # 0x66dcaacb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_damage.to_stream(data, default_override={'di_weapon_type': 9, 'di_damage': 5.0, 'di_knock_back_power': 2.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\xc1K\x87') # 0x5cc14b87
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fuse_time))
data.write(b'6\xee\xe7\x91') # 0x36eee791
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.trail_effect))
data.write(b'\xf8\xb7\xba&') # 0xf8b7ba26
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.explosion_effect))
data.write(b'\r\xd6ow') # 0xdd66f77
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.launch_sound))
data.write(b'\x1b\xc7\xf2\xfc') # 0x1bc7f2fc
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flight_sound))
data.write(b'\xdf\xbd\x90\xe1') # 0xdfbd90e1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.hit_player_sound))
data.write(b'\x92\xca\xa9}') # 0x92caa97d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.collision_sound))
data.write(b'`(\xd1\xcc') # 0x6028d1cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.explosion_sound))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
model=data['model'],
initial_speed=data['initial_speed'],
mass=data['mass'],
attack_damage=DamageInfo.from_json(data['attack_damage']),
fuse_time=data['fuse_time'],
trail_effect=data['trail_effect'],
explosion_effect=data['explosion_effect'],
launch_sound=data['launch_sound'],
flight_sound=data['flight_sound'],
hit_player_sound=data['hit_player_sound'],
collision_sound=data['collision_sound'],
explosion_sound=data['explosion_sound'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'model': self.model,
'initial_speed': self.initial_speed,
'mass': self.mass,
'attack_damage': self.attack_damage.to_json(),
'fuse_time': self.fuse_time,
'trail_effect': self.trail_effect,
'explosion_effect': self.explosion_effect,
'launch_sound': self.launch_sound,
'flight_sound': self.flight_sound,
'hit_player_sound': self.hit_player_sound,
'collision_sound': self.collision_sound,
'explosion_sound': self.explosion_sound,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_attack_damage(self, asset_manager):
yield from self.attack_damage.dependencies_for(asset_manager)
def _dependencies_for_trail_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.trail_effect)
def _dependencies_for_explosion_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.explosion_effect)
def _dependencies_for_launch_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.launch_sound)
def _dependencies_for_flight_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.flight_sound)
def _dependencies_for_hit_player_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.hit_player_sound)
def _dependencies_for_collision_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.collision_sound)
def _dependencies_for_explosion_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.explosion_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_attack_damage, "attack_damage", "DamageInfo"),
(self._dependencies_for_trail_effect, "trail_effect", "AssetId"),
(self._dependencies_for_explosion_effect, "explosion_effect", "AssetId"),
(self._dependencies_for_launch_sound, "launch_sound", "int"),
(self._dependencies_for_flight_sound, "flight_sound", "int"),
(self._dependencies_for_hit_player_sound, "hit_player_sound", "int"),
(self._dependencies_for_collision_sound, "collision_sound", "int"),
(self._dependencies_for_explosion_sound, "explosion_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SporbNeedle.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_initial_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_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': 2.0})
def _decode_fuse_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_trail_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_explosion_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_launch_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_flight_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_hit_player_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_collision_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_explosion_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc27ffa8f: ('model', _decode_model),
0xcb14d97c: ('initial_speed', _decode_initial_speed),
0x75dbb375: ('mass', _decode_mass),
0x66dcaacb: ('attack_damage', _decode_attack_damage),
0x5cc14b87: ('fuse_time', _decode_fuse_time),
0x36eee791: ('trail_effect', _decode_trail_effect),
0xf8b7ba26: ('explosion_effect', _decode_explosion_effect),
0xdd66f77: ('launch_sound', _decode_launch_sound),
0x1bc7f2fc: ('flight_sound', _decode_flight_sound),
0xdfbd90e1: ('hit_player_sound', _decode_hit_player_sound),
0x92caa97d: ('collision_sound', _decode_collision_sound),
0x6028d1cc: ('explosion_sound', _decode_explosion_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SporbNeedle.py | 0.542863 | 0.248392 | SporbNeedle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class WorldTeleporter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
world: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
area: AssetId = dataclasses.field(metadata={'asset_types': ['MREA']}, default=default_asset_id)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
player_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
platform: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
platform_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
shaft: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
shaft_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_0x2e997e0b: bool = dataclasses.field(default=True)
sound_group: AssetId = dataclasses.field(metadata={'asset_types': ['AGSC']}, default=default_asset_id)
elevator: int = dataclasses.field(default=0, metadata={'sound': True})
volume: int = dataclasses.field(default=127)
pan: int = dataclasses.field(default=64)
is_teleport: bool = dataclasses.field(default=False)
display_font: AssetId = dataclasses.field(metadata={'asset_types': ['FONT']}, default=default_asset_id)
string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
is_fade_white: bool = dataclasses.field(default=False)
character_fade_time: float = dataclasses.field(default=0.009999999776482582)
characters_per_second: float = dataclasses.field(default=8.0)
start_delay: float = dataclasses.field(default=0.0)
audio_stream: str = dataclasses.field(default='')
display_subtitles: bool = dataclasses.field(default=False)
end_delay: float = dataclasses.field(default=0.0)
subtitle_fade_in_delay: float = dataclasses.field(default=2.0)
subtitle_fade_time: float = dataclasses.field(default=3.0)
unknown_0x5657ca1c: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TEL1'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1b') # 27 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1\xec\x14\xbc') # 0x31ec14bc
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.world))
data.write(b'\xe0\xc1x\x04') # 0xe0c17804
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.area))
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'\xe5k\xa3e') # 0xe56ba365
data.write(b'\x00\x0c') # size
self.player_scale.to_stream(data)
data.write(b'\x97\x03\xf9a') # 0x9703f961
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.platform))
data.write(b'\xca\x1d\x96\x15') # 0xca1d9615
data.write(b'\x00\x0c') # size
self.platform_scale.to_stream(data)
data.write(b'\t\xf4\xb2\x12') # 0x9f4b212
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shaft))
data.write(b'\x84\xb4;\xc6') # 0x84b43bc6
data.write(b'\x00\x0c') # size
self.shaft_scale.to_stream(data)
data.write(b'.\x99~\x0b') # 0x2e997e0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2e997e0b))
data.write(b'13\xc6&') # 0x3133c626
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.sound_group))
data.write(b'\xc1\x1f\xdb;') # 0xc11fdb3b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.elevator))
data.write(b'\x80\xc6l7') # 0x80c66c37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume))
data.write(b'\xd6\x08\x8b\xc5') # 0xd6088bc5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.pan))
data.write(b'\xea\x97K\x08') # 0xea974b08
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_teleport))
data.write(b'l\x17m\xd6') # 0x6c176dd6
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.display_font))
data.write(b'\x91\x82%\x0c') # 0x9182250c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.string))
data.write(b'\xc5@\x82\xe8') # 0xc54082e8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_fade_white))
data.write(b'\xd9\xb29O') # 0xd9b2394f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.character_fade_time))
data.write(b'55\x82\xbd') # 0x353582bd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.characters_per_second))
data.write(b'\x19n\x17\xd9') # 0x196e17d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_delay))
data.write(b'\xb2\x8f7\xb1') # 0xb28f37b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.audio_stream.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\xc4\xe7\xf8') # 0xa1c4e7f8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.display_subtitles))
data.write(b'y\xcd\xa5|') # 0x79cda57c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.end_delay))
data.write(b'\x0bR@\xe3') # 0xb5240e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.subtitle_fade_in_delay))
data.write(b'qxg\x11') # 0x71786711
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.subtitle_fade_time))
data.write(b'VW\xca\x1c') # 0x5657ca1c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5657ca1c))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
world=data['world'],
area=data['area'],
animation_information=AnimationParameters.from_json(data['animation_information']),
player_scale=Vector.from_json(data['player_scale']),
platform=data['platform'],
platform_scale=Vector.from_json(data['platform_scale']),
shaft=data['shaft'],
shaft_scale=Vector.from_json(data['shaft_scale']),
unknown_0x2e997e0b=data['unknown_0x2e997e0b'],
sound_group=data['sound_group'],
elevator=data['elevator'],
volume=data['volume'],
pan=data['pan'],
is_teleport=data['is_teleport'],
display_font=data['display_font'],
string=data['string'],
is_fade_white=data['is_fade_white'],
character_fade_time=data['character_fade_time'],
characters_per_second=data['characters_per_second'],
start_delay=data['start_delay'],
audio_stream=data['audio_stream'],
display_subtitles=data['display_subtitles'],
end_delay=data['end_delay'],
subtitle_fade_in_delay=data['subtitle_fade_in_delay'],
subtitle_fade_time=data['subtitle_fade_time'],
unknown_0x5657ca1c=data['unknown_0x5657ca1c'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'world': self.world,
'area': self.area,
'animation_information': self.animation_information.to_json(),
'player_scale': self.player_scale.to_json(),
'platform': self.platform,
'platform_scale': self.platform_scale.to_json(),
'shaft': self.shaft,
'shaft_scale': self.shaft_scale.to_json(),
'unknown_0x2e997e0b': self.unknown_0x2e997e0b,
'sound_group': self.sound_group,
'elevator': self.elevator,
'volume': self.volume,
'pan': self.pan,
'is_teleport': self.is_teleport,
'display_font': self.display_font,
'string': self.string,
'is_fade_white': self.is_fade_white,
'character_fade_time': self.character_fade_time,
'characters_per_second': self.characters_per_second,
'start_delay': self.start_delay,
'audio_stream': self.audio_stream,
'display_subtitles': self.display_subtitles,
'end_delay': self.end_delay,
'subtitle_fade_in_delay': self.subtitle_fade_in_delay,
'subtitle_fade_time': self.subtitle_fade_time,
'unknown_0x5657ca1c': self.unknown_0x5657ca1c,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_platform(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.platform)
def _dependencies_for_shaft(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.shaft)
def _dependencies_for_sound_group(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.sound_group)
def _dependencies_for_elevator(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.elevator)
def _dependencies_for_display_font(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.display_font)
def _dependencies_for_string(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.string)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_platform, "platform", "AssetId"),
(self._dependencies_for_shaft, "shaft", "AssetId"),
(self._dependencies_for_sound_group, "sound_group", "AssetId"),
(self._dependencies_for_elevator, "elevator", "int"),
(self._dependencies_for_display_font, "display_font", "AssetId"),
(self._dependencies_for_string, "string", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for WorldTeleporter.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_world(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_area(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_player_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_platform(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_platform_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_shaft(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_shaft_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x2e997e0b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_group(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_elevator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_teleport(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_display_font(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_is_fade_white(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_character_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_characters_per_second(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_audio_stream(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_display_subtitles(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_end_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_subtitle_fade_in_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_subtitle_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5657ca1c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x31ec14bc: ('world', _decode_world),
0xe0c17804: ('area', _decode_area),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xe56ba365: ('player_scale', _decode_player_scale),
0x9703f961: ('platform', _decode_platform),
0xca1d9615: ('platform_scale', _decode_platform_scale),
0x9f4b212: ('shaft', _decode_shaft),
0x84b43bc6: ('shaft_scale', _decode_shaft_scale),
0x2e997e0b: ('unknown_0x2e997e0b', _decode_unknown_0x2e997e0b),
0x3133c626: ('sound_group', _decode_sound_group),
0xc11fdb3b: ('elevator', _decode_elevator),
0x80c66c37: ('volume', _decode_volume),
0xd6088bc5: ('pan', _decode_pan),
0xea974b08: ('is_teleport', _decode_is_teleport),
0x6c176dd6: ('display_font', _decode_display_font),
0x9182250c: ('string', _decode_string),
0xc54082e8: ('is_fade_white', _decode_is_fade_white),
0xd9b2394f: ('character_fade_time', _decode_character_fade_time),
0x353582bd: ('characters_per_second', _decode_characters_per_second),
0x196e17d9: ('start_delay', _decode_start_delay),
0xb28f37b1: ('audio_stream', _decode_audio_stream),
0xa1c4e7f8: ('display_subtitles', _decode_display_subtitles),
0x79cda57c: ('end_delay', _decode_end_delay),
0xb5240e3: ('subtitle_fade_in_delay', _decode_subtitle_fade_in_delay),
0x71786711: ('subtitle_fade_time', _decode_subtitle_fade_time),
0x5657ca1c: ('unknown_0x5657ca1c', _decode_unknown_0x5657ca1c),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/WorldTeleporter.py | 0.584983 | 0.281602 | WorldTeleporter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class PortalTransition(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
player_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
volume: int = dataclasses.field(default=127)
pan: int = dataclasses.field(default=64)
agsc_0xe08e2172: AssetId = dataclasses.field(metadata={'asset_types': ['AGSC']}, default=default_asset_id)
agsc_0xb3e6c4e3: AssetId = dataclasses.field(metadata={'asset_types': ['AGSC']}, default=default_asset_id)
start_portal: int = dataclasses.field(default=0, metadata={'sound': True})
in_portal1: int = dataclasses.field(default=0, metadata={'sound': True})
in_portal2: int = dataclasses.field(default=0, metadata={'sound': True})
direction: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PRTT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\xe5k\xa3e') # 0xe56ba365
data.write(b'\x00\x0c') # size
self.player_scale.to_stream(data)
data.write(b'\x80\xc6l7') # 0x80c66c37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume))
data.write(b'\xd6\x08\x8b\xc5') # 0xd6088bc5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.pan))
data.write(b'\xe0\x8e!r') # 0xe08e2172
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.agsc_0xe08e2172))
data.write(b'\xb3\xe6\xc4\xe3') # 0xb3e6c4e3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.agsc_0xb3e6c4e3))
data.write(b'P\x85 \xe1') # 0x508520e1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.start_portal))
data.write(b'4\xc7\xc1\xcc') # 0x34c7c1cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.in_portal1))
data.write(b'\xb2S\xb3b') # 0xb253b362
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.in_portal2))
data.write(b'D\x06\xdc\x02') # 0x4406dc02
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.direction))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
animation_information=AnimationParameters.from_json(data['animation_information']),
player_scale=Vector.from_json(data['player_scale']),
volume=data['volume'],
pan=data['pan'],
agsc_0xe08e2172=data['agsc_0xe08e2172'],
agsc_0xb3e6c4e3=data['agsc_0xb3e6c4e3'],
start_portal=data['start_portal'],
in_portal1=data['in_portal1'],
in_portal2=data['in_portal2'],
direction=data['direction'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation_information': self.animation_information.to_json(),
'player_scale': self.player_scale.to_json(),
'volume': self.volume,
'pan': self.pan,
'agsc_0xe08e2172': self.agsc_0xe08e2172,
'agsc_0xb3e6c4e3': self.agsc_0xb3e6c4e3,
'start_portal': self.start_portal,
'in_portal1': self.in_portal1,
'in_portal2': self.in_portal2,
'direction': self.direction,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_agsc_0xe08e2172(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.agsc_0xe08e2172)
def _dependencies_for_agsc_0xb3e6c4e3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.agsc_0xb3e6c4e3)
def _dependencies_for_start_portal(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.start_portal)
def _dependencies_for_in_portal1(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.in_portal1)
def _dependencies_for_in_portal2(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.in_portal2)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_agsc_0xe08e2172, "agsc_0xe08e2172", "AssetId"),
(self._dependencies_for_agsc_0xb3e6c4e3, "agsc_0xb3e6c4e3", "AssetId"),
(self._dependencies_for_start_portal, "start_portal", "int"),
(self._dependencies_for_in_portal1, "in_portal1", "int"),
(self._dependencies_for_in_portal2, "in_portal2", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PortalTransition.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_player_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_agsc_0xe08e2172(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_agsc_0xb3e6c4e3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_start_portal(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_in_portal1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_in_portal2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_direction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xe56ba365: ('player_scale', _decode_player_scale),
0x80c66c37: ('volume', _decode_volume),
0xd6088bc5: ('pan', _decode_pan),
0xe08e2172: ('agsc_0xe08e2172', _decode_agsc_0xe08e2172),
0xb3e6c4e3: ('agsc_0xb3e6c4e3', _decode_agsc_0xb3e6c4e3),
0x508520e1: ('start_portal', _decode_start_portal),
0x34c7c1cc: ('in_portal1', _decode_in_portal1),
0xb253b362: ('in_portal2', _decode_in_portal2),
0x4406dc02: ('direction', _decode_direction),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PortalTransition.py | 0.576184 | 0.281838 | PortalTransition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class IngSnatchingSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
state_machine: AssetId = dataclasses.field(metadata={'asset_types': ['AFSM', 'FSM2']}, default=default_asset_id)
swarm_particle_system: AssetId = dataclasses.field(metadata={'asset_types': ['PART', 'SRSC']}, default=default_asset_id)
unknown_0x7cae2ed5: float = dataclasses.field(default=0.5)
part_0x35a88fa1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0xf65e7ec5: float = dataclasses.field(default=0.3499999940395355)
lifetime: float = dataclasses.field(default=15.0)
max_linear_speed: float = dataclasses.field(default=25.0)
max_linear_acceleration: float = dataclasses.field(default=10.0)
max_turn_speed: float = dataclasses.field(default=2000.0)
unknown_0xdffdf5a2: bool = dataclasses.field(default=False)
ignore_player: bool = dataclasses.field(default=False)
unknown_0xe6b57a25: float = dataclasses.field(default=0.5)
exit_portal_distance: float = dataclasses.field(default=4.0)
unknown_0x2de5a19a: float = dataclasses.field(default=10.0)
unknown_0x4e79f717: float = dataclasses.field(default=3.0)
unknown_0xe8e0b5a6: float = dataclasses.field(default=2.0)
begin_snatching_range: float = dataclasses.field(default=5.0)
part_0x2d2afc26: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
impact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_impact: int = dataclasses.field(default=0, metadata={'sound': True})
sound_idle: int = dataclasses.field(default=0, metadata={'sound': True})
sound_move: int = dataclasses.field(default=0, metadata={'sound': True})
health: float = dataclasses.field(default=50.0)
swarm_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ISSW'
@classmethod
def modules(cls) -> typing.List[str]:
return ['IngSnatchingSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x19') # 25 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'UtA`') # 0x55744160
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.state_machine))
data.write(b'\x83\xcfe\t') # 0x83cf6509
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.swarm_particle_system))
data.write(b'|\xae.\xd5') # 0x7cae2ed5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7cae2ed5))
data.write(b'5\xa8\x8f\xa1') # 0x35a88fa1
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x35a88fa1))
data.write(b'\xf6^~\xc5') # 0xf65e7ec5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf65e7ec5))
data.write(b'2\xdcg\xf6') # 0x32dc67f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lifetime))
data.write(b'V=m\x13') # 0x563d6d13
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_linear_speed))
data.write(b'\xf5I\xe73') # 0xf549e733
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_linear_acceleration))
data.write(b'\x0b\\<\x1a') # 0xb5c3c1a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_turn_speed))
data.write(b'\xdf\xfd\xf5\xa2') # 0xdffdf5a2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xdffdf5a2))
data.write(b'wU\xf3I') # 0x7755f349
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_player))
data.write(b'\xe6\xb5z%') # 0xe6b57a25
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe6b57a25))
data.write(b'\x83\tf\xd5') # 0x830966d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.exit_portal_distance))
data.write(b'-\xe5\xa1\x9a') # 0x2de5a19a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2de5a19a))
data.write(b'Ny\xf7\x17') # 0x4e79f717
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4e79f717))
data.write(b'\xe8\xe0\xb5\xa6') # 0xe8e0b5a6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe8e0b5a6))
data.write(b'\xfc\xd8\x05{') # 0xfcd8057b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.begin_snatching_range))
data.write(b'-*\xfc&') # 0x2d2afc26
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part_0x2d2afc26))
data.write(b'\xb1mU>') # 0xb16d553e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.impact_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'\x1b\xb1n\xa5') # 0x1bb16ea5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_impact))
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'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
data.write(b'\x87\x92\xa2\xb0') # 0x8792a2b0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swarm_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
state_machine=data['state_machine'],
swarm_particle_system=data['swarm_particle_system'],
unknown_0x7cae2ed5=data['unknown_0x7cae2ed5'],
part_0x35a88fa1=data['part_0x35a88fa1'],
unknown_0xf65e7ec5=data['unknown_0xf65e7ec5'],
lifetime=data['lifetime'],
max_linear_speed=data['max_linear_speed'],
max_linear_acceleration=data['max_linear_acceleration'],
max_turn_speed=data['max_turn_speed'],
unknown_0xdffdf5a2=data['unknown_0xdffdf5a2'],
ignore_player=data['ignore_player'],
unknown_0xe6b57a25=data['unknown_0xe6b57a25'],
exit_portal_distance=data['exit_portal_distance'],
unknown_0x2de5a19a=data['unknown_0x2de5a19a'],
unknown_0x4e79f717=data['unknown_0x4e79f717'],
unknown_0xe8e0b5a6=data['unknown_0xe8e0b5a6'],
begin_snatching_range=data['begin_snatching_range'],
part_0x2d2afc26=data['part_0x2d2afc26'],
impact_damage=DamageInfo.from_json(data['impact_damage']),
sound_impact=data['sound_impact'],
sound_idle=data['sound_idle'],
sound_move=data['sound_move'],
health=data['health'],
swarm_vulnerability=DamageVulnerability.from_json(data['swarm_vulnerability']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'state_machine': self.state_machine,
'swarm_particle_system': self.swarm_particle_system,
'unknown_0x7cae2ed5': self.unknown_0x7cae2ed5,
'part_0x35a88fa1': self.part_0x35a88fa1,
'unknown_0xf65e7ec5': self.unknown_0xf65e7ec5,
'lifetime': self.lifetime,
'max_linear_speed': self.max_linear_speed,
'max_linear_acceleration': self.max_linear_acceleration,
'max_turn_speed': self.max_turn_speed,
'unknown_0xdffdf5a2': self.unknown_0xdffdf5a2,
'ignore_player': self.ignore_player,
'unknown_0xe6b57a25': self.unknown_0xe6b57a25,
'exit_portal_distance': self.exit_portal_distance,
'unknown_0x2de5a19a': self.unknown_0x2de5a19a,
'unknown_0x4e79f717': self.unknown_0x4e79f717,
'unknown_0xe8e0b5a6': self.unknown_0xe8e0b5a6,
'begin_snatching_range': self.begin_snatching_range,
'part_0x2d2afc26': self.part_0x2d2afc26,
'impact_damage': self.impact_damage.to_json(),
'sound_impact': self.sound_impact,
'sound_idle': self.sound_idle,
'sound_move': self.sound_move,
'health': self.health,
'swarm_vulnerability': self.swarm_vulnerability.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.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_swarm_particle_system(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.swarm_particle_system)
def _dependencies_for_part_0x35a88fa1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x35a88fa1)
def _dependencies_for_part_0x2d2afc26(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part_0x2d2afc26)
def _dependencies_for_impact_damage(self, asset_manager):
yield from self.impact_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_impact(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_impact)
def _dependencies_for_sound_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_swarm_vulnerability(self, asset_manager):
yield from self.swarm_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_state_machine, "state_machine", "AssetId"),
(self._dependencies_for_swarm_particle_system, "swarm_particle_system", "AssetId"),
(self._dependencies_for_part_0x35a88fa1, "part_0x35a88fa1", "AssetId"),
(self._dependencies_for_part_0x2d2afc26, "part_0x2d2afc26", "AssetId"),
(self._dependencies_for_impact_damage, "impact_damage", "DamageInfo"),
(self._dependencies_for_sound_impact, "sound_impact", "int"),
(self._dependencies_for_sound_idle, "sound_idle", "int"),
(self._dependencies_for_sound_move, "sound_move", "int"),
(self._dependencies_for_swarm_vulnerability, "swarm_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IngSnatchingSwarm.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.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_swarm_particle_system(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x7cae2ed5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part_0x35a88fa1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xf65e7ec5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lifetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_linear_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_linear_acceleration(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_unknown_0xdffdf5a2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe6b57a25(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_exit_portal_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2de5a19a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4e79f717(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe8e0b5a6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_begin_snatching_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part_0x2d2afc26(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_impact_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(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_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swarm_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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x55744160: ('state_machine', _decode_state_machine),
0x83cf6509: ('swarm_particle_system', _decode_swarm_particle_system),
0x7cae2ed5: ('unknown_0x7cae2ed5', _decode_unknown_0x7cae2ed5),
0x35a88fa1: ('part_0x35a88fa1', _decode_part_0x35a88fa1),
0xf65e7ec5: ('unknown_0xf65e7ec5', _decode_unknown_0xf65e7ec5),
0x32dc67f6: ('lifetime', _decode_lifetime),
0x563d6d13: ('max_linear_speed', _decode_max_linear_speed),
0xf549e733: ('max_linear_acceleration', _decode_max_linear_acceleration),
0xb5c3c1a: ('max_turn_speed', _decode_max_turn_speed),
0xdffdf5a2: ('unknown_0xdffdf5a2', _decode_unknown_0xdffdf5a2),
0x7755f349: ('ignore_player', _decode_ignore_player),
0xe6b57a25: ('unknown_0xe6b57a25', _decode_unknown_0xe6b57a25),
0x830966d5: ('exit_portal_distance', _decode_exit_portal_distance),
0x2de5a19a: ('unknown_0x2de5a19a', _decode_unknown_0x2de5a19a),
0x4e79f717: ('unknown_0x4e79f717', _decode_unknown_0x4e79f717),
0xe8e0b5a6: ('unknown_0xe8e0b5a6', _decode_unknown_0xe8e0b5a6),
0xfcd8057b: ('begin_snatching_range', _decode_begin_snatching_range),
0x2d2afc26: ('part_0x2d2afc26', _decode_part_0x2d2afc26),
0xb16d553e: ('impact_damage', _decode_impact_damage),
0x1bb16ea5: ('sound_impact', _decode_sound_impact),
0xaf38968e: ('sound_idle', _decode_sound_idle),
0x6c101854: ('sound_move', _decode_sound_move),
0xf0668919: ('health', _decode_health),
0x8792a2b0: ('swarm_vulnerability', _decode_swarm_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/IngSnatchingSwarm.py | 0.560012 | 0.241931 | IngSnatchingSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AreaDamage(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
pulse_time: float = dataclasses.field(default=1.0)
grace_time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ADMG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8e\x07\xe9\xd3') # 0x8e07e9d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pulse_time))
data.write(b'\xc0R\xbc\x02') # 0xc052bc02
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grace_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage=DamageInfo.from_json(data['damage']),
pulse_time=data['pulse_time'],
grace_time=data['grace_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
'pulse_time': self.pulse_time,
'grace_time': self.grace_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AreaDamage.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_pulse_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grace_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x337f9524: ('damage', _decode_damage),
0x8e07e9d3: ('pulse_time', _decode_pulse_time),
0xc052bc02: ('grace_time', _decode_grace_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AreaDamage.py | 0.600188 | 0.329257 | AreaDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class StreamedMovie(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
movie_file: str = dataclasses.field(default='')
loop: bool = dataclasses.field(default=False)
video_filter_enabled: bool = dataclasses.field(default=True)
unknown: int = dataclasses.field(default=0)
volume: int = dataclasses.field(default=127)
volume_type: int = dataclasses.field(default=0)
cache_length: float = dataclasses.field(default=0.05000000074505806)
fade_out_time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MOVI'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptStreamedMovie.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\t') # 9 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X+\x84\xa8') # 0x582b84a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.movie_file.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'6\x96;\xcc') # 0x36963bcc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.video_filter_enabled))
data.write(b'\xa7\x8a\xc0\xc0') # 0xa78ac0c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\x80\xc6l7') # 0x80c66c37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume))
data.write(b'\xe1\xffO\x04') # 0xe1ff4f04
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume_type))
data.write(b'\xad\x9e\xb7\x7f') # 0xad9eb77f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cache_length))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
movie_file=data['movie_file'],
loop=data['loop'],
video_filter_enabled=data['video_filter_enabled'],
unknown=data['unknown'],
volume=data['volume'],
volume_type=data['volume_type'],
cache_length=data['cache_length'],
fade_out_time=data['fade_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'movie_file': self.movie_file,
'loop': self.loop,
'video_filter_enabled': self.video_filter_enabled,
'unknown': self.unknown,
'volume': self.volume,
'volume_type': self.volume_type,
'cache_length': self.cache_length,
'fade_out_time': self.fade_out_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for StreamedMovie.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_movie_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_video_filter_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_cache_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x582b84a8: ('movie_file', _decode_movie_file),
0xeda47ff6: ('loop', _decode_loop),
0x36963bcc: ('video_filter_enabled', _decode_video_filter_enabled),
0xa78ac0c0: ('unknown', _decode_unknown),
0x80c66c37: ('volume', _decode_volume),
0xe1ff4f04: ('volume_type', _decode_volume_type),
0xad9eb77f: ('cache_length', _decode_cache_length),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/StreamedMovie.py | 0.574634 | 0.366902 | StreamedMovie.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class PathCamera(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_path_camera: int = dataclasses.field(default=32) # Flagset
unknown_0xd4b29446: int = dataclasses.field(default=0)
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
target_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
fov_spline: Spline = dataclasses.field(default_factory=Spline)
speed_control_spline: Spline = dataclasses.field(default_factory=Spline)
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
unknown_0x431769c6: bool = dataclasses.field(default=False)
distance: float = dataclasses.field(default=4.0)
speed: float = dataclasses.field(default=10.0)
dampen_distance: float = dataclasses.field(default=3.0)
initial_position: int = dataclasses.field(default=0)
angular_speed: float = dataclasses.field(default=120.0)
unknown_0x12861f7d: Spline = dataclasses.field(default_factory=Spline)
unknown_0x96ac52b0: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PCAM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x12') # 18 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\xbd[\xae') # 0x5cbd5bae
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_path_camera))
data.write(b'\xd4\xb2\x94F') # 0xd4b29446
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd4b29446))
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'V\x04\xd3\x04') # 0x5604d304
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xdf\xbf\xa7') # 0xc4dfbfa7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'hh\xd4\xb3') # 0x6868d4b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xd0q`') # 0xedd07160
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.speed_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\xe4h[') # 0x33e4685b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\x17i\xc6') # 0x431769c6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x431769c6))
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'2\xf85\xec') # 0x32f835ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dampen_distance))
data.write(b'\xe8\xfcr\xb6') # 0xe8fc72b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_position))
data.write(b'\xbc\xd73?') # 0xbcd7333f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angular_speed))
data.write(b'\x12\x86\x1f}') # 0x12861f7d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x12861f7d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x96\xacR\xb0') # 0x96ac52b0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x96ac52b0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_path_camera=data['flags_path_camera'],
unknown_0xd4b29446=data['unknown_0xd4b29446'],
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
target_spline_type=SplineType.from_json(data['target_spline_type']),
target_control_spline=Spline.from_json(data['target_control_spline']),
fov_spline=Spline.from_json(data['fov_spline']),
speed_control_spline=Spline.from_json(data['speed_control_spline']),
spline_type=SplineType.from_json(data['spline_type']),
unknown_0x431769c6=data['unknown_0x431769c6'],
distance=data['distance'],
speed=data['speed'],
dampen_distance=data['dampen_distance'],
initial_position=data['initial_position'],
angular_speed=data['angular_speed'],
unknown_0x12861f7d=Spline.from_json(data['unknown_0x12861f7d']),
unknown_0x96ac52b0=Spline.from_json(data['unknown_0x96ac52b0']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_path_camera': self.flags_path_camera,
'unknown_0xd4b29446': self.unknown_0xd4b29446,
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'target_spline_type': self.target_spline_type.to_json(),
'target_control_spline': self.target_control_spline.to_json(),
'fov_spline': self.fov_spline.to_json(),
'speed_control_spline': self.speed_control_spline.to_json(),
'spline_type': self.spline_type.to_json(),
'unknown_0x431769c6': self.unknown_0x431769c6,
'distance': self.distance,
'speed': self.speed,
'dampen_distance': self.dampen_distance,
'initial_position': self.initial_position,
'angular_speed': self.angular_speed,
'unknown_0x12861f7d': self.unknown_0x12861f7d.to_json(),
'unknown_0x96ac52b0': self.unknown_0x96ac52b0.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_motion_spline_type(self, asset_manager):
yield from self.motion_spline_type.dependencies_for(asset_manager)
def _dependencies_for_target_spline_type(self, asset_manager):
yield from self.target_spline_type.dependencies_for(asset_manager)
def _dependencies_for_spline_type(self, asset_manager):
yield from self.spline_type.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_motion_spline_type, "motion_spline_type", "SplineType"),
(self._dependencies_for_target_spline_type, "target_spline_type", "SplineType"),
(self._dependencies_for_spline_type, "spline_type", "SplineType"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PathCamera.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_path_camera(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xd4b29446(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[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_target_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_fov_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_speed_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_unknown_0x431769c6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_distance(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_dampen_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_position(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', 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_0x12861f7d(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x96ac52b0(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x5cbd5bae: ('flags_path_camera', _decode_flags_path_camera),
0xd4b29446: ('unknown_0xd4b29446', _decode_unknown_0xd4b29446),
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0x5604d304: ('target_spline_type', _decode_target_spline_type),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0x6868d4b3: ('fov_spline', _decode_fov_spline),
0xedd07160: ('speed_control_spline', _decode_speed_control_spline),
0x33e4685b: ('spline_type', _decode_spline_type),
0x431769c6: ('unknown_0x431769c6', _decode_unknown_0x431769c6),
0xc3bf43be: ('distance', _decode_distance),
0x6392404e: ('speed', _decode_speed),
0x32f835ec: ('dampen_distance', _decode_dampen_distance),
0xe8fc72b6: ('initial_position', _decode_initial_position),
0xbcd7333f: ('angular_speed', _decode_angular_speed),
0x12861f7d: ('unknown_0x12861f7d', _decode_unknown_0x12861f7d),
0x96ac52b0: ('unknown_0x96ac52b0', _decode_unknown_0x96ac52b0),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PathCamera.py | 0.565899 | 0.311649 | PathCamera.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Relay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Relay.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Relay.py | 0.637595 | 0.355076 | Relay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.SurroundPan import SurroundPan
@dataclasses.dataclass()
class Sound(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
sound: int = dataclasses.field(default=0, metadata={'sound': True})
max_audible_distance: float = dataclasses.field(default=50.0)
drop_off: float = dataclasses.field(default=0.20000000298023224)
delay_time: float = dataclasses.field(default=0.0)
min_volume: int = dataclasses.field(default=20)
max_volume: int = dataclasses.field(default=127)
priority: int = dataclasses.field(default=127)
surround_pan: SurroundPan = dataclasses.field(default_factory=SurroundPan)
loop: bool = dataclasses.field(default=False)
ambient: bool = dataclasses.field(default=False)
unknown: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
can_occlude: bool = dataclasses.field(default=False)
use_room_acoustics: bool = dataclasses.field(default=True)
persistent: bool = dataclasses.field(default=False)
play_always: bool = dataclasses.field(default=False)
all_area: bool = dataclasses.field(default=False)
sound_is_music: bool = dataclasses.field(default=False)
pitch: int = dataclasses.field(default=0)
echo_visor_max_volume: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SOND'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x15') # 21 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'_|5.') # 0x5f7c352e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'\x08\xbf.T') # 0x8bf2e54
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drop_off))
data.write(b'\x8e\x16\xe0\x12') # 0x8e16e012
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_time))
data.write(b'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'B\x08vP') # 0x42087650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.priority))
data.write(b'\x0b\xb6&9') # 0xbb62639
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surround_pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\x89q\xb7\xa7') # 0x8971b7a7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ambient))
data.write(b'\x84\xf3\xac=') # 0x84f3ac3d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\x94r\x11c') # 0x94721163
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_occlude))
data.write(b'\x85psT') # 0x85707354
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_room_acoustics))
data.write(b'\xea\x03\xe2X') # 0xea03e258
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.persistent))
data.write(b'\r\x7f\x8c\x7f') # 0xd7f8c7f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.play_always))
data.write(b'\xe4\\4\x99') # 0xe45c3499
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.all_area))
data.write(b'v\xd4\x00\x91') # 0x76d40091
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_music))
data.write(b'\x8avDc') # 0x8a764463
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.pitch))
data.write(b'i\xec\x91\x07') # 0x69ec9107
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.echo_visor_max_volume))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
sound=data['sound'],
max_audible_distance=data['max_audible_distance'],
drop_off=data['drop_off'],
delay_time=data['delay_time'],
min_volume=data['min_volume'],
max_volume=data['max_volume'],
priority=data['priority'],
surround_pan=SurroundPan.from_json(data['surround_pan']),
loop=data['loop'],
ambient=data['ambient'],
unknown=data['unknown'],
auto_start=data['auto_start'],
can_occlude=data['can_occlude'],
use_room_acoustics=data['use_room_acoustics'],
persistent=data['persistent'],
play_always=data['play_always'],
all_area=data['all_area'],
sound_is_music=data['sound_is_music'],
pitch=data['pitch'],
echo_visor_max_volume=data['echo_visor_max_volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'sound': self.sound,
'max_audible_distance': self.max_audible_distance,
'drop_off': self.drop_off,
'delay_time': self.delay_time,
'min_volume': self.min_volume,
'max_volume': self.max_volume,
'priority': self.priority,
'surround_pan': self.surround_pan.to_json(),
'loop': self.loop,
'ambient': self.ambient,
'unknown': self.unknown,
'auto_start': self.auto_start,
'can_occlude': self.can_occlude,
'use_room_acoustics': self.use_room_acoustics,
'persistent': self.persistent,
'play_always': self.play_always,
'all_area': self.all_area,
'sound_is_music': self.sound_is_music,
'pitch': self.pitch,
'echo_visor_max_volume': self.echo_visor_max_volume,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def _dependencies_for_surround_pan(self, asset_manager):
yield from self.surround_pan.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_sound, "sound", "int"),
(self._dependencies_for_surround_pan, "surround_pan", "SurroundPan"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Sound.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drop_off(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_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_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_surround_pan(data: typing.BinaryIO, property_size: int):
return SurroundPan.from_stream(data, property_size)
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ambient(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('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_occlude(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_room_acoustics(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_persistent(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_play_always(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_all_area(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_music(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_echo_visor_max_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x5f7c352e: ('sound', _decode_sound),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x8bf2e54: ('drop_off', _decode_drop_off),
0x8e16e012: ('delay_time', _decode_delay_time),
0x57619496: ('min_volume', _decode_min_volume),
0xc712847c: ('max_volume', _decode_max_volume),
0x42087650: ('priority', _decode_priority),
0xbb62639: ('surround_pan', _decode_surround_pan),
0xeda47ff6: ('loop', _decode_loop),
0x8971b7a7: ('ambient', _decode_ambient),
0x84f3ac3d: ('unknown', _decode_unknown),
0x3217dff8: ('auto_start', _decode_auto_start),
0x94721163: ('can_occlude', _decode_can_occlude),
0x85707354: ('use_room_acoustics', _decode_use_room_acoustics),
0xea03e258: ('persistent', _decode_persistent),
0xd7f8c7f: ('play_always', _decode_play_always),
0xe45c3499: ('all_area', _decode_all_area),
0x76d40091: ('sound_is_music', _decode_sound_is_music),
0x8a764463: ('pitch', _decode_pitch),
0x69ec9107: ('echo_visor_max_volume', _decode_echo_visor_max_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Sound.py | 0.548553 | 0.317241 | Sound.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class AtomicAlpha(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
bomb_weapon: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
bomb_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
bomb_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
bomb_drop_delay: float = dataclasses.field(default=3.0)
bomb_reappear_delay: float = dataclasses.field(default=2.0)
bomb_reappear_time: float = dataclasses.field(default=1.5)
invisible: bool = dataclasses.field(default=False)
home_while_charging: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ATMA'
@classmethod
def modules(cls) -> typing.List[str]:
return ['AtomicAlpha.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5, 'creature_size': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17 \xb9\x1f') # 0x1720b91f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.bomb_weapon))
data.write(b'\xc7_\x95\x16') # 0xc75f9516
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.bomb_model))
data.write(b'\xb4\x8d_\xe6') # 0xb48d5fe6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bomb_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\xba\x00\x9c') # 0x66ba009c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_drop_delay))
data.write(b'y\xddf\xa9') # 0x79dd66a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_reappear_delay))
data.write(b'\xbbB\x84\xea') # 0xbb4284ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_reappear_time))
data.write(b'p\x17\xed\xfc') # 0x7017edfc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.invisible))
data.write(b'&9\xf0\xb9') # 0x2639f0b9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.home_while_charging))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
bomb_weapon=data['bomb_weapon'],
bomb_model=data['bomb_model'],
bomb_damage=DamageInfo.from_json(data['bomb_damage']),
bomb_drop_delay=data['bomb_drop_delay'],
bomb_reappear_delay=data['bomb_reappear_delay'],
bomb_reappear_time=data['bomb_reappear_time'],
invisible=data['invisible'],
home_while_charging=data['home_while_charging'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'bomb_weapon': self.bomb_weapon,
'bomb_model': self.bomb_model,
'bomb_damage': self.bomb_damage.to_json(),
'bomb_drop_delay': self.bomb_drop_delay,
'bomb_reappear_delay': self.bomb_reappear_delay,
'bomb_reappear_time': self.bomb_reappear_time,
'invisible': self.invisible,
'home_while_charging': self.home_while_charging,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_bomb_weapon(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.bomb_weapon)
def _dependencies_for_bomb_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.bomb_model)
def _dependencies_for_bomb_damage(self, asset_manager):
yield from self.bomb_damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_bomb_weapon, "bomb_weapon", "AssetId"),
(self._dependencies_for_bomb_model, "bomb_model", "AssetId"),
(self._dependencies_for_bomb_damage, "bomb_damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AtomicAlpha.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_bomb_weapon(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_bomb_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_bomb_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_bomb_drop_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bomb_reappear_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bomb_reappear_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_invisible(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_home_while_charging(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x1720b91f: ('bomb_weapon', _decode_bomb_weapon),
0xc75f9516: ('bomb_model', _decode_bomb_model),
0xb48d5fe6: ('bomb_damage', _decode_bomb_damage),
0x66ba009c: ('bomb_drop_delay', _decode_bomb_drop_delay),
0x79dd66a9: ('bomb_reappear_delay', _decode_bomb_reappear_delay),
0xbb4284ea: ('bomb_reappear_time', _decode_bomb_reappear_time),
0x7017edfc: ('invisible', _decode_invisible),
0x2639f0b9: ('home_while_charging', _decode_home_while_charging),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AtomicAlpha.py | 0.54359 | 0.320104 | AtomicAlpha.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class Crystallite(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
waypoint_approach_distance: float = dataclasses.field(default=2.5)
wall_turn_speed: float = dataclasses.field(default=360.0)
floor_turn_speed: float = dataclasses.field(default=720.0)
down_turn_speed: float = dataclasses.field(default=120.0)
visible_distance: float = dataclasses.field(default=40.0)
forward_moving_priority: float = dataclasses.field(default=0.20000000298023224)
stun_time: float = dataclasses.field(default=1.5)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CRLT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'Parasite.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\xacG\xc6(') # 0xac47c628
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_turn_speed))
data.write(b'\x8eO{)') # 0x8e4f7b29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_turn_speed))
data.write(b'=<\x1bv') # 0x3d3c1b76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.down_turn_speed))
data.write(b'\xa7%0\xe8') # 0xa72530e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_distance))
data.write(b'^jT\xb8') # 0x5e6a54b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_moving_priority))
data.write(b'~\x19#\x95') # 0x7e192395
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
waypoint_approach_distance=data['waypoint_approach_distance'],
wall_turn_speed=data['wall_turn_speed'],
floor_turn_speed=data['floor_turn_speed'],
down_turn_speed=data['down_turn_speed'],
visible_distance=data['visible_distance'],
forward_moving_priority=data['forward_moving_priority'],
stun_time=data['stun_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'waypoint_approach_distance': self.waypoint_approach_distance,
'wall_turn_speed': self.wall_turn_speed,
'floor_turn_speed': self.floor_turn_speed,
'down_turn_speed': self.down_turn_speed,
'visible_distance': self.visible_distance,
'forward_moving_priority': self.forward_moving_priority,
'stun_time': self.stun_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Crystallite.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_waypoint_approach_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_floor_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_down_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_forward_moving_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0xac47c628: ('wall_turn_speed', _decode_wall_turn_speed),
0x8e4f7b29: ('floor_turn_speed', _decode_floor_turn_speed),
0x3d3c1b76: ('down_turn_speed', _decode_down_turn_speed),
0xa72530e8: ('visible_distance', _decode_visible_distance),
0x5e6a54b8: ('forward_moving_priority', _decode_forward_moving_priority),
0x7e192395: ('stun_time', _decode_stun_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Crystallite.py | 0.664758 | 0.369514 | Crystallite.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DarkCommandoData import DarkCommandoData
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class DarkCommando(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
dark_commando_properties: DarkCommandoData = dataclasses.field(default_factory=DarkCommandoData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DRKC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['PirateRagDoll.rel', 'DarkCommando.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0, 'min_attack_range': 0.0, 'creature_size': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89@\x0b\xaa') # 0x89400baa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_commando_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
dark_commando_properties=DarkCommandoData.from_json(data['dark_commando_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'dark_commando_properties': self.dark_commando_properties.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_dark_commando_properties(self, asset_manager):
yield from self.dark_commando_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_dark_commando_properties, "dark_commando_properties", "DarkCommandoData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DarkCommando.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'turn_speed': 360.0, 'min_attack_range': 0.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_dark_commando_properties(data: typing.BinaryIO, property_size: int):
return DarkCommandoData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x89400baa: ('dark_commando_properties', _decode_dark_commando_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DarkCommando.py | 0.61682 | 0.277611 | DarkCommando.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Repulsor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shape: int = dataclasses.field(default=0)
radius: float = dataclasses.field(default=1.0)
value: float = dataclasses.field(default=-1.0)
flags_repulsor: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'REPL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\xbb-\xb6') # 0xf9bb2db6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.shape))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\x8d\xcd\x89x') # 0x8dcd8978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value))
data.write(b'\x8a\xefk\xd2') # 0x8aef6bd2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_repulsor))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shape=data['shape'],
radius=data['radius'],
value=data['value'],
flags_repulsor=data['flags_repulsor'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shape': self.shape,
'radius': self.radius,
'value': self.value,
'flags_repulsor': self.flags_repulsor,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Repulsor.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shape(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flags_repulsor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf9bb2db6: ('shape', _decode_shape),
0x78c507eb: ('radius', _decode_radius),
0x8dcd8978: ('value', _decode_value),
0x8aef6bd2: ('flags_repulsor', _decode_flags_repulsor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Repulsor.py | 0.606149 | 0.35248 | Repulsor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TweakPlayerControls.UnknownStruct1 import UnknownStruct1
from retro_data_structures.properties.echoes.archetypes.TweakPlayerControls.UnknownStruct2 import UnknownStruct2
@dataclasses.dataclass()
class TweakPlayerControls(BaseObjectType):
instance_name: str = dataclasses.field(default='')
unknown_0x3c34dfed: UnknownStruct1 = dataclasses.field(default_factory=UnknownStruct1)
unknown_0x168a79f1: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWPC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<4\xdf\xed') # 0x3c34dfed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x3c34dfed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\x8ay\xf1') # 0x168a79f1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x168a79f1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
instance_name=data['instance_name'],
unknown_0x3c34dfed=UnknownStruct1.from_json(data['unknown_0x3c34dfed']),
unknown_0x168a79f1=UnknownStruct2.from_json(data['unknown_0x168a79f1']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'unknown_0x3c34dfed': self.unknown_0x3c34dfed.to_json(),
'unknown_0x168a79f1': self.unknown_0x168a79f1.to_json(),
}
def _dependencies_for_unknown_0x3c34dfed(self, asset_manager):
yield from self.unknown_0x3c34dfed.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x168a79f1(self, asset_manager):
yield from self.unknown_0x168a79f1.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unknown_0x3c34dfed, "unknown_0x3c34dfed", "UnknownStruct1"),
(self._dependencies_for_unknown_0x168a79f1, "unknown_0x168a79f1", "UnknownStruct2"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakPlayerControls.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x3c34dfed(data: typing.BinaryIO, property_size: int):
return UnknownStruct1.from_stream(data, property_size)
def _decode_unknown_0x168a79f1(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]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0x3c34dfed: ('unknown_0x3c34dfed', _decode_unknown_0x3c34dfed),
0x168a79f1: ('unknown_0x168a79f1', _decode_unknown_0x168a79f1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakPlayerControls.py | 0.556641 | 0.295408 | TweakPlayerControls.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.TriggerInfo import TriggerInfo
@dataclasses.dataclass()
class TriggerOrientated(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
deactivate_on_enter: bool = dataclasses.field(default=False)
deactivate_on_exit: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TRGO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d3F_') # 0x8d33465f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.deactivate_on_enter))
data.write(b'\x1cE9\x86') # 0x1c453986
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.deactivate_on_exit))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
trigger=TriggerInfo.from_json(data['trigger']),
deactivate_on_enter=data['deactivate_on_enter'],
deactivate_on_exit=data['deactivate_on_exit'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger': self.trigger.to_json(),
'deactivate_on_enter': self.deactivate_on_enter,
'deactivate_on_exit': self.deactivate_on_exit,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_trigger(self, asset_manager):
yield from self.trigger.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_trigger, "trigger", "TriggerInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TriggerOrientated.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_deactivate_on_enter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_deactivate_on_exit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x77a27411: ('trigger', _decode_trigger),
0x8d33465f: ('deactivate_on_enter', _decode_deactivate_on_enter),
0x1c453986: ('deactivate_on_exit', _decode_deactivate_on_exit),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TriggerOrientated.py | 0.500977 | 0.309004 | TriggerOrientated.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct31 import UnknownStruct31
@dataclasses.dataclass()
class IngSpiderballGuardian(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct31: UnknownStruct31 = dataclasses.field(default_factory=UnknownStruct31)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ISBG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['IngSpiderballGuardian.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0, 'min_attack_range': 0.0, 'creature_size': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa18\x97\x99') # 0xa1389799
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct31.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct31=UnknownStruct31.from_json(data['unknown_struct31']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct31': self.unknown_struct31.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct31(self, asset_manager):
yield from self.unknown_struct31.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_unknown_struct31, "unknown_struct31", "UnknownStruct31"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IngSpiderballGuardian.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'turn_speed': 360.0, 'min_attack_range': 0.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct31(data: typing.BinaryIO, property_size: int):
return UnknownStruct31.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa1389799: ('unknown_struct31', _decode_unknown_struct31),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/IngSpiderballGuardian.py | 0.662032 | 0.305807 | IngSpiderballGuardian.py | pypi |
import typing
import retro_data_structures.enums.corruption as _corruption_enums
import retro_data_structures.enums.dkc_returns as _dkc_returns_enums
import retro_data_structures.enums.echoes as _echoes_enums
import retro_data_structures.enums.prime as _prime_enums
import retro_data_structures.enums.prime_remastered as _prime_remastered_enums
AttackType = typing.Union[
_dkc_returns_enums.AttackType,
_dkc_returns_enums.AttackType,
_dkc_returns_enums.AttackType,
_dkc_returns_enums.AttackType,
_dkc_returns_enums.AttackType
]
Blend_Mode = typing.Union[
_corruption_enums.Mode,
_dkc_returns_enums.Mode
]
CableEnum = typing.Union[
_corruption_enums.CableEnum,
_dkc_returns_enums.CableEnum
]
CableLighting = typing.Union[
_corruption_enums.CableLighting,
_dkc_returns_enums.CableLighting
]
CableType = typing.Union[
_corruption_enums.CableType,
_dkc_returns_enums.CableType
]
CameraMode = typing.Union[
_corruption_enums.CameraMode,
_dkc_returns_enums.CameraMode
]
CinematicEndsType = typing.Union[
_corruption_enums.CinematicEndsType,
_dkc_returns_enums.CinematicEndsType
]
CollisionType = typing.Union[
_corruption_enums.CollisionType,
_corruption_enums.CollisionType,
_dkc_returns_enums.CollisionType,
_dkc_returns_enums.CollisionType,
_dkc_returns_enums.CollisionType
]
Command = typing.Union[
_corruption_enums.Command,
_dkc_returns_enums.Command
]
ConvergenceType = typing.Union[
_corruption_enums.ConvergenceType,
_dkc_returns_enums.ConvergenceType
]
Curvature = typing.Union[
_corruption_enums.Curvature,
_dkc_returns_enums.Curvature
]
DamageableTriggerEnum = typing.Union[
_corruption_enums.DamageableTriggerEnum,
_dkc_returns_enums.DamageableTriggerEnum
]
DistanceDirectionMethod = typing.Union[
_corruption_enums.DistanceDirectionMethod,
_dkc_returns_enums.DistanceDirectionMethod
]
Effect = typing.Union[
_echoes_enums.Effect,
_dkc_returns_enums.Effect
]
EnvironmentEffects = typing.Union[
_echoes_enums.EnvironmentEffects,
_corruption_enums.EnvironmentEffects
]
FOVPathObject = typing.Union[
_corruption_enums.FOVPathObject,
_dkc_returns_enums.FOVPathObject
]
FOVType = typing.Union[
_corruption_enums.FOVType,
_corruption_enums.FOVType,
_dkc_returns_enums.FOVType,
_dkc_returns_enums.FOVType
]
FilterShape = typing.Union[
_echoes_enums.FilterShape,
_corruption_enums.FilterShape
]
Function = typing.Union[
_prime_enums.Function,
_echoes_enums.Function,
_corruption_enums.Function,
_dkc_returns_enums.Function
]
ImpulseLocation = typing.Union[
_corruption_enums.ImpulseLocation,
_dkc_returns_enums.ImpulseLocation
]
InitialPosition = typing.Union[
_corruption_enums.InitialPosition,
_dkc_returns_enums.InitialPosition
]
InterpolantType = typing.Union[
_corruption_enums.InterpolantType,
_dkc_returns_enums.InterpolantType
]
InterpolationControlType = typing.Union[
_corruption_enums.InterpolationControlType,
_dkc_returns_enums.InterpolationControlType
]
LookAtType = typing.Union[
_corruption_enums.LookAtType,
_dkc_returns_enums.LookAtType
]
MemoType = typing.Union[
_prime_enums.MemoType,
_prime_remastered_enums.MemoType
]
Message = typing.Union[
_prime_enums.Message,
_echoes_enums.Message,
_corruption_enums.Message,
_dkc_returns_enums.Message,
_dkc_returns_enums.Message
]
Mode = typing.Union[
_corruption_enums.Mode,
_dkc_returns_enums.Mode,
_dkc_returns_enums.Mode,
_dkc_returns_enums.Mode,
_dkc_returns_enums.Mode,
_dkc_returns_enums.Mode,
_dkc_returns_enums.Mode
]
MotionType = typing.Union[
_corruption_enums.MotionType,
_corruption_enums.MotionType,
_dkc_returns_enums.MotionType,
_dkc_returns_enums.MotionType,
_dkc_returns_enums.MotionType
]
OffsetType = typing.Union[
_corruption_enums.OffsetType,
_dkc_returns_enums.OffsetType
]
Orientation = typing.Union[
_dkc_returns_enums.Orientation,
_dkc_returns_enums.Orientation
]
OrientationType = typing.Union[
_corruption_enums.OrientationType,
_corruption_enums.OrientationType,
_dkc_returns_enums.OrientationType,
_dkc_returns_enums.OrientationType
]
PIDType = typing.Union[
_corruption_enums.PIDType,
_dkc_returns_enums.PIDType
]
PathDeterminationMethod = typing.Union[
_corruption_enums.PathDeterminationMethod,
_dkc_returns_enums.PathDeterminationMethod
]
PathLinkType = typing.Union[
_corruption_enums.PathLinkType,
_dkc_returns_enums.PathLinkType
]
PhazonDamage = typing.Union[
_echoes_enums.PhazonDamage,
_corruption_enums.PhazonDamage
]
PhysicalControl = typing.Union[
_corruption_enums.PhysicalControl,
_dkc_returns_enums.PhysicalControl
]
PhysicalControlBoolean = typing.Union[
_corruption_enums.PhysicalControlBoolean,
_dkc_returns_enums.PhysicalControlBoolean
]
PlayerItem = typing.Union[
_prime_enums.PlayerItem,
_echoes_enums.PlayerItem,
_corruption_enums.PlayerItem,
_dkc_returns_enums.PlayerItem,
_prime_remastered_enums.PlayerItem
]
PositionType = typing.Union[
_corruption_enums.PositionType,
_dkc_returns_enums.PositionType
]
Priority = typing.Union[
_corruption_enums.Priority,
_dkc_returns_enums.Priority
]
RevolutionControlType = typing.Union[
_corruption_enums.RevolutionControlType,
_dkc_returns_enums.RevolutionControlType
]
RevolutionVirtualControl = typing.Union[
_corruption_enums.RevolutionVirtualControl,
_dkc_returns_enums.RevolutionVirtualControl
]
ScanSpeed = typing.Union[
_prime_enums.ScanSpeed,
_echoes_enums.ScanSpeed,
_corruption_enums.ScanSpeed
]
ShadowProjection = typing.Union[
_corruption_enums.ShadowProjection,
_dkc_returns_enums.ShadowProjection
]
ShakeShape = typing.Union[
_corruption_enums.ShakeShape,
_dkc_returns_enums.ShakeShape
]
Shape = typing.Union[
_corruption_enums.Shape,
_dkc_returns_enums.Shape
]
SplineInput = typing.Union[
_dkc_returns_enums.SplineInput,
_dkc_returns_enums.SplineInput
]
SplineType = typing.Union[
_corruption_enums.SplineType,
_dkc_returns_enums.SplineType
]
State = typing.Union[
_prime_enums.State,
_echoes_enums.State,
_corruption_enums.State,
_dkc_returns_enums.State
]
SurfaceType = typing.Union[
_corruption_enums.SurfaceType,
_dkc_returns_enums.SurfaceType
]
Type = typing.Union[
_corruption_enums.Type,
_dkc_returns_enums.Type
]
VisorFlags = typing.Union[
_prime_enums.VisorFlags,
_echoes_enums.VisorFlags,
_prime_remastered_enums.VisorFlags
]
WeaponType = typing.Union[
_prime_enums.WeaponType,
_echoes_enums.WeaponType
]
WorldLightingOptions = typing.Union[
_prime_enums.WorldLightingOptions,
_echoes_enums.WorldLightingOptions,
_corruption_enums.WorldLightingOptions,
_dkc_returns_enums.WorldLightingOptions
] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/enums/shared_enums.py | 0.533884 | 0.156137 | shared_enums.py | pypi |
import enum
import typing
import struct
class State(enum.Enum):
NonZero = '!ZER'
ACQU = 'ACQU'
Active = 'ACTV'
AILogicState1 = 'AIS1'
AILogicState2 = 'AIS2'
AILogicState3 = 'AIS3'
AnimOver = 'ANMO'
AnimStart = 'ANMS'
Approach = 'APRC'
Arrived = 'ARRV'
AttachedCollisionObject = 'ATCL'
AttachedAnimatedObject = 'ATOB'
ATPA = 'ATPA'
Attack = 'ATTK'
BEZR = 'BEZR'
BallIceXDamage = 'BIDG'
BeginScan = 'BSCN'
BSPL = 'BSPL'
BallXDamage = 'BXDG'
CINT = 'CINT'
Closed = 'CLOS'
Connect = 'CONN'
CameraPath = 'CPTH'
CROM = 'CROM'
CameraTarget = 'CTGT'
CameraTime = 'CTIM'
Damage = 'DAMG'
DBMB = 'DBMB'
Dead = 'DEAD'
DeGenerate = 'DGNR'
Down = 'DOWN'
DarkXDamage = 'DRKX'
Entered = 'ENTR'
EndScan = 'ESCN'
Exited = 'EXIT'
Footstep = 'FOOT'
FOVP = 'FOVP'
Freeze = 'FREZ'
GRN0 = 'GRN0'
GRN1 = 'GRN1'
Generate = 'GRNT'
InheritBounds = 'IBND'
Inactive = 'ICTV'
IceXDamage = 'IDMG'
Inside = 'INSD'
InternalState0 = 'IS00'
InternalState1 = 'IS01'
InternalState2 = 'IS02'
InternalState3 = 'IS03'
InternalState4 = 'IS04'
InternalState5 = 'IS05'
InternalState6 = 'IS06'
InternalState7 = 'IS07'
InternalState8 = 'IS08'
InternalState9 = 'IS09'
InternalState10 = 'IS10'
InternalState11 = 'IS11'
InternalState12 = 'IS12'
InternalState13 = 'IS13'
InternalState14 = 'IS14'
InternalState15 = 'IS15'
InternalState16 = 'IS16'
InternalState17 = 'IS17'
InternalState18 = 'IS18'
InternalState19 = 'IS19'
IS20 = 'IS20'
IS21 = 'IS21'
IS22 = 'IS22'
IS23 = 'IS23'
IS24 = 'IS24'
IS25 = 'IS25'
IS26 = 'IS26'
IS27 = 'IS27'
IS28 = 'IS28'
IS29 = 'IS29'
IS30 = 'IS30'
IS31 = 'IS31'
IS32 = 'IS32'
IS33 = 'IS33'
IS34 = 'IS34'
IS35 = 'IS35'
IS36 = 'IS36'
IS37 = 'IS37'
IS38 = 'IS38'
IS39 = 'IS39'
IS40 = 'IS40'
IS41 = 'IS41'
IS44 = 'IS44'
IS45 = 'IS45'
IS46 = 'IS46'
IS47 = 'IS47'
IS48 = 'IS48'
DrawAfter = 'LDWA'
DrawBefore = 'LDWB'
Left = 'LEFT'
LINR = 'LINR'
Locked = 'LOCK'
ThinkAfter = 'LTKA'
ThinkBefore = 'LTKB'
MaxReached = 'MAXR'
Modify = 'MDFY'
MOTP = 'MOTP'
MOTS = 'MOTS'
NEXT = 'NEXT'
Open = 'OPEN'
ORBO = 'ORBO'
Play = 'PLAY'
PLRP = 'PLRP'
PressA = 'PRSA'
PressB = 'PRSB'
PressStart = 'PRST'
PressX = 'PRSX'
PressY = 'PRSY'
PressZ = 'PRSZ'
Patrol = 'PTRL'
DeathRattle = 'RATL'
RCRM = 'RCRM'
SpawnResidue = 'RDUE'
ReflectedDamage = 'REFD'
ResistedDamage = 'RESD'
Right = 'RGHT'
Relay = 'RLAY'
RotationOver = 'ROTO'
RotationStart = 'ROTS'
Retreat = 'RTRT'
ScanDone = 'SCND'
ScanSource = 'SCNS'
SE01 = 'SE01'
SE02 = 'SE02'
SE03 = 'SE03'
Slave = 'SLAV'
SpawnLargeCreatures = 'SLCR'
SpawnMediumCreatures = 'SMCR'
Sequence = 'SQNC'
SpawnSmallCreatures = 'SSCR'
TGTO = 'TGTO'
TGTP = 'TGTP'
TGTS = 'TGTS'
UnFreeze = 'UFRZ'
Unlocked = 'ULCK'
Up = 'UP '
WLTE = 'WLTE'
BackToFront = 'XB2F'
XDamage = 'XDMG'
FrontToBack = 'XF2B'
InBack = 'XINB'
InFront = 'XINF'
Outside = 'XOUT'
Zero = 'ZERO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Message(enum.Enum):
Action = 'ACTN'
Activate = 'ACTV'
Alert = 'ALRT'
ARRV = 'ARRV'
Attach = 'ATCH'
AttachInstance = 'ATCI'
Close = 'CLOS'
ClearOriginator = 'CORG'
Deactivate = 'DCTV'
Decrement = 'DECR'
Down = 'DOWN'
Escape = 'ESCP'
FadeIn = 'FADI'
FadeOut = 'FADO'
Follow = 'FOLW'
InternalMessage0 = 'IM00'
InternalMessage1 = 'IM01'
InternalMessage2 = 'IM02'
InternalMessage3 = 'IM03'
InternalMessage4 = 'IM04'
InternalMessage5 = 'IM05'
InternalMessage6 = 'IM06'
InternalMessage7 = 'IM07'
InternalMessage8 = 'IM08'
InternalMessage9 = 'IM09'
InternalMessage10 = 'IM10'
InternalMessage11 = 'IM11'
InternalMessage12 = 'IM12'
InternalMessage13 = 'IM13'
InternalMessage14 = 'IM14'
InternalMessage15 = 'IM15'
InternalMessage16 = 'IM16'
InternalMessage17 = 'IM17'
InternalMessage18 = 'IM18'
InternalMessage19 = 'IM19'
IM20 = 'IM20'
IM21 = 'IM21'
IM22 = 'IM22'
IM23 = 'IM23'
IM24 = 'IM24'
IM25 = 'IM25'
IM26 = 'IM26'
IM27 = 'IM27'
IM28 = 'IM28'
IM42 = 'IM42'
IM43 = 'IM43'
Increment = 'INCR'
Kill = 'KILL'
Left = 'LEFT'
Load = 'LOAD'
Lock = 'LOCK'
Next = 'NEXT'
_None = 'NONE'
OFF = 'OFF '
ON = 'ON '
OPEN = 'OPEN'
PLAY = 'PLAY'
Right = 'RGHT'
RMOV = 'RMOV'
RSAN = 'RSAN'
Reset = 'RSET'
RSTP = 'RSTP'
ResetAndStart = 'RSTS'
StopAllSounds = 'SALL'
StopAllLoopedSounds = 'SALP'
SetToMax = 'SMAX'
SetOriginator = 'SORG'
Stop = 'STOP'
StopAndReset = 'STPR'
Start = 'STRT'
ToggleActive = 'TCTV'
ToggleOpen = 'TOPN'
Unlock = 'ULCK'
Unload = 'ULOD'
Up = 'UP '
AreaLoaded = 'XALD'
AcidOnVisor = 'XAOV'
AIUpdateDisabled = 'XAUD'
AreaUnloading = 'XAUL'
Clear = 'XCLR'
Create = 'XCRT'
Delete = 'XDEL'
XDMG = 'XDMG'
EnteredFluid = 'XENF'
XENT = 'XENT'
EnteredPhazonPool = 'XEPZ'
ExitedFluid = 'XEXF'
Falling = 'XFAL'
HitObject = 'XHIT'
InsideFluid = 'XINF'
InShrubbery = 'XINS'
InsidePhazonPool = 'XIPZ'
Launching = 'XLAU'
Landed = 'XLND'
LandedOnStaticGround = 'XLSG'
OffGround = 'XOFF'
OnDirt = 'XOND'
OnIce = 'XONI'
OnOrganic = 'XONO'
OnPlatform = 'XONP'
XRDG = 'XRDG'
WorldLoaded = 'XWLD'
XXDG = 'XXDG'
ExitedPhazonPool = 'XXPZ'
SetToZero = 'ZERO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Achievement(enum.IntEnum):
Unknown1 = 1290095210
Unknown2 = 1741167017
Unknown3 = 1941731395
Unknown4 = 1847676886
Unknown5 = 42311112
Unknown6 = 2302821108
Unknown7 = 3685060452
Unknown8 = 2575337497
Unknown9 = 977778753
Unknown10 = 1741569191
Unknown11 = 3796894174
Unknown12 = 2288784460
Unknown13 = 2046095677
Unknown14 = 3347275427
Unknown15 = 1815168570
Unknown16 = 1015929027
Unknown17 = 105107473
Unknown18 = 80518716
Unknown19 = 1831985480
Unknown20 = 1831093832
Unknown21 = 4096595954
Unknown22 = 2200577892
Unknown23 = 1437187765
Unknown24 = 291959200
Unknown25 = 3841084878
Unknown26 = 3936228971
Unknown27 = 246361685
Unknown28 = 761891303
Unknown29 = 3831947482
Unknown30 = 1643699619
Unknown31 = 1845492504
Unknown32 = 3065393673
Unknown33 = 2316897795
Unknown34 = 3682273482
Unknown35 = 2320145227
Unknown36 = 2373462654
Unknown37 = 2327213834
Unknown38 = 3078454223
Unknown39 = 923107635
Unknown40 = 964468362
Unknown41 = 3917812391
Unknown42 = 3278886900
Unknown43 = 1516668494
Unknown44 = 761378520
Unknown45 = 3986936146
Unknown46 = 311100150
Unknown47 = 1276826815
Unknown48 = 3582734640
Unknown49 = 159852610
Unknown50 = 3670289904
Unknown51 = 3035079377
Unknown52 = 2621245633
Unknown53 = 87316859
Unknown54 = 1915972077
Unknown55 = 3965189198
Unknown56 = 675653541
Unknown57 = 1583013528
Unknown58 = 3845519601
Unknown59 = 1020841902
Unknown60 = 2754677268
Unknown61 = 2238270125
Unknown62 = 2159809142
Unknown63 = 3026027834
Unknown64 = 1534640759
Unknown65 = 260599856
Unknown66 = 118390863
Unknown67 = 1657177142
Unknown68 = 1896894749
Unknown69 = 3803117518
Unknown70 = 1923499191
Unknown71 = 2458173973
Unknown72 = 335555508
Unknown73 = 3394623414
Unknown74 = 800279568
Unknown75 = 392796523
Unknown76 = 3511454777
Unknown77 = 1611981353
Unknown78 = 1331676611
Unknown79 = 4154542500
Unknown80 = 3931564681
Unknown81 = 380595334
Unknown82 = 470973530
Unknown83 = 2698926786
Unknown84 = 2439373502
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class AreaState(enum.IntEnum):
Unknown1 = 3421935818
Unknown2 = 3169953884
Unknown3 = 637073894
Unknown4 = 1392494960
Unknown5 = 3432733907
Unknown6 = 3147590725
Unknown7 = 580206079
Unknown8 = 1435635049
Unknown9 = 3308065016
Unknown10 = 2989105262
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CameraMode(enum.IntEnum):
Unknown1 = 2247187997
Unknown2 = 2392533015
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CinematicStartType(enum.IntEnum):
Unknown1 = 3248813110
Unknown2 = 2415426910
Unknown3 = 3516177437
Unknown4 = 2852706775
Unknown5 = 1552481122
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CinematicEndsType(enum.IntEnum):
Unknown1 = 1671241623
Unknown2 = 3042939236
Unknown3 = 1097122971
Unknown4 = 4076161679
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Blend_Mode(enum.IntEnum):
Unknown1 = 3843753963
Unknown2 = 4195520078
Unknown3 = 2767891128
Unknown4 = 3057539653
Unknown5 = 3505979826
Unknown6 = 188796281
Unknown7 = 2832859382
Unknown8 = 843861036
Unknown9 = 144217437
Unknown10 = 2495447389
Unknown11 = 2676901319
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class RotationBlendMode(enum.IntEnum):
Unknown1 = 3792314206
Unknown2 = 687395058
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Mode(enum.IntEnum):
Unknown1 = 1123045001
Unknown2 = 2484558442
Unknown3 = 3387220509
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ControllerType(enum.IntEnum):
Unknown1 = 3024507316
Unknown2 = 268540483
Unknown3 = 1722423905
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ReticuleType(enum.IntEnum):
Unknown1 = 1652108937
Unknown2 = 1286894661
Unknown3 = 3349492343
Unknown4 = 1604604469
Unknown5 = 2885722417
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Unknown(enum.IntEnum):
Unknown1 = 3630416747
Unknown2 = 2705574041
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class DefaultSelection(enum.IntEnum):
Unknown1 = 703550369
Unknown2 = 3553383554
Unknown3 = 2736090902
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Unknown(enum.IntEnum):
Unknown1 = 3257279650
Unknown2 = 3130803243
Unknown3 = 3689862982
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class MessageType(enum.IntEnum):
Unknown1 = 903903793
Unknown2 = 20004303
Unknown3 = 353225947
Unknown4 = 3457428906
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PathCurveType(enum.IntEnum):
Unknown1 = 4117718896
Unknown2 = 2494257178
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ProxyType(enum.IntEnum):
Unknown1 = 3560604011
Unknown2 = 3638325778
Unknown3 = 2293645153
Unknown4 = 2459374031
Unknown5 = 2561452093
Unknown6 = 3823934638
Unknown7 = 1939145129
Unknown8 = 1377309871
Unknown9 = 2544156382
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class EnvironmentEffects(enum.IntEnum):
Unknown1 = 4188577367
Unknown2 = 2965060395
Unknown3 = 829035573
Unknown4 = 187254247
Unknown5 = 1692838265
Unknown6 = 2922967539
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PhazonDamage(enum.IntEnum):
Unknown1 = 4044895378
Unknown2 = 278612995
Unknown3 = 306082665
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Priority(enum.IntEnum):
Unknown1 = 477433555
Unknown2 = 984224020
Unknown3 = 3559813316
Unknown4 = 464330772
Unknown5 = 2642601662
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class SurfaceType(enum.IntEnum):
Unknown1 = 4034626066
Unknown2 = 2580263885
Unknown3 = 653395187
Unknown4 = 1331085964
Unknown5 = 1691976390
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Unknown(enum.IntEnum):
Unknown1 = 2345054103
Unknown2 = 1079738432
Unknown3 = 238894302
Unknown4 = 4050431932
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Function(enum.IntEnum):
What = 2563092183
Function1Unused = 240618207
Function2Unused = 1025145004
Function3Unused = 326062726
BossEnergyBar = 923750542
CinematicSkip = 696482924
Function6Unused = 1225168693
Credits = 3035969
CountdownTimer = 2662821358
Function9Unused = 347364662
Function10Unused = 1986974736
Function11Unused = 3587238547
EndGame = 2114084116
GameEndChoice = 2285426762
Function14Unused = 346273372
Function15Unused = 3153780527
ExtraRenderClipPlane = 749815580
Function17Unused = 3486029411
Function18Unused = 3631301918
GameStateEnvVar = 1713293792
HUDTarget = 478141611
SimpleHint = 2830122522
Function22Unused = 3778572771
LaunchPlayer = 2416123537
MapStation = 740148357
Function25Unused = 3053209948
Inventorything = 2471085421
ModifyInventory = 1770695450
PermanentHypermode = 2206760967
Function29Unused = 3243946594
ObjectFollowsomething = 100545803
ObjectFollowLocator = 2552906403
ObjectFollowObject = 1937834755
OcclusionRelay = 2662250874
CockpitLightsLinkToPlayerArm = 4135506313
Function35Unused = 1854158585
Function36Unused = 653498141
PlayerFollowLocator = 4285373414
PlayerInArea = 4265730537
RadarRangeOverride = 1715427716
Function40Unused = 2615468805
CockpitDisplayHelmetOnMap = 2023938588
SaveStationCheckpoint = 3039339760
SetarmorformorphtoGhor = 1993807369
SetSuitType = 2401398557
Function46Unused = 1142615654
Function47Unused = 3847325796
TinCanScore = 1345026962
Function49Unused = 2209351239
Function50Unused = 2131551016
RotateSkybox = 1875478250
WaypointOverrider = 1385398492
PhaazeHypermodeHUDSwitch = 1447080691
StaticWorldRenderController = 2123107635
SunGenerator = 3621975599
Function56Unused = 3756334726
ViewFrustumTester = 312252864
VisorBlowout = 4147516617
Function59Unused = 3504523875
KillPlayer = 507958412
Unknown = 387758027
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ExtraInfo(enum.IntEnum):
Unknown1 = 3424517365
Unknown2 = 3314683043
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class VolumeType(enum.IntEnum):
Unknown1 = 2487228356
Unknown2 = 3796633071
Unknown3 = 4268377914
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class FilterShape(enum.IntEnum):
Unknown1 = 1454381642
Unknown2 = 1825123770
Unknown3 = 2968864876
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Type(enum.IntEnum):
Unknown1 = 4190668287
Unknown2 = 3649059742
Unknown3 = 2346587055
Unknown4 = 3272497734
Unknown5 = 4170916833
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Shape(enum.IntEnum):
Box = 2006824261
Ellipsoid = 2207446500
Cylinder = 971864974
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ActorMaterialType(enum.IntEnum):
kMT_Unknown = 3498468170
kMT_Stone = 1104775585
kMT_Metal = 2560325698
kMT_Grass = 4042527608
kMT_Ice = 173689903
kMT_MetaGrating = 35715264
kMT_Phazon = 687970960
kMT_Dirt = 114101165
kMT_SP_Metal = 520586891
kMT_Glass = 1077031892
kMT_Snow = 2821279656
kMT_Shield = 3064176193
kMT_Sand = 1053849610
kMT_SeedOrganics = 3543027614
kMT_Web = 3571249264
kMT_Wood = 2721575702
kMT_Organic = 1369290280
kMT_Rubber = 316113227
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ActorCollisionResponse(enum.IntEnum):
kACR_Default = 3733775805
Unknown2 = 652573799
Unknown3 = 1071627662
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class BerserkerEnum(enum.IntEnum):
Unknown1 = 2457151020
Unknown2 = 2362448510
Unknown3 = 2161792701
Unknown4 = 4046075334
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class BonusCredit(enum.IntEnum):
Unknown1 = 3550818934
Unknown2 = 725797134
Unknown3 = 828710715
Unknown4 = 3149230457
Unknown5 = 3214133816
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CableEnum(enum.IntEnum):
Unknown1 = 2161975732
Unknown2 = 617560305
Unknown3 = 590757843
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CableBloom(enum.IntEnum):
Unknown1 = 1131364394
Unknown2 = 3535683408
Unknown3 = 3476137679
Unknown4 = 1255115501
Unknown5 = 176197152
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CableLighting(enum.IntEnum):
Unknown1 = 746881774
Unknown2 = 596484757
Unknown3 = 654430001
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CableType(enum.IntEnum):
Unknown1 = 2487912838
Unknown2 = 3596787146
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class SplineType(enum.IntEnum):
Unknown1 = 3115803663
Unknown2 = 3253497337
Unknown3 = 3709664811
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ImpulseLocation(enum.IntEnum):
Unknown1 = 2161975732
Unknown2 = 590757843
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class FOVType(enum.IntEnum):
Unknown1 = 2839405128
Unknown2 = 2549691886
Unknown3 = 974872831
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class FOVPathObject(enum.IntEnum):
Unknown1 = 221052433
Unknown2 = 3545934728
Unknown3 = 2921949809
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CollisionType(enum.IntEnum):
Unknown1 = 2969932169
Unknown2 = 889975228
Unknown3 = 101998339
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class OrientationType(enum.IntEnum):
Unknown1 = 1973921119
Unknown2 = 688861620
Unknown3 = 648890987
Unknown4 = 1486504153
Unknown5 = 3322825525
Unknown6 = 3306457822
Unknown7 = 1814657251
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class LookAtType(enum.IntEnum):
Unknown1 = 869408558
Unknown2 = 3208351709
Unknown3 = 3923417272
Unknown4 = 1224849172
Unknown5 = 3331078636
Unknown6 = 4226777021
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class DistanceDirectionMethod(enum.IntEnum):
Unknown1 = 1531303199
Unknown2 = 3341593124
Unknown3 = 4205502699
Unknown4 = 3784644380
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PositionType(enum.IntEnum):
Unknown1 = 3258570459
Unknown2 = 700093416
Unknown3 = 2482478106
Unknown4 = 1505753942
Unknown5 = 279679312
Unknown6 = 330387643
Unknown7 = 2897552223
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ShakeShape(enum.IntEnum):
Unknown1 = 1492241241
Unknown2 = 1817964322
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ColliderPositionType(enum.IntEnum):
Unknown1 = 3074795145
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Command(enum.IntEnum):
Unknown1 = 3901647376
Unknown2 = 2581939688
Unknown3 = 2750450586
Unknown4 = 899849925
Unknown5 = 109932284
Unknown6 = 2446731085
Unknown7 = 3803725138
Unknown8 = 2690424049
Unknown9 = 3699295922
Unknown10 = 3996274175
Unknown11 = 137873876
Unknown12 = 2167747411
Unknown13 = 1231245019
Unknown14 = 726214613
Unknown15 = 1423451252
Unknown16 = 3416415133
Unknown17 = 4079415854
Unknown18 = 55864240
Unknown19 = 3156750812
Unknown20 = 1848293130
Unknown21 = 1773328712
Unknown22 = 4121744237
Unknown23 = 541928560
Unknown24 = 1699049272
Unknown25 = 1875089819
Unknown26 = 785211435
Unknown27 = 1067837646
Unknown28 = 3534481192
Unknown29 = 1362252510
Unknown30 = 1135613235
Unknown31 = 1130843359
Unknown32 = 1387487870
Unknown33 = 2991816435
Unknown34 = 1198525559
Unknown35 = 994331281
Unknown36 = 1292212532
Unknown37 = 3991851469
Unknown38 = 1233152379
Unknown39 = 3553892191
Unknown40 = 2579448604
Unknown41 = 2930622747
Unknown42 = 2686272281
Unknown43 = 4237958029
Unknown44 = 4155323971
Unknown45 = 1805149946
Unknown46 = 3844960534
Unknown47 = 3521809460
Unknown48 = 4101879789
Unknown49 = 2528966795
Unknown50 = 980624810
Unknown51 = 343759879
Unknown52 = 4223842739
Unknown53 = 283049438
Unknown54 = 3520575665
Unknown55 = 600453719
Unknown56 = 1968064456
Unknown57 = 3727723490
Unknown58 = 3098082481
Unknown59 = 2567258098
Unknown60 = 2867761147
Unknown61 = 3479224811
Unknown62 = 534585026
Unknown63 = 2992259733
Unknown64 = 637210426
Unknown65 = 2159907274
Unknown66 = 3861243545
Unknown67 = 2901285394
Unknown68 = 2051261897
Unknown69 = 1719198263
Unknown70 = 340038035
Unknown71 = 1288278651
Unknown72 = 3321121544
Unknown73 = 4107107956
Unknown74 = 2877067267
Unknown75 = 652527973
Unknown76 = 3415844723
Unknown77 = 1461157841
Unknown78 = 1789003583
Unknown79 = 3521624545
Unknown80 = 3228790715
Unknown81 = 2800425192
Unknown82 = 2967516577
Unknown83 = 996654954
Unknown84 = 1684683972
Unknown85 = 1520854483
Unknown86 = 2724605556
Unknown87 = 3305003303
Unknown88 = 2148884262
Unknown89 = 1360235495
Unknown90 = 714095169
Unknown91 = 2053486089
Unknown92 = 315811492
Unknown93 = 984481977
Unknown94 = 3923398827
Unknown95 = 322153173
Unknown96 = 764797371
Unknown97 = 3425615115
Unknown98 = 3298385702
Unknown99 = 2228281338
Invalid1 = 2151003287
Invalid2 = 156891041
Invalid3 = 2599178616
Invalid4 = 3674132153
Invalid5 = 1530671344
Invalid6 = 1448630541
Invalid7 = 1820496063
Invalid8 = 818144998
Invalid9 = 3113676861
Invalid10 = 3808326893
Invalid11 = 2983710080
Invalid12 = 3568842610
Invalid13 = 1948874982
Invalid14 = 179696054
Invalid15 = 1301198552
Invalid16 = 722911627
Invalid17 = 1603950717
Invalid18 = 2910162076
Invalid19 = 1019209684
Invalid20 = 2248942576
Invalid21 = 3594513416
Invalid22 = 177089843
Invalid23 = 1225243796
Invalid24 = 794959369
Invalid25 = 4221452702
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ConvergenceType(enum.IntEnum):
Unknown1 = 197952338
Unknown2 = 10840534
Unknown3 = 2916633979
Unknown4 = 1845080979
Unknown5 = 2654787412
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class DI_WeaponType(enum.IntEnum):
Power = 2410944582
Plasma = 1118216892
Nova = 2134273114
Phazon = 444481760
Missile = 17740316
ScrewAttack = 2604127627
AI = 3161493559
Friendly = 3441875184
UnknownSource = 1243625939
Electric = 4160790275
PoisonWater = 3877195498
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class DamageableTriggerEnum(enum.IntEnum):
Unknown1 = 498294111
Unknown2 = 1637064024
Unknown3 = 945710146
Unknown4 = 210876390
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class FOVType(enum.IntEnum):
Unknown1 = 706440702
Unknown2 = 1282771462
Unknown3 = 2230438793
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class FluidType(enum.IntEnum):
Unknown1 = 1425213472
Unknown2 = 230544723
Unknown3 = 1204522302
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Bloom(enum.IntEnum):
Unknown1 = 1222417634
Unknown2 = 759120936
Unknown3 = 413038581
Unknown4 = 3476137679
Unknown5 = 1255115501
Unknown6 = 131148223
Unknown7 = 176197152
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Unknown(enum.IntEnum):
Unknown1 = 3516796033
Unknown2 = 3364175296
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class HyperModeType(enum.IntEnum):
Unknown1 = 2781966248
Unknown2 = 440171881
Unknown3 = 4246244689
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class InterpolationControlType(enum.IntEnum):
Unknown1 = 1464541212
Unknown2 = 3715904643
Unknown3 = 3342922233
Unknown4 = 4055225324
Unknown5 = 3980215693
Unknown6 = 1935003390
Unknown7 = 881774861
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class MotionType(enum.IntEnum):
Unknown1 = 864275068
Unknown2 = 4166922378
Unknown3 = 3471808923
Unknown4 = 1896907209
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class WorldLightingOptions(enum.IntEnum):
Unknown1 = 0
NormalWorldLighting = 1
Unknown2 = 2
DisableWorldLighting = 3
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class MiscControls_UnknownEnum1(enum.IntEnum):
Unknown1 = 3138569503
Unknown2 = 3604958465
Unknown3 = 1504980732
Unknown4 = 3891005505
Unknown5 = 4199960577
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class MotionType(enum.IntEnum):
Unknown1 = 2003923368
Unknown2 = 1102650983
Unknown3 = 62257768
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class OffsetType(enum.IntEnum):
Unknown1 = 2512106878
Unknown2 = 142006047
Unknown3 = 3952570983
Unknown4 = 3725467126
Unknown5 = 1409063055
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class OrientationType(enum.IntEnum):
Unknown1 = 894727893
Unknown2 = 1703284864
Unknown3 = 2424825473
Unknown4 = 293088044
Unknown5 = 1061457362
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PIDType(enum.IntEnum):
Unknown1 = 1220683900
Unknown2 = 1517782930
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PathLinkType(enum.IntEnum):
Unknown1 = 3955847150
Unknown2 = 3844849857
Unknown3 = 1461363479
Unknown4 = 3983564465
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PathDeterminationMethod(enum.IntEnum):
Unknown1 = 368071499
Unknown2 = 866990353
Unknown3 = 1330523455
Unknown4 = 1762871141
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class InitialPosition(enum.IntEnum):
Unknown1 = 3529489810
Unknown2 = 3079009261
Unknown3 = 2952273734
Unknown4 = 237832937
Unknown5 = 635227635
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Curvature(enum.IntEnum):
Unknown1 = 3115803663
Unknown2 = 1176110616
Unknown3 = 3253497337
Unknown4 = 2350587168
Unknown5 = 3709664811
Unknown6 = 1108898616
Unknown7 = 1705490000
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PhysicalControl(enum.IntEnum):
Unknown1 = 538784560
Unknown2 = 3795023653
Unknown3 = 2527082480
Unknown4 = 262760010
Unknown5 = 1706296828
Unknown6 = 4240266310
Unknown7 = 3978335045
Unknown8 = 371522223
Unknown9 = 1096604377
Unknown10 = 680639111
Unknown11 = 667200906
Unknown12 = 2697488232
Unknown13 = 1761263604
Unknown14 = 2435665866
Unknown15 = 1593512693
Unknown16 = 514168199
Unknown17 = 1496847900
Unknown18 = 830697549
Unknown19 = 2753380155
Unknown20 = 2017321684
Unknown21 = 1170446731
Unknown22 = 3704277041
Unknown23 = 3114222144
Unknown24 = 1405012678
Unknown25 = 2759137981
Unknown26 = 2577594915
Unknown27 = 1462419467
Unknown28 = 1295727496
Unknown29 = 888257540
Unknown30 = 732122331
Unknown31 = 1712867438
Unknown32 = 2411151363
Unknown33 = 1133573905
Unknown34 = 1168863462
Unknown35 = 3776455486
Unknown36 = 2014409348
Unknown37 = 2238942206
Unknown38 = 4067736424
Unknown39 = 2195767795
Unknown40 = 1803414226
Unknown41 = 2678677379
Unknown42 = 1705403104
Unknown43 = 1923125713
Unknown44 = 438438636
Unknown45 = 713052917
Unknown46 = 1276650918
Unknown47 = 4150513473
Unknown48 = 620168925
Unknown49 = 3133194335
Unknown50 = 2481737266
Unknown51 = 530264547
Unknown52 = 4118034785
Unknown53 = 3915798836
Unknown54 = 2620818456
Unknown55 = 3291423487
Unknown56 = 4205769547
Unknown57 = 4018211503
Unknown58 = 4242657632
Unknown59 = 2593197220
Unknown60 = 2591663667
Unknown61 = 391300525
Unknown62 = 1938441096
Unknown63 = 1047334326
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PhysicalControlBoolean(enum.IntEnum):
Unknown1 = 3437305164
Unknown2 = 1743300625
Unknown3 = 3272702804
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PlayerItem(enum.IntEnum):
PowerBeam = 4218679992
PlasmaBeam = 2477616633
NovaBeam = 1352706725
ChargeUpgrade = 893945120
Missile = 2452465320
IceMissile = 2431700692
SeekerMissile = 3086280557
GrappleBeamPull = 1906007133
GrappleBeamSwing = 522801372
GrappleBeamVoltage = 536233745
Bomb = 3112660177
CombatVisor = 2523287191
ScanVisor = 3016416327
CommandVisor = 1943434474
XRayVisor = 1714103130
DoubleJump = 2512389418
ScrewAttack = 3654131422
SuitType = 3492481752
Energy = 649447109
HypermodeEnergy = 496397544
EnergyTank = 3010129117
ItemPercentage = 1347001155
Fuses = 2881244206
Fuse1 = 862874770
Fuse2 = 2858892584
Fuse3 = 3714059710
Fuse4 = 1124374557
Fuse5 = 872654987
Fuse6 = 2903177521
Fuse7 = 3658336679
Fuse8 = 1253233718
Fuse9 = 1035330720
MorphBall = 1211073077
BoostBall = 2988161223
SpiderBall = 1296127826
HyperModeTank = 1432926409
HyperModeBeam = 1239982508
HyperModeMissile = 1364547232
HyperModeBall = 2353547179
HyperModeGrapple = 2270562373
HyperModePermanent = 2414588173
HyperModePhaaze = 4110398365
HyperModeOriginal = 3854177617
ShipGrapple = 1470237978
ShipMissile = 2174833663
FaceCorruptionLevel = 2109957860
PhazonBall = 1373743611
CannonBall = 2070581050
ActivateMorphballBoost = 3022734302
HyperShot = 2307731988
CommandVisorJammed = 1065514078
Stat_EnemiesKilled = 3227265003
Stat_ShotsFired = 2966561623
Stat_DamageReceived = 3809976091
Stat_DataSaves = 4187912088
Stat_HypermodeUses = 1141429883
Stat_CommandoKills = 1206369514
Stat_TinCanHighScore = 574164774
Stat_TinCanCurrentScore = 951995458
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CollisionType(enum.IntEnum):
Unknown1 = 1750192226
Unknown2 = 500705356
Unknown3 = 2418955086
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class RevolutionControlType(enum.IntEnum):
Unknown1 = 1989807457
Unknown2 = 3492954719
Unknown3 = 2606158878
Unknown4 = 1231291285
Unknown5 = 3555293293
Unknown6 = 1272469130
Unknown7 = 3663496210
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class RevolutionControl_UnknownEnum1(enum.IntEnum):
Unknown1 = 2597642428
Unknown2 = 1190654113
Unknown3 = 2373762245
Unknown4 = 2784335752
Unknown5 = 1553256326
Unknown6 = 3438239968
Unknown7 = 2352913090
Unknown8 = 4049356512
Unknown9 = 3952457493
Unknown10 = 3273432152
Unknown11 = 2212135243
Unknown12 = 329330221
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class RevolutionControl_UnknownEnum2(enum.IntEnum):
Unknown1 = 1154737403
Unknown2 = 967762110
Unknown3 = 1744548478
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class RevolutionVirtualControl(enum.IntEnum):
Unknown1 = 2997493716
Unknown2 = 288465778
Unknown3 = 4009748226
Unknown4 = 3635765891
Unknown5 = 891244416
Unknown6 = 2689619302
Unknown7 = 837808268
Unknown8 = 21086754
Unknown9 = 396303202
Unknown10 = 3664856383
Unknown11 = 3484034738
Unknown12 = 733602211
Unknown13 = 3559541428
Unknown14 = 1097158738
Unknown15 = 280637756
Unknown16 = 3031673392
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ScanSpeed(enum.IntEnum):
Normal = 0
Slow = 1
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ShadowProjection(enum.IntEnum):
Unknown1 = 2220656430
Unknown2 = 2690336603
Unknown3 = 1214374227
Unknown4 = 4117616162
Unknown5 = 3804557437
Unknown6 = 193846629
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class SaveGame(enum.IntEnum):
Unknown1 = 718950382
Unknown2 = 769513116
Unknown3 = 3263590420
Unknown4 = 57119807
Unknown5 = 3218965678
Unknown6 = 634958821
Unknown7 = 3878045253
Unknown8 = 17817487
Unknown9 = 1589020689
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class InterpolantType(enum.IntEnum):
Unknown1 = 3466621951
Unknown2 = 1314609833
Unknown3 = 39922381
Unknown4 = 175739832
Unknown5 = 1623449729
Unknown6 = 2401829323
Unknown7 = 1873684334
Unknown8 = 3103654610
Unknown9 = 2842352988
Unknown10 = 1923990691
Unknown11 = 35890198
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class StaticGeometryTest(enum.IntEnum):
Unknown1 = 996120112
Unknown2 = 3961747340
Unknown3 = 1419069414
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class TeamAIState(enum.IntEnum):
Unknown1 = 4229634895
Unknown2 = 2906748314
Unknown3 = 210580899
Unknown4 = 3276372239
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class TweakGui_UnknownEnum1(enum.IntEnum):
Unknown1 = 4043628561
Unknown2 = 1745727915
Unknown3 = 520782141
Unknown4 = 2171475102
Unknown5 = 4134085640
Unknown6 = 1868592562
Unknown7 = 4292831267
Unknown8 = 1285035198
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class TweakPlayer_AimStuff_UnknownEnum1(enum.IntEnum):
Unknown1 = 3836570269
Unknown2 = 3796405200
Unknown3 = 4233376783
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class TweakPlayer_AimStuff_UnknownEnum2(enum.IntEnum):
Unknown1 = 2531440486
Unknown2 = 313036472
Unknown3 = 576609856
Unknown4 = 2183082095
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class UnknownEnum1(enum.IntEnum):
Unknown1 = 1990589437
Unknown2 = 2503861812
Unknown3 = 2707747667
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Unknown(enum.IntEnum):
Unknown1 = 2868300453
Unknown2 = 881720149
Unknown3 = 1464639200
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ScriptWeaponType(enum.IntEnum):
Unknown1 = 2667276721
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class CollisionChecks(enum.IntEnum):
Unknown1 = 2950079402
Unknown2 = 3581750714
Unknown3 = 2877254144
Unknown4 = 731683444
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/enums/corruption.py | 0.402627 | 0.153803 | corruption.py | pypi |
import enum
import typing
import struct
class State(enum.IntEnum):
Active = 0x0
Arrived = 0x1
Closed = 0x2
Entered = 0x3
Exited = 0x4
Inactive = 0x5
Inside = 0x6
MaxReached = 0x7
Open = 0x8
Zero = 0x9
Attack = 0xA
UnknownState1 = 0xB
Retreat = 0xC
Patrol = 0xD
Dead = 0xE
CameraPath = 0xF
CameraTarget = 0x10
UnknownState2 = 0x11
Play = 0x12
UnknownState3 = 0x13
DeathRattle = 0x14
UnknownState4 = 0x15
Damage = 0x16
UnknownState5 = 0x17
UnknownState6 = 0x18
Modify = 0x19
ScanDone = 0x1C
DFST = 0x1E
ReflectedDamage = 0x1F
InheritBounds = 0x20
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Message(enum.IntEnum):
Activate = 0x1
UnknownMessage1 = 0x2
Close = 0x3
Deactivate = 0x4
Decrement = 0x5
Follow = 0x6
Increment = 0x7
Next = 0x8
Open = 0x9
Reset = 0xA
ResetAndStart = 0xB
SetToMax = 0xC
SetToZero = 0xD
Start = 0xE
Stop = 0xF
StopAndReset = 0x10
ToggleActive = 0x11
UnknownMessage2 = 0x12
Action = 0x13
Play = 0x14
Alert = 0x15
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class TriggerFlags(enum.IntFlag):
DetectPlayer = 1
DetectAI = 2
DetectProjectiles = 1024
DetectBombs = 64
Unknown1 = 128
KillOnEntered = 2048
DetectMorphedPlayer = 4096
ApplyForce = 8192
DetectPlayerIfCompletelyInside = 16384
Unknown2 = 32768
DetectUnmorphedPlayer = 65536
BlockEnvironmentalEffects = 131072
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class MemoType(enum.IntEnum):
StatusMessage = 0
MessageBox = 1
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class RenderSide(enum.IntEnum):
_None = 0
North = 1
South = 2
West = 4
East = 8
Top = 16
Bottom = 32
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Flags(enum.IntFlag):
PendingAmbush = 1
CeilingAmbush = 2
NonAggressive = 4
Melee = 8
NoShuffleCloseCheck = 16
OnlyAttackInRange = 32
Unknown = 64
NoKnockbackImpulseReset = 128
NoMeleeAttack = 512
BreakAttack = 1024
Seated = 4096
ShadowPirate = 8192
AlertBeforeCloak = 16384
NoBreakDamage = 32768
FloatingCorpse = 65536
RagdollNoAiCollision = 131072
Trooper = 262144
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class Function(enum.IntEnum):
Function0 = 0
PlayerFollowLocator = 1
SpinnerController = 2
ObjectFollowLocator = 3
Function4 = 4
InventoryActivator = 5
MapStation = 6
SaveStation = 7
IntroBossRingController = 8
ViewFrustumTesterUnused = 9
ShotSpinnerController = 10
EscapeSequence = 11
BossEnergyBar = 12
EndGame = 13
HUDFadeIn = 14
CinematicSkip = 15
ScriptLayerController = 16
RainSimulator = 17
AreaDamage = 18
ObjectFollowObjectUnused = 19
RedundantHintSystem = 20
DropBomb = 21
Function22 = 22
MissileStation = 23
Billboard = 24
PlayerInAreaRelay = 25
HUDTarget = 26
FogFader = 27
EnterLogbookScreen = 28
PowerBombStation = 29
Ending = 30
FusionRelay = 31
WeaponSwitchPALonly = 32
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class EnvironmentalEffect(enum.IntEnum):
_None = 0
Snow = 1
Rain = 2
Bubbles = 3
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PhazonType(enum.IntEnum):
_None = 0
Blue = 1
Orange = 2
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ControllerMapping(enum.IntEnum):
_None = 0
LeftStickUp = 1
LeftStickDown = 2
LeftStickLeft = 3
LeftStickRight = 4
RightStickUp = 5
RightStickDown = 6
RightStickLeft = 7
RightStickRight = 8
LeftTrigger = 9
RightTrigger = 10
DPadUp = 11
DPadDown = 12
DPadLeft = 13
DPadRight = 14
AButton = 15
BButton = 16
XButton = 17
YButton = 18
ZButton = 19
LeftTriggerPress = 20
RightTriggerPress = 21
Start = 22
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class HelmetVisMode(enum.IntEnum):
ReducedUpdate = 0
NotVisible = 1
Deco = 2
HelmetDeco = 3
GlowHelmetDeco = 4
HelmetOnly = 5
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class HudVisMode(enum.IntEnum):
One = 0
Two = 1
Three = 2
Four = 3
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class WorldLightingOptions(enum.IntEnum):
Unknown1 = 0
NormalWorldLighting = 1
Unknown2 = 2
DisableWorldLighting = 3
Unknown3 = 4
Unknown4 = 5
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class LightRecalculationOptions(enum.IntEnum):
Never = 0
_8Frames = 1
_4Frames = 2
EveryFrame = 3
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class LogbookCategory(enum.IntEnum):
_None = 0
SpacePirateData = 1
ChozoLore = 2
Creatures = 3
Research = 4
Artifacts = 5
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PlayerAction(enum.IntEnum):
Forward = 0
Backward = 1
TurnLeft = 2
TurnRight = 3
StrafeLeft = 4
StrafeRight = 5
LookLeft = 6
LookRight = 7
LookUp = 8
LookDown = 9
JumpBoost = 10
FireBomb = 11
MissilePowerBomb = 12
Morph = 13
AimUp = 14
AimDown = 15
CycleBeamUp = 16
CycleBeamDown = 17
CycleItem = 18
PowerBeam = 19
IceBeam = 20
WaveBeam = 21
PlasmaBeam = 22
ToggleHolster = 23
OrbitClose = 24
OrbitFar = 25
OrbitObject = 26
OrbitSelect = 27
OrbitConfirm = 28
OrbitLeft = 29
OrbitRight = 30
OrbitUp = 31
OrbitDown = 32
LookHold1 = 33
LookHold2 = 34
LookZoomIn = 35
LookZoomOut = 36
AimHold = 37
MapCircleUp = 38
MapCircleDown = 39
MapCircleLeft = 40
MapCircleRight = 41
MapMoveForward = 42
MapMoveBack = 43
MapMoveLeft = 44
MapMoveRight = 45
MapZoomIn = 46
MapZoomOut = 47
SpiderBall = 48
ChaseCamera = 49
XRayVisor = 50
ThermoVisor = 51
EnviroVisor = 52
NoVisor = 53
VisorMenu = 54
VisorUp = 55
VisorDown = 56
UNKNOWN = 66
UseShield = 59
ScanItem = 60
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PlayerItem(enum.IntEnum):
PowerBeam = 0
IceBeam = 1
WaveBeam = 2
PlasmaBeam = 3
Missile = 4
ScanVisor = 5
MorphBallBomb = 6
PowerBomb = 7
Flamethrower = 8
ThermalVisor = 9
ChargeBeam = 10
SuperMissile = 11
GrappleBeam = 12
XRayVisor = 13
IceSpreader = 14
SpaceJumpBoots = 15
MorphBall = 16
CombatVisor = 17
BoostBall = 18
SpiderBall = 19
PowerSuit = 20
GravitySuit = 21
VariaSuit = 22
PhazonSuit = 23
EnergyTank = 24
UnknownItem1 = 25
HealthRefill = 26
UnknownItem2 = 27
Wavebuster = 28
ArtifactofTruth = 29
ArtifactofStrength = 30
ArtifactofElder = 31
ArtifactofWild = 32
ArtifactofLifegiver = 33
ArtifactofWarrior = 34
ArtifactofChozo = 35
ArtifactofNature = 36
ArtifactofSun = 37
ArtifactofWorld = 38
ArtifactofSpirit = 39
ArtifactofNewborn = 40
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ScanImagePane(enum.IntEnum):
Pane0 = 0
Pane1 = 1
Pane2 = 2
Pane3 = 3
Pane01 = 4
Pane12 = 5
Pane23 = 6
Pane012 = 7
Pane123 = 8
Pane0123 = 9
Pane4 = 10
Pane5 = 11
Pane6 = 12
Pane7 = 13
Pane45 = 14
Pane56 = 15
Pane67 = 16
Pane456 = 17
Pane567 = 18
Pane4567 = 19
_None = 4294967295
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class ScanSpeed(enum.IntEnum):
Normal = 0
Slow = 1
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class VisorFlags(enum.IntFlag):
Combat = 1
Scan = 2
Thermal = 4
XRay = 8
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class VulnerabilityType(enum.IntEnum):
DoubleDamage = 0
Normal = 1
Reflect = 2
Immune = 3
PassThrough = 4
DirectDouble = 5
DirectNormal = 6
DirectImmune = 7
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class WeaponType(enum.IntEnum):
Power = 0
Ice = 1
Wave = 2
Plasma = 3
Bomb = 4
PowerBomb = 5
Missile = 6
BoostBall = 7
Phazon = 8
AI = 9
PoisonWater = 10
Lava = 11
Hot = 12
UnusedWeapon1 = 13
UnusedWeapon2 = 14
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack(">L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack(">L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/enums/prime.py | 0.519034 | 0.499817 | prime.py | pypi |
import enum
import typing
import struct
class MemoType(enum.IntEnum):
StatusMessage = 0
MessageBox = 1
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack("<L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack("<L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class PlayerItem(enum.IntEnum):
PowerBeam = 0
IceBeam = 1
WaveBeam = 2
PlasmaBeam = 3
Missile = 4
ScanVisor = 5
MorphBallBomb = 6
PowerBomb = 7
Flamethrower = 8
ThermalVisor = 9
ChargeBeam = 10
SuperMissile = 11
GrappleBeam = 12
XRayVisor = 13
IceSpreader = 14
SpaceJumpBoots = 15
MorphBall = 16
CombatVisor = 17
BoostBall = 18
SpiderBall = 19
PowerSuit = 20
GravitySuit = 21
VariaSuit = 22
PhazonSuit = 23
EnergyTank = 24
UnknownItem1 = 25
HealthRefill = 26
UnknownItem2 = 27
Wavebuster = 28
ArtifactofTruth = 29
ArtifactofStrength = 30
ArtifactofElder = 31
ArtifactofWild = 32
ArtifactofLifegiver = 33
ArtifactofWarrior = 34
ArtifactofChozo = 35
ArtifactofNature = 36
ArtifactofSun = 37
ArtifactofWorld = 38
ArtifactofSpirit = 39
ArtifactofNewborn = 40
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack("<L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack("<L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value
class VisorFlags(enum.IntFlag):
Combat = 1
Scan = 2
Thermal = 4
XRay = 8
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None):
return cls(struct.unpack("<L", data.read(4))[0])
def to_stream(self, data: typing.BinaryIO):
data.write(struct.pack("<L", self.value))
@classmethod
def from_json(cls, data):
return cls(data)
def to_json(self):
return self.value | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/enums/prime_remastered.py | 0.566019 | 0.500183 | prime_remastered.py | pypi |
from __future__ import annotations
import re
import typing
import construct
from construct import (
Array,
Byte,
Computed,
Const,
CString,
Enum,
GreedyRange,
If,
Int32ub,
Pointer,
Rebuild,
Seek,
Struct,
Tell,
len_,
this,
)
from retro_data_structures.adapters.offset import OffsetAdapter
from retro_data_structures.base_resource import AssetType, BaseResource, Dependency
from retro_data_structures.common_types import FourCC, String
if typing.TYPE_CHECKING:
from retro_data_structures.game_check import Game
class CorruptionLanguageOffsetAdapter(OffsetAdapter):
def _get_table(self, context):
return context._.string_table
def _get_table_length(self, context):
return context._.string_table_length
def _get_item_size(self, item):
return super()._get_item_size(item) + Int32ub.sizeof()
class LanguageOffsetAdapter(OffsetAdapter):
def _get_table(self, context):
return context._.string_tables
def _get_table_length(self, context):
return context._.language_count
def _get_item_size(self, item):
return item._size_end - item._size_start
class NameTableOffsetAdapter(OffsetAdapter):
def _get_table(self, context):
return context._.name_array
def _get_table_length(self, context):
return context._.name_count
def _get_base_offset(self, context):
return context._._name_size_end - context._._size_start
class StringTableOffsetAdapter(OffsetAdapter):
def _get_table(self, context):
return context.strings
def _get_table_length(self, context):
return context._.string_count
def _get_base_offset(self, context):
return Int32ub.sizeof() * context._.string_count
def _compute_corruption_strings_size(ctx):
string_table = ctx._.string_table
offset_table = ctx.offsets
size = 0
for i in range(ctx._.string_count):
index = offset_table[i]
string = string_table[index]
size += string.size
return size
Language = Struct(
"lang" / FourCC,
"offset" / LanguageOffsetAdapter(Int32ub),
"size" / If(this._.prime2, Rebuild(Int32ub, lambda this: this._.string_tables[this.offset]._size)),
)
CorruptionLanguage = Struct(
"strings_size" / Rebuild(Int32ub, _compute_corruption_strings_size),
"offsets" / CorruptionLanguageOffsetAdapter(Int32ub)[this._.string_count],
)
NameTable = Struct(
"name_count" / Rebuild(Int32ub, len_(this.name_entries)),
"_start" / Tell,
Seek(Int32ub.sizeof(), 1),
"_size_start" / Tell,
"_entries_start" / Tell,
Seek(Int32ub.sizeof() * this.name_count * 2, 1),
"_name_size_end" / Tell,
"name_array"
/ Array(
this.name_count,
Struct(
"_size_start" / Tell,
"string" / String,
"_size_end" / Tell,
"size" / Computed(this._size_end - this._size_start),
),
),
"name_entries"
/ Pointer(
this._entries_start,
Array(
this.name_count,
Struct(
"offset" / NameTableOffsetAdapter(Int32ub),
"index" / Int32ub,
),
),
),
"_size_end" / Tell,
"size" / Pointer(this._start, Rebuild(Int32ub, this._size_end - this._size_start)),
)
StringTable = Struct(
"_start" / Tell,
If(this._.prime1, Seek(Int32ub.sizeof(), 1)),
"_size_start" / Tell,
"_offset_start" / Tell,
Seek(Int32ub.sizeof() * this._.string_count, 1),
"strings"
/ Array(
this._.string_count,
Struct(
"_size_start" / Tell,
"string" / CString("utf-16-be"),
"_size_end" / Tell,
"size" / Computed(this._size_end - this._size_start),
),
),
"_size_end" / Tell,
"offsets" / Pointer(this._offset_start, StringTableOffsetAdapter(Int32ub)[this._.string_count]),
"_size" / Computed(this._size_end - this._size_start),
"size" / If(this._.prime1, Pointer(this._start, Rebuild(Int32ub, this._size))),
)
CorruptionString = Struct(
"_start" / Tell,
Seek(Int32ub.sizeof(), 1),
"_size_start" / Tell,
"string" / String,
"_size_end" / Tell,
"size" / Pointer(this._start, Rebuild(Int32ub, this._size_end - this._size_start)),
)
STRG = Struct(
"magic" / Const(0x87654321, Int32ub),
"version" / Enum(Int32ub, prime1=0, prime2=1, prime3=3),
"language_count" / Int32ub,
"string_count" / Int32ub,
"prime1" / Computed(this.version == "prime1"),
"prime2" / Computed(this.version == "prime2"),
"prime3" / Computed(this.version == "prime3"),
"lang_table_start" / Tell,
If(this.prime1 | this.prime2, Seek((FourCC.sizeof() + Int32ub.sizeof()) * this.language_count, 1)),
If(this.prime2, Seek(Int32ub.sizeof() * this.language_count, 1)),
"name_table" / If(this.prime2 | this.prime3, NameTable),
"corr_lang_ids_start" / Tell,
If(this.prime3, Seek(FourCC.sizeof() * this.language_count, 1)),
"corr_lang_table_start" / Tell,
If(this.prime3, Seek(Int32ub.sizeof() * (this.string_count + 1) * this.language_count, 1)),
"string_tables" / If(this.prime1 | this.prime2, StringTable[this.language_count]),
"string_table" / If(this.prime3, GreedyRange(CorruptionString)),
"string_table_length" / If(this.prime3, Computed(len_(this.string_table))),
"language_table" / If(this.prime1 | this.prime2, Pointer(this.lang_table_start, Language[this.language_count])),
"language_ids" / If(this.prime3, Pointer(this.corr_lang_ids_start, FourCC[this.language_count])),
"corruption_language_table"
/ If(this.prime3, Pointer(this.corr_lang_table_start, CorruptionLanguage[this.language_count])),
"junk" / GreedyRange(Byte),
)
image_regex = re.compile(r"&image=(?:.+?,)*?((?:[a-fA-F0-9]+,?)+);")
font_regex = re.compile(r"&font=([a-fA-F0-9]+?);")
class Strg(BaseResource):
@classmethod
def resource_type(cls) -> AssetType:
return "STRG"
@classmethod
def construct_class(cls, target_game: Game) -> construct.Construct:
return STRG
def dependencies_for(self) -> typing.Iterator[Dependency]:
def _str_to_deps(id_str: str):
yield from self.asset_manager.get_dependencies_for_asset(int(id_str, 16))
for lang in self.languages:
for string in self.get_strings(lang):
for match in image_regex.finditer(string):
ids = match.group(1).split(",")
for asset_id in ids:
yield from _str_to_deps(asset_id)
for match in font_regex.finditer(string):
yield from _str_to_deps(match.group(1))
@property
def languages(self) -> typing.Iterator[str]:
if self._raw.prime3:
yield from self._raw.languageids
else:
for lang in self._raw.language_table:
yield lang.lang
def get_strings(self, language: str) -> typing.Iterator[str]:
found = False
if self._raw.prime3:
for i, lang in enumerate(self._raw.language_ids):
if lang != language:
continue
for offset in self._raw.corruption_language_table[i].offsets:
yield self._raw.string_table[offset].string
found = True
break
else:
for i, lang in enumerate(self._raw.language_table):
if lang.lang != language:
continue
for string in self._raw.string_tables[i].strings:
yield string.string
found = True
break
if not found:
raise ValueError(f"No language {language} found in STRG")
def set_strings(self, language: str, strings: list[str]):
found = False
if self._raw.prime3:
for i, lang in enumerate(self._raw.language_ids):
if lang != language:
continue
for j, offset in enumerate(self._raw.corruption_language_table[i].offsets):
self._raw.string_table[offset].string = strings[j]
found = True
break
else:
for i, lang in enumerate(self._raw.language_table):
if lang.lang != language:
continue
for j, string in enumerate(self._raw.string_tables[i].strings):
string.string = strings[j]
found = True
break
if not found:
raise ValueError(f"No language {language} found in STRG")
@property
def strings(self) -> list[str]:
return list(self.get_strings("ENGL"))
@strings.setter
def strings(self, value: list[str]):
self.set_strings("ENGL", value)
def set_string(self, index: int, value: str, *, language: str = "ENGL"):
strings = list(self.get_strings(language))
strings[index] = value
self.set_strings(language, strings) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/strg.py | 0.664758 | 0.17113 | strg.py | pypi |
from __future__ import annotations
import typing
from retro_data_structures.base_resource import AssetId, RawResource
from retro_data_structures.formats import pak_gc, pak_wiiu
from retro_data_structures.formats.pak_gc import PakBody, PakFile
from retro_data_structures.game_check import Game
def _pak_for_game(game: Game):
if game == Game.PRIME_REMASTER:
return pak_wiiu.PAK_WIIU
else:
return pak_gc.PAK_GC
class Pak:
_raw: PakBody
target_game: Game
def __init__(self, raw: PakBody, target_game: Game):
self._raw = raw
self.target_game = target_game
@staticmethod
def header_for_game(game: Game):
if game == Game.PRIME_REMASTER:
return pak_wiiu.PakWiiUNoData
else:
return pak_gc.PAKNoData
@classmethod
def parse(cls: type[Pak], data: bytes, target_game: Game) -> Pak:
return cls(_pak_for_game(target_game).parse(data, target_game=target_game), target_game)
def build(self) -> bytes:
return _pak_for_game(self.target_game).build(self._raw, target_game=self.target_game)
@classmethod
def parse_stream(cls, stream: typing.BinaryIO, target_game: Game) -> Pak:
return cls(_pak_for_game(target_game).parse_stream(stream, target_game=target_game), target_game)
def build_stream(self, stream: typing.BinaryIO) -> bytes:
return _pak_for_game(self.target_game).build_stream(self._raw, stream, target_game=self.target_game)
def get_asset(self, asset_id: AssetId) -> RawResource | None:
"""
Gets the asset of given id, getting the bytes and type
:param asset_id:
:return:
"""
for file in self._raw.files:
if file.asset_id == asset_id:
return RawResource(file.asset_type, file.get_decompressed(self.target_game))
return None
def replace_asset(self, asset_id: AssetId, asset: RawResource):
found = False
for file in self._raw.files:
if file.asset_id == asset_id:
file.asset_type = asset.type
file.set_new_data(asset.data)
found = True
if not found:
raise ValueError(f"Unknown asset id: {asset_id}")
def add_asset(self, asset_id: AssetId, asset: RawResource):
self._raw.files.append(
PakFile(
asset_id=asset_id,
asset_type=asset.type,
should_compress=False,
uncompressed_data=asset.data,
compressed_data=None,
)
)
def remove_asset(self, asset_id: AssetId):
for name, file in self._raw.named_resources.items():
if file.id == asset_id:
raise ValueError(f"Asset id {asset_id:08x} is named {name}, can't be removed.")
found = False
for file in list(self._raw.files):
if file.asset_id == asset_id:
self._raw.files.remove(file)
found = True
if not found:
raise ValueError(f"Unknown asset id: {asset_id}") | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/pak.py | 0.819749 | 0.203015 | pak.py | pypi |
from __future__ import annotations
import enum
from construct.core import (
Adapter,
Aligned,
Array,
BitsInteger,
Bitwise,
Const,
Enum,
FlagsEnum,
If,
Int8ub,
Int16ub,
Int32ub,
Int64ub,
LazyBound,
Pass,
Pointer,
Prefixed,
PrefixedArray,
Rebuild,
Struct,
Switch,
Tell,
this,
)
from retro_data_structures.common_types import AABox, Vector3
from retro_data_structures.construct_extensions.misc import ErrorWithMessage, Skip
class AreaCollisionVersion(enum.IntEnum):
prime1 = 3
prime23 = 4
dkcr = 5
VersionEnum = Enum(Int32ub, AreaCollisionVersion)
_shared_materials = {
"Unknown (Default)": 0x00000001,
"Stone": 0x00000002,
"Metal": 0x00000004,
"Grass": 0x00000008,
"Ice": 0x00000010,
"Pillar": 0x00000020,
"Metal Grating": 0x00000040,
"Phazon": 0x00000080,
"Dirt": 0x00000100,
"Snow": 0x00000800,
"Halfpipe": 0x00002000,
"Shield": 0x00010000,
"Sand": 0x00020000,
"Camera Thru": 0x00200000,
"Wood": 0x00400000,
"Organic": 0x00800000,
"See Thru": 0x04000000,
"Scan Thru": 0x08000000,
"AI Walk Thru": 0x10000000,
"Ceiling": 0x20000000,
"Wall": 0x40000000,
"Floor": 0x80000000,
}
_prime1_materials = dict(
_shared_materials,
**{
"Lava": 0x00000200,
"unknown_1": 0x00000400,
"Slow Mud": 0x00001000,
"Mud": 0x00004000,
"Glass": 0x00008000,
"Shoot Thru": 0x00040000,
"Solid": 0x00080000,
"unknown_2": 0x00100000,
"unknown_3": 0x01000000,
"Redundant Edge/Flipped Tri": 0x02000000,
},
)
_prime23_materials = dict(
_shared_materials,
**{
"SP_Metal": 0x00000200,
"Glass": 0x00000400,
"Fabric": 0x00001000,
"unused_1": 0x00004000,
"unused_2": 0x00008000,
"Moth Organics/Seed Organics": 0x00040000,
"Web": 0x00080000,
"Shoot Thru": 0x00100000,
"Redundant Edge/Flipped Tri": 0x01000000,
"Rubber": 0x02000000,
"Jump Not Allowed": 0x0400000000000000,
"Spider Ball": 0x2000000000000000,
"Screw Attack Wall Jump": 0x4000000000000000,
},
)
_internal_materials = {
"Player (Internal)": 0x0000000100000000,
"Character (Internal": 0x0000000200000000,
"Trigger (Internal)": 0x0000000400000000,
"Projectile (Internal)": 0x0000000800000000,
"Bomb (Internal)": 0x0000001000000000,
"Ground Collider (Internal)": 0x0000002000000000,
"No Static World Collision (Internal)": 0x0000004000000000,
"Scannable (Internal)": 0x0000008000000000,
"Target (Internal)": 0x0000010000000000,
"Orbit (Internal)": 0x0000020000000000,
"Occluder (Internal)": 0x0000040000000000,
"Immovable (Internal)": 0x0000080000000000,
"Debris (Internal)": 0x0000100000000000,
"Power Bomb (Internal)": 0x0000200000000000,
"Targetable Projectile (Internal)": 0x0000400000000000,
"Collision Only Actor (Internal)": 0x0000800000000000,
"AI Block (Internal)": 0x0001000000000000,
"Platform (Internal)": 0x0002000000000000,
"Non Solid Damageable (Internal)": 0x0004000000000000,
"Show on Radar (Internal)": 0x0008000000000000,
"Platform Slave (Internal)": 0x0010000000000000,
"No Ice Spread (Internal)": 0x0020000000000000,
"Grapple Thru (Internal)": 0x0040000000000000,
"Can Jump on Character (Internal)": 0x0080000000000000,
"Exclude From Line of Sight Test (Internal)": 0x0100000000000000,
"Don't Show on Radar (Internal)": 0x0200000000000000,
"Solid (Internal)": 0x0800000000000000,
"Complex (Internal)": 0x1000000000000000,
"Seek (Internal)": 0x8000000000000000,
}
_prime23_materials_all = dict(_prime23_materials, **_internal_materials)
_material_types = {
"prime1": FlagsEnum(Int32ub, **_prime1_materials),
"prime23": FlagsEnum(Int64ub, **_prime23_materials),
}
def NodeTypeEnum(subcon):
return Enum(subcon, none=0, branch=1, leaf=2)
CollisionLeaf = Struct("bounding_box" / AABox, "triangle_index_list" / Aligned(4, PrefixedArray(Int16ub, Int16ub)))
_node_types = {"none": Pass, "branch": LazyBound(lambda: CollisionBranch), "leaf": CollisionLeaf}
CollisionBranch = Struct(
"child_node_types" / Aligned(4, Bitwise(Array(8, NodeTypeEnum(BitsInteger(2))))),
"child_node_offsets" / Array(8, Int32ub), # TODO: offset adapter
"child_nodes" / Array(8, Switch(lambda this: this.child_node_types[7 - this._index], _node_types)),
)
class TriangleAdapter(Adapter):
def _decode(self, vertices, context, path):
triangles = []
for i in range(0, len(vertices), 3):
triangles.append({"edgeA": vertices[i], "edgeB": vertices[i + 1], "edgeC": vertices[i + 2]})
return triangles
def _encode(self, triangles, context, path):
vertices = []
for triangle in triangles:
vertices.extend(triangle.values())
return vertices
CollisionIndex = Struct(
"collision_materials"
/ PrefixedArray(
Int32ub, Switch(this._._.version, _material_types, ErrorWithMessage("Unknown collision material format!"))
),
"vertex_indices" / PrefixedArray(Int32ub, Int8ub),
"edge_indices" / PrefixedArray(Int32ub, Int8ub),
"triangle_indices" / PrefixedArray(Int32ub, Int8ub),
"edges" / PrefixedArray(Int32ub, Struct(vertexA=Int16ub, vertexB=Int16ub)),
"triangles" / TriangleAdapter(PrefixedArray(Int32ub, Int16ub)),
"unknowns"
/ If(
lambda this: AreaCollisionVersion[this._.version] > AreaCollisionVersion.prime1, PrefixedArray(Int32ub, Int16ub)
),
"vertices" / PrefixedArray(Int32ub, Vector3),
)
AreaCollision = Struct(
"unk" / Const(0x01000000, Int32ub),
"_size_addr" / Tell,
Skip(1, Int32ub),
"_size_start" / Tell,
"magic" / Const(0xDEAFBABE, Int32ub),
"version" / VersionEnum,
"bounding_box" / AABox,
"root_node_type" / NodeTypeEnum(Int32ub),
"octree"
/ Prefixed(
Int32ub,
Switch(
this.root_node_type,
{
"none": Pass,
"branch": CollisionBranch,
"leaf": CollisionLeaf,
},
),
),
"collision_indices" / CollisionIndex,
"_size_end" / Tell,
"size" / Pointer(this._size_addr, Rebuild(Int32ub, this._size_end - this._size_start)),
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/area_collision.py | 0.477554 | 0.377627 | area_collision.py | pypi |
from __future__ import annotations
import typing
import construct
from construct import (
Aligned,
Array,
Byte,
Bytes,
Const,
ExprAdapter,
Float16b,
Float32b,
FocusedSeq,
GreedyRange,
If,
IfThenElse,
Int8ub,
Int16ub,
Int32ub,
Pass,
Pointer,
PrefixedArray,
Probe,
Rebuild,
RepeatUntil,
Seek,
Sequence,
Struct,
Switch,
Tell,
)
from retro_data_structures import game_check
from retro_data_structures.base_resource import AssetType, BaseResource, Dependency
from retro_data_structures.common_types import AABox, AssetId32, AssetId64, Color4f, FourCC, Vector2f, Vector3
from retro_data_structures.construct_extensions.alignment import AlignTo
from retro_data_structures.construct_extensions.misc import ErrorWithMessage, Skip
from retro_data_structures.data_section import DataSection, DataSectionSizes
from retro_data_structures.game_check import Game
if typing.TYPE_CHECKING:
from retro_data_structures.asset_manager import AssetManager
UnknownType = Sequence(Probe(into=lambda ctx: ctx["_"]), ErrorWithMessage("Unknown type"))
def FourCCSwitch(element_types):
return Struct(type=FourCC, body=Switch(construct.this.type, element_types, UnknownType))
GetPass = Struct(
size=Int32ub,
_start=Tell,
subtype=FourCC,
flags=Int32ub,
id=AssetId64 * "TXTR",
uv_source=Int32ub,
uv_animation=PrefixedArray(Int32ub, Byte),
_end=Tell,
_update_pass_size=Pointer(
construct.this._start - Int32ub.length, Rebuild(Int32ub, construct.this._end - construct.this._start)
),
)
GetClr = Struct(subtype=FourCC, value=Int32ub)
GetInt = Struct(subtype=FourCC, value=Int32ub)
TEVStage = Struct(
color_input_flags=Int32ub,
alpha_input_flags=Int32ub,
color_combine_flags=Int32ub,
alpha_combine_flags=Int32ub,
padding=Byte,
konst_alpha_input=Byte,
konst_color_input=Byte,
rasterized_color_input=Byte,
)
TEVInput = Struct(
padding=Int16ub,
texture_tev_input=Byte,
tex_coord_tev_input=Byte,
)
Normal = IfThenElse(
lambda this: hasattr(this._root, "flags") and this._root.flags & 0x2,
Array(
3,
ExprAdapter(
Int16ub, # TODO: use the surface mantissa, but it's always 0x8000 for Retro anyway
lambda obj, ctx: obj / 0x8000,
lambda obj, ctx: int(obj * 0x8000),
),
),
Vector3,
)
param_count_per_uv_animtion_type = {
0: 0,
1: 0,
2: 4,
3: 2,
4: 4,
5: 4,
6: 0,
7: 2,
8: 9,
}
PASS_TYPES = {
"DIFF",
"RIML",
"BLOL",
"BLOD",
"CLR ",
"TRAN",
"INCA",
"RFLV",
"RFLD",
"LRLD",
"LURD",
"BLOI",
"XRAY",
"TOON",
}
MATERIAL_PARAMETERS = {
"PASS": GetPass,
"CLR ": GetClr,
"INT ": GetInt,
"END ": Pass,
}
UVAnimation = Struct(
animation_type=Int32ub,
parameters=Array(lambda this: param_count_per_uv_animtion_type[this.animation_type], Float32b),
)
Material = IfThenElse(
game_check.current_game_at_most(Game.ECHOES),
Struct(
flags=Int32ub,
texture_indices=PrefixedArray(Int32ub, Int32ub),
vertex_attribute_flags=Int32ub,
unk_1=If(game_check.current_game_at_least(Game.ECHOES), Int32ub),
unk_2=If(game_check.current_game_at_least(Game.ECHOES), Int32ub),
group_index=Int32ub,
konst_colors=If(construct.this.flags & 0x8, PrefixedArray(Int32ub, Int32ub)),
blend_destination_factor=Int16ub,
blend_source_factor=Int16ub,
reflection_indirect_texture_slot_index=If(construct.this.flags & 0x400, Int32ub),
color_channel_flags=PrefixedArray(Int32ub, Int32ub),
tev_stages=PrefixedArray(Int32ub, TEVStage),
tev_inputs=Array(construct.len_(construct.this.tev_stages), TEVInput),
texgen_flags=PrefixedArray(Int32ub, Int32ub),
material_animations_section_size=Int32ub,
uv_animations=PrefixedArray(Int32ub, UVAnimation),
),
Struct(
size=Int32ub,
_start=Tell,
flags=Int32ub,
group_index=Int32ub,
unk_a=Int32ub,
vertex_attribute_flags=Int32ub,
unk_b=Int32ub,
unk_c=Int32ub,
unk_d=Int32ub,
elements=RepeatUntil(
lambda x, lst, ctx: x.type == "END ",
FourCCSwitch(MATERIAL_PARAMETERS),
),
_end=Tell,
_update_material_size=Pointer(
construct.this._start - Int32ub.length,
Rebuild(Int32ub, construct.this._end - construct.this._start),
),
),
)
MaterialSet = Struct(
texture_file_ids=If(game_check.current_game_at_most(Game.ECHOES), PrefixedArray(Int32ub, AssetId32)),
_material_count=Rebuild(Int32ub, construct.len_(construct.this.materials)),
_material_end_offsets_address=Tell,
_material_end_offsets=If(
game_check.current_game_at_most(Game.ECHOES), Seek(construct.this["_material_count"] * Int32ub.length, 1)
),
_materials_start=Tell,
materials=Array(
construct.this["_material_count"],
FocusedSeq(
"material",
material=Material,
_end=Tell,
update_end_offset=If(
game_check.current_game_at_most(Game.ECHOES),
Pointer(
lambda ctx: ctx["_"]["_material_end_offsets_address"] + Int32ub.length * ctx["_index"],
Rebuild(Int32ub, lambda ctx: ctx["_end"] - ctx["_"]["_materials_start"]),
),
),
),
),
)
def get_material(context):
surface = context
while "header" not in surface:
surface = surface["_"]
return context._root.material_sets[0].materials[surface.header.material_index]
def VertexAttrib(flag):
if not flag:
raise ValueError("Invalid flag!")
shift = 0
while (flag >> shift) & 1 == 0:
shift += 1
return Switch(
lambda this: (get_material(this).vertex_attribute_flags & flag) >> shift,
{
3: Int16ub,
2: Int8ub,
1: Int8ub,
},
)
Surface = Struct(
header=Aligned(
32,
Struct(
center_point=Vector3,
material_index=Int32ub,
mantissa=Int16ub,
_display_list_size_address=Tell,
_display_list_size=Rebuild(Int16ub, lambda ctx: 0),
parent_model_pointer_storage=Int32ub,
next_surface_pointer_storage=Int32ub,
_extra_data_size=Rebuild(Int32ub, construct.len_(construct.this.extra_data)),
surface_normal=Vector3,
unk_1=If(game_check.current_game_at_least(Game.ECHOES), Int16ub),
unk_2=If(game_check.current_game_at_least(Game.ECHOES), Int16ub),
extra_data=Bytes(construct.this["_extra_data_size"]),
),
),
_primitives_address=Tell,
primitives=GreedyRange(
Struct(
type=Byte,
vertices=PrefixedArray(
Int16ub,
Struct(
matrix=Struct(
position=VertexAttrib(0x01 << 24),
tex=Struct(
*[
str(i) / VertexAttrib(flag << 24)
for i, flag in enumerate([0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80])
]
),
),
position=VertexAttrib(0x03),
normal=VertexAttrib(0x0C),
color_0=VertexAttrib(0x30),
color_1=VertexAttrib(0xC0),
tex=Struct(
*[
str(i) / VertexAttrib(flag)
for i, flag in enumerate(
[
0x00000300,
0x00000C00,
0x00003000,
0x0000C000,
0x00030000,
0x000C0000,
0x00300000,
0x00C00000,
]
)
]
),
),
),
)
),
_size=Tell,
_update_display_size=Pointer(
construct.this.header["_display_list_size_address"],
Rebuild(Int16ub, lambda ctx: ((ctx["_size"] - ctx["_primitives_address"]) + 31) & ~31),
),
)
# 0x2 = Prime 1
# 0x4 = Prime 2
# 0x5 = Prime 3
CMDL = Struct(
_magic=Const(0xDEADBABE, Int32ub),
version=Int32ub,
flags=Int32ub,
aabox=AABox,
_data_section_count=Rebuild(
Int32ub,
lambda context: (
len(context.material_sets)
+ sum(1 for k, v in context.attrib_arrays.items() if not k.startswith("_") and v is not None)
+ 1
+ len(context.surfaces)
),
),
_material_set_count=Rebuild(Int32ub, construct.len_(construct.this.material_sets)),
data_section_sizes=DataSectionSizes(construct.this._root._data_section_count),
_=AlignTo(32),
_current_section=construct.Computed(lambda this: 0),
material_sets=Array(construct.this._material_set_count, DataSection(MaterialSet)),
attrib_arrays=Struct(
positions=DataSection(GreedyRange(Vector3)),
normals=DataSection(
GreedyRange(Normal),
),
# TODO: none of Retro's games actually have data here, so this might be the wrong type!
colors=DataSection(GreedyRange(Color4f)),
uvs=DataSection(GreedyRange(Vector2f)),
lightmap_uvs=If(
lambda this: hasattr(this._root, "flags") and this._root.flags & 0x4,
DataSection(GreedyRange(Array(2, Float16b))),
),
),
_surface_header_address=Tell,
_surface_header=DataSection(
Struct(
num_surfaces=Rebuild(Int32ub, construct.len_(construct.this["_"].surfaces)),
end_offsets=Skip(construct.this.num_surfaces, Int32ub),
)
),
_surfaces_start=Tell,
surfaces=Array(
construct.this["_surface_header"].num_surfaces,
FocusedSeq(
"surface",
surface=DataSection(Surface),
end=Tell,
update_end_offset=Pointer(
# One extra Int32ub for the num_surfaces
lambda ctx: ctx["_"]["_surface_header_address"] + Int32ub.length + Int32ub.length * ctx["_index"],
Rebuild(Int32ub, lambda ctx: ctx.end - ctx["_"]["_surfaces_start"]),
),
),
),
)
def dependencies_for_material_set(mat, asset_manager: AssetManager):
if asset_manager.target_game <= Game.ECHOES:
for file_id in mat.texture_file_ids:
yield from asset_manager.get_dependencies_for_asset(file_id)
if Game.CORRUPTION <= asset_manager.target_game:
for material in mat.materials:
for element in material.element:
if element.type == "PASS":
yield from asset_manager.get_dependencies_for_asset(element.body.id)
def legacy_dependencies(obj, target_game: Game):
if target_game <= Game.ECHOES:
for material_set in obj.material_sets:
for file_id in material_set.texture_file_ids:
yield "TXTR", file_id
if Game.CORRUPTION <= target_game:
for material_set in obj.material_sets:
for material in material_set.materials:
for element in material.element:
if element.type == "PASS":
yield "TXTR", element.body.id
class Cmdl(BaseResource):
@classmethod
def resource_type(cls) -> AssetType:
return "CMDL"
@classmethod
def construct_class(cls, target_game: Game) -> construct.Construct:
return CMDL
def dependencies_for(self) -> typing.Iterator[Dependency]:
for material in self.raw.material_sets:
yield from dependencies_for_material_set(material, self.asset_manager) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/cmdl.py | 0.472683 | 0.20201 | cmdl.py | pypi |
from __future__ import annotations
import typing
from enum import IntEnum
import construct
from retro_data_structures.adapters.enum_adapter import EnumAdapter
from retro_data_structures.base_resource import AssetType, BaseResource, Dependency
from retro_data_structures.common_types import AABox, Transform4f, Vector3
from retro_data_structures.construct_extensions.misc import ErrorWithMessage
from retro_data_structures.game_check import Game, current_game_at_least_else, get_current_game
def _const(val: int):
return construct.Const(val, construct.Int32ub)
class AreaVisibilty(IntEnum):
Always = 0
VisitOrMapStation = 1
VisitOnly = 2
Never = 3
class ObjectVisibility(IntEnum):
Always = 0
AreaVisitOrMapStation = 1
DoorVisit = 2
Never = 3
AreaVisitOrMapStation2 = 4
class ObjectTypeMP1(IntEnum):
NormalDoor = 0
ShieldDoor = 1
IceDoor = 2
WaveDoor = 3
PlasmaDoor = 4
BigDoor = 5
BigDoor2 = 6
IceDoorCeil = 7
IceDoorFloor = 8
WaveDoorCeil = 9
WaveDoorFloor = 10
PlasmaDoorCeil = 11
PlasmaDoorFloor = 12
IceDoorFloor2 = 13
WaveDoorFloor2 = 14
PlasmaDoorFloor2 = 15
DownArrowYellow = 27
UpArrowYellow = 28
DownArrowGreen = 29
UpArrowGreen = 30
DownArrowRed = 31
UpArrowRed = 32
Elevator = 33
SaveStation = 34
MissileStation = 37
@property
def is_door_type(self):
return self < ObjectTypeMP1.DownArrowYellow
class ObjectTypeMP2(IntEnum):
NormalDoor = 0
MissileDoor = 1
DarkDoor = 2
AnnihilatorDoor = 3
LightDoor = 4
SuperMissileDoor = 5
SeekerMissileDoor = 6
PowerBombDoor = 7
Elevator = 16
SaveStation = 17
AmmoStation = 20
Portal = 21
LightTeleporter = 22
TranslatorGate = 23
UpArrow = 24
DownArrow = 25
@property
def is_door_type(self):
return self < ObjectTypeMP2.Elevator
class GXPrimitive(IntEnum):
GX_QUADS = 0x80
GX_TRIANGLES = 0x90
GX_TRIANGLESTRIP = 0x98
GX_TRIANGLEFAN = 0xA0
GX_LINES = 0xA8
GX_LINESTRIP = 0xB0
GX_POINTS = 0xB8
def __str__(self):
return self.name
MappableObject = construct.Struct(
type=construct.Switch(
get_current_game,
{
Game.PRIME: construct.Enum(construct.Int32sb, ObjectTypeMP1),
Game.ECHOES: construct.Enum(construct.Int32sb, ObjectTypeMP2),
},
default=construct.Int32sb,
),
visibility_mode=construct.Enum(construct.Int32ub, ObjectVisibility),
editor_id=construct.Int32ub,
unk1=construct.Int32ub,
transform=Transform4f,
unk2=construct.Int32ub[4],
)
Primitive = construct.Aligned(
4,
construct.Struct(
type=EnumAdapter(GXPrimitive),
indices=construct.PrefixedArray(construct.Int32ub, construct.Int8ub),
),
)
Border = construct.Aligned(
4,
construct.Struct(
indices=construct.PrefixedArray(construct.Int32ub, construct.Int8ub),
),
)
MAPA = construct.Aligned(
32,
construct.Struct(
header=construct.Struct(
_magic=_const(0xDEADD00D),
version=construct.Switch(
get_current_game,
{
Game.PRIME: _const(2),
Game.ECHOES: _const(3),
Game.CORRUPTION: _const(5),
},
default=ErrorWithMessage("Unknown game"),
),
type=construct.Int32ub, # Light/Dark world for Echoes
visibility_mode=construct.Enum(construct.Int32ub, AreaVisibilty),
bounding_box=AABox,
map_adjustment=current_game_at_least_else(Game.ECHOES, Vector3, construct.Pass),
mappable_object_count=construct.Int32ub,
vertex_count=construct.Int32ub,
primitive_count=construct.Int32ub,
),
mappable_objects=construct.Array(construct.this.header.mappable_object_count, MappableObject),
vertices=construct.Array(construct.this.header.vertex_count, Vector3),
primitive_headers=construct.Array(
construct.this.header.primitive_count,
construct.Struct(
normal=Vector3,
center_of_mass=Vector3,
primitive_table_start=construct.Int32ub,
border_table_start=construct.Int32ub,
),
),
primitive_tables=construct.Array(
construct.this.header.primitive_count,
construct.Struct(
primitives=construct.PrefixedArray(
construct.Int32ub,
Primitive,
),
borders=construct.PrefixedArray(
construct.Int32ub,
Border,
),
),
),
),
b"\xFF",
)
class Mapa(BaseResource):
@classmethod
def construct_class(cls, target_game: Game) -> construct.Construct:
return MAPA
@classmethod
def resource_type(cls) -> AssetType:
return "MAPA"
def dependencies_for(self) -> typing.Iterator[Dependency]:
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/mapa.py | 0.757794 | 0.256681 | mapa.py | pypi |
from __future__ import annotations
import typing
import construct
from construct import (
Aligned,
Array,
Bit,
BitsInteger,
Const,
ExprAdapter,
Float32b,
GreedyRange,
If,
IfThenElse,
Int8ub,
Int16ub,
Int32ub,
Pointer,
PrefixedArray,
Rebuild,
Struct,
Tell,
Terminated,
)
from retro_data_structures import game_check
from retro_data_structures.base_resource import AssetType, BaseResource, Dependency
from retro_data_structures.common_types import CharAnimTime
from retro_data_structures.construct_extensions.misc import BitwiseWith32Blocks
if typing.TYPE_CHECKING:
from retro_data_structures.game_check import Game
UncompressedAnimation = Struct(
duration=CharAnimTime,
key_interval=CharAnimTime,
key_count=Int32ub,
root_bone_id=Int32ub,
bone_channel_index_array=PrefixedArray(Const(0x64, Int32ub), Int8ub),
rotation_channel_index_array=If(game_check.is_prime2, PrefixedArray(Int32ub, Int8ub)),
translation_channel_index_array=PrefixedArray(Int32ub, Int8ub),
scale_channel_index_array=If(game_check.is_prime2, PrefixedArray(Int32ub, Int8ub)),
scale_key_array=If(game_check.is_prime2, PrefixedArray(Int32ub, Array(3, Float32b))),
rotation_key_array=PrefixedArray(Int32ub, Array(4, Float32b)),
translation_key_array=PrefixedArray(Int32ub, Array(3, Float32b)),
event_id=If(game_check.is_prime1, Int32ub),
)
BoneChannelBits = Struct(
"initial_x" / Int16ub,
"delta_x" / Int8ub,
"initial_y" / Int16ub,
"delta_y" / Int8ub,
"initial_z" / Int16ub,
"delta_z" / Int8ub,
)
BoneChannelDescriptor = Struct(
"bone_id" / IfThenElse(game_check.is_prime2, Int8ub, Int32ub),
"rotation_keys_count" / Int16ub,
"rotation_keys" / If(construct.this.rotation_keys_count != 0, BoneChannelBits),
"translation_keys_count" / Int16ub,
"translation_keys" / If(construct.this.translation_keys_count != 0, BoneChannelBits),
"scale_keys_count" / If(game_check.is_prime2, Int16ub),
"scale_keys" / If(game_check.is_prime2, If(construct.this.scale_keys_count != 0, BoneChannelBits)),
)
def create_bits_field(descriptor):
return Struct(
x=BitsInteger(lambda this: descriptor(this).delta_x),
y=BitsInteger(lambda this: descriptor(this).delta_y),
z=BitsInteger(lambda this: descriptor(this).delta_z),
)
def get_anim(this):
context = this
while "bone_channel_descriptors" not in context:
context = context["_"]
return context
def get_descriptor(this):
return get_anim(this).bone_channel_descriptors[this._index]
CompressedAnimation = Struct(
_start=Tell,
scratch_size=Int32ub,
event_id=If(game_check.is_prime1, Int32ub),
unk_1=If(game_check.is_prime1, Const(0x00000001, Int32ub)),
unk_2=If(game_check.is_prime2, Const(0x0101, Int16ub)),
duration=Float32b,
interval=Float32b,
root_bone_id=Int32ub,
looping_flag=Int32ub,
rotation_divisor=Int32ub,
translation_multiplier=Float32b,
scale_multiplier=If(game_check.is_prime2, Float32b),
_bone_channel_count=Rebuild(Int32ub, construct.len_(construct.this.bone_channel_descriptors)),
unk_3=Int32ub,
_key_bitmap_count=Rebuild(Int32ub, construct.len_(construct.this.animation_keys) + 1),
_key_bitmap_array=BitwiseWith32Blocks(
Aligned(
32,
Array(
construct.this._key_bitmap_count,
Rebuild(
ExprAdapter(Bit, lambda raw, ctx: bool(raw), lambda i, ctx: int(i)),
lambda ctx: ctx.animation_keys[ctx._index - 1].channels is not None if ctx._index > 0 else True,
),
),
)
),
_bone_channel_count_2=If(game_check.is_prime1, Rebuild(Int32ub, construct.this._bone_channel_count)),
bone_channel_descriptors=PrefixedArray(Int32ub, BoneChannelDescriptor),
animation_keys=BitwiseWith32Blocks(
Aligned(
32,
Array(
construct.this._key_bitmap_count - 1,
Struct(
channels=If(
lambda this: get_anim(this)._key_bitmap_array[this._index + 1],
Array(
lambda this: get_anim(this)._bone_channel_count,
Struct(
rotation=If(
lambda this: get_descriptor(this).rotation_keys_count > 0,
Struct(
wsign=Bit,
data=create_bits_field(lambda this: get_descriptor(this).rotation_keys),
),
),
translation=If(
lambda this: get_descriptor(this).translation_keys_count > 0,
create_bits_field(lambda this: get_descriptor(this).translation_keys),
),
scale=If(
lambda this: game_check.is_prime2(this)
and get_descriptor(this).scale_keys_count > 0,
create_bits_field(lambda this: get_descriptor(this).scale_keys),
),
),
),
),
),
),
)
),
_end=Tell,
_update_scratch_size=Pointer(construct.this._start, Rebuild(Int32ub, construct.this._end - construct.this._start)),
)
ANIM = Struct(
anim_version=Int32ub,
anim=IfThenElse(construct.this.anim_version == 0x00000000, UncompressedAnimation, CompressedAnimation),
trailing_bytes=GreedyRange(Const(b"\xFF")),
_terminated=Terminated,
)
class Anim(BaseResource):
@classmethod
def resource_type(cls) -> AssetType:
return "ANIM"
@classmethod
def construct_class(cls, target_game: Game) -> construct.Construct:
return ANIM
def dependencies_for(self) -> typing.Iterator[Dependency]:
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/anim.py | 0.771843 | 0.247368 | anim.py | pypi |
from __future__ import annotations
import enum
import construct
from construct import Byte, Float32b, Int32ub, Int64ub, PrefixedArray, Struct, Switch
from retro_data_structures.adapters.enum_adapter import EnumAdapter
from retro_data_structures.common_types import AssetId32, AssetId64, String
class MetaAnimationType(enum.IntEnum):
Play = 0
Blend = 1
PhaseBlend = 2
Random = 3
Sequence = 4
CharAnimTime = Struct(
time=Float32b,
differential_state=Int32ub, # TODO: use enum
)
def create(asset_id):
meta_bodies = {}
meta = Struct(
type=EnumAdapter(MetaAnimationType),
body=Switch(construct.this.type, meta_bodies),
)
meta_bodies[MetaAnimationType.Play] = Struct(
asset_id=asset_id,
primitive_id=Int32ub,
name=String,
unknown=CharAnimTime,
)
meta_bodies[MetaAnimationType.Blend] = meta_bodies[MetaAnimationType.PhaseBlend] = Struct(
anim_a=meta,
anim_b=meta,
unknown_1=Float32b,
unknown_2=Byte,
)
meta_bodies[MetaAnimationType.Random] = PrefixedArray(
Int32ub,
Struct(
animation=meta,
probability=Int32ub,
),
)
meta_bodies[MetaAnimationType.Sequence] = PrefixedArray(Int32ub, meta)
return meta
MetaAnimation_AssetId32 = create(AssetId32)
MetaAnimation_AssetId64 = create(AssetId64)
by_asset_type = {
Int32ub: MetaAnimation_AssetId32,
Int64ub: MetaAnimation_AssetId64,
}
def legacy_dependencies(obj, target_game):
if obj.type == MetaAnimationType.Play:
yield "ANIM", obj.body.asset_id
elif obj.type in (MetaAnimationType.Blend, MetaAnimationType.PhaseBlend):
yield from legacy_dependencies(obj.body.anim_a, target_game)
yield from legacy_dependencies(obj.body.anim_b, target_game)
elif obj.type == MetaAnimationType.Random:
for anim in obj.body:
yield from legacy_dependencies(anim.animation, target_game)
elif obj.type == MetaAnimationType.Sequence:
for item in obj.body:
yield from legacy_dependencies(item, target_game)
def dependencies_for(obj, asset_manager):
if obj.type == MetaAnimationType.Play:
yield from asset_manager.get_dependencies_for_asset(obj.body.asset_id)
elif obj.type in (MetaAnimationType.Blend, MetaAnimationType.PhaseBlend):
yield from dependencies_for(obj.body.anim_a, asset_manager)
yield from dependencies_for(obj.body.anim_b, asset_manager)
elif obj.type == MetaAnimationType.Random:
for anim in obj.body:
yield from dependencies_for(anim.animation, asset_manager)
elif obj.type == MetaAnimationType.Sequence:
for item in obj.body:
yield from dependencies_for(item, asset_manager) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/meta_animation.py | 0.504639 | 0.165458 | meta_animation.py | pypi |
from __future__ import annotations
import io
import typing
import construct
from construct import Const, Struct
from retro_data_structures.base_resource import AssetType, BaseResource, Dependency
from retro_data_structures.common_types import FourCC
from retro_data_structures.formats.form_descriptor import FormDescriptor
if typing.TYPE_CHECKING:
from retro_data_structures.game_check import Game
MSBTHeader = construct.Aligned(
16,
Struct(
magic=construct.Const(b"MsgStdBn"),
bom=construct.Const(0xFEFF, construct.Int16ul),
unk1=construct.Int16ul,
maybe_major_version=construct.Int8ul,
maybe_minor_version=construct.Int8ul,
section_count=construct.Int16ul,
unk3=construct.Int16ul,
file_size=construct.Int32ul,
),
)
def TableHeader(magic: str):
return construct.Aligned(
16,
Struct(
magic=construct.Const(magic, FourCC),
table_size=construct.Int32ul,
),
)
class SectionBody(construct.Construct):
def __init__(self, header_magic: str, entry: construct.Construct, has_entry_size: bool):
super().__init__()
self.header_magic = header_magic
self.entry_header = construct.Int32ul
self.entry = entry
self.has_entry_size = has_entry_size
self.int_type = typing.cast(construct.Construct, construct.Int32ul)
def get_offset_from_header(self, item):
return item
def _header_for_entry(self, offset: int, entry):
return offset
def _context_for_entry(self, context, entry_header):
return context
def _parse(self, stream, context, path):
table_size = TableHeader(self.header_magic)._parsereport(stream, context, path).table_size
table_start = construct.stream_tell(stream, path)
count = self.int_type._parsereport(stream, context, path)
if self.has_entry_size:
# Read the entry size. It's always 4.
construct.Const(4, self.int_type)._parsereport(stream, context, path)
entry_headers = construct.Array(count, self.entry_header)._parsereport(stream, context, path)
all_offsets = [self.get_offset_from_header(entry_header) for entry_header in entry_headers]
all_offsets.append(table_size)
result = construct.ListContainer()
for entry_header, next_offset in zip(entry_headers, all_offsets[1:]):
this_offset = self.get_offset_from_header(entry_header)
current_offset = construct.stream_tell(stream, path)
if current_offset != table_start + this_offset:
raise construct.CheckError("incorrect offset in data", path=path)
new_context = self._context_for_entry(context, entry_header)
entry_data = io.BytesIO(construct.stream_read(stream, next_offset - this_offset, path))
result.append(self.entry._parsereport(entry_data, new_context, path))
if not construct.stream_iseof(entry_data):
raise construct.CheckError("expected entry to read entire data", path=path)
return result
def _build(self, obj, stream, context, path):
items = []
entry_headers = []
count = len(obj)
offset = self.int_type._sizeof(construct.Container(), path)
if self.has_entry_size:
offset += self.int_type._sizeof(construct.Container(), path)
offset += count * self.entry_header._sizeof(context, path)
for item in obj:
new_context = self._context_for_entry(context, item)
stream2 = io.BytesIO()
self.entry._build(item, stream2, new_context, path)
items.append(stream2.getvalue())
entry_headers.append(
self._header_for_entry(
offset,
item,
)
)
offset += len(items[-1])
# Build!
TableHeader(self.header_magic)._build(
construct.Container(
table_size=offset,
),
stream,
context,
path,
)
table_start = construct.stream_tell(stream, path)
self.int_type._build(count, stream, context, path)
if self.has_entry_size:
# Read the entry size. It's always 4.
construct.Const(4, self.int_type)._build(None, stream, context, path)
construct.Array(count, self.entry_header)._build(entry_headers, stream, context, path)
for entry_header, entry in zip(entry_headers, items):
this_offset = self.get_offset_from_header(entry_header)
current_offset = construct.stream_tell(stream, path)
if current_offset != table_start + this_offset:
raise construct.CheckError("incorrect offset in data", path=path)
construct.stream_write(stream, entry, len(entry), path)
class LabelsSectionBody(SectionBody):
def __init__(self):
super().__init__(
"LBL1",
entry=construct.Array(
lambda ctx: ctx.entry_header.string_count,
Struct(
str=construct.PascalString(construct.Int8ul, "ascii"),
string_table_index=construct.Int32ul,
),
),
has_entry_size=False,
)
self.entry_header = Struct(
string_count=construct.Int32ul,
string_offset=construct.Int32ul,
)
def get_offset_from_header(self, item):
return item.string_offset
def _header_for_entry(self, offset: int, entry):
return construct.Container(
string_offset=offset,
string_count=len(entry),
)
def _context_for_entry(self, context, entry_or_header):
new_context = construct.Container(
_=context,
_params=context._params,
_root=None,
_parsing=context._parsing,
_building=context._building,
_sizing=context._sizing,
_io=context._io,
_index=context.get("_index", None),
)
new_context._root = new_context._.get("_root", context)
if context._building:
new_context.entry_header = self._header_for_entry(0, entry_or_header)
else:
new_context.entry_header = entry_or_header
return new_context
LabelsSection = construct.Aligned(16, LabelsSectionBody(), b"\xAB")
AttributesSection = construct.Aligned(
16,
SectionBody(
header_magic="ATR1",
entry=construct.CString("utf_16_le"),
has_entry_size=True,
),
b"\xAB",
)
TextsSection = construct.Aligned(
16,
SectionBody(
header_magic="TXT2",
entry=construct.StringEncoded(construct.GreedyBytes, "utf_16_le"),
has_entry_size=False,
),
b"\xAB",
)
def Language(language_code: str):
return Struct(
header=Struct(
magic=Const(language_code, FourCC),
file_size=construct.Int32ul,
unk=construct.Int32ul[4],
),
contents=Struct(
header=MSBTHeader,
labels=LabelsSection,
attributes=AttributesSection,
texts=TextsSection,
),
)
MSBT = FormDescriptor(
"MSBT",
10,
10,
Struct(
us_english=Language("USEN"),
eu_english=Language("EUEN"),
eu_french=Language("EUFR"),
us_french=Language("USFR"),
eu_spanish=Language("EUSP"),
eu_german=Language("EUGE"),
eu_italian=Language("EUIT"),
eu_dutch=Language("EUDU"),
jp_japanese=Language("JPJP"),
ko_korean=Language("KOKO"),
ch_traditionalchinese=Language("CHTC"),
ch_simplifiedchinese=Language("CHSC"),
us_spanish=Language("USSP"),
),
)
class Msbt(BaseResource):
@classmethod
def resource_type(cls) -> AssetType:
return "MSBT"
@classmethod
def construct_class(cls, target_game: Game) -> construct.Construct:
return MSBT
def dependencies_for(self) -> typing.Iterator[Dependency]:
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/msbt.py | 0.768993 | 0.160069 | msbt.py | pypi |
from __future__ import annotations
import typing
import construct
from construct import (
Adapter,
Array,
Bitwise,
Const,
Container,
CString,
Error,
Flag,
Float32b,
FocusedSeq,
Int8ub,
Int16ub,
Int32ub,
ListContainer,
Peek,
PrefixedArray,
Sequence,
Struct,
Switch,
)
from retro_data_structures.base_resource import AssetType, BaseResource, Dependency, NameOrAssetId
from retro_data_structures.common_types import AssetId32, AssetId64, Vector3
from retro_data_structures.construct_extensions.misc import PrefixedArrayWithExtra
from retro_data_structures.exceptions import UnknownAssetId
from retro_data_structures.formats import Mapw
from retro_data_structures.formats.guid import GUID
from retro_data_structures.formats.mrea import (
Area,
AreaDependencyAdapter,
AreaModuleDependencyAdapter,
)
from retro_data_structures.formats.savw import Savw
from retro_data_structures.formats.strg import Strg
from retro_data_structures.game_check import Game
if typing.TYPE_CHECKING:
from collections.abc import Iterator
pass
MLVLConnectingDock = Struct(
area_index=Int32ub,
dock_index=Int32ub,
)
MLVLDock = Struct(
connecting_dock=PrefixedArray(Int32ub, MLVLConnectingDock),
dock_coordinates=PrefixedArray(Int32ub, Vector3),
)
MLVLMemoryRelay = Struct(
memory_relay_index=Int32ub,
target_index=Int32ub,
message=Int16ub,
active=Int8ub,
)
class LayerFlags(Adapter):
def __init__(self):
super().__init__(
Struct(
layer_count=Int32ub,
layer_flags=Bitwise(Array(64, Flag)),
)
)
def _decode(self, obj, context, path):
return ListContainer(reversed(obj.layer_flags))[: obj.layer_count]
def _encode(self, obj, context, path):
flags = [True for i in range(64)]
flags[: len(obj)] = obj
return Container({"layer_count": len(obj), "layer_flags": list(reversed(flags))})
def create_area(version: int, asset_id):
area_fields = [
"area_name_id" / asset_id,
"area_transform" / Array(12, Float32b),
"area_bounding_box" / Array(6, Float32b),
"area_mrea_id" / asset_id,
"internal_area_id" / asset_id,
]
# DKCR
if version < 0x1B:
area_fields.append("attached_area_index" / PrefixedArray(Int32ub, Int16ub))
# Corruption
if version < 0x19:
area_fields.append("dependencies" / AreaDependencyAdapter(asset_id))
area_fields.append("docks" / PrefixedArray(Int32ub, MLVLDock))
# Echoes
if version == 0x17:
area_fields.append("module_dependencies" / AreaModuleDependencyAdapter())
# DKCR
if version >= 0x1B:
# Unknown, always 0?
area_fields.append(Const(0, Int32ub))
# Prime 2 Demo
if version >= 0x14:
area_fields.append("internal_area_name" / CString("utf-8"))
return Struct(*area_fields)
def create(version: int, asset_id):
area = create_area(version, asset_id)
fields = [
"magic" / Const(0xDEAFBABE, Int32ub),
"version" / Const(version, Int32ub),
"world_name_id" / asset_id,
]
# Prime 2
if version == 0x17:
fields.append("dark_world_name_id" / asset_id)
# Prime 2 and 3
if 0x17 <= version <= 0x19:
fields.append("temple_key_world_index" / Int32ub)
# TODO: time attack for DKCR
fields.extend(
[
"world_save_info_id" / asset_id,
"default_skybox_id" / asset_id,
]
)
# Prime 1
if version <= 0x11:
# Array describing all outgoing Memory Relay connections in this world.
# Memory Relays connected to multiple objects are listed multiple times.
fields.append("memory_relays" / PrefixedArray(Int32ub, MLVLMemoryRelay))
# Prime 1
if version <= 0x11:
# Extra field is unknown, always 1
fields.append("areas" / PrefixedArrayWithExtra(Int32ub, Const(1, Int32ub), area))
else:
fields.append("areas" / PrefixedArray(Int32ub, area))
# DKCR
if version <= 0x1B:
fields.append("world_map_id" / asset_id) # MAPW
# This is presumably the same unknown value as at the beginning of the SCLY format. Always 0.
fields.append("unknown_scly_field" / Const(0, Int8ub))
# The MLVL format embeds a script layer. This script layer is used in the MP1 demo for storing Dock instances,
# but it's unused in all retail builds, so this is always 0.
fields.append("script_instance_count" / Const(0x0, Int32ub))
# Prime 1
if version <= 0x11:
fields.append(
"audio_group"
/ PrefixedArray(
Int32ub,
Struct(
group_id=Int32ub,
agsc_id=asset_id,
),
)
)
# Unknown purpose, always empty
fields.append(CString("utf-8"))
fields.extend(
[
"area_layer_flags" / PrefixedArray(Int32ub, LayerFlags()),
"layer_names" / PrefixedArray(Int32ub, CString("utf-8")),
]
)
# Corruption
if version >= 0x19:
fields.append("layer_guid" / PrefixedArray(Int32ub, GUID))
fields.append("area_layer_name_offset" / PrefixedArray(Int32ub, Int32ub))
return Struct(*fields)
Prime1MLVL = create(0x11, AssetId32)
Prime2MLVL = create(0x17, AssetId32)
Prime3MLVL = create(0x19, AssetId64)
MLVL = FocusedSeq(
"mlvl",
header=Peek(Sequence(Int32ub, Int32ub)),
mlvl=Switch(
lambda this: this.header[1] if this._parsing else this.mlvl.version,
{
0x11: Prime1MLVL,
0x17: Prime2MLVL,
0x19: Prime3MLVL,
},
Error,
),
)
class Mlvl(BaseResource):
_mapw: Mapw = None
_savw: Savw = None
@classmethod
def resource_type(cls) -> AssetType:
return "MLVL"
@classmethod
def construct_class(cls, target_game: Game) -> construct.Construct:
return MLVL
def dependencies_for(self) -> typing.Iterator[Dependency]:
for area in self.areas:
area.build_mlvl_dependencies(False)
yield from area.dependencies_for()
mlvl_deps = [self._raw.world_name_id, self._raw.world_save_info_id, self._raw.default_skybox_id]
if self.asset_manager.target_game == Game.ECHOES:
mlvl_deps.append(self._raw.dark_world_name_id)
if self.asset_manager.target_game <= Game.CORRUPTION:
mlvl_deps.append(self._raw.world_map_id)
for dep in mlvl_deps:
yield from self.asset_manager.get_dependencies_for_asset(dep)
def __repr__(self) -> str:
try:
if self.asset_manager.target_game == Game.ECHOES:
return f"{self.world_name} ({self.dark_world_name})"
return self.world_name
except UnknownAssetId:
return super().__repr__()
@property
def areas(self) -> Iterator[Area]:
offsets = self._raw.area_layer_name_offset
names = self._raw.layer_names
for i, area in enumerate(self._raw.areas):
area_layer_names = (
names[offsets[i] :] if i == len(self._raw.areas) - 1 else names[offsets[i] : offsets[i + 1]]
)
yield Area(area, self.asset_manager, self._raw.area_layer_flags[i], area_layer_names, i, self)
def get_area(self, asset_id: NameOrAssetId) -> Area:
return next(area for area in self.areas if area.mrea_asset_id == self.asset_manager._resolve_asset_id(asset_id))
_name_strg_cached: Strg = None
_dark_strg_cached: Strg = None
@property
def _name_strg(self) -> Strg:
if self._name_strg_cached is None:
self._name_strg_cached = self.asset_manager.get_file(self._raw.world_name_id, type_hint=Strg)
return self._name_strg_cached
@property
def _dark_strg(self) -> Strg:
if self.asset_manager.target_game != Game.ECHOES:
raise ValueError("Only Echoes has dark world names.")
if self._dark_strg_cached is None:
self._dark_strg_cached = self.asset_manager.get_file(self._raw.dark_world_name_id, type_hint=Strg)
return self._dark_strg_cached
@property
def world_name(self) -> str:
return self._name_strg.strings[0]
@world_name.setter
def world_name(self, value: str):
self._name_strg.set_string(0, value)
@property
def dark_world_name(self) -> str:
return self._dark_strg.strings[0]
@dark_world_name.setter
def dark_world_name(self, value: str):
self._dark_strg.set_string(0, value)
@property
def mapw(self) -> Mapw:
if self._mapw is None:
self._mapw = self.asset_manager.get_file(self.raw.world_map_id, type_hint=Mapw)
return self._mapw
@property
def savw(self) -> Savw:
if self._savw is None:
self._savw = self.asset_manager.get_file(self.raw.world_save_info_id, type_hint=Savw)
return self._savw | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/mlvl.py | 0.489015 | 0.161155 | mlvl.py | pypi |
from __future__ import annotations
from typing import TYPE_CHECKING
from retro_data_structures.formats.ancs import ANCS, Ancs
from retro_data_structures.formats.anim import ANIM, Anim
from retro_data_structures.formats.audio_group import AGSC, ATBL, Agsc, Atbl
from retro_data_structures.formats.char import CHAR, Char
from retro_data_structures.formats.cinf import CINF, Cinf
from retro_data_structures.formats.cmdl import CMDL, Cmdl
from retro_data_structures.formats.cskr import CSKR, Cskr
from retro_data_structures.formats.cspp import CSPP, Cspp
from retro_data_structures.formats.dgrp import DGRP, Dgrp
from retro_data_structures.formats.effect_script import (
CRSC,
DPSC,
ELSC,
PART,
SPSC,
SRSC,
SWHC,
WPSC,
Crsc,
Dpsc,
Elsc,
Part,
Spsc,
Srsc,
Swhc,
Wpsc,
)
from retro_data_structures.formats.evnt import EVNT, Evnt
from retro_data_structures.formats.mapa import MAPA, Mapa
from retro_data_structures.formats.mapu import MAPU, Mapu
from retro_data_structures.formats.mapw import MAPW, Mapw
from retro_data_structures.formats.mlvl import MLVL, Mlvl
from retro_data_structures.formats.mrea import MREA, Mrea
from retro_data_structures.formats.msbt import Msbt
from retro_data_structures.formats.pak import Pak
from retro_data_structures.formats.room import Room
from retro_data_structures.formats.sand import SAND, Sand
from retro_data_structures.formats.savw import SAVW, Savw
from retro_data_structures.formats.scan import SCAN, Scan
from retro_data_structures.formats.strg import STRG, Strg
from retro_data_structures.formats.txtr import TXTR, Txtr
if TYPE_CHECKING:
from construct import Construct
from retro_data_structures.base_resource import AssetType, BaseResource
ALL_FORMATS = {
"ANCS": ANCS,
"ANIM": ANIM,
"CHAR": CHAR,
"CINF": CINF,
"CMDL": CMDL,
"CSKR": CSKR,
"CSPP": CSPP,
"DGRP": DGRP,
"EVNT": EVNT,
"MAPA": MAPA,
"MAPW": MAPW,
"MAPU": MAPU,
"MLVL": MLVL,
"MREA": MREA,
"PART": PART,
"SAND": SAND,
"SAVW": SAVW,
"SCAN": SCAN,
"STRG": STRG,
"TXTR": TXTR,
"DPSC": DPSC,
"WPSC": WPSC,
"CRSC": CRSC,
"SRSC": SRSC,
"SPSC": SPSC,
"ELSC": ELSC,
"SWHC": SWHC,
"AGSC": AGSC,
"ATBL": ATBL,
}
ALL_RESOURCE_TYPES = {
"ANCS": Ancs,
"ANIM": Anim,
"CHAR": Char,
"CINF": Cinf,
"CMDL": Cmdl,
"CSKR": Cskr,
"CSPP": Cspp,
"DGRP": Dgrp,
"EVNT": Evnt,
"MAPA": Mapa,
"MAPU": Mapu,
"MAPW": Mapw,
"MLVL": Mlvl,
"MREA": Mrea,
"MSBT": Msbt,
"PAK": Pak,
"PART": Part,
"ROOM": Room,
"SAND": Sand,
"SAVW": Savw,
"SCAN": Scan,
"STRG": Strg,
"TXTR": Txtr,
"DPSC": Dpsc,
"WPSC": Wpsc,
"CRSC": Crsc,
"SRSC": Srsc,
"SPSC": Spsc,
"ELSC": Elsc,
"SWHC": Swhc,
"AGSC": Agsc,
"ATBL": Atbl,
}
def format_for(type_name: AssetType) -> Construct:
return ALL_FORMATS[type_name.upper()]
def resource_type_for(type_name: AssetType) -> type[BaseResource]:
return ALL_RESOURCE_TYPES[type_name.upper()]
def has_format(type_name: AssetType) -> bool:
return type_name in ALL_FORMATS
def has_resource_type(type_name: AssetType) -> bool:
return type_name in ALL_RESOURCE_TYPES
__all__ = ["format_for", "resource_type_for", "has_format", "has_resource_type"] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/formats/__init__.py | 0.672547 | 0.243319 | __init__.py | pypi |
from retro.graph import Vertex, Edge, Graph
from retro.errors import TerminalTooSmall
class View:
BORDER_X = 2
BORDER_Y = 3
STATE_HEIGHT = 5
DEBUG_WIDTH = 60
def __init__(self, terminal, color='white_on_black'):
self.terminal = terminal
self.color = color
def render(self, game):
self.render_layout(game)
ox, oy = self.get_board_origin_coords(game)
self.render_state(game)
if game.debug:
self.render_debug_log(game)
for agent in sorted(game.agents, key=lambda a: getattr(a, 'z', 0)):
if getattr(agent, 'display', True):
ax, ay = agent.position
if hasattr(agent, 'color'):
color = self.get_color(agent.color)
print(self.terminal.move_xy(ox + ax, oy + ay) + color(agent.character))
else:
print(self.terminal.move_xy(ox + ax, oy + ay) + agent.character)
def render_layout(self, game):
bw, bh = game.board_size
self.check_terminal_size(game)
self.clear_screen()
layout_graph = self.get_layout_graph(game)
layout_graph.render(self.terminal)
def clear_screen(self):
print(self.terminal.home + self.get_color(self.color) + self.terminal.clear)
def get_color(self, color_string):
if not hasattr(self.terminal, color_string):
msg = (
f"{color_string} is not a supported color."
"See https://blessed.readthedocs.io/en/latest/colors.html"
)
raise ValueError(msg)
return getattr(self.terminal, color_string)
def render_state(self, game):
bw, bh = game.board_size
ox, oy = self.get_state_origin_coords(game)
for i, key in enumerate(sorted(game.state.keys())):
msg = f"{key}: {game.state[key]}"[:bw]
print(self.terminal.move_xy(ox, oy + i) + msg)
def render_debug_log(self, game):
bw, bh = game.board_size
debug_height = bh + self.STATE_HEIGHT
ox, oy = self.get_debug_origin_coords(game)
for i, (turn_number, message) in enumerate(game.log_messages[-debug_height:]):
msg = f"{turn_number}. {message}"[:self.DEBUG_WIDTH]
print(self.terminal.move_xy(ox, oy + i) + msg)
def get_layout_graph(self, game):
bw, bh = game.board_size
sh = self.STATE_HEIGHT
ox, oy = self.get_board_origin_coords(game)
vertices = [
Vertex(ox - 1, oy - 1),
Vertex(ox + bw, oy - 1),
Vertex(ox + bw, oy + bh),
Vertex(ox + bw, oy + bh + sh),
Vertex(ox - 1, oy + bh + sh),
Vertex(ox - 1, oy + bh)
]
edges = [
Edge(vertices[0], vertices[1]),
Edge(vertices[1], vertices[2]),
Edge(vertices[2], vertices[3]),
Edge(vertices[3], vertices[4]),
Edge(vertices[4], vertices[5]),
Edge(vertices[5], vertices[0]),
Edge(vertices[5], vertices[2]),
]
graph = Graph(vertices, edges)
if game.debug:
dw = self.DEBUG_WIDTH
graph.vertices.append(Vertex(ox + bw + dw, oy - 1))
graph.vertices.append(Vertex(ox + bw + dw, oy + bh + sh))
graph.edges.append(Edge(graph.vertices[1], graph.vertices[6]))
graph.edges.append(Edge(graph.vertices[6], graph.vertices[7]))
graph.edges.append(Edge(graph.vertices[3], graph.vertices[7]))
return graph
def check_terminal_size(self, game):
bw, bh = game.board_size
width_needed = bw + self.BORDER_X
height_needed = bh + self.BORDER_Y + self.STATE_HEIGHT
if self.terminal.width < width_needed:
raise TerminalTooSmall(width=self.terminal.width, width_needed=width_needed)
elif self.terminal.height < height_needed:
raise TerminalTooSmall(height=self.terminal.height, height_needed=height_needed)
def board_origin(self, game):
x, y = self.get_board_origin_coords(game)
return self.terminal.move_xy(x, y)
def get_board_origin_coords(self, game):
bw, bh = game.board_size
margin_top = (self.terminal.height - bh - self.BORDER_Y) // 2
if game.debug:
margin_left = (self.terminal.width - bw - self.DEBUG_WIDTH - self.BORDER_X) // 2
else:
margin_left = (self.terminal.width - bw - self.BORDER_X) // 2
return margin_left, margin_top
def get_state_origin_coords(self, game):
bw, bh = game.board_size
ox, oy = self.get_board_origin_coords(game)
return ox, oy + bh + 1
def get_debug_origin_coords(self, game):
bw, bh = game.board_size
ox, oy = self.get_board_origin_coords(game)
return ox + bw + 1, oy | /retro_games-0.1.2.tar.gz/retro_games-0.1.2/retro/view.py | 0.563618 | 0.213695 | view.py | pypi |
from collections import defaultdict
from signal import signal, SIGWINCH
from time import sleep, perf_counter
from blessed import Terminal
from retro.view import View
from retro.validation import (
validate_agent,
validate_state,
validate_agent_name,
validate_position,
)
from retro.errors import (
AgentWithNameAlreadyExists,
AgentNotFoundByName,
IllegalMove,
)
class Game:
"""
Creates a playable game.
You will use Game to create games, but don't need to read or understand how
this class works. The main work in creating a
Arguments:
agents (list): A list of agents to add to the game.
state (dict): A dict containing the game's initial state.
board_size (int, int): (Optional) The two-dimensional size of the game board. D
debug (bool): (Optional) Turn on debug mode, showing log messages while playing.
framerate (int): (Optional) The target number of frames per second at which the
game should run.
color (str): (Optional) The game's background color scheme. `Available colors <https://blessed.readthedocs.io/en/latest/colors.html>`_.
::
# This example will create a simple game.
from retro.game import Game
from retro.agent import ArrowKeyAgent
agents = [ArrowKeyAgent()]
state = {}
game = Game(agents, state)
game.play()
"""
STATE_HEIGHT = 5
EXIT_CHARACTERS = ("KEY_ENTER", "KEY_ESCAPE")
def __init__(self, agents, state, board_size=(64, 32), debug=False, framerate=24,
color="white_on_black"):
self.log_messages = []
self.agents_by_name = {}
self.agents = []
self.state = validate_state(state)
self.board_size = board_size
self.debug = debug
self.framerate = framerate
self.turn_number = 0
self.color = color
for agent in agents:
self.add_agent(agent)
def play(self):
"""Starts the game.
"""
self.playing = True
terminal = Terminal()
with terminal.fullscreen(), terminal.hidden_cursor(), terminal.cbreak():
view = View(terminal, color=self.color)
while self.playing:
turn_start_time = perf_counter()
self.turn_number += 1
self.keys_pressed = self.collect_keystrokes(terminal)
if self.debug and self.keys_pressed:
self.log("Keys: " + ', '.join(k.name or str(k) for k in self.keys_pressed))
for agent in self.agents:
if hasattr(agent, 'handle_keystroke'):
for key in self.keys_pressed:
agent.handle_keystroke(key, self)
if hasattr(agent, 'play_turn'):
agent.play_turn(self)
if getattr(agent, 'display', True):
if not self.on_board(agent.position):
raise IllegalMove(agent, agent.position)
view.render(self)
turn_end_time = perf_counter()
time_elapsed_in_turn = turn_end_time - turn_start_time
time_remaining_in_turn = max(0, 1/self.framerate - time_elapsed_in_turn)
sleep(time_remaining_in_turn)
while True:
if terminal.inkey().name in self.EXIT_CHARACTERS:
break
def collect_keystrokes(self, terminal):
keys = set()
while True:
key = terminal.inkey(0.001)
if key:
keys.add(key)
else:
break
return keys
def log(self, message):
"""Write a log message.
Log messages are only shown when debug mode is on.
They can be very useful for debugging.
Arguments:
message (str): The message to log.
"""
self.log_messages.append((self.turn_number, message))
def end(self):
"""Ends the game. No more turns will run.
"""
self.playing = False
def add_agent(self, agent):
"""Adds an agent to the game.
Whenever you want to add a new agent during the game, you must add it to
the game using this method.
Arguments:
agent: An instance of an agent class.
"""
validate_agent(agent)
if getattr(agent, "display", True) and not self.on_board(agent.position):
raise IllegalMove(agent, agent.position)
if hasattr(agent, "name"):
if agent.name in self.agents_by_name:
raise AgentWithNameAlreadyExists(agent.name)
self.agents_by_name[agent.name] = agent
self.agents.append(agent)
def get_agent_by_name(self, name):
"""Looks up an agent by name.
This is useful when one agent needs to interact with another agent.
Arguments:
name (str): The agent's name. If there is no agent with this name,
you will get an error.
Returns:
An agent.
"""
validate_agent_name(name)
if name in self.agents_by_name:
return self.agents_by_name[name]
else:
raise AgentNotFoundByName(name)
def is_empty(self, position):
"""Checks whether a position is occupied by any agents.
Arguments:
position (int, int): The position to check.
Returns:
A bool
"""
return position not in self.get_agents_by_position()
def get_agents_by_position(self):
"""Returns a dict where each key is a position (e.g. (10, 20)) and
each value is a list containing all the agents at that position.
This is useful when an agent needs to find out which other agents are
on the same space or nearby.
"""
positions = defaultdict(list)
for agent in self.agents:
if getattr(agent, "display", True):
validate_position(agent.position)
positions[agent.position].append(agent)
return positions
def remove_agent(self, agent):
"""Removes an agent from the game.
Arguments:
agent (Agent): the agent to remove.
"""
if agent not in self.agents:
raise AgentNotInGame(agent)
else:
self.agents.remove(agent)
if hasattr(agent, "name"):
self.agents_by_name.pop(agent.name)
def remove_agent_by_name(self, name):
"""Removes an agent from the game.
Arguments:
name (str): the agent's name.
"""
validate_agent_name(name)
if name not in self.agents_by_name:
raise AgentNotFoundByName(name)
agent = self.agents_by_name.pop(name)
self.agents.remove(agent)
def on_board(self, position):
"""Checks whether a position is on the game board.
Arguments:
position (int, int): The position to check
Returns:
A bool
"""
validate_position(position)
x, y = position
bx, by = self.board_size
return x >= 0 and x < bx and y >= 0 and y < by | /retro_games-0.1.2.tar.gz/retro_games-0.1.2/retro/game.py | 0.836555 | 0.279054 | game.py | pypi |
class Agent:
"""Represents a character in the game. To create an Agent, define a new
class with some of the attributes and methods below. You may change any of
the Agent's attributes at any time, and the result will immediately be
visible in the game.
After you create your Agents, add them to the ``Game``, either when it is created
or using ``Game.add_agent`` later on. Then the Game will take care of calling
the Agent's methods at the appropriate times.
Attributes:
position: (Required) The character's ``(int, int)`` position on the game
board.
character: (Required unless display is ``False``.) A one-character string
which will be displayed at the Agent's position on the game board.
name: (Optional) If an agent has a name, it must be unique within the game.
Agent names can be used to look up agents with
:py:meth:`retro.game.Game.get_agent_by_name`.
color (str): (Optional) The agent's color.
`Available colors <https://blessed.readthedocs.io/en/latest/colors.html>`_.
display: (Optional) When ``False``, the Agent will not be displayed on the
board. This is useful when you want to create an agent which will be displayed
later, or when you want to create an agent which acts on the Game indirectly,
for example by spawning other Agents. Defaults to True.
z: (Optional) When multiple Agents have the same position on the board, the
Agent with the highest ``z`` value will be displayed.
The Game is played on a two-dimensional (x, y) board, but you can think of
``z`` as a third "up" dimension. Defaults to 0.
"""
character = "*"
position = (0, 0)
name = "agent"
color = "white_on_black"
display = True
z = 0
def play_turn(self, game):
"""If an Agent has this method, it will be called once
each turn.
Arguments:
game (Game): The game which is currently being played will be
passed to the Agent, in case it needs to check anything about
the game or make any changes.
"""
pass
def handle_keystroke(self, keystroke, game):
"""If an Agent has a this method, it will be called every
time a key is pressed in the game.
Arguments:
keystroke (blessed.keyboard.Keystroke): The key which was pressed. You can
compare a Keystroke with a string (e.g. ``if keystroke == 'q'``) to check
whether it is a regular letter, number, or symbol on the keyboard. You can
check special keys using the keystroke's name
(e.g. ``if keystroke.name == "KEY_RIGHT"``). Run your game in debug mode to
see the names of keystrokes.
game (Game): The game which is currently being played will be
passed to the Agent, in case it needs to check anything about
the game or make any changes.
"""
pass
class ArrowKeyAgent:
"""A simple agent which can be moved around with the arrow keys.
"""
name = "ArrowKeyAgent"
character = "*"
position = (0,0)
display = True
z = 0
def play_turn(self, game):
pass
def handle_keystroke(self, keystroke, game):
"""Moves the agent's position if the keystroke is one of the arrow keys.
One by one, checks the keystroke's name against each arrow key.
Then uses :py:meth:`try_to_move` to check whether the move is on the
game's board before moving.
"""
x, y = self.position
if keystroke.name == "KEY_RIGHT":
self.try_to_move((x + 1, y), game)
elif keystroke.name == "KEY_UP":
self.try_to_move((x, y - 1), game)
elif keystroke.name == "KEY_LEFT":
self.try_to_move((x - 1, y), game)
elif keystroke.name == "KEY_DOWN":
self.try_to_move((x, y + 1), game)
def try_to_move(self, position, game):
"""Moves to the position if it is on the game board.
"""
if game.on_board(position):
self.position = position
game.log(f"Position: {self.position}") | /retro_games-0.1.2.tar.gz/retro_games-0.1.2/retro/agent.py | 0.89141 | 0.814901 | agent.py | pypi |
from retro.errors import GraphError
class Graph:
def __init__(self, vertices=None, edges=None):
self.vertices = vertices or []
self.edges = edges or []
def __str__(self):
return '\n'.join(str(e) for e in self.edges)
def get_or_create_vertex(self, x, y):
for v in self.vertices:
if x == v.x and y == v.y:
return v
for e in self.edges:
if e.crosses(x, y):
return self.split_edge(e, x, y)
v = Vertex(x, y)
self.vertices.append(v)
return v
def get_or_create_edge(self, x0, y0, x1, y1):
v0 = self.get_or_create_vertex(x0, y0)
v1 = self.get_or_create_vertex(x1, y1)
new_edge = Edge(v0, v1)
for e in self.edges:
if e == new_edge:
new_edge.remove()
return e
return new_edge
def split_edge(self, edge, x, y):
"""
Splits an edge by inserting a new vertex along the edge.
"""
if not edge.crosses(x, y):
raise GraphError(f"Can't split edge {edge} at ({x}, {y})")
self.remove_edge(edge)
v = Vertex(x, y)
self.vertices.append(v)
self.edges.append(Edge(edge.begin, v))
self.edges.append(Edge(v, edge.end))
def remove_edge(self, edge):
if edge not in self.edges:
raise GraphError(f"Edge {edge} is not in the graph")
self.edges.remove(edge)
edge.begin.edges.remove(edge)
edge.end.edges.remove(edge)
def render(self, terminal):
for v in self.vertices:
v.render(terminal)
for e in self.edges:
e.render(terminal)
class Vertex:
CHARACTERS = {
"0000": " ",
"0001": "═",
"0010": "║",
"0011": "╗",
"0100": "═",
"0101": "═",
"0110": "╔",
"0111": "╦",
"1000": "║",
"1001": "╝",
"1010": "║",
"1011": "╣",
"1100": "╚",
"1101": "╩",
"1110": "╠",
"1111": "╬",
}
def __init__(self, x, y):
self.x = x
self.y = y
self.edges = []
def __str__(self):
return f"({self.x}, {self.y})"
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def neighbors(self):
vertices = []
for edge in self.edges:
if self == edge.begin:
vertices.append(edge.end)
else:
vertices.append(edge.begin)
return vertices
def render(self, terminal):
print(terminal.move_xy(self.x, self.y) + self.get_character())
def get_character(self):
u = self.has_up_edge()
r = self.has_right_edge()
d = self.has_down_edge()
l = self.has_left_edge()
code = ''.join([str(int(direction)) for direction in [u, r, d, l]])
return self.CHARACTERS[code]
def has_up_edge(self):
return any([v.x == self.x and v.y < self.y for v in self.neighbors()])
def has_right_edge(self):
return any([v.y == self.y and self.x < v.x for v in self.neighbors()])
def has_down_edge(self):
return any([v.x == self.x and self.y < v.y for v in self.neighbors()])
def has_left_edge(self):
return any([v.y == self.y and v.x < self.x for v in self.neighbors()])
class Edge:
def __init__(self, begin, end):
if not isinstance(begin, Vertex) or not isinstance(end, Vertex):
raise ValueError("Tried to initialize an Edge with a non-vertex")
if begin.x < end.x or begin.y < end.y:
self.begin = begin
self.end = end
else:
self.begin = end
self.end = begin
if not (self.is_horizontal() or self.is_vertical()):
raise ValueError("Edges must be horizontal or vertical.")
if self.is_horizontal() and self.is_vertical():
raise ValueError("Self-edges are not allowed.")
self.begin.edges.append(self)
self.end.edges.append(self)
def __str__(self):
return f"{self.begin} -> {self.end}"
def render(self, terminal):
if self.is_horizontal():
with terminal.location(self.begin.x + 1, self.begin.y):
line = "═" * (self.end.x - self.begin.x - 1)
print(line)
else:
for y in range(self.begin.y + 1, self.end.y):
print(terminal.move_xy(self.begin.x, y) + "║")
def is_horizontal(self):
return self.begin.y == self.end.y
def is_vertical(self):
return self.begin.x == self.end.x
def crosses(self, x, y):
if self.is_horizontal():
return self.begin.y == y and self.begin.x < x and x < self.end.x
else:
return self.begin.x == x and self.begin.y < y and y < self.end.y
def remove(self):
self.begin.edges.remove(self)
self.end.edges.remove(self) | /retro_games-0.1.2.tar.gz/retro_games-0.1.2/retro/graph.py | 0.792865 | 0.514949 | graph.py | pypi |
from random import randint
from retro.game import Game
class Apple:
"""An agent representing the Apple.
Note how Apple doesn't have ``play_turn`` or
``handle_keystroke`` methods: the Apple doesn't need to do
anything in this game. It just sits there waiting to get
eaten.
Attributes:
name: "Apple"
character: '@'
color: "red_on_black" (`Here's documentation on how colors
work <https://blessed.readthedocs.io/en/latest/colors.html>`_
position: (0, 0). The Apple will choose a random position
as soon as the game starts, but it needs an initial
position to be assigned.
"""
name = "Apple"
character = '@'
color = "red_on_black"
position = (0, 0)
def relocate(self, game):
"""Sets position to a random empty position. This method is
called whenever the snake's head touches the apple.
Arguments:
game (Game): The current game.
"""
self.position = self.random_empty_position(game)
def random_empty_position(self, game):
"""Returns a randomly-selected empty position. Uses a very
simple algorithm: Get the game's board size, choose a
random x-value between 0 and the board width, and choose
a random y-value between 0 and the board height. Now use
the game to check whether any Agents are occupying this
position. If so, keep randomly choosing a new position
until the position is empty.
"""
bw, bh = game.board_size
occupied_positions = game.get_agents_by_position()
while True:
position = (randint(0, bw-1), randint(0, bh-1))
if position not in occupied_positions:
return position
class SnakeHead:
"""An Agent representing the snake's head. When the game starts, you control
the snake head using the arrow keys. The SnakeHead always has a direction, and
will keep moving in that direction every turn. When you press an arrow key,
you change the SnakeHead's direction.
Attributes:
name: "Snake head"
position: (0,0)
character: ``'v'`` Depending on the snake head's direction, its character
changes to ``'<'``, ``'^'``, ``'>'``, or ``'v'``.
next_segment: Initially ``None``, this is a reference to a SnakeBodySegment.
growing: When set to True, the snake will grow a new segment on its next move.
"""
RIGHT = (1, 0)
UP = (0, -1)
LEFT = (-1, 0)
DOWN = (0, 1)
name = "Snake head"
position = (0, 0)
direction = DOWN
character = 'v'
next_segment = None
growing = False
def play_turn(self, game):
"""On each turn, the snake head uses its position and direction to figure out
its next position. If the snake head is able to move there (it's on the board and
not occuppied by part of the snake's body), it moves.
Then, if the snake head is on the Apple, the Apple moves to a new random position
and ``growing`` is set to True.
Now we need to deal with two situations. First, if ``next_segment`` is not None, there is
a SnakeBodySegment attached to the head. We need the body to follow the head,
so we call ``self.next_segment.move``, passing the head's old position
(this will be the body's new position), a reference to the game, and a value for
``growing``. If the snake needs to grow, we need to pass this information along
the body until it reaches the tail--this is where the next segment will be attached.
If there is no ``next_segment`` but ``self.growing`` is True, it's time to add
a body! We set ``self.next_segment`` to a new SnakeBodySegment, set its
position to the head's old position, and add it to the game. We also add 1 to the
game's score.
"""
x, y = self.position
dx, dy = self.direction
if self.can_move((x+dx, y+dy), game):
self.position = (x+dx, y+dy)
if self.is_on_apple(self.position, game):
apple = game.get_agent_by_name("Apple")
apple.relocate(game)
self.growing = True
if self.next_segment:
self.next_segment.move((x, y), game, growing=self.growing)
elif self.growing:
self.next_segment = SnakeBodySegment(1, (x, y))
game.add_agent(self.next_segment)
game.state['score'] += 1
self.growing = False
def handle_keystroke(self, keystroke, game):
"""Checks whether one of the arrow keys has been pressed.
If so, sets the SnakeHead's direction and character.
"""
x, y = self.position
if keystroke.name == "KEY_RIGHT":
self.direction = self.RIGHT
self.character = '>'
elif keystroke.name == "KEY_UP":
self.direction = self.UP
self.character = '^'
elif keystroke.name == "KEY_LEFT":
self.direction = self.LEFT
self.character = '<'
elif keystroke.name == "KEY_DOWN":
self.direction = self.DOWN
self.character = 'v'
def can_move(self, position, game):
on_board = game.on_board(position)
empty = game.is_empty(position)
on_apple = self.is_on_apple(position, game)
return on_board and (empty or on_apple)
def is_on_apple(self, position, game):
apple = game.get_agent_by_name("Apple")
return apple.position == position
class SnakeBodySegment:
"""Finally, we need an Agent for the snake's body segments.
SnakeBodySegment doesn't have ``play_turn`` or ``handle_keystroke`` methods because
it never does anything on its own. It only moves when the SnakeHead, or the previous
segment, tells it to move.
Arguments:
segment_id (int): Keeps track of how far back this segment is from the head.
This is used to give the segment a unique name, and also to keep track
of how many points the player earns for eating the next apple.
position (int, int): The initial position.
Attributes:
character: '*'
next_segment: Initially ``None``, this is a reference to a SnakeBodySegment
when this segment is not the last one in the snake's body.
"""
character = '*'
next_segment = None
def __init__(self, segment_id, position):
self.segment_id = segment_id
self.name = f"Snake body segment {segment_id}"
self.position = position
def move(self, new_position, game, growing=False):
"""When SnakeHead moves, it sets off a chain reaction, moving all its
body segments. Whenever the head or a body segment has another segment
(``next_segment``), it calls that segment's ``move`` method.
This method updates the SnakeBodySegment's position. Then, if
``self.next_segment`` is not None, calls that segment's ``move`` method.
If there is no next segment and ``growing`` is True, then we set
``self.next_segment`` to a new SnakeBodySegment in this segment's old
position, and update the game's score.
Arguments:
new_position (int, int): The new position.
game (Game): A reference to the current game.
growing (bool): (Default False) When True, the snake needs to
add a new segment.
"""
old_position = self.position
self.position = new_position
if self.next_segment:
self.next_segment.move(old_position, game, growing=growing)
elif growing:
self.next_segment = SnakeBodySegment(self.segment_id + 1, old_position)
game.add_agent(self.next_segment)
game.state['score'] += self.segment_id + 1
if __name__ == '__main__':
head = SnakeHead()
apple = Apple()
game = Game([head, apple], {'score': 0}, board_size=(32, 16), framerate=12)
apple.relocate(game)
game.play() | /retro_games-0.1.2.tar.gz/retro_games-0.1.2/retro/examples/snake.py | 0.867822 | 0.563198 | snake.py | pypi |
from random import randint
from retro.game import Game
HEIGHT = 25
WIDTH = 25
class Spaceship:
"""A player-controlled agent which moves left and right, dodging asteroids.
Spaceship is a pretty simple class. The ship's character is ``^``, and
its position starts at the bottom center of the screen.
"""
name = "ship"
character = '^'
position = (WIDTH // 2, HEIGHT - 1)
color = "black_on_skyblue1"
def handle_keystroke(self, keystroke, game):
"""When the
left or arrow key is pressed, it moves left or right. If the ship's
new position is empty, it moves to that position. If the new position
is occupied (by an asteroid!) the game ends.
"""
x, y = self.position
if keystroke.name in ("KEY_LEFT", "KEY_RIGHT"):
if keystroke.name == "KEY_LEFT":
new_position = (x - 1, y)
else:
new_position = (x + 1, y)
if game.on_board(new_position):
if game.is_empty(new_position):
self.position = new_position
else:
self.explode()
game.end()
def explode(self):
"""Sets the ship's character to ``*`` and its color to red.
"""
self.color = "crimson_on_skyblue1"
self.character = '*'
class Asteroid:
"""When Asteroids are spawned, they fall down the screen until they
reach the bottom row and are removed.
An Asteroid's position is set when it is created.
Whenever an asteroid moves, it
checks whether it has it the ship.
"""
character = 'O'
color = "deepskyblue1_on_skyblue1"
def __init__(self, position):
self.position = position
def play_turn(self, game):
"""Nothing happens unless
``game.turn_number`` is divisible by 2. The result is that asteroids
only move on even-numbered turns. If the asteroid is at the bottom of
the screen, it has run its course and should be removed from the game.
Otherwise, the asteroid's new position is one space down from its old
position. If the asteroid's new position is the same as the ship's
position, the game ends.
"""
if game.turn_number % 2 == 0:
self.set_color()
x, y = self.position
if y == HEIGHT - 1:
game.remove_agent(self)
else:
ship = game.get_agent_by_name('ship')
new_position = (x, y + 1)
if new_position == ship.position:
ship.explode()
game.end()
else:
self.position = new_position
def set_color(self):
"""To add to the game's drama, asteroids gradually become visible as they
fall down the screen. This method calculates the ratio of the asteroid's
position compared to the screen height--0 is the top of the screen and 1 is
the bottom ot the screen. Then sets the asteroid's color depending on the
ratio. (`Available colors <https://blessed.readthedocs.io/en/latest/colors.html>`_)
"""
x, y = self.position
ratio = y / HEIGHT
if ratio < 0.2:
self.color = "deepskyblue1_on_skyblue1"
elif ratio < 0.4:
self.color = "deepskyblue2_on_skyblue1"
elif ratio < 0.6:
self.color = "deepskyblue3_on_skyblue1"
else:
self.color = "deepskyblue4_on_skyblue1"
class AsteroidSpawner:
"""An agent which is not displayed on the board, but which constantly spawns
asteroids.
"""
display = False
def play_turn(self, game):
"""Adds 1 to the game score and then uses
:py:meth:`~retro.examples.nav.should_spawn_asteroid` to decide whether to
spawn an asteroid. When :py:meth:`~retro.examples.nav.should_spawn_asteroid`
comes back ``True``, creates a new instance of
:py:class:`~retro.examples.nav.Asteroid` at a random position along the
top of the screen and adds the asteroid to the game.
"""
game.state['score'] += 1
if self.should_spawn_asteroid(game.turn_number):
asteroid = Asteroid((randint(0, WIDTH - 1), 0))
game.add_agent(asteroid)
def should_spawn_asteroid(self, turn_number):
"""Decides whether to spawn an asteroid.
Uses a simple but effective algorithm to make the game get
progressively more difficult: choose a random number and return
``True`` if the number is less than the current turn number. At
the beginning of the game, few asteroids will be spawned. As the
turn number climbs toward 1000, asteroids are spawned almost
every turn.
Arguments:
turn_number (int): The current turn in the game.
"""
return randint(0, 1000) < turn_number
if __name__ == '__main__':
ship = Spaceship()
spawner = AsteroidSpawner()
game = Game(
[ship, spawner],
{"score": 0},
board_size=(WIDTH, HEIGHT),
color="deepskyblue4_on_skyblue1",
)
game.play() | /retro_games-0.1.2.tar.gz/retro_games-0.1.2/retro/examples/nav.py | 0.819424 | 0.4856 | nav.py | pypi |
from functools import partial
import numpy as np
import torch
from torch.utils.data import Dataset
from retro_pytorch.retrieval import EOS_ID
from retro_pytorch.utils import memmap
# knn to retrieved chunks
def knn_to_retrieved_chunks(
knns,
chunks_memmap,
*,
add_continuations,
num_chunks,
pad_id = 0,
eos_id = EOS_ID,
):
# derive mask for no neighbors found (-1)
no_neighbor_mask = knns == -1
knns = np.maximum(knns, 0)
# get neighbor and continuation chunks
knn_chunks = chunks_memmap[knns]
is_last_document_chunk = np.any(knn_chunks == eos_id, axis = -1, keepdims = True)
# use presence of [EOS] in chunk as way to detect document boundaries
# [EOS] in BERT tokenizer is 102
retrieved = knn_chunks[..., :-1]
if add_continuations:
continuation_indices = np.clip(knns + 1, 0, num_chunks - 1) # chunks are stored contiguously
continuation_chunks = chunks_memmap[continuation_indices][..., :-1]
continuation_chunks *= ~is_last_document_chunk
# combine neighbors with continuations
retrieved = np.concatenate((retrieved, continuation_chunks), axis = -1)
# mask out any nearest neighbor chunks that was -1 (not found at index time) to padding id
retrieved = np.where(~no_neighbor_mask[..., None], retrieved, pad_id)
return retrieved
# dataset
class RETRODataset(Dataset):
def __init__(
self,
*,
num_chunks,
chunk_size,
seq_len,
num_sequences,
num_neighbors,
chunk_memmap_path,
chunk_nn_memmap_path,
seq_memmap_path,
eos_id = EOS_ID,
pad_id = 0.,
add_continuations = True
):
super().__init__()
self.num_chunks = num_chunks
self.num_sequences = num_sequences
self.seq_num_chunks = seq_len // chunk_size
self.eos_id = eos_id
self.pad_id = pad_id
num_chunks_with_padding = num_chunks + self.seq_num_chunks
chunks_shape = (num_chunks_with_padding, chunk_size + 1)
knn_shape = (num_chunks_with_padding, num_neighbors)
self.add_continuations = add_continuations
self.get_chunks = partial(memmap, chunk_memmap_path, dtype = np.int32, shape = chunks_shape)
self.get_knns = partial(memmap, chunk_nn_memmap_path, dtype = np.int32, shape = knn_shape)
self.get_seqs = partial(memmap, seq_memmap_path, dtype = np.int32, shape = (num_sequences,))
def __len__(self):
return self.num_sequences
def __getitem__(self, ind):
with self.get_chunks() as chunks_memmap, self.get_knns() as knns_memmap, self.get_seqs() as seqs_memmap:
begin_chunk_index = seqs_memmap[ind]
chunk_range = slice(begin_chunk_index, (begin_chunk_index + self.seq_num_chunks))
chunks = chunks_memmap[chunk_range]
# excise the last token, except for last token of last chunk
seq_tokens = np.concatenate((chunks[:, :-1].flatten(), chunks[-1, -1:]))
# mask out (with padding tokens) any token following an <eos> | disallow having more than 1 document in a sequence, as it would break RETRO's CCA
seq_mask = np.cumsum(seq_tokens == self.eos_id, axis = 0)
seq_mask = np.pad(seq_mask, (1, 0))[:-1] == 0.
seq_tokens = np.where(seq_mask, seq_tokens, 0.)
# derive retrieved tokens
knns = knns_memmap[chunk_range]
retrieved = knn_to_retrieved_chunks(
knns,
chunks_memmap,
add_continuations = self.add_continuations,
eos_id = self.eos_id,
num_chunks = self.num_chunks
)
seq_tokens_torch = torch.from_numpy(seq_tokens).long()
retrieved_torch = torch.from_numpy(retrieved).long()
return seq_tokens_torch, retrieved_torch | /retro_pytorch-0.3.8-py3-none-any.whl/retro_pytorch/data.py | 0.733261 | 0.413714 | data.py | pypi |
from typing import List
from rich.console import Console
import torch
from transformers import BertTokenizer, BertModel
from transformers import logging
logging.set_verbosity_error()
class BERTForChunkEmbeddings:
"""
## BERT Embeddings
For a given chunk of text $N$ this class generates BERT embeddings $\text{B\small{ERT}}(N)$.
$\text{B\small{ERT}}(N)$ is the average of BERT embeddings of all the tokens in $N$.
"""
def __init__(self, model_name, device: torch.device):
self.device = device
console = Console()
with console.status(f"Loading {model_name} tokenizer") as status:
# Load the BERT tokenizer from [HuggingFace](https://huggingface.co/bert-base-uncased)
self.tokenizer = BertTokenizer.from_pretrained(model_name)
console.log(f"{model_name} tokenizer loaded")
with console.status(f"Loading {model_name} model") as status:
# Load the BERT model from [HuggingFace](https://huggingface.co/bert-base-uncased)
self.model = BertModel.from_pretrained(model_name)
# Move the model to `device`
self.model.to(device)
console.log(f"{model_name} loaded")
@staticmethod
def _trim_chunk(chunk: str):
"""
In this implementation, we do not make chunks with a fixed number of tokens.
One of the reasons is that this implementation uses character-level tokens and BERT
uses its sub-word tokenizer.
So this method will truncate the text to make sure there are no partial tokens.
For instance, a chunk could be like `s a popular programming la`, with partial
words (partial sub-word tokens) on the ends.
We strip them off to get better BERT embeddings.
As mentioned earlier this is not necessary if we broke chunks after tokenizing.
"""
# Strip whitespace
stripped = chunk.strip()
# Break words
parts = stripped.split()
# Remove first and last pieces
stripped = stripped[len(parts[0]):-len(parts[-1])]
# Remove whitespace
stripped = stripped.strip()
# If empty return original string
if not stripped:
return chunk
# Otherwise, return the stripped string
else:
return stripped
def __call__(self, chunks: List[str]):
"""
### Get $\text{B\small{ERT}}(N)$ for a list of chunks.
"""
with torch.no_grad():
trimmed_chunks = [self._trim_chunk(c) for c in chunks]
tokens = self.tokenizer(trimmed_chunks, return_tensors='pt', add_special_tokens=False, padding=True)
input_ids = tokens['input_ids'].to(self.device)
attention_mask = tokens['attention_mask'].to(self.device)
token_type_ids = tokens['token_type_ids'].to(self.device)
output = self.model(input_ids=input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids)
state = output['last_hidden_state']
emb = (state * attention_mask[:, :, None]).sum(dim=1) / attention_mask[:, :, None].sum(dim=1)
return emb | /retro_transformer-1.0.3.tar.gz/retro_transformer-1.0.3/retro_transformer/bert.py | 0.934099 | 0.828315 | bert.py | pypi |
from typing import Dict
from labml_nn.optimizers import WeightDecay
from labml_nn.optimizers.amsgrad import AMSGrad
class Noam(AMSGrad):
"""
## Noam Optimizer
This class extends from Adam optimizer defined in [`adam.py`](adam.html).
"""
def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-16,
weight_decay: WeightDecay = WeightDecay(),
optimized_update: bool = True,
amsgrad=False,
warmup=0, d_model=512, defaults=None):
"""
### Initialize the optimizer
* `params` is the list of parameters
* `lr` is the learning rate $\alpha$
* `betas` is a tuple of ($\beta_1$, $\beta_2$)
* `eps` is $\hat{\epsilon}$ or $\epsilon$ based on `optimized_update`
* `weight_decay` is an instance of class `WeightDecay` defined in [`__init__.py`](index.html)
* 'optimized_update' is a flag whether to optimize the bias correction of the second moment
by doing it after adding $\epsilon$
* `amsgrad` is a flag indicating whether to use AMSGrad or fallback to plain Adam
* `warmup` number of warmup steps
* `d_model` model size; i.e. number of dimensions in the transformer
* `defaults` is a dictionary of default for group values.
This is useful when you want to extend the class `AdamWarmup`.
"""
defaults = {} if defaults is None else defaults
defaults.update(dict(warmup=warmup))
super().__init__(params, lr, betas, eps, weight_decay, optimized_update, amsgrad, defaults)
self.d_model = d_model
def get_lr(self, state: Dict[str, any], group: Dict[str, any]):
"""
### Get learning-rate
$$\alpha \frac{1}{\sqrt{d_{model}}} \min \bigg(\frac{1}{\sqrt{t}}, \frac{t}{w^{3/2}}\bigg)$$
where $w$ is the number of warmup steps.
"""
# $$\min \bigg(\frac{1}{\sqrt{t}}, \frac{t}{w^{3/2}}\bigg)$$
factor = min(state['step'] ** (-0.5), state['step'] * group['warmup'] ** (-1.5))
# $$\alpha \frac{1}{\sqrt{d_{model}}} \min \bigg(\frac{1}{\sqrt{t}}, \frac{t}{w^{3/2}}\bigg)$$
return group['lr'] * self.d_model ** (-0.5) * factor | /retro_transformer-1.0.3.tar.gz/retro_transformer-1.0.3/retro_transformer/tools/optimizer.py | 0.954052 | 0.852874 | optimizer.py | pypi |
import dataclasses
from copy import copy, deepcopy
from dataclasses import field, dataclass
from typing import (
Any,
Dict,
List,
Type,
Union,
Generic,
Mapping,
TypeVar,
Iterable,
Iterator,
)
__all__ = ["T_Message", "T_MessageSegment", "T_MS", "Message", "MessageSegment"]
T_Message = TypeVar("T_Message", bound="Message")
T_MessageSegment = TypeVar("T_MessageSegment", bound="MessageSegment")
# 可以转化为 MessageSegment 的类型
T_MS = Union[T_MessageSegment, str, Mapping]
class Message(List[T_MessageSegment]):
"""消息。
本类是 `List` 的子类，并重写了 `__init__()` 方法，
可以直接处理 str, Mapping, Iterable[Mapping], T_MessageSegment, T_Message。
其中 str 的支持需要适配器开发者重写 `_str_to_message_segment()` 方法实现。
本类重写了 `+` 和 `+=` 运算符，可以直接和 Message, MessageSegment 等类型的对象执行取和运算。
若开发者实现了 MessageSegment 的子类则需要重写 `_message_segment_class()` 方法，
并在 MessageSegment 的子类中重写 `_message_class()` 方法。
"""
def __init__(
self,
message: Union[None, T_Message, T_MS, Iterable[T_MS]] = None,
*args,
**kwargs,
):
super().__init__(*args, **kwargs)
if message is None:
return
elif isinstance(message, self.__class__):
self.extend(message)
else:
self.extend(self._construct(message))
@property
def _message_segment_class(self) -> Type[T_MessageSegment]:
"""若开发者实现了 MessageSegment 的子类则需要重写此方法。
Returns:
MessageSegment 类。
"""
return MessageSegment
@classmethod
def __get_validators__(cls):
"""pydantic 自定义校验器。"""
yield cls._validate
@classmethod
def _validate(cls, value):
return cls(value)
def _construct(
self, msg: Union[T_MS, Iterable[T_MS]]
) -> Iterator[T_MessageSegment]:
"""用于将 str, Mapping, Iterable[Mapping] 等类型转换为 MessageSegment。
用于 pydantic 数据解析和方便用户使用。
Args:
msg: 要解析为 MessageSegment 的数据。
Returns:
MessageSegment 生成器。
"""
if isinstance(msg, self._message_segment_class):
yield msg
elif isinstance(msg, Mapping):
yield self._mapping_to_message_segment(msg)
elif isinstance(msg, str):
yield self._str_to_message_segment(msg)
elif isinstance(msg, Iterable):
for seg in msg:
for i in self._construct(seg):
yield i
def _mapping_to_message_segment(self, msg: Mapping) -> T_MessageSegment:
"""用于将 Mapping 转换为 MessageSegment，如有需要，子类可重写此方法以更改对 Mapping 的默认行为。
Args:
msg: 要解析为 MessageSegment 的数据。
Returns:
由 Mapping 转换的 MessageSegment。
"""
return self._message_segment_class(**msg)
def _str_to_message_segment(self, msg: str) -> T_MessageSegment:
"""用于将 str 转换为 MessageSegment，子类应重写此方法以支持 str 及支持新的消息字段类。
Args:
msg: 要解析为 MessageSegment 的数据。
Returns:
由 str 转换的 MessageSegment。
"""
raise NotImplementedError
def __repr__(self) -> str:
return "Message:[{}]".format(",".join(map(lambda x: repr(x), self)))
def __str__(self) -> str:
return "".join(map(lambda x: str(x), self))
def __contains__(self, item) -> bool:
if isinstance(item, str):
return item in str(self)
return super().__contains__(item)
def __add__(
self: T_Message, other: Union[T_Message, T_MessageSegment, str]
) -> T_Message:
return self.__class__(self).__iadd__(other)
def __radd__(
self: T_Message, other: Union[T_Message, T_MessageSegment, str]
) -> T_Message:
return self.__class__(other).__iadd__(self)
def __iadd__(
self: T_Message, other: Union[T_Message, T_MessageSegment, str]
) -> T_Message:
if isinstance(other, type(self)):
self.extend(other)
if isinstance(other, self._message_segment_class):
self.append(other)
elif isinstance(other, str):
self.extend(self._construct(other))
else:
raise TypeError(
f"unsupported operand type(s) for +: '{type(self)}' and '{type(other)}'"
)
return self
def is_text(self) -> bool:
"""
Returns:
是否是纯文本消息。
"""
return all(map(lambda x: x.is_text(), self))
def get_plain_text(self) -> str:
"""获取消息中的纯文本部分。
Returns:
消息中的纯文本部分。
"""
return "".join(map(lambda x: str(x), filter(lambda x: x.is_text(), self)))
def copy(self) -> T_Message:
"""返回自身的浅复制。
Returns:
自身的浅复制。
"""
return self.__class__(self)
def deepcopy(self) -> T_Message:
"""返回自身的深复制。
Returns:
自身的深复制。
"""
return deepcopy(self)
def startswith(
self, prefix: Union[str, T_MessageSegment], start=None, end=None
) -> bool:
"""实现类似字符串的 `startswith()` 方法。
当 `prefix` 类型是 str 时，会将自身转换为 str 类型，再调用 str 类型的 `startswith()` 方法。
当 `prefix` 类型是 T_MessageSegment 时，`start` 和 `end` 参数将不其作用，
会判断列表的第一个消息字段是否和 `prefix` 相等。
Args:
prefix: 前缀。
start: 开始检查位置。
end: 停止检查位置。
Returns:
检查结果。
"""
if isinstance(prefix, str):
return str(self).startswith(prefix, start, end)
elif isinstance(prefix, self._message_segment_class):
if len(self) == 0:
return False
return self[0] == prefix
raise TypeError(
f"first arg must be str or {self._message_segment_class}，not {type(prefix)}"
)
def endswith(
self, suffix: Union[str, T_MessageSegment], start=None, end=None
) -> bool:
"""实现类似字符串的 `endswith()` 方法。
当 `suffix` 类型是 str 时，会将自身转换为 str 类型，再调用 str 类型的 `endswith()` 方法。
当 `suffix` 类型是 T_MessageSegment 时，`start` 和 `end` 参数将不其作用，
会判断列表的最后一个消息字段是否和 `suffix` 相等。
Args:
suffix: 后缀。
start: 开始检查位置。
end: 停止检查位置。
Returns:
检查结果。
"""
if isinstance(suffix, str):
return str(self).endswith(suffix, start, end)
elif isinstance(suffix, self._message_segment_class):
if len(self) == 0:
return False
return self[-1] == suffix
raise TypeError(
f"first arg must be str or {self._message_segment_class}，not {type(suffix)}"
)
def replace(
self,
old: Union[str, T_MessageSegment],
new: Union[str, T_MessageSegment, None],
count: int = -1,
) -> T_Message:
"""实现类似字符串的 `replace()` 方法。
当 `old` 为 str 类型时，`new` 也必须是 str ，本方法将仅对 `is_text()` 为 True 的消息字段进行处理。
当 `old` 为 MessageSegment 类型时，`new` 可以是 MessageSegment 或 None，本方法将对所有消息字段进行处理，
并替换符合条件的消息字段。None 表示删除匹配到的消息字段。
Args:
old: 被匹配的字符串或消息字段。
new: 被替换为的字符串或消息字段。
count: 替换的次数。
Returns:
替换后的消息对象。
"""
if type(old) == str:
if type(new) != str:
raise TypeError("when type of old is str, type of new must be str.")
return self._replace_str(old, new, count)
elif isinstance(old, self._message_segment_class):
if not (isinstance(new, self._message_segment_class) or new is None):
raise TypeError(
"when type of old is MessageSegment, "
"type of new must be MessageSegment or None."
)
temp_msg = self.deepcopy()
for index, item in enumerate(temp_msg):
if count == 0:
break
if item == old:
temp_msg[index] = new
count -= 1
if new is None:
temp_msg = self.__class__(filter(lambda x: x is not None, self))
return temp_msg
else:
raise TypeError("type of old must be str or MessageSegment")
def _replace_str(self, old: str, new: str, count: int = -1) -> T_Message:
"""实现类似字符串的 `replace()` 方法。
本方法将被 `replace()` 方法调用以处理 str 类型的替换，
默认将 MessageSegment 对象的 data['text'] 视为存放纯文本的位置。
适配器开发者可自行重写此方法以适配其他情况。
Args:
old: 被匹配的字符串或消息字段。
new: 被替换为的字符串或消息字段。
count: 替换的次数。
Returns:
替换后的消息对象。
"""
temp_msg = self.deepcopy()
for index, item in enumerate(temp_msg):
item: MessageSegment
if count == 0:
break
if item.is_text() and old in item.data["text"]:
if count == -1:
temp_msg[index].data["text"] = item.data["text"].replace(old, new)
else:
replace_times = min(count, item.data["text"].count(old))
temp_msg[index].data["text"] = item.data["text"].replace(
old, new, replace_times
)
count -= replace_times
return temp_msg
@dataclass
class MessageSegment(Mapping, Generic[T_Message]):
"""消息字段。
本类实现了所有映射类型的方法，这些方法全部是对 `data` 属性的操作。
本类重写了 `+` 和 `+=` 运算符，可以直接和 Message, MessageSegment 等类型的对象执行取和运算，返回 Message 对象。
若开发者实现了 Message 和 MessageSegment 的子类则需要重写 `_message_class()` 方法。
Attributes:
type: 消息字段类型。
data: 消息字段内容。
"""
type: str
data: Dict[str, Any] = field(default_factory=dict)
@property
def _message_class(self) -> Type[T_Message]:
"""若开发者实现了 Message 和 MessageSegment 的子类则需要重写此方法。
Returns:
Message 类。
"""
return Message
def as_dict(self) -> Dict[str, Any]:
"""将当前对象解析为 Dict 对象，开发者可重写本方法以适配特殊的解析方式。
Returns:
Dict 对象。
"""
return dataclasses.asdict(self)
def __str__(self) -> str:
return str(self.data)
def __repr__(self) -> str:
return f"MessageSegment<{self.type}>:{str(self)}"
def __getitem__(self, key) -> Any:
return self.data[key]
def __setitem__(self, key, value):
self.data[key] = value
def __delitem__(self, key):
del self.data[key]
def __len__(self) -> int:
return len(self.data)
def __iter__(self):
yield from self.data.__iter__()
def __contains__(self, key) -> bool:
return key in self.data
def __eq__(self, other: T_MessageSegment) -> bool:
return self.type == other.type and self.data == other.data
def __ne__(self, other: T_MessageSegment) -> bool:
return not self.__eq__(other)
def __add__(self, other) -> T_Message:
return self._message_class(self) + other
def __radd__(self, other) -> T_Message:
return self._message_class(other) + self
def get(self, key: str, default=None):
return self.data.get(key, default)
def keys(self):
return self.data.keys()
def values(self):
return self.data.values()
def items(self):
return self.data.items()
def is_text(self) -> bool:
"""
Returns:
是否是纯文本消息字段。
"""
return self.type == "text"
def copy(self) -> T_MessageSegment:
"""返回自身的浅复制。
Returns:
自身的浅复制。
"""
return copy(self)
def deepcopy(self) -> T_MessageSegment:
"""返回自身的深复制。
Returns:
自身的深复制。
"""
return deepcopy(self) | /retrofor_wut-4.0.2-py3-none-any.whl/retrofor_wut/message.py | 0.856692 | 0.261832 | message.py | pypi |
import os
import json
import asyncio
import inspect
import os.path
import pkgutil
import importlib
import traceback
import dataclasses
from abc import ABC
from types import ModuleType
from functools import partial
from typing_extensions import ParamSpec
from importlib.abc import MetaPathFinder
from importlib.machinery import PathFinder
from typing import Any, List, Type, Tuple, TypeVar, Callable, Iterable, Coroutine
from retrofor_wut.config import ConfigModel
__all__ = [
"ModulePathFinder",
"is_config_class",
"get_classes_from_module",
"get_classes_from_module_name",
"get_classes_from_dir",
"DataclassEncoder",
"samefile",
"sync_func_wrapper",
]
_T = TypeVar("_T")
_P = ParamSpec("_P")
_R = TypeVar("_R")
class ModulePathFinder(MetaPathFinder):
"""用于查找 retrofor_wut 组件的元路径查找器。"""
path: List[str] = []
def find_spec(self, fullname, path=None, target=None):
if path is None:
path = []
return PathFinder.find_spec(fullname, self.path + list(path), target)
def is_config_class(config_class: Any) -> bool:
"""判断一个对象是否是配置类。
Args:
config_class: 待判断的对象。
Returns:
返回是否是配置类。
"""
return (
inspect.isclass(config_class)
and issubclass(config_class, ConfigModel)
and isinstance(getattr(config_class, "__config_name__", None), str)
and ABC not in config_class.__bases__
and not inspect.isabstract(config_class)
)
def get_classes_from_module(
module: ModuleType, super_class: Type[_T]
) -> List[Type[_T]]:
"""从模块中查找指定类型的类。
Args:
module: Python 模块。
super_class: 要查找的类的超类。
Returns:
返回符合条件的类的列表。
"""
classes: List[Type[_T]] = []
for _, module_attr in inspect.getmembers(module, inspect.isclass):
module_attr: type
if (
(inspect.getmodule(module_attr) or module) is module
and issubclass(module_attr, super_class)
and module_attr != super_class
and ABC not in module_attr.__bases__
and not inspect.isabstract(module_attr)
):
classes.append(module_attr)
return classes
def get_classes_from_module_name(
name: str, super_class: Type[_T]
) -> List[Tuple[Type[_T], ModuleType]]:
"""从指定名称的模块中查找指定类型的类。
Args:
name: 模块名称，格式和 Python `import` 语句相同。
super_class: 要查找的类的超类。
Returns:
返回由符合条件的类和模块组成的元组的列表。
Raises:
ImportError: 当导入模块过程中出现错误。
"""
try:
importlib.invalidate_caches()
module = importlib.import_module(name)
importlib.reload(module)
return list(
map(lambda x: (x, module), get_classes_from_module(module, super_class))
)
except BaseException as e:
# 不捕获 KeyboardInterrupt
# 捕获 KeyboardInterrupt 会阻止用户关闭 Python 当正在导入的模块陷入死循环时
if isinstance(e, KeyboardInterrupt):
raise e
raise ImportError(e, traceback.format_exc()) from e
def get_classes_from_dir(
dirs: Iterable[str], super_class: Type[_T]
) -> List[Tuple[Type[_T], ModuleType]]:
"""从指定路径列表中的所有模块中查找指定类型的类，以 `_` 开头的插件不会被导入。路径可以是相对路径或绝对路径。
Args:
dirs: 储存模块的路径的列表。
super_class: 要查找的类的超类。
Returns:
返回由符合条件的类和模块组成的元组的列表。
"""
classes: List[Tuple[Type[_T], ModuleType]] = []
for module_info in pkgutil.iter_modules(dirs):
if not module_info.name.startswith("_"):
try:
classes.extend(
get_classes_from_module_name(module_info.name, super_class)
)
except ImportError:
continue
return classes
class DataclassEncoder(json.JSONEncoder):
"""用于解析 MessageSegment 的 JSONEncoder 类。"""
def default(self, o):
if dataclasses.is_dataclass(o):
return o.as_dict()
return super().default(o)
def samefile(path1: str, path2: str) -> bool:
"""一个 `os.path.samefile` 的简单包装。
Args:
path1: 路径1。
path2: 路径2。
Returns:
如果两个路径是否指向相同的文件或目录。
"""
try:
return path1 == path2 or os.path.samefile(path1, path2)
except OSError:
return False
def sync_func_wrapper(
func: Callable[_P, _R], to_thread: bool = False
) -> Callable[_P, Coroutine[None, None, _R]]:
"""包装一个同步函数为异步函数，当 func 为
Args:
func: 待包装的同步函数。
to_thread: 在独立的线程中运行同步函数。
Returns:
异步函数。
"""
if to_thread:
async def _wrapper(*args: _P.args, **kwargs: _P.kwargs):
loop = asyncio.get_running_loop()
func_call = partial(func, *args, **kwargs)
return await loop.run_in_executor(None, func_call)
else:
async def _wrapper(*args: _P.args, **kwargs: _P.kwargs):
return func(*args, **kwargs)
return _wrapper | /retrofor_wut-4.0.2-py3-none-any.whl/retrofor_wut/utils.py | 0.583322 | 0.163596 | utils.py | pypi |
import json
from typing import Any, Dict, List, Type, Union, Mapping, Iterable, Optional
from retrofor_wut.utils import DataclassEncoder
from retrofor_wut.message import Message, MessageSegment
__all__ = ["T_MiraiMSG", "MiraiMessage", "MiraiMessageSegment"]
T_MiraiMSG = Union[
str, Mapping, Iterable[Mapping], "MiraiMessageSegment", "MiraiMessage"
]
class MiraiMessage(Message["MiraiMessageSegment"]):
@property
def _message_segment_class(self) -> Type["MiraiMessageSegment"]:
return MiraiMessageSegment
def _str_to_message_segment(self, msg: str) -> "MiraiMessageSegment":
return self._message_segment_class.plain(msg)
def as_message_chain(self) -> List[Dict[str, Any]]:
"""返回符合 Mirai-api-http 标准的 messageChain 数组。
Returns:
messageChain 数组。
"""
return list(map(lambda x: x.as_dict(), self))
class MiraiMessageSegment(MessageSegment["MiraiMessage"]):
def __init__(self, type: str, **data): # noqa
super().__init__(
type=type, data={k: v for k, v in data.items() if v is not None}
)
def _message_class(self) -> Type["MiraiMessage"]:
return MiraiMessage
def __str__(self) -> str:
if self.type == "Plain":
return self.data.get("text", "")
return json.dumps(self, cls=DataclassEncoder)
def as_dict(self) -> Dict[str, Any]:
"""返回符合 Mirai-api-http 标准的消息字段字典。
Returns:
符合 Mirai-api-http 标准的消息字段字典。
"""
return {"type": self.type, **self.data}
def is_text(self) -> bool:
"""
Returns:
是否是纯文本消息字段。
"""
return self.type == "Plain"
@classmethod
def source(cls, id_: int, time: int):
return cls(type="Source", id=id_, time=time)
@classmethod
def quote(
cls,
id_: int,
group_id: int,
sender_id: int,
target_id: int,
origin: MiraiMessage,
):
return cls(
type="Quote",
id=id_,
groupId=group_id,
senderId=sender_id,
targetId=target_id,
origin=origin.as_message_chain(),
)
@classmethod
def at(cls, target: int):
return cls(type="At", target=target)
@classmethod
def at_all(cls):
return cls(type="AtAll")
@classmethod
def face(cls, face_id: Optional[int] = None, name: Optional[str] = None):
return cls(type="Face", faceId=face_id, name=name)
@classmethod
def plain(cls, text: str):
return cls(type="Plain", text=text)
@classmethod
def image(
cls,
image_id: Optional[str] = None,
url: Optional[str] = None,
path: Optional[str] = None,
):
return cls(type="Image", imageId=image_id, url=url, path=path)
@classmethod
def flash_image(
cls,
image_id: Optional[str] = None,
url: Optional[str] = None,
path: Optional[str] = None,
):
return cls(type="FlashImage", imageId=image_id, url=url, path=path)
@classmethod
def voice(
cls,
voice_id: Optional[str] = None,
url: Optional[str] = None,
path: Optional[str] = None,
):
return cls(type="Voice", imageId=voice_id, url=url, path=path)
@classmethod
def xml(cls, xml: str):
return cls(type="Xml", xml=xml)
@classmethod
def json(cls, json_: str):
return cls(type="Json", json=json_)
@classmethod
def app(cls, content: str):
return cls(type="App", content=content)
@classmethod
def poke(cls, name: str):
return cls(type="Poke", name=name)
@classmethod
def dice(cls, value: int):
return cls(type="Dice", value=value)
@classmethod
def music_share(
cls,
kind: str,
title: str,
summary: str,
jump_url: str,
picture_url: str,
music_url: str,
brief: str,
):
return cls(
type="MusicShare",
kind=kind,
title=title,
summary=summary,
jumpUrl=jump_url,
pictureUrl=picture_url,
musicUrl=music_url,
brief=brief,
) | /retrofor_wut-4.0.2-py3-none-any.whl/retrofor_wut/adapter/mirai/message.py | 0.795579 | 0.178025 | message.py | pypi |
from typing import Any, Dict, List, Optional
from retrofor_wut.message import MessageSegment
__all__ = ["DingTalkMessage"]
class DingTalkMessage(MessageSegment[None]):
"""DingTalk 消息"""
@property
def _message_class(self) -> None:
return None
def __str__(self):
if self.type == "text":
return self.data["content"]
else:
return super().__str__()
def as_dict(self) -> Dict[str, Dict[str, Any]]:
"""返回符合钉钉消息标准的消息字段字典。
Returns:
符合钉钉消息标准的消息字段字典。
"""
if self.type == "raw":
return self.data
else:
return {self.type: self.data}
@classmethod
def raw(cls, data: Dict[str, Any]) -> "DingTalkMessage":
"""DingTalk 原始消息"""
return cls(type="raw", data=data)
@classmethod
def text(cls, content: str) -> "DingTalkMessage":
"""DingTalk text 消息"""
return cls(type="text", data={"content": content})
@classmethod
def link(
cls, text: str, title: str, message_url: str, pic_url: Optional[str] = None
):
"""DingTalk link 消息"""
return cls(
type="link",
data={
"text": text,
"title": title,
"messageUrl": message_url,
"picUrl": pic_url,
},
)
@classmethod
def markdown(cls, title: str, text: str):
"""DingTalk markdown 消息"""
return cls(type="markdown", data={"title": title, "text": text})
@classmethod
def action_card_single_btn(
cls,
title: str,
text: str,
single_title: str,
single_url: str,
btn_orientation: str = "0",
):
"""DingTalk 整体跳转 actionCard 消息"""
return cls(
type="actionCard",
data={
"title": title,
"text": text,
"singleTitle": single_title,
"singleURL": single_url,
"btnOrientation": btn_orientation,
},
)
@classmethod
def action_card_multi_btns(
cls, title: str, text: str, btns: list, btn_orientation: str = "0"
):
"""DingTalk 独立跳转 actionCard 消息"""
return cls(
type="actionCard",
data={
"title": title,
"text": text,
"btns": btns,
"btnOrientation": btn_orientation,
},
)
@classmethod
def feed_card(cls, links: list):
"""DingTalk feedCard 消息"""
return cls(type="feedCard", data={"links": links})
@classmethod
def at(
cls,
at_mobiles: Optional[List[str]] = None,
at_user_ids: Optional[List[str]] = None,
is_at_all: bool = False,
):
"""DingTalk At 信息"""
return cls(
type="at",
data={
"atMobiles": at_mobiles,
"atUserIds": at_user_ids,
"isAtAll": is_at_all,
},
) | /retrofor_wut-4.0.2-py3-none-any.whl/retrofor_wut/adapter/dingtalk/message.py | 0.785309 | 0.229039 | message.py | pypi |
from typing import Type, Union, Literal, Mapping, Iterable, Optional
from retrofor_wut.message import Message, MessageSegment
__all__ = ["T_CQMSG", "CQHTTPMessage", "CQHTTPMessageSegment", "escape"]
T_CQMSG = Union[
str, Mapping, Iterable[Mapping], "CQHTTPMessageSegment", "CQHTTPMessage"
]
class CQHTTPMessage(Message["CQHTTPMessageSegment"]):
"""CQHTTP 消息。"""
@property
def _message_segment_class(self) -> Type["CQHTTPMessageSegment"]:
return CQHTTPMessageSegment
def _str_to_message_segment(self, msg) -> "CQHTTPMessageSegment":
return CQHTTPMessageSegment.text(msg)
class CQHTTPMessageSegment(MessageSegment["CQHTTPMessage"]):
"""CQHTTP 消息字段。"""
@property
def _message_class(self) -> Type["CQHTTPMessage"]:
return CQHTTPMessage
def __str__(self) -> str:
if self.type == "text":
return self.data.get("text", "")
return self.get_cqcode()
def get_cqcode(self) -> str:
"""
Returns:
此消息字段的 CQ 码形式。
"""
if self.type == "text":
return escape(self.data.get("text", ""), escape_comma=False)
params = ",".join(
[f"{k}={escape(str(v))}" for k, v in self.data.items() if v is not None]
)
return f'[CQ:{self.type}{"," if params else ""}{params}]'
@classmethod
def text(cls, text: str) -> "CQHTTPMessageSegment":
"""纯文本"""
return cls(type="text", data={"text": text})
@classmethod
def face(cls, id_: int) -> "CQHTTPMessageSegment":
"""QQ 表情"""
return cls(type="face", data={"id": str(id_)})
@classmethod
def image(
cls,
file: str,
type_: Optional[Literal["flash"]] = None,
cache: bool = True,
proxy: bool = True,
timeout: Optional[int] = None,
) -> "CQHTTPMessageSegment":
"""图片"""
return cls(
type="image",
data={
"file": file,
"type": type_,
"cache": cache,
"proxy": proxy,
"timeout": timeout,
},
)
@classmethod
def record(
cls,
file: str,
magic: bool = False,
cache: bool = True,
proxy: bool = True,
timeout: Optional[int] = None,
) -> "CQHTTPMessageSegment":
"""语音"""
return cls(
type="record",
data={
"file": file,
"magic": magic,
"cache": cache,
"proxy": proxy,
"timeout": timeout,
},
)
@classmethod
def video(
cls,
file: str,
cache: bool = True,
proxy: bool = True,
timeout: Optional[int] = None,
) -> "CQHTTPMessageSegment":
"""短视频"""
return cls(
type="video",
data={"file": file, "cache": cache, "proxy": proxy, "timeout": timeout},
)
@classmethod
def at(cls, qq: Union[int, Literal["all"]]) -> "CQHTTPMessageSegment":
"""@某人"""
return cls(type="at", data={"qq": str(qq)})
@classmethod
def rps(cls) -> "CQHTTPMessageSegment":
"""猜拳魔法表情"""
return cls(type="rps", data={})
@classmethod
def dice(cls) -> "CQHTTPMessageSegment":
"""掷骰子魔法表情"""
return cls(type="dice", data={})
@classmethod
def shake(cls) -> "CQHTTPMessageSegment":
"""窗口抖动（戳一戳）"""
return cls(type="shake", data={})
@classmethod
def poke(cls, type_: str, id_: int) -> "CQHTTPMessageSegment":
"""戳一戳"""
return cls(type="poke", data={"type": type_, "id": str(id_)})
@classmethod
def anonymous(cls, ignore: Optional[bool] = None) -> "CQHTTPMessageSegment":
"""匿名发消息"""
return cls(type="anonymous", data={"ignore": ignore})
@classmethod
def share(
cls,
url: str,
title: str,
content: Optional[str] = None,
image: Optional[str] = None,
) -> "CQHTTPMessageSegment":
"""链接分享"""
return cls(
type="share",
data={"url": url, "title": title, "content": content, "image": image},
)
@classmethod
def contact(cls, type_: Literal["qq", "group"], id_: int) -> "CQHTTPMessageSegment":
"""推荐好友/推荐群"""
return cls(type="contact", data={"type": type_, "id": str(id_)})
@classmethod
def contact_friend(cls, id_: int) -> "CQHTTPMessageSegment":
"""推荐好友"""
return cls(type="contact", data={"type": "qq", "id": str(id_)})
@classmethod
def contact_group(cls, id_: int) -> "CQHTTPMessageSegment":
"""推荐好友"""
return cls(type="contact", data={"type": "group", "id": str(id_)})
@classmethod
def location(
cls, lat: float, lon: float, title: Optional[str], content: Optional[str] = None
) -> "CQHTTPMessageSegment":
"""位置"""
return cls(
type="location",
data={"lat": str(lat), "lon": str(lon), "title": title, "content": content},
)
@classmethod
def music(
cls, type_: Literal["qq", "163", "xm"], id_: int
) -> "CQHTTPMessageSegment":
"""音乐分享"""
return cls(type="music", data={"type": type_, "id": str(id_)})
@classmethod
def music_custom(
cls,
url: str,
audio: str,
title: str,
content: Optional[str] = None,
image: Optional[str] = None,
) -> "CQHTTPMessageSegment":
"""音乐自定义分享"""
return cls(
type="music",
data={
"type": "custom",
"url": url,
"audio": audio,
"title": title,
"content": content,
"image": image,
},
)
@classmethod
def reply(cls, id_: int) -> "CQHTTPMessageSegment":
"""回复"""
return cls(type="reply", data={"id": str(id_)})
@classmethod
def node(cls, id_: int) -> "CQHTTPMessageSegment":
"""合并转发节点"""
return cls(type="node", data={"id": str(id_)})
@classmethod
def node_custom(
cls, user_id: int, nickname, content: "CQHTTPMessage"
) -> "CQHTTPMessageSegment":
"""合并转发自定义节点"""
return cls(
type="node",
data={
"user_id": str(user_id),
"nickname": str(nickname),
"content": content,
},
)
@classmethod
def xml_message(cls, data: str) -> "CQHTTPMessageSegment":
"""XML 消息"""
return cls(type="xml", data={"data": data})
@classmethod
def json_message(cls, data: str) -> "CQHTTPMessageSegment":
"""JSON 消息"""
return cls(type="json", data={"data": data})
def escape(s: str, *, escape_comma: bool = True) -> str:
"""对 CQ 码中的特殊字符进行转义。
Args:
s: 待转义的字符串。
escape_comma: 是否转义 `,`。
Returns:
转义后的字符串。
"""
s = s.replace("&", "&").replace("[", "[").replace("]", "]")
if escape_comma:
s = s.replace(",", ",")
return s | /retrofor_wut-4.0.2-py3-none-any.whl/retrofor_wut/adapter/cqhttp/message.py | 0.841468 | 0.280038 | message.py | pypi |
from __future__ import unicode_literals
import csv
import click
import prettytable
def interact(seq, desc, count, row, mtx):
# status output
keys = sorted(mtx)
table = prettytable.PrettyTable(keys)
table.add_row([
'\033[92m\u2713\u2713\033[0m' if mtx[key] else '--'
for key in keys
])
print """
Sequence: {seq}
{desc}
Interpreted: {i_balls}-{i_strikes}
Final: {balls}-{strikes}
{mtx}
""".format(seq=seq, desc=', '.join(desc),
i_balls=count['balls'], i_strikes=count['strikes'],
balls=row['BALLS_CT'], strikes=row['STRIKES_CT'],
mtx=table)
# keep going?
if raw_input('Continue? [Y/n]: ').lower() == 'n':
exit()
@click.command()
@click.option('files', '-f', type=click.File('r'), multiple=True,
required=True, help='Chadwick-parsed event log')
@click.option('imode', '-i', is_flag=True, default=False,
help='Enable interactive mode')
@click.option('output', '-o', type=click.File('w'), required=True,
help='Path to output file')
def extract_sequences(files, imode, output):
"""Converts a pitch sequences into a matrix
of ball-strike counts.
"""
seq_obv = set()
mtx = {
'00': 1, '01': 0, '02': 0,
'10': 0, '20': 0, '30': 0,
'11': 0, '12': 0, '21': 0,
'22': 0, '31': 0, '32': 0,
}
# write header row
writer = csv.writer(output)
headers = ['pitch_seq_tx']
headers.extend(['c' + key for key in sorted(mtx)])
writer.writerow(headers)
for f in files:
reader = csv.DictReader(f)
for row in reader:
seq = row['PITCH_SEQ_TX']
if seq in seq_obv:
continue
count = {'balls': 0, 'strikes': 0}
desc = []
for pitch in seq:
# handle walks
if pitch in ('B', 'I', 'V'):
if count['balls'] < 3:
count['balls'] += 1
desc.append('Ball')
else:
# ball 4, take your base
break
# handle fouls that do not terminate an at-bat
elif pitch in ('F', 'R'):
# keep going forever
if count['strikes'] < 2:
count['strikes'] += 1
desc.append('Foul')
# handle strikes that can terminate an at-bat
elif pitch in ('C', 'K', 'L', 'O', 'Q', 'S', 'T'):
if count['strikes'] == 2:
# batter struck out
break
else:
count['strikes'] += 1
desc.append('Strike')
else:
continue
key = '%s%s' % (count['balls'], count['strikes'])
if mtx[key] < 1:
mtx[key] += 1
if imode is True:
interact(seq, desc, count, row, mtx)
# write output
values = [seq]
for key in sorted(mtx):
values.append(mtx[key])
writer.writerow(values)
# mark sequence as observed
seq_obv.add(seq)
# reset matrix
for key in mtx:
mtx[key] = 0
mtx['00'] = 1
if __name__ == '__main__':
extract_sequences() | /retrosheet-pitch-sequences-1.1.0.tar.gz/retrosheet-pitch-sequences-1.1.0/rs_pitch_seq.py | 0.50293 | 0.201283 | rs_pitch_seq.py | pypi |
import multiprocessing
import retro
import gc
MAKE_RETRIES = 5
def set_retro_make( new_retro_make_func ):
RetroWrapper.retro_make_func = new_retro_make_func
def _retrocom(rx, tx, game, kwargs):
"""
This function is the target for RetroWrapper's internal
process and does all the work of communicating with the
environment.
"""
env = RetroWrapper.retro_make_func(game, **kwargs)
# Sit around on the queue, waiting for calls from RetroWrapper
while True:
attr, args, kwargs = rx.get()
# First, handle special case where the wrapper is asking if attr is callable.
# In this case, we actually have RetroWrapper.symbol, attr, and {}.
if attr == RetroWrapper.symbol:
result = env.__getattribute__(args)
tx.put(callable(result))
elif attr == "close":
env.close()
break
else:
# Otherwise, handle the request
result = getattr(env, attr)
if callable(result):
result = result(*args, **kwargs)
tx.put(result)
class RetroWrapper():
"""
This class is a thin wrapper around a retro environment.
The purpose of this class is to protect us from the fact
that each Python process can only have a single retro
environment at a time, and we would like potentially
several.
This class gets around this limitation by spawning a process
internally that sits around waiting for retro environment
API calls, asking its own local copy of the environment, and
then returning the answer.
Call functions on this object exactly as if it were a retro env.
"""
symbol = "THIS IS A SPECIAL MESSAGE FOR YOU"
retro_make_func = retro.make
def __init__(self, game, **kwargs):
tempenv = None
retry_counter = MAKE_RETRIES
while True:
try:
tempenv = RetroWrapper.retro_make_func(game, **kwargs)
except RuntimeError: # Sometimes we need to gc.collect because previous tempenvs haven't been cleaned up.
gc.collect()
retry_counter -= 1
if retry_counter > 0:
continue
break
if tempenv == None:
raise RuntimeError( 'Unable to create tempenv' )
tempenv.reset()
if hasattr( tempenv, 'unwrapped' ): # Wrappers don't have gamename or initial_state
tempenv_unwrapped = tempenv.unwrapped
self.gamename = tempenv_unwrapped.gamename
self.initial_state = tempenv_unwrapped.initial_state
self.action_space = tempenv.action_space
self.metadata = tempenv.metadata
self.observation_space = tempenv.observation_space
self.reward_range = tempenv.reward_range
tempenv.close()
self._rx = multiprocessing.Queue()
self._tx = multiprocessing.Queue()
self._proc = multiprocessing.Process(target=_retrocom, args=(self._tx, self._rx, game, kwargs), daemon=True)
self._proc.start()
def __del__(self):
"""
Make sure to clean up.
"""
self.close()
def __getattr__(self, attr):
"""
Any time a client calls anything on our object, we want to check to
see if we can answer without having to ask the retro process. Usually,
we will have to ask it. If we do, we put a request into the queue for the
result of whatever the client requested and block until it comes back.
Otherwise we simply give the client whatever we have that they want.
BTW: This doesn't work for magic methods. To get those working is a little more involved. TODO
"""
# E.g.: Client calls env.step(action)
ignore_list = ['class', 'mro', 'new', 'init', 'setattr', 'getattr', 'getattribute']
if attr in self.__dict__ and attr not in ignore_list:
# 1. Check if we have a step function. If so, return it.
return attr
else:
# 2. If we don't, return a function that calls step with whatever args are passed in to it.
is_callable = self._ask_if_attr_is_callable(attr)
if is_callable:
# The result of getattr(attr) is a callable, so return a wrapper
# that pretends to be the function the user was trying to call
def wrapper(*args, **kwargs):
self._tx.put((attr, args, kwargs))
return self._rx.get()
return wrapper
else:
# The result of getattr(attr) is not a callable, so we should just
# execute the request for the user and return the result
self._tx.put((attr, [], {}))
return self._tx.get()
def _ask_if_attr_is_callable(self, attr):
"""
Returns whether or not the attribute is a callable.
"""
self._tx.put((RetroWrapper.symbol, attr, {}))
return self._rx.get()
def close(self):
"""
Shutdown the environment.
"""
if "_tx" in self.__dict__ and "_proc" in self.__dict__:
self._tx.put(("close", (), {}))
self._proc.join() | /retrowrapper-0.3.0-py3-none-any.whl/retrowrapper.py | 0.430985 | 0.194139 | retrowrapper.py | pypi |
import typing as T
import logging
import random
import time
from functools import partial
from decorator import decorator
logging_logger = logging.getLogger(__name__)
EXCEPTIONS = T.Union[T.Tuple[T.Type[Exception], ...], T.Type[Exception]]
P = T.ParamSpec("P")
def __retry_internal_sync(
f: T.Callable[P, T.Any],
exceptions: EXCEPTIONS = Exception,
tries: int = -1,
delay: float = 0,
max_delay: float = None,
backoff: float = 1,
jitter: float = 0,
logger: logging.Logger = logging_logger,
) -> T.Any:
"""
Executes a function and retries it if it failed.
:param f: the function to execute.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: the result of the f function.
"""
_tries, _delay = tries, delay
while _tries:
try:
return f()
except exceptions as e:
_tries -= 1
if not _tries:
raise
if logger is not None:
logger.warning("%s, retrying in %s seconds...", e, _delay)
time.sleep(_delay)
_delay *= backoff
if isinstance(jitter, tuple):
_delay += random.uniform(*jitter)
else:
_delay += jitter
if max_delay is not None:
_delay = min(_delay, max_delay)
async def __retry_internal_async(
f: T.Callable[P, T.Any],
exceptions: EXCEPTIONS = Exception,
tries: int = -1,
delay: float = 0,
max_delay: float = None,
backoff: float = 1,
jitter: float = 0,
logger: logging.Logger = logging_logger,
) -> T.Any:
"""
Executes a function and retries it if it failed.
:param f: the function to execute.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: the result of the f function.
"""
_tries, _delay = tries, delay
while _tries:
try:
return await f()
except exceptions as e:
_tries -= 1
if not _tries:
raise
if logger is not None:
logger.warning("%s, retrying in %s seconds...", e, _delay)
time.sleep(_delay)
_delay *= backoff
if isinstance(jitter, tuple):
_delay += random.uniform(*jitter)
else:
_delay += jitter
if max_delay is not None:
_delay = min(_delay, max_delay)
DecSpecs = T.ParamSpec("DecSpecs")
def retry(
exceptions: EXCEPTIONS = Exception,
*,
is_async: bool,
tries: int = -1,
delay: float = 0,
max_delay: float = None,
backoff: float = 1,
jitter: float = 0,
logger: logging.Logger = logging_logger,
) -> T.Callable[..., T.Any]:
"""Returns a retry decorator.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: a retry decorator.
"""
if is_async:
@decorator
async def retry_decorator_async(
f: T.Callable[P, T.Any], *fargs: T.Any, **fkwargs: T.Any
) -> T.Any:
args = fargs if fargs else list()
kwargs = fkwargs if fkwargs else dict()
return await __retry_internal_async(
partial(f, *args, **kwargs),
exceptions,
tries,
delay,
max_delay,
backoff,
jitter,
logger,
)
return retry_decorator_async
else:
@decorator
def retry_decorator_sync(
f: T.Callable[P, T.Any], *fargs: T.Any, **fkwargs: T.Any
) -> T.Any:
args = fargs if fargs else list()
kwargs = fkwargs if fkwargs else dict()
return __retry_internal_sync(
partial(f, *args, **kwargs),
exceptions,
tries,
delay,
max_delay,
backoff,
jitter,
logger,
)
return retry_decorator_sync
def retry_call_sync(
f: T.Callable[P, T.Any],
fargs: T.Any = None,
fkwargs: T.Any = None,
exceptions: EXCEPTIONS = Exception,
tries: int = -1,
delay: float = 0,
max_delay: float = None,
backoff: float = 1,
jitter: float = 0,
logger: logging.Logger = logging_logger,
) -> T.Any:
"""
Calls a function and re-executes it if it failed.
:param f: the function to execute.
:param fargs: the positional arguments of the function to execute.
:param fkwargs: the named arguments of the function to execute.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: the result of the f function.
"""
args = fargs if fargs else list()
kwargs = fkwargs if fkwargs else dict()
return __retry_internal_sync(
partial(f, *args, **kwargs),
exceptions,
tries,
delay,
max_delay,
backoff,
jitter,
logger,
)
async def retry_call_async(
f: T.Callable[P, T.Any],
fargs: T.Any = None,
fkwargs: T.Any = None,
exceptions: EXCEPTIONS = Exception,
tries: int = -1,
delay: float = 0,
max_delay: float = None,
backoff: float = 1,
jitter: float = 0,
logger: logging.Logger = logging_logger,
) -> T.Any:
"""
Calls a function and re-executes it if it failed.
:param f: the function to execute.
:param fargs: the positional arguments of the function to execute.
:param fkwargs: the named arguments of the function to execute.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: the result of the f function.
"""
args = fargs if fargs else list()
kwargs = fkwargs if fkwargs else dict()
return await __retry_internal_async(
partial(f, *args, **kwargs),
exceptions,
tries,
delay,
max_delay,
backoff,
jitter,
logger,
) | /retry_async-0.1.3-py3-none-any.whl/retry_async/api.py | 0.695338 | 0.310204 | api.py | pypi |
import asyncio
import logging
import random
import time
import functools
from typing import Callable, Optional, Any
DEFAULT_LOGGER = logging.getLogger(__name__)
DEFAULT_ASYNC_LOGGER = logging.getLogger("asyncio")
def __retry_internal(
f: Callable,
args: tuple,
kwargs: dict,
exceptions: tuple = (Exception,),
tries: int = -1,
delay: int = 0,
max_delay: Optional[int] = None,
backoff: int = 1,
jitter: int = 0,
logger: logging.Logger = DEFAULT_LOGGER,
):
"""
Executes a function and retries it if it failed.
Args:
f:
the function to execute.
exceptions:
an exception or a tuple of exceptions to catch. default: Exception.
tries:
the maximum number of attempts. default: -1 (infinite).
delay:
initial delay between attempts. default: 0.
max_delay:
the maximum value of delay. default: None (no limit).
backoff:
multiplier applied to delay between attempts. default: 1 (no backoff).
jitter:
extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
logger:
Instance of logging.Logger to be called on failed attempts.
default: retry.DEFAULT_LOGGER. if None, logging is disabled.
Returns:
Result of the f function.
"""
_tries, _delay = tries, delay
while _tries:
try:
return f(*args, **kwargs)
except exceptions as e:
_tries -= 1
if not _tries:
raise
if logger is not None:
logger.warning("%s, retrying in %s seconds...", e, _delay)
time.sleep(_delay)
_delay *= backoff
if isinstance(jitter, tuple):
_delay += random.uniform(*jitter)
else:
_delay += jitter
if max_delay is not None:
_delay = min(_delay, max_delay)
async def __retry_internal_async(
f: Callable,
args: tuple,
kwargs: dict,
exceptions: tuple = (Exception,),
tries: int = -1,
delay: int = 0,
max_delay: Optional[int] = None,
backoff: int = 1,
jitter: int = 0,
logger: logging.Logger = DEFAULT_ASYNC_LOGGER,
):
"""
Executes a function and retries it if it failed.
Args:
f:
the coroutine function to execute.
exceptions:
an exception or a tuple of exceptions to catch. default: Exception.
tries:
the maximum number of attempts. default: -1 (infinite).
delay:
initial delay between attempts. default: 0.
max_delay:
the maximum value of delay. default: None (no limit).
backoff:
multiplier applied to delay between attempts. default: 1 (no backoff).
jitter:
extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
logger:
Instance of logging.Logger to be called on failed attempts.
default: retry.DEFAULT_LOGGER. if None, logging is disabled.
Returns:
Result of the f function.
"""
_tries, _delay = tries, delay
while _tries:
try:
return await f(*args, **kwargs)
except exceptions as e:
_tries -= 1
if not _tries:
raise
if logger is not None:
logger.warning("%s, retrying in %s seconds...", e, _delay)
await asyncio.sleep(_delay)
_delay *= backoff
if isinstance(jitter, tuple):
_delay += random.uniform(*jitter)
else:
_delay += jitter
if max_delay is not None:
_delay = min(_delay, max_delay)
def retry(
# func,
exceptions: tuple = (Exception,),
tries: int = -1,
delay: int = 0,
max_delay: Optional[int] = None,
backoff: int = 1,
jitter: int = 0,
logger: logging.Logger = DEFAULT_LOGGER,
):
"""
Returns a retry decorator.
Args:
exceptions:
an exception or a tuple of exceptions to catch. default: Exception.
tries:
the maximum number of attempts. default: -1 (infinite).
delay:
initial delay between attempts. default: 0.
max_delay:
the maximum value of delay. default: None (no limit).
backoff:
multiplier applied to delay between attempts. default: 1 (no backoff).
jitter:
extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
logger:
logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.DEFAULT_LOGGER. if None, logging is disabled.
Returns:
a retry decorator.
"""
def retry_decorator(func):
@functools.wraps(func)
def wrapper(*args: tuple, **kwargs: dict) -> Any:
return __retry_internal(func, args, kwargs, exceptions, tries, delay, max_delay, backoff, jitter, logger)
@functools.wraps(func)
async def wrapper_async(*args: tuple, **kwargs: dict) -> Any:
return await __retry_internal_async(
func, args, kwargs, exceptions, tries, delay, max_delay, backoff, jitter, logger
)
if asyncio.iscoroutinefunction(func):
return wrapper_async
return wrapper
return retry_decorator
def retry_call(
f,
fargs: tuple = None,
fkwargs: dict = None,
exceptions: tuple = (Exception,),
tries: int = -1,
delay: int = 0,
max_delay: Optional[int] = None,
backoff: int = 1,
jitter: int = 0,
logger: logging.Logger = DEFAULT_LOGGER,
):
"""
Calls a function and re-executes it if it failed.
Args:
f:
the function to execute.
fargs:
the positional arguments of the function to execute.
fkwargs:
the named arguments of the function to execute.
exceptions:
an exception or a tuple of exceptions to catch. default: Exception.
tries:
the maximum number of attempts. default: -1 (infinite).
delay:
initial delay between attempts. default: 0.
max_delay:
the maximum value of delay. default: None (no limit).
backoff:
multiplier applied to delay between attempts. default: 1 (no backoff).
jitter:
extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
logger:
logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.DEFAULT_LOGGER. if None, logging is disabled.
Returns:
the result of the f function.
"""
args = fargs if fargs else tuple()
kwargs = fkwargs if fkwargs else dict()
if asyncio.iscoroutinefunction(f):
return __retry_internal_async(f, args, kwargs, exceptions, tries, delay, max_delay, backoff, jitter, logger)
return __retry_internal(f, args, kwargs, exceptions, tries, delay, max_delay, backoff, jitter, logger) | /retry_extended-0.2.3.tar.gz/retry_extended-0.2.3/retry/api.py | 0.847274 | 0.193986 | api.py | pypi |
from math import ceil
from time import sleep
from typing import Callable, List
import allure
from allure_commons import plugin_manager
from allure_commons.utils import uuid4
from retry_pytest.command import Command
from retry_pytest.custom_errors import NegativeAction
class Retry:
def __init__(
self, *expected_exceptions,
timeout=10,
poll_frequency=1,
title='Retry',
error_msg='',
show_expected=False,
**kwargs
):
self._exceptions = expected_exceptions if expected_exceptions else (NegativeAction,)
self._timeout = timeout
error_msg = error_msg if error_msg else f'timeout {timeout}s exceeded'
self._timeout_msg = f'{title}: {error_msg}'
self._poll_frequency = poll_frequency
self._command_queue = []
self._title = title
self._step_params = kwargs
self._current_step = None
self._show_expected = show_expected
@property
def commands(self) -> List[Command]:
return self._command_queue
@property
def last_command(self) -> Command:
return self._command_queue[-1]
def __enter__(self):
self._current_step = uuid4()
plugin_manager.hook.start_step(uuid=self._current_step, title=self._title, params=self._step_params)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
try:
for _ in range(ceil(self._timeout / self._poll_frequency)):
try:
sleep(self._poll_frequency)
if all([f() for f in self._command_queue]):
break
except self._exceptions as e:
if self._show_expected:
allure.attach(
f'{e.__class__.__name__}: {str(e)}', 'Expected exception', allure.attachment_type.TEXT
)
else:
exc_type = AssertionError
exc_val = exc_type(self._timeout_msg)
exc_tb = None
except Exception as e:
exc_type = e.__class__
exc_val = e
exc_tb = None
plugin_manager.hook.stop_step(
uuid=self._current_step,
title=self._title,
exc_type=exc_type,
exc_val=exc_val,
exc_tb=exc_tb
)
if exc_val:
raise exc_val
def check(self, func: Callable, *args, **kwargs) -> Command:
self._command_queue.append(Command(func, *args, **kwargs))
return self._command_queue[-1] | /retry_pytest-1.0.4.tar.gz/retry_pytest-1.0.4/retry_pytest/retry.py | 0.769643 | 0.193604 | retry.py | pypi |
/**@constructor*/
RussianStemmer = function() {
var base = new BaseStemmer();
/** @const */ var a_0 = [
["\u0432", -1, 1],
["\u0438\u0432", 0, 2],
["\u044B\u0432", 0, 2],
["\u0432\u0448\u0438", -1, 1],
["\u0438\u0432\u0448\u0438", 3, 2],
["\u044B\u0432\u0448\u0438", 3, 2],
["\u0432\u0448\u0438\u0441\u044C", -1, 1],
["\u0438\u0432\u0448\u0438\u0441\u044C", 6, 2],
["\u044B\u0432\u0448\u0438\u0441\u044C", 6, 2]
];
/** @const */ var a_1 = [
["\u0435\u0435", -1, 1],
["\u0438\u0435", -1, 1],
["\u043E\u0435", -1, 1],
["\u044B\u0435", -1, 1],
["\u0438\u043C\u0438", -1, 1],
["\u044B\u043C\u0438", -1, 1],
["\u0435\u0439", -1, 1],
["\u0438\u0439", -1, 1],
["\u043E\u0439", -1, 1],
["\u044B\u0439", -1, 1],
["\u0435\u043C", -1, 1],
["\u0438\u043C", -1, 1],
["\u043E\u043C", -1, 1],
["\u044B\u043C", -1, 1],
["\u0435\u0433\u043E", -1, 1],
["\u043E\u0433\u043E", -1, 1],
["\u0435\u043C\u0443", -1, 1],
["\u043E\u043C\u0443", -1, 1],
["\u0438\u0445", -1, 1],
["\u044B\u0445", -1, 1],
["\u0435\u044E", -1, 1],
["\u043E\u044E", -1, 1],
["\u0443\u044E", -1, 1],
["\u044E\u044E", -1, 1],
["\u0430\u044F", -1, 1],
["\u044F\u044F", -1, 1]
];
/** @const */ var a_2 = [
["\u0435\u043C", -1, 1],
["\u043D\u043D", -1, 1],
["\u0432\u0448", -1, 1],
["\u0438\u0432\u0448", 2, 2],
["\u044B\u0432\u0448", 2, 2],
["\u0449", -1, 1],
["\u044E\u0449", 5, 1],
["\u0443\u044E\u0449", 6, 2]
];
/** @const */ var a_3 = [
["\u0441\u044C", -1, 1],
["\u0441\u044F", -1, 1]
];
/** @const */ var a_4 = [
["\u043B\u0430", -1, 1],
["\u0438\u043B\u0430", 0, 2],
["\u044B\u043B\u0430", 0, 2],
["\u043D\u0430", -1, 1],
["\u0435\u043D\u0430", 3, 2],
["\u0435\u0442\u0435", -1, 1],
["\u0438\u0442\u0435", -1, 2],
["\u0439\u0442\u0435", -1, 1],
["\u0435\u0439\u0442\u0435", 7, 2],
["\u0443\u0439\u0442\u0435", 7, 2],
["\u043B\u0438", -1, 1],
["\u0438\u043B\u0438", 10, 2],
["\u044B\u043B\u0438", 10, 2],
["\u0439", -1, 1],
["\u0435\u0439", 13, 2],
["\u0443\u0439", 13, 2],
["\u043B", -1, 1],
["\u0438\u043B", 16, 2],
["\u044B\u043B", 16, 2],
["\u0435\u043C", -1, 1],
["\u0438\u043C", -1, 2],
["\u044B\u043C", -1, 2],
["\u043D", -1, 1],
["\u0435\u043D", 22, 2],
["\u043B\u043E", -1, 1],
["\u0438\u043B\u043E", 24, 2],
["\u044B\u043B\u043E", 24, 2],
["\u043D\u043E", -1, 1],
["\u0435\u043D\u043E", 27, 2],
["\u043D\u043D\u043E", 27, 1],
["\u0435\u0442", -1, 1],
["\u0443\u0435\u0442", 30, 2],
["\u0438\u0442", -1, 2],
["\u044B\u0442", -1, 2],
["\u044E\u0442", -1, 1],
["\u0443\u044E\u0442", 34, 2],
["\u044F\u0442", -1, 2],
["\u043D\u044B", -1, 1],
["\u0435\u043D\u044B", 37, 2],
["\u0442\u044C", -1, 1],
["\u0438\u0442\u044C", 39, 2],
["\u044B\u0442\u044C", 39, 2],
["\u0435\u0448\u044C", -1, 1],
["\u0438\u0448\u044C", -1, 2],
["\u044E", -1, 2],
["\u0443\u044E", 44, 2]
];
/** @const */ var a_5 = [
["\u0430", -1, 1],
["\u0435\u0432", -1, 1],
["\u043E\u0432", -1, 1],
["\u0435", -1, 1],
["\u0438\u0435", 3, 1],
["\u044C\u0435", 3, 1],
["\u0438", -1, 1],
["\u0435\u0438", 6, 1],
["\u0438\u0438", 6, 1],
["\u0430\u043C\u0438", 6, 1],
["\u044F\u043C\u0438", 6, 1],
["\u0438\u044F\u043C\u0438", 10, 1],
["\u0439", -1, 1],
["\u0435\u0439", 12, 1],
["\u0438\u0435\u0439", 13, 1],
["\u0438\u0439", 12, 1],
["\u043E\u0439", 12, 1],
["\u0430\u043C", -1, 1],
["\u0435\u043C", -1, 1],
["\u0438\u0435\u043C", 18, 1],
["\u043E\u043C", -1, 1],
["\u044F\u043C", -1, 1],
["\u0438\u044F\u043C", 21, 1],
["\u043E", -1, 1],
["\u0443", -1, 1],
["\u0430\u0445", -1, 1],
["\u044F\u0445", -1, 1],
["\u0438\u044F\u0445", 26, 1],
["\u044B", -1, 1],
["\u044C", -1, 1],
["\u044E", -1, 1],
["\u0438\u044E", 30, 1],
["\u044C\u044E", 30, 1],
["\u044F", -1, 1],
["\u0438\u044F", 33, 1],
["\u044C\u044F", 33, 1]
];
/** @const */ var a_6 = [
["\u043E\u0441\u0442", -1, 1],
["\u043E\u0441\u0442\u044C", -1, 1]
];
/** @const */ var a_7 = [
["\u0435\u0439\u0448\u0435", -1, 1],
["\u043D", -1, 2],
["\u0435\u0439\u0448", -1, 1],
["\u044C", -1, 3]
];
/** @const */ var /** Array<int> */ g_v = [33, 65, 8, 232];
var /** number */ I_p2 = 0;
var /** number */ I_pV = 0;
/** @return {boolean} */
function r_mark_regions() {
I_pV = base.limit;
I_p2 = base.limit;
var /** number */ v_1 = base.cursor;
lab0: {
golab1: while(true)
{
lab2: {
if (!(base.in_grouping(g_v, 1072, 1103)))
{
break lab2;
}
break golab1;
}
if (base.cursor >= base.limit)
{
break lab0;
}
base.cursor++;
}
I_pV = base.cursor;
golab3: while(true)
{
lab4: {
if (!(base.out_grouping(g_v, 1072, 1103)))
{
break lab4;
}
break golab3;
}
if (base.cursor >= base.limit)
{
break lab0;
}
base.cursor++;
}
golab5: while(true)
{
lab6: {
if (!(base.in_grouping(g_v, 1072, 1103)))
{
break lab6;
}
break golab5;
}
if (base.cursor >= base.limit)
{
break lab0;
}
base.cursor++;
}
golab7: while(true)
{
lab8: {
if (!(base.out_grouping(g_v, 1072, 1103)))
{
break lab8;
}
break golab7;
}
if (base.cursor >= base.limit)
{
break lab0;
}
base.cursor++;
}
I_p2 = base.cursor;
}
base.cursor = v_1;
return true;
};
/** @return {boolean} */
function r_R2() {
if (!(I_p2 <= base.cursor))
{
return false;
}
return true;
};
/** @return {boolean} */
function r_perfective_gerund() {
var /** number */ among_var;
base.ket = base.cursor;
among_var = base.find_among_b(a_0);
if (among_var == 0)
{
return false;
}
base.bra = base.cursor;
switch (among_var) {
case 1:
lab0: {
var /** number */ v_1 = base.limit - base.cursor;
lab1: {
if (!(base.eq_s_b("\u0430")))
{
break lab1;
}
break lab0;
}
base.cursor = base.limit - v_1;
if (!(base.eq_s_b("\u044F")))
{
return false;
}
}
if (!base.slice_del())
{
return false;
}
break;
case 2:
if (!base.slice_del())
{
return false;
}
break;
}
return true;
};
/** @return {boolean} */
function r_adjective() {
base.ket = base.cursor;
if (base.find_among_b(a_1) == 0)
{
return false;
}
base.bra = base.cursor;
if (!base.slice_del())
{
return false;
}
return true;
};
/** @return {boolean} */
function r_adjectival() {
var /** number */ among_var;
if (!r_adjective())
{
return false;
}
var /** number */ v_1 = base.limit - base.cursor;
lab0: {
base.ket = base.cursor;
among_var = base.find_among_b(a_2);
if (among_var == 0)
{
base.cursor = base.limit - v_1;
break lab0;
}
base.bra = base.cursor;
switch (among_var) {
case 1:
lab1: {
var /** number */ v_2 = base.limit - base.cursor;
lab2: {
if (!(base.eq_s_b("\u0430")))
{
break lab2;
}
break lab1;
}
base.cursor = base.limit - v_2;
if (!(base.eq_s_b("\u044F")))
{
base.cursor = base.limit - v_1;
break lab0;
}
}
if (!base.slice_del())
{
return false;
}
break;
case 2:
if (!base.slice_del())
{
return false;
}
break;
}
}
return true;
};
/** @return {boolean} */
function r_reflexive() {
base.ket = base.cursor;
if (base.find_among_b(a_3) == 0)
{
return false;
}
base.bra = base.cursor;
if (!base.slice_del())
{
return false;
}
return true;
};
/** @return {boolean} */
function r_verb() {
var /** number */ among_var;
base.ket = base.cursor;
among_var = base.find_among_b(a_4);
if (among_var == 0)
{
return false;
}
base.bra = base.cursor;
switch (among_var) {
case 1:
lab0: {
var /** number */ v_1 = base.limit - base.cursor;
lab1: {
if (!(base.eq_s_b("\u0430")))
{
break lab1;
}
break lab0;
}
base.cursor = base.limit - v_1;
if (!(base.eq_s_b("\u044F")))
{
return false;
}
}
if (!base.slice_del())
{
return false;
}
break;
case 2:
if (!base.slice_del())
{
return false;
}
break;
}
return true;
};
/** @return {boolean} */
function r_noun() {
base.ket = base.cursor;
if (base.find_among_b(a_5) == 0)
{
return false;
}
base.bra = base.cursor;
if (!base.slice_del())
{
return false;
}
return true;
};
/** @return {boolean} */
function r_derivational() {
base.ket = base.cursor;
if (base.find_among_b(a_6) == 0)
{
return false;
}
base.bra = base.cursor;
if (!r_R2())
{
return false;
}
if (!base.slice_del())
{
return false;
}
return true;
};
/** @return {boolean} */
function r_tidy_up() {
var /** number */ among_var;
base.ket = base.cursor;
among_var = base.find_among_b(a_7);
if (among_var == 0)
{
return false;
}
base.bra = base.cursor;
switch (among_var) {
case 1:
if (!base.slice_del())
{
return false;
}
base.ket = base.cursor;
if (!(base.eq_s_b("\u043D")))
{
return false;
}
base.bra = base.cursor;
if (!(base.eq_s_b("\u043D")))
{
return false;
}
if (!base.slice_del())
{
return false;
}
break;
case 2:
if (!(base.eq_s_b("\u043D")))
{
return false;
}
if (!base.slice_del())
{
return false;
}
break;
case 3:
if (!base.slice_del())
{
return false;
}
break;
}
return true;
};
this.stem = /** @return {boolean} */ function() {
var /** number */ v_1 = base.cursor;
lab0: {
while(true)
{
var /** number */ v_2 = base.cursor;
lab1: {
golab2: while(true)
{
var /** number */ v_3 = base.cursor;
lab3: {
base.bra = base.cursor;
if (!(base.eq_s("\u0451")))
{
break lab3;
}
base.ket = base.cursor;
base.cursor = v_3;
break golab2;
}
base.cursor = v_3;
if (base.cursor >= base.limit)
{
break lab1;
}
base.cursor++;
}
if (!base.slice_from("\u0435"))
{
return false;
}
continue;
}
base.cursor = v_2;
break;
}
}
base.cursor = v_1;
r_mark_regions();
base.limit_backward = base.cursor; base.cursor = base.limit;
if (base.cursor < I_pV)
{
return false;
}
var /** number */ v_6 = base.limit_backward;
base.limit_backward = I_pV;
var /** number */ v_7 = base.limit - base.cursor;
lab4: {
lab5: {
var /** number */ v_8 = base.limit - base.cursor;
lab6: {
if (!r_perfective_gerund())
{
break lab6;
}
break lab5;
}
base.cursor = base.limit - v_8;
var /** number */ v_9 = base.limit - base.cursor;
lab7: {
if (!r_reflexive())
{
base.cursor = base.limit - v_9;
break lab7;
}
}
lab8: {
var /** number */ v_10 = base.limit - base.cursor;
lab9: {
if (!r_adjectival())
{
break lab9;
}
break lab8;
}
base.cursor = base.limit - v_10;
lab10: {
if (!r_verb())
{
break lab10;
}
break lab8;
}
base.cursor = base.limit - v_10;
if (!r_noun())
{
break lab4;
}
}
}
}
base.cursor = base.limit - v_7;
var /** number */ v_11 = base.limit - base.cursor;
lab11: {
base.ket = base.cursor;
if (!(base.eq_s_b("\u0438")))
{
base.cursor = base.limit - v_11;
break lab11;
}
base.bra = base.cursor;
if (!base.slice_del())
{
return false;
}
}
var /** number */ v_12 = base.limit - base.cursor;
r_derivational();
base.cursor = base.limit - v_12;
var /** number */ v_13 = base.limit - base.cursor;
r_tidy_up();
base.cursor = base.limit - v_13;
base.limit_backward = v_6;
base.cursor = base.limit_backward;
return true;
};
/**@return{string}*/
this['stemWord'] = function(/**string*/word) {
base.setCurrent(word);
this.stem();
return base.getCurrent();
};
}; | /retry_pytest-1.0.4.tar.gz/retry_pytest-1.0.4/retry_pytest/docs/build/html/_static/russian-stemmer.js | 0.531696 | 0.543651 | russian-stemmer.js | pypi |
from datetime import timedelta
from typing import Optional, Tuple, TypeVar, Union
import requests
from requests.adapters import HTTPAdapter
from urllib3 import Retry
T = TypeVar("T", bound=requests.Session)
class TSession(requests.Session):
"""A session that has a timeout for all of its requests."""
def __init__(self, timeout: Union[int, timedelta] = 5):
"""
Args:
timeout: Time that requests will wait to receive the first
response bytes (not the whole time) from the server.
An int in seconds or a timedelta object.
"""
super().__init__()
self.timeout = timeout if isinstance(timeout, int) else timeout.seconds
def request(self, method, url, *args, **kwargs):
kwargs.setdefault("timeout", self.timeout)
return super().request(method, url, *args, **kwargs)
class RSession(TSession):
"""A session that has a timeout and a ``raises_for_status``
for all of its requests.
"""
def __init__(self, timeout: Union[int, timedelta] = 5):
super().__init__(timeout)
self.hooks["response"] = lambda r, *args, **kwargs: r.raise_for_status()
def retry(
session: Optional[T] = None,
retries: int = 3,
backoff_factor: float = 1,
status_to_retry: Tuple[int, ...] = (500, 502, 504),
prefixes: Tuple[str, ...] = ("http://", "https://"),
**kwargs
) -> Union[T, TSession]:
"""
Configures the passed-in session to retry on failed requests
due to connection errors, specific HTTP response codes and
30X redirections.
Args:
session: A session to allow to retry. None creates a new Session.
retries: The number of maximum retries before raising an
exception.
backoff_factor: A factor used to compute the waiting time
between retries.
See :arg:`urllib3.util.retry.Retry.backoff_factor`.
status_to_retry: A tuple of status codes that trigger the reply
behaviour.
prefixes: A tuple of URL prefixes that this retry configuration
affects. By default, ``https`` and ``https``.
**kwargs: Extra arguments that are passed to
:class:`urllib3.util.retry.Retry`.
Returns:
A session object with the retry setup.
"""
session = session or TSession()
# Retry too in non-idempotent methods like POST
kwargs.setdefault("allowed_methods", None)
r = Retry(
total=retries,
read=retries,
connect=retries,
backoff_factor=backoff_factor,
status_forcelist=status_to_retry,
**kwargs
)
adapter = HTTPAdapter(max_retries=r)
for prefix in prefixes:
session.mount(prefix, adapter)
return session | /retry_requests-2.0.0-py3-none-any.whl/retry_requests/__init__.py | 0.942606 | 0.232332 | __init__.py | pypi |
import time
import random
import asyncio
import logging
from functools import partial
from decorator import decorator
logging_logger = logging.getLogger(__name__)
def __retry_internal(
f, exceptions=Exception, tries=-1, delay=0, max_delay=None, backoff=1, jitter=0, logger=logging_logger
):
"""
Executes a function and retries it if it failed.
:param f: the function to execute.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: the result of the f function.
"""
_tries, _delay = tries, delay
while _tries:
try:
return f()
except exceptions as e:
_tries -= 1
if not _tries:
raise
if logger is not None:
logger.warning("%s, retrying in %s seconds...", e, _delay)
time.sleep(_delay)
_delay *= backoff
if isinstance(jitter, tuple):
_delay += random.uniform(*jitter)
else:
_delay += jitter
if max_delay is not None:
_delay = min(_delay, max_delay)
async def __retry_internal_async(
f, exceptions=Exception, tries=-1, delay=0, max_delay=None, backoff=1, jitter=0, logger=logging_logger
):
_tries, _delay = tries, delay
while _tries:
try:
return await f()
except exceptions as e:
_tries -= 1
if not _tries:
raise
if logger is not None:
logger.warning("%s, retrying in %s seconds...", e, _delay)
await asyncio.sleep(_delay)
_delay *= backoff
if isinstance(jitter, tuple):
_delay += random.uniform(*jitter)
else:
_delay += jitter
if max_delay is not None:
_delay = min(_delay, max_delay)
def retry(exceptions=Exception, tries=-1, delay=0, max_delay=None, backoff=1, jitter=0, logger=logging_logger):
"""Returns a retry decorator.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:param async: If True then return generator
:returns: a retry decorator.
"""
@decorator
def retry_decorator(f, *fargs, **fkwargs):
if not asyncio.iscoroutinefunction(f):
return __retry_internal(
partial(f, *fargs, **fkwargs), exceptions, tries, delay, max_delay, backoff, jitter, logger
)
else:
return __retry_internal_async(
partial(f, *fargs, **fkwargs), exceptions, tries, delay, max_delay, backoff, jitter, logger
)
return retry_decorator
def retry_call(
f,
fargs=None,
fkwargs=None,
exceptions=Exception,
tries=-1,
delay=0,
max_delay=None,
backoff=1,
jitter=0,
logger=logging_logger,
):
"""
Calls a function and re-executes it if it failed.
:param f: the function to execute.
:param fargs: the positional arguments of the function to execute.
:param fkwargs: the named arguments of the function to execute.
:param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
:param tries: the maximum number of attempts. default: -1 (infinite).
:param delay: initial delay between attempts. default: 0.
:param max_delay: the maximum value of delay. default: None (no limit).
:param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
:param jitter: extra seconds added to delay between attempts. default: 0.
fixed if a number, random if a range tuple (min, max)
:param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
default: retry.logging_logger. if None, logging is disabled.
:returns: the result of the f function.
"""
args = fargs if fargs else list()
kwargs = fkwargs if fkwargs else dict()
return __retry_internal(partial(f, *args, **kwargs), exceptions, tries, delay, max_delay, backoff, jitter, logger) | /retry-sh-1.0.5.tar.gz/retry-sh-1.0.5/retry/api.py | 0.7478 | 0.205256 | api.py | pypi |
import functools
import itertools
import logging
import os
from select import poll, POLLIN
from threading import Timer
import time
from decorator import decorator
class _DummyException(Exception):
pass
class MaximumRetriesExceeded(Exception):
pass
class MaximumTimeoutExceeded(Exception):
pass
def _timeout(pipe_w):
with os.fdopen(pipe_w, 'w') as p:
p.write('stop')
def retry(
exceptions=(Exception,), interval=0, max_retries=10, success=None,
timeout=-1):
"""Decorator to retry a function 'max_retries' amount of times
:param tuple exceptions: Exceptions to be caught for retries
:param int interval: Interval between retries in seconds
:param int max_retries: Maximum number of retries to have, if
set to -1 the decorator will loop forever
:param function success: Function to indicate success criteria
:param int timeout: Timeout interval in seconds, if -1 will retry forever
:raises MaximumRetriesExceeded: Maximum number of retries hit without
reaching the success criteria
:raises TypeError: Both exceptions and success were left None causing the
decorator to have no valid exit criteria.
Example:
Use it to decorate a function!
.. sourcecode:: python
from retry import retry
@retry(exceptions=(ArithmeticError,), success=lambda x: x > 0)
def foo(bar):
if bar < 0:
raise ArithmeticError('testing this')
return bar
foo(5)
# Should return 5
foo(-1)
# Should raise ArithmeticError
foo(0)
# Should raise MaximumRetriesExceeded
"""
if not exceptions and success is None:
raise TypeError(
'`exceptions` and `success` parameter can not both be None')
# For python 3 compatability
exceptions = exceptions or (_DummyException,)
_retries_error_msg = ('Exceeded maximum number of retries {} at '
'an interval of {}s for function {}')
_timeout_error_msg = 'Maximum timeout of {}s reached for function {}'
@decorator
def wrapper(func, *args, **kwargs):
run_func = functools.partial(func, *args, **kwargs)
logger = logging.getLogger(func.__module__)
if max_retries < 0:
iterator = itertools.count()
else:
iterator = range(max_retries)
timer = None
if timeout > 0:
r, w = os.pipe()
timer = Timer(timeout, _timeout, [w])
timer.start()
p = poll()
p.register(r, POLLIN)
for num, _ in enumerate(iterator, 1):
try:
result = run_func()
if success is None or success(result):
if timer:
timer.cancel()
return result
except exceptions:
logger.exception(
'Exception experienced when trying function {}'.format(
func.__name__))
if num == max_retries:
raise
logger.warning(
'Retrying {} in {}s...'.format(
func.__name__, interval))
if timer:
r_state = p.poll(interval * 1000)
if r_state and r_state[0][1] & POLLIN:
raise MaximumTimeoutExceeded(
_timeout_error_msg.format(timeout, func.__name__)
)
else:
time.sleep(interval)
else:
raise MaximumRetriesExceeded(
_retries_error_msg.format(
max_retries, interval, func.__name__))
return wrapper | /retry.it-2.0.tar.gz/retry.it-2.0/retry.py | 0.763748 | 0.168002 | retry.py | pypi |
from typing import Optional, Sequence
from rets.client.resource import Resource
from rets.client.utils import get_metadata_data
from rets.http import RetsHttpClient
"""
Example of metadata dict:
metadata = [{
'ResourceID': 'Property',
'KeyField': 'Matrix_Unique_ID',
'_classes': [
{
'ClassName': 'Listing',
'HasKeyIndex': '1',
'_table': [
... column fields
],
}
],
'_object_types': [
'ObjectType': 'LargePhoto',
'MIMEType': 'image/jpeg',
]
}, {
'ResourceID': 'Agent',
'KeyField': 'Matrix_Unique_ID',
'_classes': [
{
'ClassName': 'Listing',
'HasKeyIndex': '1',
}
],
}]
"""
class RetsClient:
def __init__(self,
*args,
http_client: RetsHttpClient = None,
metadata: Sequence[dict] = (),
capability_urls: dict = None,
cookie_dict: dict = None,
**kwargs):
self.http = http_client or RetsHttpClient(*args,
capability_urls=capability_urls, cookie_dict=cookie_dict,
**kwargs)
if not (capability_urls and cookie_dict):
self.http.login()
self._resources = self._resources_from_metadata(metadata)
@property
def metadata(self) -> Sequence[dict]:
return tuple(resource.metadata for resource in self._resources)
@property
def resources(self) -> Sequence[Resource]:
if not self._resources:
# TODO(ML) Differentiate between not having the metadata and
# having an empty metadata
self._resources = self._fetch_resources()
return self._resources
def get_resource(self, name: str) -> Optional[Resource]:
for resource in self.resources:
if resource.name == name:
return resource
raise KeyError('unknown resource %s' % name)
def _fetch_resources(self) -> Sequence[Resource]:
metadata = get_metadata_data(self.http, 'resource')
return self._resources_from_metadata(metadata)
def _resources_from_metadata(self, metadata: Sequence[dict]) -> Sequence[Resource]:
return tuple(Resource(m, self.http) for m in metadata) | /rets-python-0.4.9.tar.gz/rets-python-0.4.9/rets/client/client.py | 0.80651 | 0.163345 | client.py | pypi |
import logging
import re
from collections import OrderedDict
from datetime import datetime, time, timezone
from decimal import Decimal
from functools import partial
from typing import Any, Sequence
import udatetime
from rets.errors import RetsParseError
logger = logging.getLogger('rets')
class RecordDecoder:
def __init__(self, table: Sequence[dict], include_tz: bool = False):
self._metadata_map = {field['SystemName']: field for field in table}
self._include_tz = include_tz
def decode(self, rows: Sequence[dict]) -> Sequence[dict]:
if not rows:
return ()
# Build dict of field to decoder functions, assuming that all rows have the same fields.
decoders = self._build_decoders(tuple(rows[0].keys()))
def decode_field(field: str, value: str) -> Any:
if value == '':
return None
try:
return decoders[field](value)
except Exception as e:
raise ValueError(f"Error decoding field {field} with value {value}. Error: {e}") from e
return tuple(OrderedDict((field, decode_field(field, value)) for field, value in row.items())
for row in rows)
def _build_decoders(self, fields: Sequence[str]) -> dict:
decoders = {}
for field in fields:
try:
field_metadata = self._metadata_map[field]
except KeyError:
logger.warning('field %s not found in table metadata', field)
field_metadata = {'DataType': 'Character'}
decoders[field] = _get_decoder(
data_type=field_metadata['DataType'],
interpretation=field_metadata.get('Interpretation', ''),
include_tz=self._include_tz,
)
return decoders
def _get_decoder(data_type: str, interpretation: str, include_tz: bool = False):
if interpretation == _LOOKUP_TYPE:
return str
elif interpretation in _LOOKUP_MULTI_TYPES:
return lambda value: value.split(',')
if data_type in _TIMEZONE_AWARE_DECODERS:
return partial(_TIMEZONE_AWARE_DECODERS[data_type], include_tz=include_tz)
try:
return _DECODERS[data_type]
except KeyError:
raise RetsParseError('unknown data type %s' % data_type) from None
def _decode_datetime(value: str, include_tz: bool) -> datetime:
# Correct `0000-00-00` to `0000-00-00T00:00:00`
if len(value) == 10:
value = '%sT00:00:00' % value[0:10]
# Correct `0000-00-00 00:00:00` to `0000-00-00T00:00:00`
elif value[10] == ' ':
value = '%sT%s' % (value[0:10], value[11:])
decoded = udatetime.from_string(value)
if not include_tz:
return decoded.astimezone(timezone.utc).replace(tzinfo=None)
return decoded
def _decode_time(value: str, include_tz: bool) -> time:
decoded = _decode_datetime('1970-01-01T' + value, include_tz)
return decoded.time().replace(tzinfo=decoded.tzinfo)
def _decode_date(value: str, include_tz: bool) -> datetime:
try:
decoded = datetime.strptime(value, '%Y-%m-%d')
return decoded
except ValueError:
return _decode_datetime(value, include_tz)
_LOOKUP_TYPE = 'Lookup'
_LOOKUP_MULTI_TYPES = frozenset(('LookupMulti', 'LookupBitstring', 'LookupBitmask'))
_TIMEZONE_AWARE_DECODERS = {
'DateTime': _decode_datetime,
'Time': _decode_time,
'Date': _decode_date,
}
_DECODERS = {
'Boolean': lambda value: value == '1',
'Character': str,
'Tiny': int,
'Small': int,
'Int': int,
'Long': int,
'Decimal': Decimal,
'Number': int,
# Point is new "Edm.GeographyPoint" from RESO, look online for spec. Can store as Postgres Point, see https://bit.ly/2BDPgUS
'Point': str,
} | /rets-python-0.4.9.tar.gz/rets-python-0.4.9/rets/client/decoder.py | 0.798462 | 0.282298 | decoder.py | pypi |
from typing import FrozenSet, Mapping, Sequence, Union
from rets.client.decoder import RecordDecoder
from rets.client.record import Record
from rets.client.utils import get_metadata_data
from rets.errors import RetsClientError
from rets.http import RetsHttpClient, SearchResult
class ResourceClass:
def __init__(self, resource, metadata: dict, http_client: RetsHttpClient):
self.resource = resource
self._http = http_client
self._metadata = metadata
self._table = metadata.get('_table')
self._fields = None
@property
def name(self) -> str:
return self._metadata['ClassName']
@property
def has_key_index(self) -> bool:
return self._metadata.get('HasKeyIndex') == '1'
@property
def metadata(self) -> dict:
metadata = dict(self._metadata)
if self._table:
metadata['_table'] = self._table
return metadata
@property
def table(self) -> Sequence[dict]:
if self._table is None:
self._table = tuple(get_metadata_data(self._http, 'table', resource=self.resource.name, class_=self.name))
return self._table
@property
def fields(self) -> FrozenSet[str]:
if self._fields is None:
self._fields = frozenset(field['SystemName'] for field in self.table)
return self._fields
def search(self,
query: Union[str, Mapping[str, str]],
fields: Sequence[str] = None,
parse: bool = True,
include_tz: bool = False,
**kwargs) -> SearchResult:
query = self._validate_query(query)
if fields:
fields = self._validate_fields(fields)
result = self._http.search(
resource=self.resource.name,
class_=self.name,
query=query,
select=fields,
**kwargs,
)
if parse:
decoder = RecordDecoder(self.table, include_tz)
rows = decoder.decode(result.data)
else:
rows = result.data
return SearchResult(
count=result.count,
max_rows=result.max_rows,
data=tuple(Record(self, row) for row in rows),
)
def _validate_query(self, query: Union[str, Mapping[str, str]]) -> str:
if isinstance(query, str):
return query
self._assert_fields(query)
return ','.join('(%s=%s)' % (field, value) for field, value in query.items())
def _validate_fields(self, fields: Sequence[str]) -> str:
self._assert_fields(fields)
return ','.join(fields)
def _assert_fields(self, fields: Sequence[str]) -> None:
permissible = self.fields
invalid = tuple(f for f in fields if f not in permissible)
if invalid:
raise RetsClientError('invalid fields %s' % ','.join(invalid))
def __repr__(self) -> str:
return '<Class: %s:%s>' % (self.resource.name, self.name) | /rets-python-0.4.9.tar.gz/rets-python-0.4.9/rets/client/resource_class.py | 0.899466 | 0.188193 | resource_class.py | pypi |
# RETS
[](https://pypi.python.org/pypi/rets/)
[](https://travis-ci.org/refindlyllc/rets)
[](https://coveralls.io/github/refindlyllc/rets?branch=master)
A pure python RETS client for real estate data. Make requests to the MLS
server to get real estate listings, media, and metadata.
## Installation
The easiest way to install is through pip.
`pip install rets`
If you need to build the package locally, it can be downloaded
from [github](https://github.com/refindlyllc/rets) and installed
through setuptools.
```bash
git clone https://github.com/refindlyllc/rets.git
cd python-rets
python setup.py install
```
You can now import the rets module within Python.
## Quickstart
After [installing](##installation) the rets package locally,
make requests to an MLS server for data.
```python
>>> from rets import Session
>>> login_url = 'http://retrsprovider.com/login'
>>> username = 'user123'
>>> password = 'a48a*32fa$5'
>>> rets_client = Session(login_url, username, password)
>>> rets_client.login()
>>> system_data = rets_client.get_system_metadata()
>>> system_data
{'version': '1.11.76004', 'system_description': 'MLS-RETS', 'system_id': 'MLS-RETS'}
>>> resources = rets_client.get_resource_metadata((resource='Agent')
>>> resources
{'ClassCount': '1',
'ClassDate': '2016-04-20T15:17:13Z',
'ClassVersion': '1.00.00023',
'Date': '2016-12-08T16:15:15Z',
'Description': 'Agent',
'EditMaskDate': '2013-03-26T00:10:01Z',
'EditMaskVersion': '1.00.00000',
'KeyField': 'unique_id',
'LookupDate': '2016-05-06T17:05:40Z',
'LookupVersion': '1.00.00369',
'ObjectDate': '2014-06-20T14:15:57Z',
'ObjectVersion': '1.00.00001',
'ResourceID': 'Agent',
'SearchHelpDate': '2013-03-26T00:10:01Z',
'SearchHelpVersion': '1.00.00000',
'StandardName': 'Agent',
'TableName': 'AGENT',
'UpdateHelpDate': '2013-03-26T00:10:01Z',
'UpdateHelpVersion': '1.00.00000',
'ValidationExpressionDate': '2013-03-26T00:10:01Z',
'ValidationExpressionVersion': '1.00.00000',
'ValidationExternalDate': '2013-03-26T00:10:01Z',
'ValidationExternalVersion': '1.00.00000',
'ValidationLookupDate': '2013-03-26T00:10:01Z',
'ValidationLookupVersion': '1.00.00000',
'Version': '1.11.73255',
'VisibleName': 'Agent'}
>>> search_results = rets_client.search(resource='Property', resource_class='RES', limit=1, dmql_query='(ListPrice=150000+)')
>>> for result in search_results:
... result
{'Acres': '0.0000',
'ActiveOpenHouseCount': '',
'AdditionalRooms': 'LAINRE,SCPOLA',
'AmenRecFreq': '',
'Amenities': 'BASKET,CLUBHO,COMPOO,COMSPA,EXEROO,EXTSTO,PRIMEM,PUTGRE,SAUNA,SIDEWA,STREET,TENCOU,UNDUTI',
'AmenityRecFee': '0.00',
'ApplicationFee': '100.00',
'ApproxLivingArea': '1946',
'AssociationMngmtPhone': '',
'BathsFull': '2',
'BathsHalf': '0',
'BathsTotal': '2.00',
'BedroomDesc': '',
'Bedrooms': '3',
'BedsTotal': '3',
...
}
>>> rets_client.logout()
```
## The Session Object
All requests to a RETS server must be authenticated. The login credential
fields must be passed to the Session object at instantiation. As some
RETS servers limit the number of concurrent requests, it is also ideal
to logout when requests to the RETS server are complete.
### Session Parameters
- login_url: The login URL for the RETS feed
- username: The username for the RETS feed
- password: The password for the RETS feed
- version: The RETS version is typically provided from the server at login.
You can set the version here to override the value provided by the server
- user_agent: The useragent for the RETS feed. Not all servers require this.
- user_agent_password: The useragent password for the RETS feed. Not all servers require this.
- follow_redirects: Follow HTTP redirects. The default True.
- use_post_method: Use HTTP POST method when making requests instead of GET. The default is True
- metadata_format: COMPACT_DECODED or STANDARD_XML. The client will attempt to set this automatically based on response codes from the RETS server.
- session_id_cookie_name: The session cookie name returned by the RETS server. Default is RETS-Session-ID
### Context Manager
If you don't want to manually call the session's login and logout methods,
the Session object can be opened in a context manager that logs the client
in and out automatically.
```python
with Session(rets_client = Session(login_url, username, password) as s:
print('Now logged in')
system_metadata = s.get_system_metadata()
search_results = s.search(resource='Property', resource_class='RES', limit=100, dmql_query='(ListPrice=150000+)')
print('Now logged out')
## do stuff with the search results
```
## Metadata Methods
The session object can get RETS metadata through the following methods:
### rets_client.get_system_metadata()
Returns the METADATA-SYSTEM information in a dictionary.
### rets_client.get_resource_metadata(resource=None)
Returns the METADATA-RESOURCE information in a list of dicts. The
resource argument can be supplied to this method to limit the returned
value to just the dict containing that resource.
### rets_client.get_class_metadata(resource)
Returns the METADATA-CLASS information for a given resource in a list
of dicts.
### rets_client.get_table_metadata(resource, class)
Returns the METADATA-TABLE information for a resource and class
in a list of dicts.
### rets_client.get_object_metadata(resource)
Returns the METADATA-OBJECT information for a resource in a list of dicts
### rets_client.get_lookup_values(resource, lookup_name)
Returns the METADATA-LOOKUP_TYPE information for a field of a resource. The
result is a list of the lookup values for the given lookup_name.
Some RETS servers allow a wildcard `*` for the lookup name and will return all lookup values.
In these cases, a dict is returned with the keys being each of the lookup_names and
the values being the corresponding lists of values.
## Object Methods
The session can get RETS Objects through the GetObject request. There
are two methods for obtaining objects.
### rets_client.get_preferred_object(resource, object_type, content_id, location=0)
Returns a dict containing information on the preferred object for a
given content_id.
### rets_client.get_object(resource, object_type, content_ids, object_ids='*', location=0)
Returns a list of dicts containing information on objects for one or more
content_ids. The content_ids can be passed as a list if there are multiple
content_ids. The object_ids variable limits the objects returned to the index
number of each object on the server. This can be useful when getting a single
object or subset of total objects. Each dict contains a key of content_md5 that
contains the md5 checksum for the object. This should help users identify duplicates
supplied by the RETS servers or compare the objects against their previously
saved objects.
Here is an example of getting an object's images and saving them to file:
```python
with Session(rets_client = Session(login_url, username, password) as s:
unique_listing_id = '123456789'
object_dict_list = s.get_object(
resource='Property',
object_type='LargePhoto',
content_ids=unique_listing_id
)
for ob in object_dict_list:
## Save the images individually
file_name = "{}_{}.jpg".format(unique_listing_id, ob['content_id'])
with open(file_name, 'wb') as f:
f.write(ob['content'])
```
## Searching
Use the client's search method to search for real estate data. All searches
must have the resource, class, and search query. The query can be sent
as either a Data Mining Query Language string or a search filter dictionary.
The search method takes the following parameters:
- resource: The resource that contains the class to search
- resource_class: The class to search
- search_filter=None: The query as a dict
- dmql_query=None: The query in dmql format
- limit=None: Limit search values count
- offset=None: Offset for RETS request. Useful when RETS limits number of results or transactions
- optional_parameters=None: Values for option paramters
- query_type: The query type to submit as. Defaults to `DMQL2`
- standard_names: Boolean for if the search uses standard names.
Defaults to `0` indicating the search uses system field names
- response_format: The format of the response you would like back, defaults to `COMPACT-DECODED`
The resource and resource_class parameters are required. You must also provide either
the search_filter parameter or the dmql_query parameter.
The dmql query is what RETS is expecting and the search_filter dict ends up
creating the dmql to be sent to rets.
```python
>>> search_res = rets_client.search('Property', 'RES', dmql_query='(Status=A)')
>>> the_same_res = rets_client.search('Property', 'RES', search_filter={'Status': 'A"})
```
Many RETS servers limit the number of results returned with a search request.
You may pass the limit and/or offset parameters to the search method to better
control the result set.
```python
>>> small_res = rets_client.search('Property', 'RES', search_filter={'Status': 'A"}, limit=1)
```
The small_res just has a single listing returned.
```python
>>> first_res = rets_client.search('Property', 'RES', search_filter={'Status': 'A"})
```
The RETS server only returned the first 10,000 results from this query.
Do a second query to get the rest of the results.
```python
>>> second_res = rets_client.search('Property', 'RES', search_filter={'Status': 'A"}, offset=10000)
```
Lastly, if there are any other parameters to send to the Search end point,
you may provide them in the optional_parameters dict.
### Filters
Complex queries in DQML can be troublesome to read and maintain. Creating
these queries as search_filter dictionaries can make this a little better.
The following logical operators are parsed by client.
- $gte: numeric or datetime values greater than or equal to this.
- $lte: numeric or datetime values less than or equal than to this.
- $contains: a string contains these characters anywhere.
- $begins: a string begins with these characters.
- $ends: a string ends with these characters.
- $in: a list of possible values a field can contain.
- $nin: a list of values a field cannot contain.
- $neq: the value must not equal this.
Additionally, all date, datetime, and time objects passed to the search_filter
are converted to the appropriate format expected by RETS server.
### Examples Search Filters
Active listings in the past 48 hours.
```python
>>> two_days_ago = datetime.today() - datetime.timedelta(days=2)
>>> filter = {
"Status": "Active",
"CreatedDatetime": {
"$gte": two_days_ago
}
}
>>> results = rets_client.search('Property', 'RES', search_filter=filter)
```
Expensive properties that have been on the market over 5 months
```python
>>> five_months_ago = datetime.today() - datetime.timedelta(months=5)
>>> filter = {
"Status": "Active",
"CreatedDatetime": {
"$lte": five_months_ago
}
}
}
>>> results = rets_client.search('Property', 'RES', search_filter=filter)
```
Listings on a "Main" street in a neighborhood that contains "Quail West".
(Some RETS use legal descriptions of neighborhood data or allow brokers to
enter inconsistent neighborhood names)
```python
>>> filter = {
"Status": "Active",
"StreetName": {
"$begins": "Main S"
},
"DevelopmentName": {
"$contains": "Quail West"
}
>>> results = rets_client.search('Property', 'RES', search_filter=filter)
```
At least four bedrooms, two to three bathrooms, under $150,000.
```python
>>> filter = {
"Status": "Active",
"Bedrooms": {
"$gte": 4
},
"Bathrooms": {
"$in": [2, 3]
},
"ListPrice": {
"$lte": 150000
}
}
>>> results = rets_client.search('Property', 'RES', search_filter=filter)
```
### Search Results
Searches with the RETS client return a list of dictionaries that represents listings of a search result.
### Custom Results Parser
Some RETS server return non-standard search result responses. In these cases it is useful to create your own parser class.
This class must define a method `generator` that takes a single argument of the rets server response. A simple example of
this can be found in the [CREA Test](tests/custom_parser_example.py) file.
When the Session is instantiated, pass the and instance of the class as the `search_parser` class.
## RETS Exceptions
There are many RETS Reply Codes that can be returned from the server. As a rule, this rets library raises a
`rets.exceptions.RETSException` for all reply codes that are non-zero. The reply_code and reply_text are set as
parameters for the exception to make it easier for applications to catch and respond to specific reply codes.
## Contributing
This RETS client has a long way to go, and keeping up with new [RESO Standards](http://www.reso.org/data-dictionary/)
, RETS 2.0, and other features will require ongoing maintenance.
Please feel free to fork this repo and make pull requests to the development branch
if you wish to contribute. Ensure that all new code has accompanying
tests. Travis-CI will run your code through the current and new tests
when you make a pull request.
All pull requests should reference an [Github issue](https://github.com/refindlyllc/rets/issues). Features
and bugs should be discussed in the issue rather than be discussed in a pull request.
Many thanks to the passive contribution of [@troydavisson](https://github.com/troydavisson)
for his work on [PHRETS](https://github.com/troydavisson/PHRETS). We shamelessly used many of his great conventions to
make this project successful.
## Testing
If you wish to test the code prior to contribution use tox to test on python 2 and 3.
```bash
tox
```
## Helpful RETS Links
- [http://www.reso.org/glossary/](http://www.reso.org/glossary/)
- [https://www.flexmls.com/developers/rets/tutorials/example-rets-session/](https://www.flexmls.com/developers/rets/tutorials/example-rets-session/)
- [http://www.realtor.org/retsorg.nsf/pages/docs](http://www.realtor.org/retsorg.nsf/pages/docs)
| /rets-0.4.11.tar.gz/rets-0.4.11/README.md | 0.497803 | 0.834339 | README.md | pypi |
import functools
import math
import matplotlib.pyplot as plt
import numpy as np
SMALL_SIZE = 10
MEDIUM_SIZE = 12
BIGGER_SIZE = 14
plt.rc('axes', axisbelow=True)
plt.rc('font', size=SMALL_SIZE)
plt.rc('axes', titlesize=MEDIUM_SIZE)
plt.rc('axes', labelsize=MEDIUM_SIZE)
plt.rc('xtick', labelsize=MEDIUM_SIZE)
plt.rc('ytick', labelsize=MEDIUM_SIZE)
plt.rc('legend', fontsize=MEDIUM_SIZE)
plt.rc('figure', titlesize=BIGGER_SIZE)
hatches = ['//', '\\\\', '||', '--', '++', 'xx', 'oo', 'OO', '..', '**', '/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*']
# Default plot configs
default_plot_config = {
"show_legend": True,
"ygrid": True,
"show_hatch": False,
# Bar plot
"gmean": False,
}
def calc_gmean(numbers):
sum_of_logs = functools.reduce(lambda x, y: x+y,
map(math.log, numbers))
return pow(math.e, sum_of_logs/len(numbers))
def save_or_show_figure(plot_config, filename):
"""Save or show plot
:param plot_config: Plot configuration
:type plot_config: dict
:param filename: File name to save the plot
:type filename: str
"""
# Legend
if ('show_legend' in plot_config) and plot_config['show_legend']:
plt.legend()
if filename:
plt.tight_layout()
plt.savefig(filename, bbox_inches='tight', pad_inches = 0.1, dpi=300)
else:
plt.show()
def generic_plot(plot_config):
"""Create a plot and do generic configuration
:param plot_config: Plot configuration
:type plot_config: dict
"""
# Figure size
if 'figure_size' in plot_config:
fig, ax = plt.subplots(figsize=(plot_config['figure_size']['width'], plot_config['figure_size']['height']))
else:
fig, ax = plt.subplots()
# Title and Axes
if 'title' in plot_config:
ax.set_title(plot_config['title'])
if 'xlabel' in plot_config:
ax.set_xlabel(plot_config['xlabel'])
if 'ylabel' in plot_config:
ax.set_ylabel(plot_config['ylabel'])
if ('ygrid' in plot_config) and plot_config['ygrid']:
ax.grid(axis='y', which='major')
if 'yscale' in plot_config:
ax.set_yscale(plot_config['yscale'])
# Y limits
ylim = None
if 'ylim' in plot_config:
if 'min' in plot_config['ylim']:
ax.set_ylim(bottom=float(plot_config['ylim']['min']))
if 'max' in plot_config['ylim']:
ax.set_ylim(top=float(plot_config['ylim']['max']))
return fig, ax
def set_plot_xticks(ax, xticks, plot_config, data):
"""Configure and add xticks
:param ax: Matplotlib axis
:type ax: matplotlib Axis
:param xticks: List of benchmarks
:type xticks: list
:param plot_config: Plot configuration
:type plot_config: dict
:param data: Dictionary with data to plot (needed to add gmean)
:type data: dict
"""
# Xticks
xticks = xticks[:]
if ('gmean' in plot_config) and (plot_config['gmean']):
for model in data.keys():
data[model].append(calc_gmean(data[model]))
xticks.append("gmean")
xticks_rotation = 0
if 'xticks_rotation' in plot_config:
xticks_rotation = plot_config['xticks_rotation']
xticks_ha = 'center'
if 'xticks_horizontal_alignment' in plot_config:
xticks_ha = plot_config['xticks_horizontal_alignment']
ax.set_xticks(np.arange(len(xticks)), xticks, rotation=xticks_rotation, ha=xticks_ha)
def config_value(plot_config, name, default_value):
if name in plot_config:
return plot_config[name]
else:
return default_value
def bar_plot(data, xticks, plot_config, filename=None):
"""Create a Bar plot
:param data: Dictionary with data to plot (model => [model_value for each benchmark])
:type data: dict
:param xticks: List of benchmarks
:type xticks: list
:param plot_config: Plot configuration
:type plot_config: dict
:param filename: File name to save the plot
:type filename: str
"""
fig, ax = generic_plot(plot_config)
# Bar plot config values
bar_width = config_value(plot_config, 'bar_width', 1)
intra_bar_gap = config_value(plot_config, 'intra_bar_gap', 0.1)
inter_bar_gap = config_value(plot_config, 'inter_bar_gap', 0.5)
annotate_outliers = config_value(plot_config, 'annotate_outliers', False)
annotate_all = config_value(plot_config, 'annotate_all', False)
annotation_gap = config_value(plot_config, 'annotation_gap', 0.01)
xticks_rotation = config_value(plot_config, 'xticks_rotation', 0)
xticks_ha = config_value(plot_config, 'xticks_horizontal_alignment', 'center')
show_gmean = config_value(plot_config, 'gmean', False)
show_hatch = config_value(plot_config, 'show_hatch', False)
if show_gmean:
xticks.append("gmean")
for model in data.keys():
gmean_value = calc_gmean(data[model])
data[model].append(gmean_value)
print(f"Gmean for {model}: {round(gmean_value,5)}")
start_x = np.arange(len(xticks)) * (len(data) * bar_width + (len(data) - 1) * intra_bar_gap + inter_bar_gap)
xticks_positions = start_x + (len(data) * bar_width + (len(data) - 1) * intra_bar_gap) / 2.0 - (bar_width/2.0)
ax.set_xticks(xticks_positions, xticks, rotation=xticks_rotation, ha=xticks_ha)
for i, model in enumerate(data.keys()):
current_plot_data = data[model]
x_values = start_x + i*(bar_width+intra_bar_gap)
chosen_hatch = None
if show_hatch:
chosen_hatch = hatches[i]
ax.bar(x_values, current_plot_data, width=bar_width, label=model, hatch=chosen_hatch, alpha=.99)
max_val = ax.get_ylim()[1]
for item_i, value in enumerate(current_plot_data):
label = str.format("{:.2f}",round(value,2))
if value > max_val:
if annotate_all or annotate_outliers:
ax.annotate(label,
xy=(x_values[item_i], max_val + annotation_gap),
annotation_clip=False,
ha='center', va='bottom',rotation=90,size=15).draggable()
elif annotate_all:
ax.annotate(label,
xy=(x_values[item_i], value + annotation_gap),
annotation_clip=False,
ha='center', va='bottom',rotation=90,size=15).draggable()
save_or_show_figure(plot_config, filename)
def stacked_bar_plot(data, xticks, plot_config, filename=None):
"""Create a stacked bar plot
:param data: Dictionary with data to plot (model => [[model_value for each benchmark] for each stack]))
:type data: dict
:param xticks: List of benchmarks
:type xticks: list
:param plot_config: Plot configuration
:type plot_config: dict
:param filename: File name to save the plot
:type filename: str
"""
fig, ax = generic_plot(plot_config)
set_plot_xticks(ax, xticks, plot_config, data)
models = data.keys()
colors = {}
selected_hatches = {}
bar_width = 0.8
plot_bar_labels = plot_config['stack_labels']
per_model_width = bar_width / len(models)
initial_x_vals = np.array(range(0,len(xticks))) - 0.5 * bar_width + 0.5 * per_model_width
for j, model in enumerate(models):
bottom = np.zeros(len(xticks))
x_vals = initial_x_vals + j * per_model_width
for i, stack_bar in enumerate(plot_bar_labels):
if stack_bar not in colors:
selected_hatches[stack_bar] = None
if plot_config['show_hatch']:
selected_hatches[stack_bar] = hatches[i]
bar = ax.bar(x_vals, data[model][i], label=stack_bar, hatch=selected_hatches[stack_bar], bottom=bottom, width=per_model_width, alpha=.99)
colors[stack_bar] = bar.patches[0].get_facecolor()
else:
ax.bar(x_vals, data[model][i], color=colors[stack_bar], hatch=selected_hatches[stack_bar], bottom=bottom, width=per_model_width, alpha=.99)
bottom += data[model][i]
save_or_show_figure(plot_config, filename)
def violin_plot(data, xticks, plot_config, filename=None):
"""Create a violin plot
:param data: Dictionary with data to plot (model => [list of values for each benchmark])
:type data: dict
:param xticks: List of benchmarks
:type xticks: list
:param plot_config: Plot configuration
:type plot_config: dict
:param filename: File name to save the plot
:type filename: str
"""
fig, ax = generic_plot(plot_config)
set_plot_xticks(ax, xticks, plot_config, data)
showmeans = False
if 'show_means' in plot_config:
showmeans = plot_config['show_means']
for model in data.keys():
model_data = data[model]
plt.violinplot(model_data, positions=(list(range(len(xticks)))), showmeans=showmeans)
save_or_show_figure(plot_config, filename)
def line_plot(data, plot_config, filename=None):
"""Create a line plot
:param data: Dictionary with data to plot (line_label => [y_value for each n]))
:type data: dict
:param plot_config: Plot configuration
:type plot_config: dict
:param filename: File name to save the plot
:type filename: str
"""
fig, ax = generic_plot(plot_config)
for line_label in data.keys():
line_data = data[line_label]
x_vals = np.array(list(range(1,len(line_data)+1)))/float(len(line_data))
ax.plot(x_vals, line_data, label=line_label)
save_or_show_figure(plot_config, filename) | /rettool-0.0.1-py3-none-any.whl/ret/plot.py | 0.666171 | 0.488405 | plot.py | pypi |
# Changelog
This is a list of notable new features,
or any changes which could potentially break or change the behavior of existing setups.
This is intentionally kept short. For a full change log, just see the Git log.
## 2021-03-18: Subnetwork sub layer can be independent ([#473](https://github.com/rwth-i6/returnn/pull/473))
This has an effect on recurrent subnetworks.
In the optimization phase, individual sub layers can be optimized out of the loop now.
This is crucial to allow for an easy use of nested subnetworks.
Nested subnetworks are important to allow for generic building blocks
such as in the [returnn_common](https://github.com/rwth-i6/returnn_common) recipes.
This was a larger internal change in RETURNN,
which possibly can simplify other code in RETURNN like losses in subnetworks.
## 2021-03-08: Packed arrays ([#466](https://github.com/rwth-i6/returnn/issues/466), [#467](https://github.com/rwth-i6/returnn/pull/467), [#469](https://github.com/rwth-i6/returnn/pull/469)) and extended batch information (`BatchInfo`)
The extended batch information (`BatchInfo` attached to `Data`)
contains information about merged or packed dimensions in the batch dimension,
such as a beam (from beam search), fixed dimensions or variable-length dimensions.
This has an effect on keeping the information of beam search,
on `FlattenBatchLayer`, `SplitBatchTimeLayer`, `MergeDimsLayer` (on batch dim) and related.
## 2021-03-05: Fast literal Python parsing via native `literal_py_to_pickle`
We use literal Python format as serialization format in many places,
e.g. `OggZipDataset`.
The idea was that Python should be very fast in parsing Python code
(e.g. via `eval` or `ast.literal_eval`).
Unfortunately, it turned out that Python is not very fast at this
(specifically to parse *literal Python*, a subset of Python),
and e.g. JSON parsing is much faster.
We now have native code to parse literal Python,
which is much faster than before,
and this is already used in `OggZipDataset`.
Everything should work as before but just be faster.
Note that for the future,
it is probably a better idea to use JSON for serialization,
or some binary format.
## 2021-03-03: Simplified [`logging`](https://docs.python.org/3/library/logging.html) usage
## 2021-03-01: External module import with `import_` ([#436](https://github.com/rwth-i6/returnn/discussions/436))
Together with this mechanism, some common recipes are being developed
in [rwth-i6/returnn_common](https://github.com/rwth-i6/returnn_common).
## 2021-02-27: `SentencePieces` vocabulary class for [SentencePiece](https://github.com/google/sentencepiece/)
This can use BPE but also potentially better alternatives like unigram language model based subword units.
This can also do stochastic sampling for training.
## 2020-12-09: New `batch_norm` settings
We did not change the defaults.
However, we observed that the defaults don't make sense.
So if you have used `batch_norm` with the defaults before,
you likely want to redo any such experiments.
See [here](https://github.com/rwth-i6/pytorch-to-returnn/blob/a209cb6b2d43ae5a6dc46db42101b3c653dad03b/pytorch_to_returnn/torch/nn/modules/batchnorm.py#L97)
for reasonable defaults.
Esp you want to set `momentum` to a small number, like 0.1,
and you probably want `update_sample_only_in_training=True`
and `delay_sample_update=True`.
## 2020-11-06: [PyTorch-to-RETURNN project](https://github.com/rwth-i6/pytorch-to-returnn)
## 2020-08-03: New code structure ([discussion](https://github.com/rwth-i6/returnn/issues/162))
`TFEngine` (or `returnn.TFEngine`) becomes `returnn.tf.engine`, etc.
## 2020-06-30: New generic training pipeline / extended custom pretraining ([discussion](https://github.com/rwth-i6/returnn/issues/311))
Define `def get_network(epoch: int, **kwargs): ...` in your config,
as an alternative to `pretrain` with custom `construction_algo` and `network`.
Otherwise this is pretty similar in behavior
(with all similar features, such as `#config` overwrites, dataset overwrites, etc),
but not treated as "pretraining",
but used always.
## 2020-06-12: TensorFlow 2 support ([discussion](https://github.com/rwth-i6/returnn/issues/283))
Configs basically should "just work".
We recommend everyone to use TF2 now.
## 2020-06-10: Distributed TensorFlow support ([discussion](https://github.com/rwth-i6/returnn/issues/296), [wiki](https://github.com/rwth-i6/returnn/wiki/Distributed-TensorFlow))
See [`returnn.tf.distributed`](https://returnn.readthedocs.io/en/latest/api/tf.distributed.html).
## 2020-06-05: New TF dataset pipeline via `tf.dataset` ([discussion](https://github.com/rwth-i6/returnn/issues/292))
Define `def dataset_pipeline(context: InputContext) -> tf.data.Dataset`
in your config.
See [`returnn.tf.data_pipeline`](https://returnn.readthedocs.io/en/latest/api/tf.data_pipeline.html).
## 2019-08-20: Pretrain `#config` can overwrite datasets (`train`, `dev`, `eval`)
## 2019-08-13: `Data` `batch_shape_meta` extra debug repr output
This will show the same information as before, but much more compact,
and also in addition the dimension tags (`DimensionTag`),
which also got improved in many further cases.
## 2019-08-07: overlay nets (`extra_nets`)
You can have e.g. multiple additional networks which redefine
existing layers (they would automatically share params),
which can use different flags (e.g. enable the search flag).
## 2019-07: multiple stochastic (latent) variables
It was designed to support this from the very beginning,
but the implementation was never fully finished for this.
Now examples like hard attention work.
## 2019-05: better support for RETURNN as a framework
`pip install returnn`, and then `import returnn`.
## 2019-03-29: remove hard Theano dependency
## 2019-03-24 and ongoing: automatic linter checks
Currently pylint and PyCharm inspection checks automatically run in Travis.
Both have some false positives, but so far the PyCharm inspections seems much more sane.
A lot of code cleanup is being done now.
This is not complete yet, and thus the failing tests are ignored.
## 2019-03-01: `GenericAttentionLayer` reimplemented
Based on `DotLayer` now.
Is more generic if the attention weights
have multiple time axes (e.g. in Transformer training).
Does checks whether the base time axis
and weights time axis match,
and should automatically select the right one from weights
if there are multiple
(before: it always used the first weights time axis).
The output format (order of axes) might be
different than it was before in some cases.
## 2019-03-01: `Data` some slight behavior changes
E.g. the default feature dim axis (if unspecified)
is the last non-dynamic axis.
Also in some cases the time axis will be
automatically re-selected if the original one
was removed and there are multiple dynamic axes.
`DimensionTag` support was extended.
When copying compatible to some other data
with multiple dynamic axes, it will more correctly
match the dynamic axes via the dimension tags
(see test cases for examples).
## 2019-03-01: `SqueezeLayer`, `enforce_batch_dim_axis` by default `None`
I.e. the output format (order of axes) might be
different than it was before in some cases.
## 2019-02-27: `CombineLayer` / `EvalLayer` / any which concatenate multiple sources, extended automatic broadcasting
See e.g. `concat_sources`.
## 2019-02-21: `HDFDataset` huge speedup for `cache_size=0`
If your whole dataset does not fit into memory
(or you don't want to consume so much memory),
for TensorFlow,
you should always use `cache_size = 0` (or `"0"`) in the config.
This case got a huge speedup.
## 2019-02-18: `MergeDimsLayer`, `SplitBatchTimeLayer`
If you used `MergeDimsLayer` with `"axes": "BT"` **on some time-major input**,
and then later `SplitBatchTimeLayer` to get the time-axis back, it was likely incorrect.
## 2019-02-09: `LayerBase` `updater_opts`, individual updater/optimizer options per layer
## 2019-01-30: video: RETURNN overview
## 2018-08: multi-GPU support via [Horovod](https://github.com/horovod/horovod)
## 2017-05: flexible `RecLayer`, encoder-decoder attention, beam search (Albert Zeyer)
## 2016-12: start on [TensorFlow](https://www.tensorflow.org/) support (Albert Zeyer)
Initial working support already finished within that month.
TF 0.12.0.
## 2015-07: fast CUDA LSTM kernel (Paul Voigtlaender)
## 2015-03: `SprintDataset`, interface to [RASR](https://www-i6.informatik.rwth-aachen.de/rwth-asr/) (Albert Zeyer)
## 2015-01: Albert Zeyer joined
## ~2013-2014 (?): Patrick Doetsch started the project (Theano)
| /returnn-1.20230902.233313.tar.gz/returnn-1.20230902.233313/CHANGELOG.md | 0.900119 | 0.751876 | CHANGELOG.md | pypi |
# No RETURNN dependency needed for the basic search. Just TF itself.
import typing
import os
import json
import argparse
import tensorflow as tf
import numpy
class Hyp:
"""
Represents a hypothesis in a given decoder step, including the label sequence so far.
"""
def __init__(self, idx):
"""
:param int idx: hyp idx (to identify it in a beam)
"""
self.idx = idx
self.source_idx = None # type: typing.Optional[int] # source hyp idx
self.score = 0.0
self.seq = [] # label seq
def expand(self, idx, label, score):
"""
:param int idx:
:param int label:
:param float score:
:rtype: Hyp
"""
new_hyp = Hyp(idx=idx)
new_hyp.source_idx = self.idx
new_hyp.seq = list(self.seq) + [label]
new_hyp.score = score
return new_hyp
def main():
"""
Main entry.
"""
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("--graph", help="compiled TF graph", required=True)
arg_parser.add_argument("--chkpt", help="TF checkpoint (model params)", required=True)
arg_parser.add_argument("--beam_size", type=int, default=12)
arg_parser.add_argument("--rec_step_by_step_json", required=True)
args = arg_parser.parse_args()
# We operate only on a single seq (i.e. initially batch dim == 1, then batch dim == beam size).
def make_initial_feed_dict():
"""
:return: whatever placeholders we have for input features...
:rtype: dict
"""
# TODO...
return {}
# Load rec-step-by-step info. See compile_tf_graph.py for details.
info = json.load(open(args.rec_step_by_step_json))
assert isinstance(info, dict)
# Load the graph
if os.path.splitext(args.graph)[1] in [".meta", ".metatxt"]: # meta graph
saver = tf.compat.v1.train.import_meta_graph(args.graph)
else: # normal graph
graph_def = tf.compat.v1.GraphDef()
graph_def.ParseFromString(open(args.graph, "rb").read())
tf.import_graph_def(graph_def)
saver = tf.compat.v1.train.Saver()
with tf.compat.v1.Session() as session:
# Load the params.
saver.restore(session, args.chkpt)
# Calculate encoder states and initial decoder states.
initial_feed_dict = make_initial_feed_dict()
session.run(info["init_op"], feed_dict=initial_feed_dict)
hyps = [Hyp(idx=0)]
# Now loop over decoder steps.
max_dec_len = 100 # TODO better default... depending on input len. or configurable...
for i in range(max_dec_len):
# Loop over all stochastic variables.
for stochastic_var in info["stochastic_var_order"]:
assert isinstance(stochastic_var, str)
# Calculate the scores.
session.run(info["stochastic_vars"][stochastic_var]["calc_scores_op"])
# Get the scores (probabilities in +log space).
scores = session.run(info["state_vars"]["stochastic_var_scores_%s" % stochastic_var])
assert isinstance(scores, numpy.ndarray) and scores.ndim == 2 and scores.shape[0] == len(hyps)
all_possibilities = [
(hyp.score + scores[i, j], j, hyp) for i, hyp in enumerate(hyps) for j in range(scores.shape[1])
]
# TODO: length norm here?
# Select new hypotheses.
best_possibilities = sorted(all_possibilities)[
: args.beam_size
] # type: typing.List[typing.Tuple[float,int,Hyp]]
assert len(best_possibilities) == args.beam_size
hyps = [
hyp.expand(idx=i, label=label, score=score)
for i, (score, label, hyp) in enumerate(best_possibilities)
]
# Set the choices.
session.run(
info["state_vars"]["stochastic_var_scores_%s" % stochastic_var] + "/Assign...?", # TODO...
feed_dict={
info["state_vars"]["stochastic_var_scores_%s" % stochastic_var]
+ "/Initial...?": [[hyp.seq[-1] for hyp in hyps]] # TODO...
},
)
# Select source beams.
session.run(
info["select_src_beams"]["op"],
feed_dict={info["select_src_beams"]["src_beams_placeholder"]: [[hyp.source_idx] for hyp in hyps]},
)
# Update state.
session.run(info["next_step_op"])
# TODO: stopping criterion?
print("Best hypotheses:")
for hyp in hyps:
print("score %.2f: %r" % (hyp.score, hyp.seq))
if __name__ == "__main__":
from returnn.util import better_exchook
better_exchook.install()
main() | /returnn-1.20230902.233313.tar.gz/returnn-1.20230902.233313/demos/demo-tf-search-compiled-graph.py | 0.623148 | 0.470737 | demo-tf-search-compiled-graph.py | pypi |
from __future__ import annotations
import os
import sys
import time
import tensorflow as tf
import numpy
import typing
import _setup_returnn_env # noqa
import returnn.__main__ as rnn
from returnn.log import log
import argparse
from returnn.util.basic import Stats, hms
from returnn.datasets.basic import Dataset, init_dataset
import returnn.util.basic as util
import returnn.tf.compat as tf_compat
import returnn.tf.util.basic as tf_util
class WerComputeGraph:
"""
Creates TF computation graph to calculate the WER.
We accumulate the absolute number of edits and normalize by the accumulated seq lens.
"""
def __init__(self):
self.hyps = tf_compat.v1.placeholder(tf.string, [None])
self.refs = tf_compat.v1.placeholder(tf.string, [None])
self.wer, self.ref_num_words = tf_util.string_words_calc_wer(hyps=self.hyps, refs=self.refs)
self.total_wer_var = tf.Variable(initial_value=0, trainable=False, dtype=tf.int64)
self.total_ref_num_words_var = tf.Variable(initial_value=0, trainable=False, dtype=tf.int64)
self.update_total_wer = self.total_wer_var.assign_add(tf.reduce_sum(self.wer))
self.update_ref_num_words = self.total_ref_num_words_var.assign_add(tf.reduce_sum(self.ref_num_words))
self.updated_normalized_wer = tf.cast(self.update_total_wer, tf.float32) / tf.cast(
self.update_ref_num_words, tf.float32
)
# noinspection PyShadowingNames
def step(self, session, hyps, refs):
"""
:param tf.compat.v1.Session session:
:param list[str] hyps:
:param list[str] refs:
:return: updated normalized WER
:rtype: float
"""
return session.run(self.updated_normalized_wer, feed_dict={self.hyps: hyps, self.refs: refs})
def calc_wer_on_dataset(dataset, refs, options, hyps):
"""
:param Dataset|None dataset:
:param dict[str,str]|None refs: seq tag -> ref string (words delimited by space)
:param options: argparse.Namespace
:param dict[str,str] hyps: seq tag -> hyp string (words delimited by space)
:return: WER
:rtype: float
"""
assert dataset or refs
start_time = time.time()
seq_len_stats = {"refs": Stats(), "hyps": Stats()}
seq_idx = options.startseq
if options.endseq < 0:
options.endseq = float("inf")
wer = 1.0
remaining_hyp_seq_tags = set(hyps.keys())
interactive = util.is_tty() and not log.verbose[5]
collected = {"hyps": [], "refs": []}
max_num_collected = 1
if dataset:
dataset.init_seq_order(epoch=1)
else:
refs = sorted(refs.items(), key=lambda item: len(item[1]))
while True:
if seq_idx > options.endseq:
break
if dataset:
if not dataset.is_less_than_num_seqs(seq_idx):
break
dataset.load_seqs(seq_idx, seq_idx + 1)
complete_frac = dataset.get_complete_frac(seq_idx)
seq_tag = dataset.get_tag(seq_idx)
assert isinstance(seq_tag, str)
ref = dataset.get_data(seq_idx, options.key)
if isinstance(ref, numpy.ndarray):
assert ref.shape == ()
ref = ref.flatten()[0] # get the entry itself (str or bytes)
if isinstance(ref, bytes):
ref = ref.decode("utf8")
assert isinstance(ref, str)
try:
num_seqs_s = str(dataset.num_seqs)
except NotImplementedError:
try:
num_seqs_s = "~%i" % dataset.estimated_num_seqs
except TypeError: # a number is required, not NoneType
num_seqs_s = "?"
else:
if seq_idx >= len(refs):
break
complete_frac = (seq_idx + 1) / float(len(refs))
seq_tag, ref = refs[seq_idx]
assert isinstance(seq_tag, str)
assert isinstance(ref, str)
num_seqs_s = str(len(refs))
start_elapsed = time.time() - start_time
progress_prefix = "%i/%s (WER %.02f%%)" % (seq_idx, num_seqs_s, wer * 100)
progress = "%s (%.02f%%)" % (progress_prefix, complete_frac * 100)
if complete_frac > 0:
total_time_estimated = start_elapsed / complete_frac
remaining_estimated = total_time_estimated - start_elapsed
progress += " (%s)" % hms(remaining_estimated)
remaining_hyp_seq_tags.remove(seq_tag)
hyp = hyps[seq_tag]
seq_len_stats["hyps"].collect([len(hyp)])
seq_len_stats["refs"].collect([len(ref)])
collected["hyps"].append(hyp)
collected["refs"].append(ref)
if len(collected["hyps"]) >= max_num_collected:
wer = wer_compute.step(session, **collected)
del collected["hyps"][:]
del collected["refs"][:]
if interactive:
util.progress_bar_with_time(complete_frac, prefix=progress_prefix)
elif log.verbose[5]:
print(progress_prefix, "seq tag %r, ref/hyp len %i/%i chars" % (seq_tag, len(ref), len(hyp)))
seq_idx += 1
if len(collected["hyps"]) > 0:
wer = wer_compute.step(session, **collected)
print("Done. Num seqs %i. Total time %s." % (seq_idx, hms(time.time() - start_time)), file=log.v1)
print("Remaining num hyp seqs %i." % (len(remaining_hyp_seq_tags),), file=log.v1)
if dataset:
print("More seqs which we did not dumped: %s." % dataset.is_less_than_num_seqs(seq_idx), file=log.v1)
for key in ["hyps", "refs"]:
seq_len_stats[key].dump(stream_prefix="Seq-length %r %r " % (key, options.key), stream=log.v2)
if options.expect_full:
assert not remaining_hyp_seq_tags, "There are still remaining hypotheses."
return wer
config = None # type: typing.Optional["returnn.config.Config"]
def init(config_filename, log_verbosity):
"""
:param str config_filename: filename to config-file
:param int log_verbosity:
"""
rnn.init_better_exchook()
rnn.init_thread_join_hack()
if config_filename:
print("Using config file %r." % config_filename)
assert os.path.exists(config_filename)
rnn.init_config(config_filename=config_filename, command_line_options=[])
global config
config = rnn.config
config.set("task", "calculate_wer")
config.set("log", None)
config.set("log_verbosity", log_verbosity)
config.set("use_tensorflow", True)
rnn.init_log()
print("Returnn calculate-word-error-rate starting up.", file=log.v1)
rnn.returnn_greeting()
rnn.init_backend_engine()
assert util.BackendEngine.is_tensorflow_selected(), "this is only for TensorFlow"
rnn.init_faulthandler()
rnn.print_task_properties()
def load_hyps_refs(filename):
"""
:param str filename:
:return: dict of seq_tag -> ref
:rtype: dict[str,str]
"""
if filename.endswith(".gz"):
import gzip
content_str = gzip.open(filename, "rt").read()
else:
content_str = open(filename).read()
content = eval(content_str)
# See dump-dataset-raw-strings.py.
# We expect that it is stored as a dict.
assert isinstance(content, dict)
assert len(content) > 0
example_hyp = next(iter(content.items()))
assert isinstance(example_hyp[0], str) # seq tag
if isinstance(example_hyp[1], list):
assert isinstance(example_hyp[1][0][1], str)
# n-best list output format needs to be converted first
# always pick the best (first) entry from the list (which is [(score, text), ...]
content = {seq_tag: nbest_list[0][1] for seq_tag, nbest_list in content.items()}
else:
assert isinstance(example_hyp[1], str)
return content
wer_compute = None # type: typing.Optional[WerComputeGraph]
session = None # type: typing.Optional[tf.compat.v1.Session]
def main(argv):
"""
Main entry.
"""
arg_parser = argparse.ArgumentParser(description="Dump something from dataset.")
arg_parser.add_argument("--config", help="filename to config-file. will use dataset 'eval' from it")
arg_parser.add_argument("--dataset", help="dataset, overwriting config")
arg_parser.add_argument("--refs", help="same format as hyps. alternative to providing dataset/config")
arg_parser.add_argument("--hyps", help="hypotheses, dumped via search in py format")
arg_parser.add_argument("--startseq", type=int, default=0, help="start seq idx (inclusive) (default: 0)")
arg_parser.add_argument("--endseq", type=int, default=-1, help="end seq idx (inclusive) or -1 (default: -1)")
arg_parser.add_argument("--key", default="raw", help="data-key, e.g. 'data' or 'classes'. (default: 'raw')")
arg_parser.add_argument("--verbosity", default=4, type=int, help="5 for all seqs (default: 4)")
arg_parser.add_argument("--out", help="if provided, will write WER% (as string) to this file")
arg_parser.add_argument("--expect_full", action="store_true", help="full dataset should be scored")
args = arg_parser.parse_args(argv[1:])
assert args.config or args.dataset or args.refs
init(config_filename=args.config, log_verbosity=args.verbosity)
dataset = None
refs = None
if args.refs:
refs = load_hyps_refs(args.refs)
elif args.dataset:
dataset = init_dataset(args.dataset)
elif config.value("wer_data", "eval") in ["train", "dev", "eval"]:
dataset = init_dataset(config.opt_typed_value(config.value("search_data", "eval")))
else:
dataset = init_dataset(config.opt_typed_value("wer_data"))
hyps = load_hyps_refs(args.hyps)
global wer_compute
wer_compute = WerComputeGraph()
with tf_compat.v1.Session(config=tf_compat.v1.ConfigProto(device_count={"GPU": 0})) as _session:
global session
session = _session
session.run(tf_compat.v1.global_variables_initializer())
try:
wer = calc_wer_on_dataset(dataset=dataset, refs=refs, options=args, hyps=hyps)
print("Final WER: %.02f%%" % (wer * 100), file=log.v1)
if args.out:
with open(args.out, "w") as output_file:
output_file.write("%.02f\n" % (wer * 100))
print("Wrote WER%% to %r." % args.out)
except KeyboardInterrupt:
print("KeyboardInterrupt")
sys.exit(1)
finally:
rnn.finalize()
if __name__ == "__main__":
main(sys.argv) | /returnn-1.20230902.233313.tar.gz/returnn-1.20230902.233313/tools/calculate-word-error-rate.py | 0.568056 | 0.259538 | calculate-word-error-rate.py | pypi |
from __future__ import annotations
import os
import sys
from argparse import ArgumentParser
import gzip
from xml.etree import ElementTree
import _setup_returnn_env # noqa
class BlissItem:
"""
Bliss item.
"""
def __init__(self, segment_name, recording_filename, start_time, end_time, orth):
"""
:param str segment_name:
:param str recording_filename:
:param float start_time:
:param float end_time:
:param str orth:
"""
self.segment_name = segment_name
self.recording_filename = recording_filename
self.start_time = start_time
self.end_time = end_time
self.orth = orth
def __repr__(self):
keys = ["segment_name", "recording_filename", "start_time", "end_time", "orth"]
return "BlissItem(%s)" % ", ".join(["%s=%r" % (key, getattr(self, key)) for key in keys])
@property
def delta_time(self):
"""
:rtype: float
"""
return self.end_time - self.start_time
def iter_bliss(filename):
"""
:param str filename:
:return: yields BlissItem
:rtype: list[BlissItem]
"""
corpus_file = open(filename, "rb")
if filename.endswith(".gz"):
corpus_file = gzip.GzipFile(fileobj=corpus_file)
context = iter(ElementTree.iterparse(corpus_file, events=("start", "end")))
_, root = next(context) # get root element
name_tree = [root.attrib["name"]]
elem_tree = [root]
count_tree = [0]
recording_filename = None
for event, elem in context:
if elem.tag == "recording":
recording_filename = elem.attrib["audio"] if event == "start" else None
if event == "end" and elem.tag == "segment":
elem_orth = elem.find("orth")
orth_raw = elem_orth.text or "" # should be unicode
orth_split = orth_raw.split()
orth = " ".join(orth_split)
segment_name = "/".join(name_tree)
yield BlissItem(
segment_name=segment_name,
recording_filename=recording_filename,
start_time=float(elem.attrib["start"]),
end_time=float(elem.attrib["end"]),
orth=orth,
)
root.clear() # free memory
if event == "start":
count_tree[-1] += 1
count_tree.append(0)
elem_tree += [elem]
elem_name = elem.attrib.get("name", None)
if elem_name is None:
elem_name = str(count_tree[-2])
assert isinstance(elem_name, str)
name_tree += [elem_name]
elif event == "end":
assert elem_tree[-1] is elem
elem_tree = elem_tree[:-1]
name_tree = name_tree[:-1]
count_tree = count_tree[:-1]
def main():
"""
Main entry.
"""
arg_parser = ArgumentParser()
arg_parser.add_argument("bliss_filename")
arg_parser.add_argument("--subset_segment_file")
arg_parser.add_argument("--output_type", default="", help="e.g. segment_name")
arg_parser.add_argument("--merge_swb_ab", action="store_true")
arg_parser.add_argument("--sort_by_time", action="store_true")
arg_parser.add_argument("--merge_segs_up_to_time", type=float)
args = arg_parser.parse_args()
subset_segment_list = None
if args.subset_segment_file:
subset_segment_list = set(open(args.subset_segment_file).read().splitlines())
rec_filenames = set()
items_by_rec = {}
for bliss_item in iter_bliss(args.bliss_filename):
if subset_segment_list and bliss_item.segment_name not in subset_segment_list:
continue
rec_name = bliss_item.recording_filename
assert rec_name, "invalid item %r" % bliss_item
if args.merge_swb_ab:
rec_name = os.path.basename(rec_name)
rec_name, _ = os.path.splitext(rec_name)
rec_filenames.add(rec_name)
assert rec_name[-1] in "AB"
rec_name = rec_name[:-1]
else:
rec_filenames.add(rec_name)
items_by_rec.setdefault(rec_name, []).append(bliss_item)
assert items_by_rec
if args.merge_swb_ab:
if subset_segment_list:
for key in list(items_by_rec.keys()):
if key + "A" not in rec_filenames or key + "B" not in rec_filenames:
del items_by_rec[key]
assert items_by_rec, "rec_filenames %r" % (rec_filenames,)
else:
for key in items_by_rec.keys():
assert key + "A" in rec_filenames
assert key + "B" in rec_filenames
for key, ls in items_by_rec.items():
assert isinstance(ls, list)
if args.sort_by_time:
ls.sort(key=lambda item: item.start_time)
if args.merge_segs_up_to_time:
for key, ls in items_by_rec.items():
i = 0
while i < len(ls):
j = i + 1
dt = ls[i].delta_time
while j < len(ls):
if dt + ls[j].delta_time > args.merge_segs_up_to_time:
break
dt += ls[j].delta_time
j += 1
if j > i + 1:
ls[i:j] = [
BlissItem(
segment_name=";".join([item.segment_name for item in ls[i:j]]),
recording_filename=ls[i].recording_filename, # might be wrong if merge_swb_ab...
start_time=0.0,
end_time=dt, # dummy times
orth=" ".join([item.orth for item in ls[i:j]]),
)
]
i += 1
output_types = args.output_type.split(",")
for key, ls in items_by_rec.items():
assert isinstance(ls, list)
for item in ls:
assert isinstance(item, BlissItem)
if not output_types:
print(item)
else:
print(" ".join([str(getattr(item, key)) for key in output_types]))
if __name__ == "__main__":
from returnn.util import better_exchook
better_exchook.install()
try:
main()
except BrokenPipeError:
print("BrokenPipeError")
sys.exit(1) | /returnn-1.20230902.233313.tar.gz/returnn-1.20230902.233313/tools/bliss-get-segment-names.py | 0.421314 | 0.208662 | bliss-get-segment-names.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.