code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class SampleBankHint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SampleBankHint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return SampleBankHint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/SampleBankHint.py | 0.615203 | 0.255727 | SampleBankHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MIDIControllerMessageEmitter(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MIDIControllerMessageEmitter]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MIDIControllerMessageEmitter(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MIDIControllerMessageEmitter.py | 0.61451 | 0.245277 | MIDIControllerMessageEmitter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class StreamedMovie(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[StreamedMovie]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return StreamedMovie(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/StreamedMovie.py | 0.610918 | 0.270739 | 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 BaseProperty
import base64
@dataclasses.dataclass()
class AmbientParticleEffect(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AmbientParticleEffect]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AmbientParticleEffect(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AmbientParticleEffect.py | 0.607896 | 0.277112 | AmbientParticleEffect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Choreographer(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Choreographer]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Choreographer(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Choreographer.py | 0.606149 | 0.262812 | Choreographer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Relay(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Relay]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Relay(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Relay.py | 0.608361 | 0.260748 | 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 BaseProperty
import base64
@dataclasses.dataclass()
class RelayAutoFire(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RelayAutoFire]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RelayAutoFire(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RelayAutoFire.py | 0.603932 | 0.258736 | RelayAutoFire.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureHitReactionBehavior(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureHitReactionBehavior]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureHitReactionBehavior(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureHitReactionBehavior.py | 0.611382 | 0.257152 | CreatureHitReactionBehavior.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RealNumberComparison(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RealNumberComparison]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RealNumberComparison(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RealNumberComparison.py | 0.616243 | 0.262021 | RealNumberComparison.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Sound(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Sound]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Sound(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Sound.py | 0.605916 | 0.262765 | 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 BaseProperty
import base64
@dataclasses.dataclass()
class NearVisible(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[NearVisible]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return NearVisible(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/NearVisible.py | 0.624637 | 0.266131 | NearVisible.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlCommandMappingOne(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommandMappingOne]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlCommandMappingOne(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlCommandMappingOne.py | 0.608012 | 0.253607 | ControlCommandMappingOne.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class HealthDisplay(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HealthDisplay]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return HealthDisplay(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/HealthDisplay.py | 0.610802 | 0.261655 | HealthDisplay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class WorldTransition(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[WorldTransition]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return WorldTransition(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/WorldTransition.py | 0.61682 | 0.26389 | WorldTransition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlCommandMappingZero(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommandMappingZero]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlCommandMappingZero(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlCommandMappingZero.py | 0.60871 | 0.265107 | ControlCommandMappingZero.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CollisionLogic(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CollisionLogic]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CollisionLogic(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CollisionLogic.py | 0.606964 | 0.270224 | CollisionLogic.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BloodFlowerMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BloodFlowerMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BloodFlowerMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BloodFlowerMP1.py | 0.602296 | 0.2644 | BloodFlowerMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ScriptedAnimationData(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ScriptedAnimationData]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ScriptedAnimationData(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ScriptedAnimationData.py | 0.616128 | 0.267396 | ScriptedAnimationData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Retronome(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Retronome]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Retronome(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Retronome.py | 0.607197 | 0.270703 | Retronome.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class FleePoint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FleePoint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return FleePoint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/FleePoint.py | 0.60964 | 0.264715 | FleePoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlCommandMappingDebugMenuInt(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommandMappingDebugMenuInt]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlCommandMappingDebugMenuInt(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlCommandMappingDebugMenuInt.py | 0.580947 | 0.245367 | ControlCommandMappingDebugMenuInt.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureSpawnBehavior(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureSpawnBehavior]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureSpawnBehavior(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureSpawnBehavior.py | 0.610453 | 0.260972 | CreatureSpawnBehavior.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MIDIResponderArpeggiator(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MIDIResponderArpeggiator]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MIDIResponderArpeggiator(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MIDIResponderArpeggiator.py | 0.614278 | 0.244374 | MIDIResponderArpeggiator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RandomRelayMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RandomRelayMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RandomRelayMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RandomRelayMP1.py | 0.600305 | 0.259286 | RandomRelayMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BossMeterState(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BossMeterState]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BossMeterState(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BossMeterState.py | 0.572364 | 0.261696 | BossMeterState.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlCommandMappingScriptedReal(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommandMappingScriptedReal]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlCommandMappingScriptedReal(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlCommandMappingScriptedReal.py | 0.607896 | 0.253156 | ControlCommandMappingScriptedReal.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class LavaRenderVolume(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[LavaRenderVolume]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return LavaRenderVolume(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/LavaRenderVolume.py | 0.607081 | 0.257975 | LavaRenderVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PhaseRelay(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PhaseRelay]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PhaseRelay(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PhaseRelay.py | 0.62681 | 0.259157 | PhaseRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class NotSTD_DockMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[NotSTD_DockMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return NotSTD_DockMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/NotSTD_DockMP1.py | 0.595257 | 0.260107 | NotSTD_DockMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class TriggerDeathFall(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TriggerDeathFall]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return TriggerDeathFall(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/TriggerDeathFall.py | 0.602179 | 0.25689 | TriggerDeathFall.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ScreenShot(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ScreenShot]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ScreenShot(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ScreenShot.py | 0.606149 | 0.258613 | ScreenShot.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PoiObject(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PoiObject]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PoiObject(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PoiObject.py | 0.592313 | 0.258268 | PoiObject.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AnimatedMeter(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AnimatedMeter]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AnimatedMeter(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AnimatedMeter.py | 0.610337 | 0.265041 | AnimatedMeter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class SpecialFunctionMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SpecialFunctionMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return SpecialFunctionMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/SpecialFunctionMP1.py | 0.601711 | 0.263831 | SpecialFunctionMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class InventoryItem(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[InventoryItem]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return InventoryItem(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/InventoryItem.py | 0.609292 | 0.254706 | InventoryItem.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.LightParameters import LightParameters
from retro_data_structures.properties.prime.archetypes.ScannableParameters import ScannableParameters
from retro_data_structures.properties.prime.archetypes.VisorParameters import VisorParameters
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ActorParameters(BaseProperty):
unnamed_0x00000000: LightParameters = dataclasses.field(default_factory=LightParameters)
unnamed_0x00000001: ScannableParameters = dataclasses.field(default_factory=ScannableParameters)
x_ray_visor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
x_ray_visor_skin: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
thermal_visor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
thermal_visor_skin: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
unknown_1: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unnamed_0x00000009: VisorParameters = dataclasses.field(default_factory=VisorParameters)
enable_thermal_heat: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: bool = dataclasses.field(default=False)
unknown_6: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unnamed_0x00000000 = LightParameters.from_stream(data, property_size)
unnamed_0x00000001 = ScannableParameters.from_stream(data, property_size)
x_ray_visor_model = struct.unpack(">L", data.read(4))[0]
x_ray_visor_skin = struct.unpack(">L", data.read(4))[0]
thermal_visor_model = struct.unpack(">L", data.read(4))[0]
thermal_visor_skin = struct.unpack(">L", data.read(4))[0]
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unnamed_0x00000009 = VisorParameters.from_stream(data, property_size)
enable_thermal_heat = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>?', data.read(1))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
return cls(unnamed_0x00000000, unnamed_0x00000001, x_ray_visor_model, x_ray_visor_skin, thermal_visor_model, thermal_visor_skin, unknown_1, unknown_2, unknown_3, unnamed_0x00000009, enable_thermal_heat, unknown_4, unknown_5, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.unnamed_0x00000000.to_stream(data)
self.unnamed_0x00000001.to_stream(data)
data.write(struct.pack(">L", self.x_ray_visor_model))
data.write(struct.pack(">L", self.x_ray_visor_skin))
data.write(struct.pack(">L", self.thermal_visor_model))
data.write(struct.pack(">L", self.thermal_visor_skin))
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
self.unnamed_0x00000009.to_stream(data)
data.write(struct.pack('>?', self.enable_thermal_heat))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>?', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
unnamed_0x00000000=LightParameters.from_json(data['unnamed_0x00000000']),
unnamed_0x00000001=ScannableParameters.from_json(data['unnamed_0x00000001']),
x_ray_visor_model=data['x_ray_visor_model'],
x_ray_visor_skin=data['x_ray_visor_skin'],
thermal_visor_model=data['thermal_visor_model'],
thermal_visor_skin=data['thermal_visor_skin'],
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unnamed_0x00000009=VisorParameters.from_json(data['unnamed_0x00000009']),
enable_thermal_heat=data['enable_thermal_heat'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'unnamed_0x00000000': self.unnamed_0x00000000.to_json(),
'unnamed_0x00000001': self.unnamed_0x00000001.to_json(),
'x_ray_visor_model': self.x_ray_visor_model,
'x_ray_visor_skin': self.x_ray_visor_skin,
'thermal_visor_model': self.thermal_visor_model,
'thermal_visor_skin': self.thermal_visor_skin,
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unnamed_0x00000009': self.unnamed_0x00000009.to_json(),
'enable_thermal_heat': self.enable_thermal_heat,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
}
def _dependencies_for_unnamed_0x00000000(self, asset_manager):
yield from self.unnamed_0x00000000.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000001(self, asset_manager):
yield from self.unnamed_0x00000001.dependencies_for(asset_manager)
def _dependencies_for_x_ray_visor_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.x_ray_visor_model)
def _dependencies_for_x_ray_visor_skin(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.x_ray_visor_skin)
def _dependencies_for_thermal_visor_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.thermal_visor_model)
def _dependencies_for_thermal_visor_skin(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.thermal_visor_skin)
def _dependencies_for_unnamed_0x00000009(self, asset_manager):
yield from self.unnamed_0x00000009.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000000, "unnamed_0x00000000", "LightParameters"),
(self._dependencies_for_unnamed_0x00000001, "unnamed_0x00000001", "ScannableParameters"),
(self._dependencies_for_x_ray_visor_model, "x_ray_visor_model", "AssetId"),
(self._dependencies_for_x_ray_visor_skin, "x_ray_visor_skin", "AssetId"),
(self._dependencies_for_thermal_visor_model, "thermal_visor_model", "AssetId"),
(self._dependencies_for_thermal_visor_skin, "thermal_visor_skin", "AssetId"),
(self._dependencies_for_unnamed_0x00000009, "unnamed_0x00000009", "VisorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ActorParameters.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/ActorParameters.py | 0.741768 | 0.160891 | ActorParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerHintStruct(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: bool = dataclasses.field(default=False)
disable_unmorph: bool = dataclasses.field(default=False)
disable_morph: bool = dataclasses.field(default=False)
disable_controls: bool = dataclasses.field(default=False)
disable_boost: bool = dataclasses.field(default=False)
activate_combat_visor: bool = dataclasses.field(default=False)
activate_scan_visor: bool = dataclasses.field(default=False)
activate_thermal_visor: bool = dataclasses.field(default=False)
activate_x_ray_visor: bool = dataclasses.field(default=False)
unknown_6: bool = dataclasses.field(default=False)
face_object_on_unmorph: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>?', data.read(1))[0]
disable_unmorph = struct.unpack('>?', data.read(1))[0]
disable_morph = struct.unpack('>?', data.read(1))[0]
disable_controls = struct.unpack('>?', data.read(1))[0]
disable_boost = struct.unpack('>?', data.read(1))[0]
activate_combat_visor = struct.unpack('>?', data.read(1))[0]
activate_scan_visor = struct.unpack('>?', data.read(1))[0]
activate_thermal_visor = struct.unpack('>?', data.read(1))[0]
activate_x_ray_visor = struct.unpack('>?', data.read(1))[0]
unknown_6 = struct.unpack('>?', data.read(1))[0]
face_object_on_unmorph = struct.unpack('>?', data.read(1))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, disable_unmorph, disable_morph, disable_controls, disable_boost, activate_combat_visor, activate_scan_visor, activate_thermal_visor, activate_x_ray_visor, unknown_6, face_object_on_unmorph)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>?', self.unknown_5))
data.write(struct.pack('>?', self.disable_unmorph))
data.write(struct.pack('>?', self.disable_morph))
data.write(struct.pack('>?', self.disable_controls))
data.write(struct.pack('>?', self.disable_boost))
data.write(struct.pack('>?', self.activate_combat_visor))
data.write(struct.pack('>?', self.activate_scan_visor))
data.write(struct.pack('>?', self.activate_thermal_visor))
data.write(struct.pack('>?', self.activate_x_ray_visor))
data.write(struct.pack('>?', self.unknown_6))
data.write(struct.pack('>?', self.face_object_on_unmorph))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
disable_unmorph=data['disable_unmorph'],
disable_morph=data['disable_morph'],
disable_controls=data['disable_controls'],
disable_boost=data['disable_boost'],
activate_combat_visor=data['activate_combat_visor'],
activate_scan_visor=data['activate_scan_visor'],
activate_thermal_visor=data['activate_thermal_visor'],
activate_x_ray_visor=data['activate_x_ray_visor'],
unknown_6=data['unknown_6'],
face_object_on_unmorph=data['face_object_on_unmorph'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'disable_unmorph': self.disable_unmorph,
'disable_morph': self.disable_morph,
'disable_controls': self.disable_controls,
'disable_boost': self.disable_boost,
'activate_combat_visor': self.activate_combat_visor,
'activate_scan_visor': self.activate_scan_visor,
'activate_thermal_visor': self.activate_thermal_visor,
'activate_x_ray_visor': self.activate_x_ray_visor,
'unknown_6': self.unknown_6,
'face_object_on_unmorph': self.face_object_on_unmorph,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PlayerHintStruct.py | 0.674587 | 0.191063 | PlayerHintStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class RidleyStruct2(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>?', data.read(1))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>?', self.unknown_9))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/RidleyStruct2.py | 0.768212 | 0.207676 | RidleyStruct2.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class GrappleParameters(BaseProperty):
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: float = dataclasses.field(default=0.0)
disable_turning: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
disable_turning = struct.unpack('>?', data.read(1))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, disable_turning)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
data.write(struct.pack('>?', self.disable_turning))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
disable_turning=data['disable_turning'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'disable_turning': self.disable_turning,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/GrappleParameters.py | 0.745398 | 0.193281 | GrappleParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
@dataclasses.dataclass()
class DamageInfo(BaseProperty):
weapon_type: enums.WeaponType = dataclasses.field(default=enums.WeaponType.Power)
damage: float = dataclasses.field(default=0.0)
radius: float = dataclasses.field(default=0.0)
knockback_power: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
weapon_type = enums.WeaponType.from_stream(data)
damage = struct.unpack('>f', data.read(4))[0]
radius = struct.unpack('>f', data.read(4))[0]
knockback_power = struct.unpack('>f', data.read(4))[0]
return cls(weapon_type, damage, radius, knockback_power)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.weapon_type.to_stream(data)
data.write(struct.pack('>f', self.damage))
data.write(struct.pack('>f', self.radius))
data.write(struct.pack('>f', self.knockback_power))
@classmethod
def from_json(cls, data: dict):
return cls(
weapon_type=enums.WeaponType.from_json(data['weapon_type']),
damage=data['damage'],
radius=data['radius'],
knockback_power=data['knockback_power'],
)
def to_json(self) -> dict:
return {
'weapon_type': self.weapon_type.to_json(),
'damage': self.damage,
'radius': self.radius,
'knockback_power': self.knockback_power,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/DamageInfo.py | 0.768646 | 0.235856 | DamageInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PrimeStruct5(BaseProperty):
unknown_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_2: int = dataclasses.field(default=0)
unknown_3: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
unknown_4: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_5: int = dataclasses.field(default=0)
unknown_6: int = dataclasses.field(default=0)
unknown_7: int = dataclasses.field(default=0)
unknown_8: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack(">L", data.read(4))[0]
unknown_2 = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack(">L", data.read(4))[0]
unknown_4 = struct.unpack(">L", data.read(4))[0]
unknown_5 = struct.unpack('>l', data.read(4))[0]
unknown_6 = struct.unpack('>l', data.read(4))[0]
unknown_7 = struct.unpack('>l', data.read(4))[0]
unknown_8 = struct.unpack('>l', data.read(4))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack(">L", self.unknown_1))
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack(">L", self.unknown_3))
data.write(struct.pack(">L", self.unknown_4))
data.write(struct.pack('>l', self.unknown_5))
data.write(struct.pack('>l', self.unknown_6))
data.write(struct.pack('>l', self.unknown_7))
data.write(struct.pack('>l', self.unknown_8))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
}
def _dependencies_for_unknown_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_1)
def _dependencies_for_unknown_3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_3)
def _dependencies_for_unknown_4(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_4)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unknown_1, "unknown_1", "AssetId"),
(self._dependencies_for_unknown_3, "unknown_3", "AssetId"),
(self._dependencies_for_unknown_4, "unknown_4", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PrimeStruct5.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PrimeStruct5.py | 0.617397 | 0.161783 | PrimeStruct5.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.PrimeStruct3 import PrimeStruct3
@dataclasses.dataclass()
class PrimeStruct2(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
prime_struct3_1: PrimeStruct3 = dataclasses.field(default_factory=PrimeStruct3)
prime_struct3_2: PrimeStruct3 = dataclasses.field(default_factory=PrimeStruct3)
prime_struct3_3: PrimeStruct3 = dataclasses.field(default_factory=PrimeStruct3)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
prime_struct3_1 = PrimeStruct3.from_stream(data, property_size)
prime_struct3_2 = PrimeStruct3.from_stream(data, property_size)
prime_struct3_3 = PrimeStruct3.from_stream(data, property_size)
return cls(unknown_1, unknown_2, unknown_3, prime_struct3_1, prime_struct3_2, prime_struct3_3)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
self.prime_struct3_1.to_stream(data)
self.prime_struct3_2.to_stream(data)
self.prime_struct3_3.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
prime_struct3_1=PrimeStruct3.from_json(data['prime_struct3_1']),
prime_struct3_2=PrimeStruct3.from_json(data['prime_struct3_2']),
prime_struct3_3=PrimeStruct3.from_json(data['prime_struct3_3']),
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'prime_struct3_1': self.prime_struct3_1.to_json(),
'prime_struct3_2': self.prime_struct3_2.to_json(),
'prime_struct3_3': self.prime_struct3_3.to_json(),
}
def _dependencies_for_prime_struct3_1(self, asset_manager):
yield from self.prime_struct3_1.dependencies_for(asset_manager)
def _dependencies_for_prime_struct3_2(self, asset_manager):
yield from self.prime_struct3_2.dependencies_for(asset_manager)
def _dependencies_for_prime_struct3_3(self, asset_manager):
yield from self.prime_struct3_3.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_prime_struct3_1, "prime_struct3_1", "PrimeStruct3"),
(self._dependencies_for_prime_struct3_2, "prime_struct3_2", "PrimeStruct3"),
(self._dependencies_for_prime_struct3_3, "prime_struct3_3", "PrimeStruct3"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PrimeStruct2.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PrimeStruct2.py | 0.672547 | 0.303558 | PrimeStruct2.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
@dataclasses.dataclass()
class BeamCombos(BaseProperty):
super_missile: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
ice_spreader: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
wavebuster: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
flamethrower: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
phazon_combo: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
super_missile = enums.VulnerabilityType.from_stream(data)
ice_spreader = enums.VulnerabilityType.from_stream(data)
wavebuster = enums.VulnerabilityType.from_stream(data)
flamethrower = enums.VulnerabilityType.from_stream(data)
phazon_combo = enums.VulnerabilityType.from_stream(data)
return cls(super_missile, ice_spreader, wavebuster, flamethrower, phazon_combo)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.super_missile.to_stream(data)
self.ice_spreader.to_stream(data)
self.wavebuster.to_stream(data)
self.flamethrower.to_stream(data)
self.phazon_combo.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
super_missile=enums.VulnerabilityType.from_json(data['super_missile']),
ice_spreader=enums.VulnerabilityType.from_json(data['ice_spreader']),
wavebuster=enums.VulnerabilityType.from_json(data['wavebuster']),
flamethrower=enums.VulnerabilityType.from_json(data['flamethrower']),
phazon_combo=enums.VulnerabilityType.from_json(data['phazon_combo']),
)
def to_json(self) -> dict:
return {
'super_missile': self.super_missile.to_json(),
'ice_spreader': self.ice_spreader.to_json(),
'wavebuster': self.wavebuster.to_json(),
'flamethrower': self.flamethrower.to_json(),
'phazon_combo': self.phazon_combo.to_json(),
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/BeamCombos.py | 0.687525 | 0.296094 | BeamCombos.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
@dataclasses.dataclass()
class ChargedBeams(BaseProperty):
power: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
ice: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
wave: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
plasma: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
phazon: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
power = enums.VulnerabilityType.from_stream(data)
ice = enums.VulnerabilityType.from_stream(data)
wave = enums.VulnerabilityType.from_stream(data)
plasma = enums.VulnerabilityType.from_stream(data)
phazon = enums.VulnerabilityType.from_stream(data)
return cls(power, ice, wave, plasma, phazon)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.power.to_stream(data)
self.ice.to_stream(data)
self.wave.to_stream(data)
self.plasma.to_stream(data)
self.phazon.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
power=enums.VulnerabilityType.from_json(data['power']),
ice=enums.VulnerabilityType.from_json(data['ice']),
wave=enums.VulnerabilityType.from_json(data['wave']),
plasma=enums.VulnerabilityType.from_json(data['plasma']),
phazon=enums.VulnerabilityType.from_json(data['phazon']),
)
def to_json(self) -> dict:
return {
'power': self.power.to_json(),
'ice': self.ice.to_json(),
'wave': self.wave.to_json(),
'plasma': self.plasma.to_json(),
'phazon': self.phazon.to_json(),
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/ChargedBeams.py | 0.747984 | 0.306605 | ChargedBeams.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MagdoliteStruct(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_2: int = dataclasses.field(default=0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
particle = struct.unpack(">L", data.read(4))[0]
unknown_2 = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
return cls(unknown_1, particle, unknown_2, unknown_3, unknown_4, unknown_5)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack(">L", self.particle))
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
particle=data['particle'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'particle': self.particle,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
}
def _dependencies_for_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_particle, "particle", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MagdoliteStruct.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/MagdoliteStruct.py | 0.69368 | 0.204382 | MagdoliteStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Color import Color
@dataclasses.dataclass()
class RidleyStruct1(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
unknown_2: int = dataclasses.field(default=0)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
texture_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture_2: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: float = dataclasses.field(default=0.0)
unknown_12: Color = dataclasses.field(default_factory=Color)
unknown_13: Color = dataclasses.field(default_factory=Color)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>l', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
texture_1 = struct.unpack(">L", data.read(4))[0]
texture_2 = struct.unpack(">L", data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
unknown_12 = Color.from_stream(data)
unknown_13 = Color.from_stream(data)
return cls(unknown_1, unknown_2, particle_1, particle_2, texture_1, texture_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.texture_1))
data.write(struct.pack(">L", self.texture_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
self.unknown_12.to_stream(data)
self.unknown_13.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
particle_1=data['particle_1'],
particle_2=data['particle_2'],
texture_1=data['texture_1'],
texture_2=data['texture_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=Color.from_json(data['unknown_12']),
unknown_13=Color.from_json(data['unknown_13']),
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'texture_1': self.texture_1,
'texture_2': self.texture_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12.to_json(),
'unknown_13': self.unknown_13.to_json(),
}
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_texture_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_1)
def _dependencies_for_texture_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_2)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_texture_1, "texture_1", "AssetId"),
(self._dependencies_for_texture_2, "texture_2", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for RidleyStruct1.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/RidleyStruct1.py | 0.706596 | 0.1844 | RidleyStruct1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class BehaveChance(BaseProperty):
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>l', data.read(4))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>l', self.unknown_7))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/BehaveChance.py | 0.768212 | 0.201479 | BehaveChance.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PathCameraStruct(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: bool = dataclasses.field(default=False)
unknown_6: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>?', data.read(1))[0]
unknown_6 = struct.unpack('>?', data.read(1))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>?', self.unknown_5))
data.write(struct.pack('>?', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PathCameraStruct.py | 0.711331 | 0.234823 | PathCameraStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
from retro_data_structures.properties.prime.archetypes.BeamCombos import BeamCombos
from retro_data_structures.properties.prime.archetypes.ChargedBeams import ChargedBeams
@dataclasses.dataclass()
class DamageVulnerability(BaseProperty):
power: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
ice: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
wave: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
plasma: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
bomb: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
power_bomb: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
missile: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
boost_ball: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
phazon: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
ai: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
poison_water: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
lava: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
hot: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
unused_weapon_1: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
unused_weapon_2: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
unused_weapon_3: enums.VulnerabilityType = dataclasses.field(default=enums.VulnerabilityType.DoubleDamage)
unnamed_0x00000010: ChargedBeams = dataclasses.field(default_factory=ChargedBeams)
unnamed_0x00000011: BeamCombos = dataclasses.field(default_factory=BeamCombos)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
power = enums.VulnerabilityType.from_stream(data)
ice = enums.VulnerabilityType.from_stream(data)
wave = enums.VulnerabilityType.from_stream(data)
plasma = enums.VulnerabilityType.from_stream(data)
bomb = enums.VulnerabilityType.from_stream(data)
power_bomb = enums.VulnerabilityType.from_stream(data)
missile = enums.VulnerabilityType.from_stream(data)
boost_ball = enums.VulnerabilityType.from_stream(data)
phazon = enums.VulnerabilityType.from_stream(data)
ai = enums.VulnerabilityType.from_stream(data)
poison_water = enums.VulnerabilityType.from_stream(data)
lava = enums.VulnerabilityType.from_stream(data)
hot = enums.VulnerabilityType.from_stream(data)
unused_weapon_1 = enums.VulnerabilityType.from_stream(data)
unused_weapon_2 = enums.VulnerabilityType.from_stream(data)
unused_weapon_3 = enums.VulnerabilityType.from_stream(data)
unnamed_0x00000010 = ChargedBeams.from_stream(data, property_size)
unnamed_0x00000011 = BeamCombos.from_stream(data, property_size)
return cls(power, ice, wave, plasma, bomb, power_bomb, missile, boost_ball, phazon, ai, poison_water, lava, hot, unused_weapon_1, unused_weapon_2, unused_weapon_3, unnamed_0x00000010, unnamed_0x00000011)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.power.to_stream(data)
self.ice.to_stream(data)
self.wave.to_stream(data)
self.plasma.to_stream(data)
self.bomb.to_stream(data)
self.power_bomb.to_stream(data)
self.missile.to_stream(data)
self.boost_ball.to_stream(data)
self.phazon.to_stream(data)
self.ai.to_stream(data)
self.poison_water.to_stream(data)
self.lava.to_stream(data)
self.hot.to_stream(data)
self.unused_weapon_1.to_stream(data)
self.unused_weapon_2.to_stream(data)
self.unused_weapon_3.to_stream(data)
self.unnamed_0x00000010.to_stream(data)
self.unnamed_0x00000011.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
power=enums.VulnerabilityType.from_json(data['power']),
ice=enums.VulnerabilityType.from_json(data['ice']),
wave=enums.VulnerabilityType.from_json(data['wave']),
plasma=enums.VulnerabilityType.from_json(data['plasma']),
bomb=enums.VulnerabilityType.from_json(data['bomb']),
power_bomb=enums.VulnerabilityType.from_json(data['power_bomb']),
missile=enums.VulnerabilityType.from_json(data['missile']),
boost_ball=enums.VulnerabilityType.from_json(data['boost_ball']),
phazon=enums.VulnerabilityType.from_json(data['phazon']),
ai=enums.VulnerabilityType.from_json(data['ai']),
poison_water=enums.VulnerabilityType.from_json(data['poison_water']),
lava=enums.VulnerabilityType.from_json(data['lava']),
hot=enums.VulnerabilityType.from_json(data['hot']),
unused_weapon_1=enums.VulnerabilityType.from_json(data['unused_weapon_1']),
unused_weapon_2=enums.VulnerabilityType.from_json(data['unused_weapon_2']),
unused_weapon_3=enums.VulnerabilityType.from_json(data['unused_weapon_3']),
unnamed_0x00000010=ChargedBeams.from_json(data['unnamed_0x00000010']),
unnamed_0x00000011=BeamCombos.from_json(data['unnamed_0x00000011']),
)
def to_json(self) -> dict:
return {
'power': self.power.to_json(),
'ice': self.ice.to_json(),
'wave': self.wave.to_json(),
'plasma': self.plasma.to_json(),
'bomb': self.bomb.to_json(),
'power_bomb': self.power_bomb.to_json(),
'missile': self.missile.to_json(),
'boost_ball': self.boost_ball.to_json(),
'phazon': self.phazon.to_json(),
'ai': self.ai.to_json(),
'poison_water': self.poison_water.to_json(),
'lava': self.lava.to_json(),
'hot': self.hot.to_json(),
'unused_weapon_1': self.unused_weapon_1.to_json(),
'unused_weapon_2': self.unused_weapon_2.to_json(),
'unused_weapon_3': self.unused_weapon_3.to_json(),
'unnamed_0x00000010': self.unnamed_0x00000010.to_json(),
'unnamed_0x00000011': self.unnamed_0x00000011.to_json(),
}
def _dependencies_for_unnamed_0x00000010(self, asset_manager):
yield from self.unnamed_0x00000010.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000011(self, asset_manager):
yield from self.unnamed_0x00000011.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000010, "unnamed_0x00000010", "ChargedBeams"),
(self._dependencies_for_unnamed_0x00000011, "unnamed_0x00000011", "BeamCombos"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DamageVulnerability.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/DamageVulnerability.py | 0.618665 | 0.315077 | DamageVulnerability.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.ShotParam import ShotParam
@dataclasses.dataclass()
class BeamInfo(BaseProperty):
cooldown: float = dataclasses.field(default=0.0)
normal_damage: ShotParam = dataclasses.field(default_factory=ShotParam)
charged_damage: ShotParam = dataclasses.field(default_factory=ShotParam)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
cooldown = struct.unpack('>f', data.read(4))[0]
normal_damage = ShotParam.from_stream(data, property_size)
charged_damage = ShotParam.from_stream(data, property_size)
return cls(cooldown, normal_damage, charged_damage)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>f', self.cooldown))
self.normal_damage.to_stream(data)
self.charged_damage.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
cooldown=data['cooldown'],
normal_damage=ShotParam.from_json(data['normal_damage']),
charged_damage=ShotParam.from_json(data['charged_damage']),
)
def to_json(self) -> dict:
return {
'cooldown': self.cooldown,
'normal_damage': self.normal_damage.to_json(),
'charged_damage': self.charged_damage.to_json(),
}
def _dependencies_for_normal_damage(self, asset_manager):
yield from self.normal_damage.dependencies_for(asset_manager)
def _dependencies_for_charged_damage(self, asset_manager):
yield from self.charged_damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_normal_damage, "normal_damage", "ShotParam"),
(self._dependencies_for_charged_damage, "charged_damage", "ShotParam"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for BeamInfo.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/BeamInfo.py | 0.711732 | 0.221751 | BeamInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.prime.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class PatternedAITypedef(BaseProperty):
mass: float = dataclasses.field(default=0.0)
speed: float = dataclasses.field(default=0.0)
turn_speed: float = dataclasses.field(default=0.0)
detection_range: float = dataclasses.field(default=0.0)
detection_height_range: float = dataclasses.field(default=0.0)
detection_angle: float = dataclasses.field(default=0.0)
min_attack_range: float = dataclasses.field(default=0.0)
max_attack_range: float = dataclasses.field(default=0.0)
average_attack_time: float = dataclasses.field(default=0.0)
attack_time_variation: float = dataclasses.field(default=0.0)
leash_radius: float = dataclasses.field(default=0.0)
player_leash_radius: float = dataclasses.field(default=0.0)
player_leash_time: float = dataclasses.field(default=0.0)
contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_wait_time: float = dataclasses.field(default=0.0)
unnamed: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: Vector = dataclasses.field(default_factory=Vector)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
death_sound: int = dataclasses.field(default=0, metadata={'sound': True})
animation_parameters: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=False)
state_machine: AssetId = dataclasses.field(metadata={'asset_types': ['AFSM']}, default=default_asset_id)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: int = dataclasses.field(default=0)
unknown_12: Vector = dataclasses.field(default_factory=Vector)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_13: int = dataclasses.field(default=0)
unknown_14: Vector = dataclasses.field(default_factory=Vector)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
ice_shatter_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
mass = struct.unpack('>f', data.read(4))[0]
speed = struct.unpack('>f', data.read(4))[0]
turn_speed = struct.unpack('>f', data.read(4))[0]
detection_range = struct.unpack('>f', data.read(4))[0]
detection_height_range = struct.unpack('>f', data.read(4))[0]
detection_angle = struct.unpack('>f', data.read(4))[0]
min_attack_range = struct.unpack('>f', data.read(4))[0]
max_attack_range = struct.unpack('>f', data.read(4))[0]
average_attack_time = struct.unpack('>f', data.read(4))[0]
attack_time_variation = struct.unpack('>f', data.read(4))[0]
leash_radius = struct.unpack('>f', data.read(4))[0]
player_leash_radius = struct.unpack('>f', data.read(4))[0]
player_leash_time = struct.unpack('>f', data.read(4))[0]
contact_damage = DamageInfo.from_stream(data, property_size)
damage_wait_time = struct.unpack('>f', data.read(4))[0]
unnamed = HealthInfo.from_stream(data, property_size)
vulnerability = DamageVulnerability.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = Vector.from_stream(data)
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
death_sound = struct.unpack('>l', data.read(4))[0]
animation_parameters = AnimationParameters.from_stream(data, property_size)
active = struct.unpack('>?', data.read(1))[0]
state_machine = struct.unpack(">L", data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>l', data.read(4))[0]
unknown_12 = Vector.from_stream(data)
particle_1 = struct.unpack(">L", data.read(4))[0]
unknown_13 = struct.unpack('>l', data.read(4))[0]
unknown_14 = Vector.from_stream(data)
particle_2 = struct.unpack(">L", data.read(4))[0]
ice_shatter_sound = struct.unpack('>l', data.read(4))[0]
return cls(mass, speed, turn_speed, detection_range, detection_height_range, detection_angle, min_attack_range, max_attack_range, average_attack_time, attack_time_variation, leash_radius, player_leash_radius, player_leash_time, contact_damage, damage_wait_time, unnamed, vulnerability, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, death_sound, animation_parameters, active, state_machine, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, particle_1, unknown_13, unknown_14, particle_2, ice_shatter_sound)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>f', self.mass))
data.write(struct.pack('>f', self.speed))
data.write(struct.pack('>f', self.turn_speed))
data.write(struct.pack('>f', self.detection_range))
data.write(struct.pack('>f', self.detection_height_range))
data.write(struct.pack('>f', self.detection_angle))
data.write(struct.pack('>f', self.min_attack_range))
data.write(struct.pack('>f', self.max_attack_range))
data.write(struct.pack('>f', self.average_attack_time))
data.write(struct.pack('>f', self.attack_time_variation))
data.write(struct.pack('>f', self.leash_radius))
data.write(struct.pack('>f', self.player_leash_radius))
data.write(struct.pack('>f', self.player_leash_time))
self.contact_damage.to_stream(data)
data.write(struct.pack('>f', self.damage_wait_time))
self.unnamed.to_stream(data)
self.vulnerability.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
self.unknown_3.to_stream(data)
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>l', self.death_sound))
self.animation_parameters.to_stream(data)
data.write(struct.pack('>?', self.active))
data.write(struct.pack(">L", self.state_machine))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>l', self.unknown_11))
self.unknown_12.to_stream(data)
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack('>l', self.unknown_13))
self.unknown_14.to_stream(data)
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack('>l', self.ice_shatter_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
mass=data['mass'],
speed=data['speed'],
turn_speed=data['turn_speed'],
detection_range=data['detection_range'],
detection_height_range=data['detection_height_range'],
detection_angle=data['detection_angle'],
min_attack_range=data['min_attack_range'],
max_attack_range=data['max_attack_range'],
average_attack_time=data['average_attack_time'],
attack_time_variation=data['attack_time_variation'],
leash_radius=data['leash_radius'],
player_leash_radius=data['player_leash_radius'],
player_leash_time=data['player_leash_time'],
contact_damage=DamageInfo.from_json(data['contact_damage']),
damage_wait_time=data['damage_wait_time'],
unnamed=HealthInfo.from_json(data['unnamed']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=Vector.from_json(data['unknown_3']),
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
death_sound=data['death_sound'],
animation_parameters=AnimationParameters.from_json(data['animation_parameters']),
active=data['active'],
state_machine=data['state_machine'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=Vector.from_json(data['unknown_12']),
particle_1=data['particle_1'],
unknown_13=data['unknown_13'],
unknown_14=Vector.from_json(data['unknown_14']),
particle_2=data['particle_2'],
ice_shatter_sound=data['ice_shatter_sound'],
)
def to_json(self) -> dict:
return {
'mass': self.mass,
'speed': self.speed,
'turn_speed': self.turn_speed,
'detection_range': self.detection_range,
'detection_height_range': self.detection_height_range,
'detection_angle': self.detection_angle,
'min_attack_range': self.min_attack_range,
'max_attack_range': self.max_attack_range,
'average_attack_time': self.average_attack_time,
'attack_time_variation': self.attack_time_variation,
'leash_radius': self.leash_radius,
'player_leash_radius': self.player_leash_radius,
'player_leash_time': self.player_leash_time,
'contact_damage': self.contact_damage.to_json(),
'damage_wait_time': self.damage_wait_time,
'unnamed': self.unnamed.to_json(),
'vulnerability': self.vulnerability.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3.to_json(),
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'death_sound': self.death_sound,
'animation_parameters': self.animation_parameters.to_json(),
'active': self.active,
'state_machine': self.state_machine,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12.to_json(),
'particle_1': self.particle_1,
'unknown_13': self.unknown_13,
'unknown_14': self.unknown_14.to_json(),
'particle_2': self.particle_2,
'ice_shatter_sound': self.ice_shatter_sound,
}
def _dependencies_for_contact_damage(self, asset_manager):
yield from self.contact_damage.dependencies_for(asset_manager)
def _dependencies_for_unnamed(self, asset_manager):
yield from self.unnamed.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_death_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.death_sound)
def _dependencies_for_animation_parameters(self, asset_manager):
yield from self.animation_parameters.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_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_ice_shatter_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.ice_shatter_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_contact_damage, "contact_damage", "DamageInfo"),
(self._dependencies_for_unnamed, "unnamed", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_death_sound, "death_sound", "int"),
(self._dependencies_for_animation_parameters, "animation_parameters", "AnimationParameters"),
(self._dependencies_for_state_machine, "state_machine", "AssetId"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_ice_shatter_sound, "ice_shatter_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PatternedAITypedef.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PatternedAITypedef.py | 0.708818 | 0.357539 | PatternedAITypedef.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PrimeStruct1(BaseProperty):
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: float = dataclasses.field(default=0.0)
unknown_12: float = dataclasses.field(default=0.0)
unknown_13: float = dataclasses.field(default=0.0)
unknown_14: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
unknown_12 = struct.unpack('>f', data.read(4))[0]
unknown_13 = struct.unpack('>f', data.read(4))[0]
unknown_14 = struct.unpack('>f', data.read(4))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13, unknown_14)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
data.write(struct.pack('>f', self.unknown_12))
data.write(struct.pack('>f', self.unknown_13))
data.write(struct.pack('>f', self.unknown_14))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=data['unknown_12'],
unknown_13=data['unknown_13'],
unknown_14=data['unknown_14'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12,
'unknown_13': self.unknown_13,
'unknown_14': self.unknown_14,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PrimeStruct1.py | 0.744006 | 0.187467 | PrimeStruct1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
from retro_data_structures.properties.prime.core.Color import Color
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class LightParameters(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
shadow_tessellation: int = dataclasses.field(default=0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: Color = dataclasses.field(default_factory=Color)
unknown_6: bool = dataclasses.field(default=False)
world_lighting_options: enums.WorldLightingOptions = dataclasses.field(default=enums.WorldLightingOptions.Unknown1)
light_recalculation_options: enums.LightRecalculationOptions = dataclasses.field(default=enums.LightRecalculationOptions.Never)
unknown_7: Vector = dataclasses.field(default_factory=Vector)
unknown_8: int = dataclasses.field(default=0)
unknown_9: int = dataclasses.field(default=0)
unknown_10: bool = dataclasses.field(default=False)
light_layer_index: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
shadow_tessellation = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = Color.from_stream(data)
unknown_6 = struct.unpack('>?', data.read(1))[0]
world_lighting_options = enums.WorldLightingOptions.from_stream(data)
light_recalculation_options = enums.LightRecalculationOptions.from_stream(data)
unknown_7 = Vector.from_stream(data)
unknown_8 = struct.unpack('>l', data.read(4))[0]
unknown_9 = struct.unpack('>l', data.read(4))[0]
unknown_10 = struct.unpack('>?', data.read(1))[0]
light_layer_index = struct.unpack('>l', data.read(4))[0]
return cls(unknown_1, unknown_2, shadow_tessellation, unknown_3, unknown_4, unknown_5, unknown_6, world_lighting_options, light_recalculation_options, unknown_7, unknown_8, unknown_9, unknown_10, light_layer_index)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>l', self.shadow_tessellation))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
self.unknown_5.to_stream(data)
data.write(struct.pack('>?', self.unknown_6))
self.world_lighting_options.to_stream(data)
self.light_recalculation_options.to_stream(data)
self.unknown_7.to_stream(data)
data.write(struct.pack('>l', self.unknown_8))
data.write(struct.pack('>l', self.unknown_9))
data.write(struct.pack('>?', self.unknown_10))
data.write(struct.pack('>l', self.light_layer_index))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
shadow_tessellation=data['shadow_tessellation'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=Color.from_json(data['unknown_5']),
unknown_6=data['unknown_6'],
world_lighting_options=enums.WorldLightingOptions.from_json(data['world_lighting_options']),
light_recalculation_options=enums.LightRecalculationOptions.from_json(data['light_recalculation_options']),
unknown_7=Vector.from_json(data['unknown_7']),
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
light_layer_index=data['light_layer_index'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'shadow_tessellation': self.shadow_tessellation,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5.to_json(),
'unknown_6': self.unknown_6,
'world_lighting_options': self.world_lighting_options.to_json(),
'light_recalculation_options': self.light_recalculation_options.to_json(),
'unknown_7': self.unknown_7.to_json(),
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'light_layer_index': self.light_layer_index,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/LightParameters.py | 0.767603 | 0.291031 | LightParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.core.Color import Color
@dataclasses.dataclass()
class PrimeStruct6(BaseProperty):
unnamed: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_1: Color = dataclasses.field(default_factory=Color)
unknown_2: int = dataclasses.field(default=0)
unknown_3: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unnamed = DamageVulnerability.from_stream(data, property_size)
unknown_1 = Color.from_stream(data)
unknown_2 = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack('>l', data.read(4))[0]
return cls(unnamed, unknown_1, unknown_2, unknown_3)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.unnamed.to_stream(data)
self.unknown_1.to_stream(data)
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack('>l', self.unknown_3))
@classmethod
def from_json(cls, data: dict):
return cls(
unnamed=DamageVulnerability.from_json(data['unnamed']),
unknown_1=Color.from_json(data['unknown_1']),
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
)
def to_json(self) -> dict:
return {
'unnamed': self.unnamed.to_json(),
'unknown_1': self.unknown_1.to_json(),
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
}
def _dependencies_for_unnamed(self, asset_manager):
yield from self.unnamed.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed, "unnamed", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PrimeStruct6.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PrimeStruct6.py | 0.688468 | 0.216115 | PrimeStruct6.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Color import Color
@dataclasses.dataclass()
class FlareDef(BaseProperty):
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: Color = dataclasses.field(default_factory=Color)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
texture = struct.unpack(">L", data.read(4))[0]
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = Color.from_stream(data)
return cls(texture, unknown_1, unknown_2, unknown_3)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack(">L", self.texture))
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
self.unknown_3.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
texture=data['texture'],
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=Color.from_json(data['unknown_3']),
)
def to_json(self) -> dict:
return {
'texture': self.texture,
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3.to_json(),
}
def _dependencies_for_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_texture, "texture", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FlareDef.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/FlareDef.py | 0.746046 | 0.205495 | FlareDef.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
@dataclasses.dataclass()
class ShotParam(BaseProperty):
unnamed: enums.WeaponType = dataclasses.field(default=enums.WeaponType.Power)
damage: float = dataclasses.field(default=0.0)
radius_damage: float = dataclasses.field(default=0.0)
radius: float = dataclasses.field(default=0.0)
knockback_power: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unnamed = enums.WeaponType.from_stream(data)
damage = struct.unpack('>f', data.read(4))[0]
radius_damage = struct.unpack('>f', data.read(4))[0]
radius = struct.unpack('>f', data.read(4))[0]
knockback_power = struct.unpack('>f', data.read(4))[0]
return cls(unnamed, damage, radius_damage, radius, knockback_power)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.unnamed.to_stream(data)
data.write(struct.pack('>f', self.damage))
data.write(struct.pack('>f', self.radius_damage))
data.write(struct.pack('>f', self.radius))
data.write(struct.pack('>f', self.knockback_power))
@classmethod
def from_json(cls, data: dict):
return cls(
unnamed=enums.WeaponType.from_json(data['unnamed']),
damage=data['damage'],
radius_damage=data['radius_damage'],
radius=data['radius'],
knockback_power=data['knockback_power'],
)
def to_json(self) -> dict:
return {
'unnamed': self.unnamed.to_json(),
'damage': self.damage,
'radius_damage': self.radius_damage,
'radius': self.radius,
'knockback_power': self.knockback_power,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/ShotParam.py | 0.763307 | 0.291126 | ShotParam.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SpindleCameraStruct(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
unknown_2: int = dataclasses.field(default=0)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/SpindleCameraStruct.py | 0.744842 | 0.19477 | SpindleCameraStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.core.Color import Color
@dataclasses.dataclass()
class EnergyBarColors(BaseProperty):
energy_bar_filled: Color = dataclasses.field(default_factory=Color)
energy_bar_empty: Color = dataclasses.field(default_factory=Color)
energy_bar_shadow: Color = dataclasses.field(default_factory=Color)
energy_tank_filled: Color = dataclasses.field(default_factory=Color)
energy_tank_empty: Color = dataclasses.field(default_factory=Color)
energy_digits_font: Color = dataclasses.field(default_factory=Color)
energy_digits_outline: Color = dataclasses.field(default_factory=Color)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
energy_bar_filled = Color.from_stream(data)
energy_bar_empty = Color.from_stream(data)
energy_bar_shadow = Color.from_stream(data)
energy_tank_filled = Color.from_stream(data)
energy_tank_empty = Color.from_stream(data)
energy_digits_font = Color.from_stream(data)
energy_digits_outline = Color.from_stream(data)
return cls(energy_bar_filled, energy_bar_empty, energy_bar_shadow, energy_tank_filled, energy_tank_empty, energy_digits_font, energy_digits_outline)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.energy_bar_filled.to_stream(data)
self.energy_bar_empty.to_stream(data)
self.energy_bar_shadow.to_stream(data)
self.energy_tank_filled.to_stream(data)
self.energy_tank_empty.to_stream(data)
self.energy_digits_font.to_stream(data)
self.energy_digits_outline.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
energy_bar_filled=Color.from_json(data['energy_bar_filled']),
energy_bar_empty=Color.from_json(data['energy_bar_empty']),
energy_bar_shadow=Color.from_json(data['energy_bar_shadow']),
energy_tank_filled=Color.from_json(data['energy_tank_filled']),
energy_tank_empty=Color.from_json(data['energy_tank_empty']),
energy_digits_font=Color.from_json(data['energy_digits_font']),
energy_digits_outline=Color.from_json(data['energy_digits_outline']),
)
def to_json(self) -> dict:
return {
'energy_bar_filled': self.energy_bar_filled.to_json(),
'energy_bar_empty': self.energy_bar_empty.to_json(),
'energy_bar_shadow': self.energy_bar_shadow.to_json(),
'energy_tank_filled': self.energy_tank_filled.to_json(),
'energy_tank_empty': self.energy_tank_empty.to_json(),
'energy_digits_font': self.energy_digits_font.to_json(),
'energy_digits_outline': self.energy_digits_outline.to_json(),
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/EnergyBarColors.py | 0.845974 | 0.323006 | EnergyBarColors.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class NewCameraShakerStruct(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: int = dataclasses.field(default=0)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: int = dataclasses.field(default=0)
unknown_10: bool = dataclasses.field(default=False)
unknown_11: float = dataclasses.field(default=0.0)
unknown_12: float = dataclasses.field(default=0.0)
unknown_13: float = dataclasses.field(default=0.0)
unknown_14: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>l', data.read(4))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>l', data.read(4))[0]
unknown_10 = struct.unpack('>?', data.read(1))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
unknown_12 = struct.unpack('>f', data.read(4))[0]
unknown_13 = struct.unpack('>f', data.read(4))[0]
unknown_14 = struct.unpack('>f', data.read(4))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13, unknown_14)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>l', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>l', self.unknown_9))
data.write(struct.pack('>?', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
data.write(struct.pack('>f', self.unknown_12))
data.write(struct.pack('>f', self.unknown_13))
data.write(struct.pack('>f', self.unknown_14))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=data['unknown_12'],
unknown_13=data['unknown_13'],
unknown_14=data['unknown_14'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12,
'unknown_13': self.unknown_13,
'unknown_14': self.unknown_14,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/NewCameraShakerStruct.py | 0.73173 | 0.174375 | NewCameraShakerStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PrimeStruct3(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PrimeStruct3.py | 0.774199 | 0.209571 | PrimeStruct3.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerActorStruct(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>?', data.read(1))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>?', self.unknown_5))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PlayerActorStruct.py | 0.723993 | 0.213439 | PlayerActorStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PrimeStruct5 import PrimeStruct5
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Color import Color
@dataclasses.dataclass()
class PrimeStruct4(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
unknown_2: int = dataclasses.field(default=0)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
texture_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture_2: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: float = dataclasses.field(default=0.0)
unknown_12: Color = dataclasses.field(default_factory=Color)
unknown_13: Color = dataclasses.field(default_factory=Color)
wpsc: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage_info_1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unnamed: PrimeStruct5 = dataclasses.field(default_factory=PrimeStruct5)
unknown_22: float = dataclasses.field(default=0.0)
damage_info_2: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>l', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
texture_1 = struct.unpack(">L", data.read(4))[0]
texture_2 = struct.unpack(">L", data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
unknown_12 = Color.from_stream(data)
unknown_13 = Color.from_stream(data)
wpsc = struct.unpack(">L", data.read(4))[0]
damage_info_1 = DamageInfo.from_stream(data, property_size)
unnamed = PrimeStruct5.from_stream(data, property_size)
unknown_22 = struct.unpack('>f', data.read(4))[0]
damage_info_2 = DamageInfo.from_stream(data, property_size)
return cls(unknown_1, unknown_2, particle_1, particle_2, texture_1, texture_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13, wpsc, damage_info_1, unnamed, unknown_22, damage_info_2)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.texture_1))
data.write(struct.pack(">L", self.texture_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
self.unknown_12.to_stream(data)
self.unknown_13.to_stream(data)
data.write(struct.pack(">L", self.wpsc))
self.damage_info_1.to_stream(data)
self.unnamed.to_stream(data)
data.write(struct.pack('>f', self.unknown_22))
self.damage_info_2.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
particle_1=data['particle_1'],
particle_2=data['particle_2'],
texture_1=data['texture_1'],
texture_2=data['texture_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=Color.from_json(data['unknown_12']),
unknown_13=Color.from_json(data['unknown_13']),
wpsc=data['wpsc'],
damage_info_1=DamageInfo.from_json(data['damage_info_1']),
unnamed=PrimeStruct5.from_json(data['unnamed']),
unknown_22=data['unknown_22'],
damage_info_2=DamageInfo.from_json(data['damage_info_2']),
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'texture_1': self.texture_1,
'texture_2': self.texture_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12.to_json(),
'unknown_13': self.unknown_13.to_json(),
'wpsc': self.wpsc,
'damage_info_1': self.damage_info_1.to_json(),
'unnamed': self.unnamed.to_json(),
'unknown_22': self.unknown_22,
'damage_info_2': self.damage_info_2.to_json(),
}
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_texture_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_1)
def _dependencies_for_texture_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_2)
def _dependencies_for_wpsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc)
def _dependencies_for_damage_info_1(self, asset_manager):
yield from self.damage_info_1.dependencies_for(asset_manager)
def _dependencies_for_unnamed(self, asset_manager):
yield from self.unnamed.dependencies_for(asset_manager)
def _dependencies_for_damage_info_2(self, asset_manager):
yield from self.damage_info_2.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_texture_1, "texture_1", "AssetId"),
(self._dependencies_for_texture_2, "texture_2", "AssetId"),
(self._dependencies_for_wpsc, "wpsc", "AssetId"),
(self._dependencies_for_damage_info_1, "damage_info_1", "DamageInfo"),
(self._dependencies_for_unnamed, "unnamed", "PrimeStruct5"),
(self._dependencies_for_damage_info_2, "damage_info_2", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PrimeStruct4.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/PrimeStruct4.py | 0.682256 | 0.194693 | PrimeStruct4.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime as enums
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanImage(BaseProperty):
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
appear_percentage: float = dataclasses.field(default=0.0)
unnamed: enums.ScanImagePane = dataclasses.field(default=enums.ScanImagePane._None)
animation_cell_width: int = dataclasses.field(default=0)
animation_cell_height: int = dataclasses.field(default=0)
animation_swap_interval: float = dataclasses.field(default=0.0)
fade_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
texture = struct.unpack(">L", data.read(4))[0]
appear_percentage = struct.unpack('>f', data.read(4))[0]
unnamed = enums.ScanImagePane.from_stream(data)
animation_cell_width = struct.unpack('>l', data.read(4))[0]
animation_cell_height = struct.unpack('>l', data.read(4))[0]
animation_swap_interval = struct.unpack('>f', data.read(4))[0]
fade_time = struct.unpack('>f', data.read(4))[0]
return cls(texture, appear_percentage, unnamed, animation_cell_width, animation_cell_height, animation_swap_interval, fade_time)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack(">L", self.texture))
data.write(struct.pack('>f', self.appear_percentage))
self.unnamed.to_stream(data)
data.write(struct.pack('>l', self.animation_cell_width))
data.write(struct.pack('>l', self.animation_cell_height))
data.write(struct.pack('>f', self.animation_swap_interval))
data.write(struct.pack('>f', self.fade_time))
@classmethod
def from_json(cls, data: dict):
return cls(
texture=data['texture'],
appear_percentage=data['appear_percentage'],
unnamed=enums.ScanImagePane.from_json(data['unnamed']),
animation_cell_width=data['animation_cell_width'],
animation_cell_height=data['animation_cell_height'],
animation_swap_interval=data['animation_swap_interval'],
fade_time=data['fade_time'],
)
def to_json(self) -> dict:
return {
'texture': self.texture,
'appear_percentage': self.appear_percentage,
'unnamed': self.unnamed.to_json(),
'animation_cell_width': self.animation_cell_width,
'animation_cell_height': self.animation_cell_height,
'animation_swap_interval': self.animation_swap_interval,
'fade_time': self.fade_time,
}
def _dependencies_for_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_texture, "texture", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScanImage.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/ScanImage.py | 0.688992 | 0.188287 | ScanImage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Color import Color
@dataclasses.dataclass()
class ScriptBeamStruct(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
texture_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture_2: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: Color = dataclasses.field(default_factory=Color)
unknown_12: Color = dataclasses.field(default_factory=Color)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
texture_1 = struct.unpack(">L", data.read(4))[0]
texture_2 = struct.unpack(">L", data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = Color.from_stream(data)
unknown_12 = Color.from_stream(data)
return cls(unknown_1, particle_1, particle_2, texture_1, texture_2, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.texture_1))
data.write(struct.pack(">L", self.texture_2))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
self.unknown_11.to_stream(data)
self.unknown_12.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
particle_1=data['particle_1'],
particle_2=data['particle_2'],
texture_1=data['texture_1'],
texture_2=data['texture_2'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=Color.from_json(data['unknown_11']),
unknown_12=Color.from_json(data['unknown_12']),
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'texture_1': self.texture_1,
'texture_2': self.texture_2,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11.to_json(),
'unknown_12': self.unknown_12.to_json(),
}
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_texture_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_1)
def _dependencies_for_texture_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_2)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_texture_1, "texture_1", "AssetId"),
(self._dependencies_for_texture_2, "texture_2", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScriptBeamStruct.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/ScriptBeamStruct.py | 0.708818 | 0.189915 | ScriptBeamStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class CameraHintStruct(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: bool = dataclasses.field(default=False)
unknown_6: bool = dataclasses.field(default=False)
unknown_7: bool = dataclasses.field(default=False)
unknown_8: bool = dataclasses.field(default=False)
unknown_9: bool = dataclasses.field(default=False)
unknown_10: bool = dataclasses.field(default=False)
unknown_11: bool = dataclasses.field(default=False)
unknown_12: bool = dataclasses.field(default=False)
unknown_13: bool = dataclasses.field(default=False)
unknown_14: bool = dataclasses.field(default=False)
unknown_15: bool = dataclasses.field(default=False)
unknown_16: bool = dataclasses.field(default=False)
unknown_17: bool = dataclasses.field(default=False)
unknown_18: bool = dataclasses.field(default=False)
unknown_19: bool = dataclasses.field(default=False)
unknown_21: bool = dataclasses.field(default=False)
unknown_22: bool = dataclasses.field(default=False)
unknown_23: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>?', data.read(1))[0]
unknown_6 = struct.unpack('>?', data.read(1))[0]
unknown_7 = struct.unpack('>?', data.read(1))[0]
unknown_8 = struct.unpack('>?', data.read(1))[0]
unknown_9 = struct.unpack('>?', data.read(1))[0]
unknown_10 = struct.unpack('>?', data.read(1))[0]
unknown_11 = struct.unpack('>?', data.read(1))[0]
unknown_12 = struct.unpack('>?', data.read(1))[0]
unknown_13 = struct.unpack('>?', data.read(1))[0]
unknown_14 = struct.unpack('>?', data.read(1))[0]
unknown_15 = struct.unpack('>?', data.read(1))[0]
unknown_16 = struct.unpack('>?', data.read(1))[0]
unknown_17 = struct.unpack('>?', data.read(1))[0]
unknown_18 = struct.unpack('>?', data.read(1))[0]
unknown_19 = struct.unpack('>?', data.read(1))[0]
unknown_21 = struct.unpack('>?', data.read(1))[0]
unknown_22 = struct.unpack('>?', data.read(1))[0]
unknown_23 = struct.unpack('>?', data.read(1))[0]
return cls(unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13, unknown_14, unknown_15, unknown_16, unknown_17, unknown_18, unknown_19, unknown_21, unknown_22, unknown_23)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>?', self.unknown_5))
data.write(struct.pack('>?', self.unknown_6))
data.write(struct.pack('>?', self.unknown_7))
data.write(struct.pack('>?', self.unknown_8))
data.write(struct.pack('>?', self.unknown_9))
data.write(struct.pack('>?', self.unknown_10))
data.write(struct.pack('>?', self.unknown_11))
data.write(struct.pack('>?', self.unknown_12))
data.write(struct.pack('>?', self.unknown_13))
data.write(struct.pack('>?', self.unknown_14))
data.write(struct.pack('>?', self.unknown_15))
data.write(struct.pack('>?', self.unknown_16))
data.write(struct.pack('>?', self.unknown_17))
data.write(struct.pack('>?', self.unknown_18))
data.write(struct.pack('>?', self.unknown_19))
data.write(struct.pack('>?', self.unknown_21))
data.write(struct.pack('>?', self.unknown_22))
data.write(struct.pack('>?', self.unknown_23))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=data['unknown_12'],
unknown_13=data['unknown_13'],
unknown_14=data['unknown_14'],
unknown_15=data['unknown_15'],
unknown_16=data['unknown_16'],
unknown_17=data['unknown_17'],
unknown_18=data['unknown_18'],
unknown_19=data['unknown_19'],
unknown_21=data['unknown_21'],
unknown_22=data['unknown_22'],
unknown_23=data['unknown_23'],
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12,
'unknown_13': self.unknown_13,
'unknown_14': self.unknown_14,
'unknown_15': self.unknown_15,
'unknown_16': self.unknown_16,
'unknown_17': self.unknown_17,
'unknown_18': self.unknown_18,
'unknown_19': self.unknown_19,
'unknown_21': self.unknown_21,
'unknown_22': self.unknown_22,
'unknown_23': self.unknown_23,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/CameraHintStruct.py | 0.677474 | 0.217576 | CameraHintStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class FluidLayerMotion(BaseProperty):
fluid_uv_motion: int = dataclasses.field(default=0)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
fluid_uv_motion = struct.unpack('>l', data.read(4))[0]
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
return cls(fluid_uv_motion, unknown_1, unknown_2, unknown_3, unknown_4)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.fluid_uv_motion))
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
@classmethod
def from_json(cls, data: dict):
return cls(
fluid_uv_motion=data['fluid_uv_motion'],
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
)
def to_json(self) -> dict:
return {
'fluid_uv_motion': self.fluid_uv_motion,
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/FluidLayerMotion.py | 0.765067 | 0.185892 | FluidLayerMotion.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.archetypes.PrimeStruct2 import PrimeStruct2
from retro_data_structures.properties.prime.archetypes.PrimeStruct4 import PrimeStruct4
from retro_data_structures.properties.prime.archetypes.PrimeStruct6 import PrimeStruct6
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MassivePrimeStruct(BaseProperty):
unknown_1: int = dataclasses.field(default=0)
unnamed_0x00000001: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000002: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_2: int = dataclasses.field(default=0)
prime_struct2_1: PrimeStruct2 = dataclasses.field(default_factory=PrimeStruct2)
prime_struct2_2: PrimeStruct2 = dataclasses.field(default_factory=PrimeStruct2)
prime_struct2_3: PrimeStruct2 = dataclasses.field(default_factory=PrimeStruct2)
unknown_3: int = dataclasses.field(default=0)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_3: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_info_1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
texture_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_6: int = dataclasses.field(default=0)
unknown_7: int = dataclasses.field(default=0, metadata={'sound': True})
particle_4: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
prime_struct4_1: PrimeStruct4 = dataclasses.field(default_factory=PrimeStruct4)
prime_struct4_2: PrimeStruct4 = dataclasses.field(default_factory=PrimeStruct4)
prime_struct4_3: PrimeStruct4 = dataclasses.field(default_factory=PrimeStruct4)
prime_struct4_4: PrimeStruct4 = dataclasses.field(default_factory=PrimeStruct4)
wpsc_1: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage_info_2: DamageInfo = dataclasses.field(default_factory=DamageInfo)
prime_struct2_4: PrimeStruct2 = dataclasses.field(default_factory=PrimeStruct2)
wpsc_2: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage_info_3: DamageInfo = dataclasses.field(default_factory=DamageInfo)
prime_struct2_5: PrimeStruct2 = dataclasses.field(default_factory=PrimeStruct2)
unknown_8: int = dataclasses.field(default=0)
particle_5: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_info_4: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: float = dataclasses.field(default=0.0)
texture_2: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_12: bool = dataclasses.field(default=False)
unknown_13: bool = dataclasses.field(default=False)
unknown_14: bool = dataclasses.field(default=False)
unknown_15: bool = dataclasses.field(default=False)
damage_info_5: DamageInfo = dataclasses.field(default_factory=DamageInfo)
prime_struct2_6: PrimeStruct2 = dataclasses.field(default_factory=PrimeStruct2)
particle_6: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
swhc: AssetId = dataclasses.field(metadata={'asset_types': ['SWHC']}, default=default_asset_id)
particle_7: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_8: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
prime_struct6_1: PrimeStruct6 = dataclasses.field(default_factory=PrimeStruct6)
prime_struct6_2: PrimeStruct6 = dataclasses.field(default_factory=PrimeStruct6)
prime_struct6_3: PrimeStruct6 = dataclasses.field(default_factory=PrimeStruct6)
prime_struct6_4: PrimeStruct6 = dataclasses.field(default_factory=PrimeStruct6)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
unknown_1 = struct.unpack('>l', data.read(4))[0]
unnamed_0x00000001 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000002 = ActorParameters.from_stream(data, property_size)
unknown_2 = struct.unpack('>l', data.read(4))[0]
prime_struct2_1 = PrimeStruct2.from_stream(data, property_size)
prime_struct2_2 = PrimeStruct2.from_stream(data, property_size)
prime_struct2_3 = PrimeStruct2.from_stream(data, property_size)
unknown_3 = struct.unpack('>l', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
particle_3 = struct.unpack(">L", data.read(4))[0]
damage_info_1 = DamageInfo.from_stream(data, property_size)
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
texture_1 = struct.unpack(">L", data.read(4))[0]
unknown_6 = struct.unpack('>l', data.read(4))[0]
unknown_7 = struct.unpack('>l', data.read(4))[0]
particle_4 = struct.unpack(">L", data.read(4))[0]
prime_struct4_1 = PrimeStruct4.from_stream(data, property_size)
prime_struct4_2 = PrimeStruct4.from_stream(data, property_size)
prime_struct4_3 = PrimeStruct4.from_stream(data, property_size)
prime_struct4_4 = PrimeStruct4.from_stream(data, property_size)
wpsc_1 = struct.unpack(">L", data.read(4))[0]
damage_info_2 = DamageInfo.from_stream(data, property_size)
prime_struct2_4 = PrimeStruct2.from_stream(data, property_size)
wpsc_2 = struct.unpack(">L", data.read(4))[0]
damage_info_3 = DamageInfo.from_stream(data, property_size)
prime_struct2_5 = PrimeStruct2.from_stream(data, property_size)
unknown_8 = struct.unpack('>l', data.read(4))[0]
particle_5 = struct.unpack(">L", data.read(4))[0]
damage_info_4 = DamageInfo.from_stream(data, property_size)
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
texture_2 = struct.unpack(">L", data.read(4))[0]
unknown_12 = struct.unpack('>?', data.read(1))[0]
unknown_13 = struct.unpack('>?', data.read(1))[0]
unknown_14 = struct.unpack('>?', data.read(1))[0]
unknown_15 = struct.unpack('>?', data.read(1))[0]
damage_info_5 = DamageInfo.from_stream(data, property_size)
prime_struct2_6 = PrimeStruct2.from_stream(data, property_size)
particle_6 = struct.unpack(">L", data.read(4))[0]
swhc = struct.unpack(">L", data.read(4))[0]
particle_7 = struct.unpack(">L", data.read(4))[0]
particle_8 = struct.unpack(">L", data.read(4))[0]
prime_struct6_1 = PrimeStruct6.from_stream(data, property_size)
prime_struct6_2 = PrimeStruct6.from_stream(data, property_size)
prime_struct6_3 = PrimeStruct6.from_stream(data, property_size)
prime_struct6_4 = PrimeStruct6.from_stream(data, property_size)
return cls(unknown_1, unnamed_0x00000001, unnamed_0x00000002, unknown_2, prime_struct2_1, prime_struct2_2, prime_struct2_3, unknown_3, particle_1, particle_2, particle_3, damage_info_1, unknown_4, unknown_5, texture_1, unknown_6, unknown_7, particle_4, prime_struct4_1, prime_struct4_2, prime_struct4_3, prime_struct4_4, wpsc_1, damage_info_2, prime_struct2_4, wpsc_2, damage_info_3, prime_struct2_5, unknown_8, particle_5, damage_info_4, unknown_9, unknown_10, unknown_11, texture_2, unknown_12, unknown_13, unknown_14, unknown_15, damage_info_5, prime_struct2_6, particle_6, swhc, particle_7, particle_8, prime_struct6_1, prime_struct6_2, prime_struct6_3, prime_struct6_4)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack('>l', self.unknown_1))
self.unnamed_0x00000001.to_stream(data)
self.unnamed_0x00000002.to_stream(data)
data.write(struct.pack('>l', self.unknown_2))
self.prime_struct2_1.to_stream(data)
self.prime_struct2_2.to_stream(data)
self.prime_struct2_3.to_stream(data)
data.write(struct.pack('>l', self.unknown_3))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.particle_3))
self.damage_info_1.to_stream(data)
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack(">L", self.texture_1))
data.write(struct.pack('>l', self.unknown_6))
data.write(struct.pack('>l', self.unknown_7))
data.write(struct.pack(">L", self.particle_4))
self.prime_struct4_1.to_stream(data)
self.prime_struct4_2.to_stream(data)
self.prime_struct4_3.to_stream(data)
self.prime_struct4_4.to_stream(data)
data.write(struct.pack(">L", self.wpsc_1))
self.damage_info_2.to_stream(data)
self.prime_struct2_4.to_stream(data)
data.write(struct.pack(">L", self.wpsc_2))
self.damage_info_3.to_stream(data)
self.prime_struct2_5.to_stream(data)
data.write(struct.pack('>l', self.unknown_8))
data.write(struct.pack(">L", self.particle_5))
self.damage_info_4.to_stream(data)
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
data.write(struct.pack(">L", self.texture_2))
data.write(struct.pack('>?', self.unknown_12))
data.write(struct.pack('>?', self.unknown_13))
data.write(struct.pack('>?', self.unknown_14))
data.write(struct.pack('>?', self.unknown_15))
self.damage_info_5.to_stream(data)
self.prime_struct2_6.to_stream(data)
data.write(struct.pack(">L", self.particle_6))
data.write(struct.pack(">L", self.swhc))
data.write(struct.pack(">L", self.particle_7))
data.write(struct.pack(">L", self.particle_8))
self.prime_struct6_1.to_stream(data)
self.prime_struct6_2.to_stream(data)
self.prime_struct6_3.to_stream(data)
self.prime_struct6_4.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unnamed_0x00000001=PatternedAITypedef.from_json(data['unnamed_0x00000001']),
unnamed_0x00000002=ActorParameters.from_json(data['unnamed_0x00000002']),
unknown_2=data['unknown_2'],
prime_struct2_1=PrimeStruct2.from_json(data['prime_struct2_1']),
prime_struct2_2=PrimeStruct2.from_json(data['prime_struct2_2']),
prime_struct2_3=PrimeStruct2.from_json(data['prime_struct2_3']),
unknown_3=data['unknown_3'],
particle_1=data['particle_1'],
particle_2=data['particle_2'],
particle_3=data['particle_3'],
damage_info_1=DamageInfo.from_json(data['damage_info_1']),
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
texture_1=data['texture_1'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
particle_4=data['particle_4'],
prime_struct4_1=PrimeStruct4.from_json(data['prime_struct4_1']),
prime_struct4_2=PrimeStruct4.from_json(data['prime_struct4_2']),
prime_struct4_3=PrimeStruct4.from_json(data['prime_struct4_3']),
prime_struct4_4=PrimeStruct4.from_json(data['prime_struct4_4']),
wpsc_1=data['wpsc_1'],
damage_info_2=DamageInfo.from_json(data['damage_info_2']),
prime_struct2_4=PrimeStruct2.from_json(data['prime_struct2_4']),
wpsc_2=data['wpsc_2'],
damage_info_3=DamageInfo.from_json(data['damage_info_3']),
prime_struct2_5=PrimeStruct2.from_json(data['prime_struct2_5']),
unknown_8=data['unknown_8'],
particle_5=data['particle_5'],
damage_info_4=DamageInfo.from_json(data['damage_info_4']),
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
texture_2=data['texture_2'],
unknown_12=data['unknown_12'],
unknown_13=data['unknown_13'],
unknown_14=data['unknown_14'],
unknown_15=data['unknown_15'],
damage_info_5=DamageInfo.from_json(data['damage_info_5']),
prime_struct2_6=PrimeStruct2.from_json(data['prime_struct2_6']),
particle_6=data['particle_6'],
swhc=data['swhc'],
particle_7=data['particle_7'],
particle_8=data['particle_8'],
prime_struct6_1=PrimeStruct6.from_json(data['prime_struct6_1']),
prime_struct6_2=PrimeStruct6.from_json(data['prime_struct6_2']),
prime_struct6_3=PrimeStruct6.from_json(data['prime_struct6_3']),
prime_struct6_4=PrimeStruct6.from_json(data['prime_struct6_4']),
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unnamed_0x00000001': self.unnamed_0x00000001.to_json(),
'unnamed_0x00000002': self.unnamed_0x00000002.to_json(),
'unknown_2': self.unknown_2,
'prime_struct2_1': self.prime_struct2_1.to_json(),
'prime_struct2_2': self.prime_struct2_2.to_json(),
'prime_struct2_3': self.prime_struct2_3.to_json(),
'unknown_3': self.unknown_3,
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'particle_3': self.particle_3,
'damage_info_1': self.damage_info_1.to_json(),
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'texture_1': self.texture_1,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'particle_4': self.particle_4,
'prime_struct4_1': self.prime_struct4_1.to_json(),
'prime_struct4_2': self.prime_struct4_2.to_json(),
'prime_struct4_3': self.prime_struct4_3.to_json(),
'prime_struct4_4': self.prime_struct4_4.to_json(),
'wpsc_1': self.wpsc_1,
'damage_info_2': self.damage_info_2.to_json(),
'prime_struct2_4': self.prime_struct2_4.to_json(),
'wpsc_2': self.wpsc_2,
'damage_info_3': self.damage_info_3.to_json(),
'prime_struct2_5': self.prime_struct2_5.to_json(),
'unknown_8': self.unknown_8,
'particle_5': self.particle_5,
'damage_info_4': self.damage_info_4.to_json(),
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'texture_2': self.texture_2,
'unknown_12': self.unknown_12,
'unknown_13': self.unknown_13,
'unknown_14': self.unknown_14,
'unknown_15': self.unknown_15,
'damage_info_5': self.damage_info_5.to_json(),
'prime_struct2_6': self.prime_struct2_6.to_json(),
'particle_6': self.particle_6,
'swhc': self.swhc,
'particle_7': self.particle_7,
'particle_8': self.particle_8,
'prime_struct6_1': self.prime_struct6_1.to_json(),
'prime_struct6_2': self.prime_struct6_2.to_json(),
'prime_struct6_3': self.prime_struct6_3.to_json(),
'prime_struct6_4': self.prime_struct6_4.to_json(),
}
def _dependencies_for_unnamed_0x00000001(self, asset_manager):
yield from self.unnamed_0x00000001.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000002(self, asset_manager):
yield from self.unnamed_0x00000002.dependencies_for(asset_manager)
def _dependencies_for_prime_struct2_1(self, asset_manager):
yield from self.prime_struct2_1.dependencies_for(asset_manager)
def _dependencies_for_prime_struct2_2(self, asset_manager):
yield from self.prime_struct2_2.dependencies_for(asset_manager)
def _dependencies_for_prime_struct2_3(self, asset_manager):
yield from self.prime_struct2_3.dependencies_for(asset_manager)
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_particle_3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_3)
def _dependencies_for_damage_info_1(self, asset_manager):
yield from self.damage_info_1.dependencies_for(asset_manager)
def _dependencies_for_texture_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_1)
def _dependencies_for_unknown_7(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_7)
def _dependencies_for_particle_4(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_4)
def _dependencies_for_prime_struct4_1(self, asset_manager):
yield from self.prime_struct4_1.dependencies_for(asset_manager)
def _dependencies_for_prime_struct4_2(self, asset_manager):
yield from self.prime_struct4_2.dependencies_for(asset_manager)
def _dependencies_for_prime_struct4_3(self, asset_manager):
yield from self.prime_struct4_3.dependencies_for(asset_manager)
def _dependencies_for_prime_struct4_4(self, asset_manager):
yield from self.prime_struct4_4.dependencies_for(asset_manager)
def _dependencies_for_wpsc_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc_1)
def _dependencies_for_damage_info_2(self, asset_manager):
yield from self.damage_info_2.dependencies_for(asset_manager)
def _dependencies_for_prime_struct2_4(self, asset_manager):
yield from self.prime_struct2_4.dependencies_for(asset_manager)
def _dependencies_for_wpsc_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc_2)
def _dependencies_for_damage_info_3(self, asset_manager):
yield from self.damage_info_3.dependencies_for(asset_manager)
def _dependencies_for_prime_struct2_5(self, asset_manager):
yield from self.prime_struct2_5.dependencies_for(asset_manager)
def _dependencies_for_particle_5(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_5)
def _dependencies_for_damage_info_4(self, asset_manager):
yield from self.damage_info_4.dependencies_for(asset_manager)
def _dependencies_for_texture_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_2)
def _dependencies_for_damage_info_5(self, asset_manager):
yield from self.damage_info_5.dependencies_for(asset_manager)
def _dependencies_for_prime_struct2_6(self, asset_manager):
yield from self.prime_struct2_6.dependencies_for(asset_manager)
def _dependencies_for_particle_6(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_6)
def _dependencies_for_swhc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.swhc)
def _dependencies_for_particle_7(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_7)
def _dependencies_for_particle_8(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_8)
def _dependencies_for_prime_struct6_1(self, asset_manager):
yield from self.prime_struct6_1.dependencies_for(asset_manager)
def _dependencies_for_prime_struct6_2(self, asset_manager):
yield from self.prime_struct6_2.dependencies_for(asset_manager)
def _dependencies_for_prime_struct6_3(self, asset_manager):
yield from self.prime_struct6_3.dependencies_for(asset_manager)
def _dependencies_for_prime_struct6_4(self, asset_manager):
yield from self.prime_struct6_4.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000001, "unnamed_0x00000001", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000002, "unnamed_0x00000002", "ActorParameters"),
(self._dependencies_for_prime_struct2_1, "prime_struct2_1", "PrimeStruct2"),
(self._dependencies_for_prime_struct2_2, "prime_struct2_2", "PrimeStruct2"),
(self._dependencies_for_prime_struct2_3, "prime_struct2_3", "PrimeStruct2"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_particle_3, "particle_3", "AssetId"),
(self._dependencies_for_damage_info_1, "damage_info_1", "DamageInfo"),
(self._dependencies_for_texture_1, "texture_1", "AssetId"),
(self._dependencies_for_unknown_7, "unknown_7", "int"),
(self._dependencies_for_particle_4, "particle_4", "AssetId"),
(self._dependencies_for_prime_struct4_1, "prime_struct4_1", "PrimeStruct4"),
(self._dependencies_for_prime_struct4_2, "prime_struct4_2", "PrimeStruct4"),
(self._dependencies_for_prime_struct4_3, "prime_struct4_3", "PrimeStruct4"),
(self._dependencies_for_prime_struct4_4, "prime_struct4_4", "PrimeStruct4"),
(self._dependencies_for_wpsc_1, "wpsc_1", "AssetId"),
(self._dependencies_for_damage_info_2, "damage_info_2", "DamageInfo"),
(self._dependencies_for_prime_struct2_4, "prime_struct2_4", "PrimeStruct2"),
(self._dependencies_for_wpsc_2, "wpsc_2", "AssetId"),
(self._dependencies_for_damage_info_3, "damage_info_3", "DamageInfo"),
(self._dependencies_for_prime_struct2_5, "prime_struct2_5", "PrimeStruct2"),
(self._dependencies_for_particle_5, "particle_5", "AssetId"),
(self._dependencies_for_damage_info_4, "damage_info_4", "DamageInfo"),
(self._dependencies_for_texture_2, "texture_2", "AssetId"),
(self._dependencies_for_damage_info_5, "damage_info_5", "DamageInfo"),
(self._dependencies_for_prime_struct2_6, "prime_struct2_6", "PrimeStruct2"),
(self._dependencies_for_particle_6, "particle_6", "AssetId"),
(self._dependencies_for_swhc, "swhc", "AssetId"),
(self._dependencies_for_particle_7, "particle_7", "AssetId"),
(self._dependencies_for_particle_8, "particle_8", "AssetId"),
(self._dependencies_for_prime_struct6_1, "prime_struct6_1", "PrimeStruct6"),
(self._dependencies_for_prime_struct6_2, "prime_struct6_2", "PrimeStruct6"),
(self._dependencies_for_prime_struct6_3, "prime_struct6_3", "PrimeStruct6"),
(self._dependencies_for_prime_struct6_4, "prime_struct6_4", "PrimeStruct6"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MassivePrimeStruct.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/MassivePrimeStruct.py | 0.688468 | 0.197851 | MassivePrimeStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime.archetypes.FluidLayerMotion import FluidLayerMotion
@dataclasses.dataclass()
class FluidUVMotion(BaseProperty):
fluid_layer_motion_1: FluidLayerMotion = dataclasses.field(default_factory=FluidLayerMotion)
fluid_layer_motion_2: FluidLayerMotion = dataclasses.field(default_factory=FluidLayerMotion)
fluid_layer_motion_3: FluidLayerMotion = dataclasses.field(default_factory=FluidLayerMotion)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
fluid_layer_motion_1 = FluidLayerMotion.from_stream(data, property_size)
fluid_layer_motion_2 = FluidLayerMotion.from_stream(data, property_size)
fluid_layer_motion_3 = FluidLayerMotion.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
return cls(fluid_layer_motion_1, fluid_layer_motion_2, fluid_layer_motion_3, unknown_1, unknown_2)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
self.fluid_layer_motion_1.to_stream(data)
self.fluid_layer_motion_2.to_stream(data)
self.fluid_layer_motion_3.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
@classmethod
def from_json(cls, data: dict):
return cls(
fluid_layer_motion_1=FluidLayerMotion.from_json(data['fluid_layer_motion_1']),
fluid_layer_motion_2=FluidLayerMotion.from_json(data['fluid_layer_motion_2']),
fluid_layer_motion_3=FluidLayerMotion.from_json(data['fluid_layer_motion_3']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
)
def to_json(self) -> dict:
return {
'fluid_layer_motion_1': self.fluid_layer_motion_1.to_json(),
'fluid_layer_motion_2': self.fluid_layer_motion_2.to_json(),
'fluid_layer_motion_3': self.fluid_layer_motion_3.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
}
def _dependencies_for_fluid_layer_motion_1(self, asset_manager):
yield from self.fluid_layer_motion_1.dependencies_for(asset_manager)
def _dependencies_for_fluid_layer_motion_2(self, asset_manager):
yield from self.fluid_layer_motion_2.dependencies_for(asset_manager)
def _dependencies_for_fluid_layer_motion_3(self, asset_manager):
yield from self.fluid_layer_motion_3.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_fluid_layer_motion_1, "fluid_layer_motion_1", "FluidLayerMotion"),
(self._dependencies_for_fluid_layer_motion_2, "fluid_layer_motion_2", "FluidLayerMotion"),
(self._dependencies_for_fluid_layer_motion_3, "fluid_layer_motion_3", "FluidLayerMotion"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FluidUVMotion.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/archetypes/FluidUVMotion.py | 0.675978 | 0.183795 | FluidUVMotion.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Waypoint(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
active: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
delay: float = dataclasses.field(default=0.0)
unknown_4: int = dataclasses.field(default=0)
unknown_5: int = dataclasses.field(default=0)
unknown_6: int = dataclasses.field(default=0)
unknown_7: int = dataclasses.field(default=0)
unknown_8: int = dataclasses.field(default=0)
unknown_9: int = dataclasses.field(default=0)
unknown_10: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x2
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
active = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
delay = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>l', data.read(4))[0]
unknown_5 = struct.unpack('>l', data.read(4))[0]
unknown_6 = struct.unpack('>l', data.read(4))[0]
unknown_7 = struct.unpack('>l', data.read(4))[0]
unknown_8 = struct.unpack('>l', data.read(4))[0]
unknown_9 = struct.unpack('>l', data.read(4))[0]
unknown_10 = struct.unpack('>l', data.read(4))[0]
return cls(name, position, rotation, active, unknown_2, delay, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\r') # 13 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.active))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.delay))
data.write(struct.pack('>l', self.unknown_4))
data.write(struct.pack('>l', self.unknown_5))
data.write(struct.pack('>l', self.unknown_6))
data.write(struct.pack('>l', self.unknown_7))
data.write(struct.pack('>l', self.unknown_8))
data.write(struct.pack('>l', self.unknown_9))
data.write(struct.pack('>l', self.unknown_10))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
active=data['active'],
unknown_2=data['unknown_2'],
delay=data['delay'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'active': self.active,
'unknown_2': self.unknown_2,
'delay': self.delay,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Waypoint.py | 0.763396 | 0.332446 | Waypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.GrappleParameters import GrappleParameters
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class GrapplePoint(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
active: bool = dataclasses.field(default=False)
unnamed: GrappleParameters = dataclasses.field(default_factory=GrappleParameters)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x30
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
active = struct.unpack('>?', data.read(1))[0]
unnamed = GrappleParameters.from_stream(data, property_size)
return cls(name, position, rotation, active, unnamed)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x05') # 5 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.active))
self.unnamed.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
active=data['active'],
unnamed=GrappleParameters.from_json(data['unnamed']),
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'active': self.active,
'unnamed': self.unnamed.to_json(),
}
def _dependencies_for_unnamed(self, asset_manager):
yield from self.unnamed.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed, "unnamed", "GrappleParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for GrapplePoint.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/GrapplePoint.py | 0.801781 | 0.340102 | GrapplePoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class FlaahgraTentacle(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x5C
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x06') # 6 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FlaahgraTentacle.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/FlaahgraTentacle.py | 0.750553 | 0.390331 | FlaahgraTentacle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class FlickerBat(BaseObjectType):
name: str = dataclasses.field(default='')
unknown_1: int = dataclasses.field(default=0)
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000005: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000006: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x2E
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_1 = struct.unpack('>l', data.read(4))[0]
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000005 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000006 = ActorParameters.from_stream(data, property_size)
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
return cls(name, unknown_1, position, rotation, scale, unnamed_0x00000005, unnamed_0x00000006, unknown_2, unknown_3, unknown_4)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\n') # 10 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>l', self.unknown_1))
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
self.unnamed_0x00000006.to_stream(data)
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
unknown_1=data['unknown_1'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000005=PatternedAITypedef.from_json(data['unnamed_0x00000005']),
unnamed_0x00000006=ActorParameters.from_json(data['unnamed_0x00000006']),
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'unknown_1': self.unknown_1,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unnamed_0x00000006': self.unnamed_0x00000006.to_json(),
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
}
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000006(self, asset_manager):
yield from self.unnamed_0x00000006.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000006, "unnamed_0x00000006", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FlickerBat.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/FlickerBat.py | 0.708112 | 0.360968 | FlickerBat.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
@dataclasses.dataclass()
class StreamedAudio(BaseObjectType):
name: str = dataclasses.field(default='')
active: bool = dataclasses.field(default=False)
audio_file: str = dataclasses.field(default='')
unknown_2: bool = dataclasses.field(default=False)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: int = dataclasses.field(default=0)
unknown_6: int = dataclasses.field(default=0)
unknown_7: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x61
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
active = struct.unpack('>?', data.read(1))[0]
audio_file = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>l', data.read(4))[0]
unknown_6 = struct.unpack('>l', data.read(4))[0]
unknown_7 = struct.unpack('>?', data.read(1))[0]
return cls(name, active, audio_file, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\t') # 9 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>?', self.active))
data.write(self.audio_file.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>l', self.unknown_5))
data.write(struct.pack('>l', self.unknown_6))
data.write(struct.pack('>?', self.unknown_7))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
active=data['active'],
audio_file=data['audio_file'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'active': self.active,
'audio_file': self.audio_file,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/StreamedAudio.py | 0.715623 | 0.256774 | StreamedAudio.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Door(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
animation_parameters: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unnamed: ActorParameters = dataclasses.field(default_factory=ActorParameters)
scan_offset: Vector = dataclasses.field(default_factory=Vector)
collision_size: Vector = dataclasses.field(default_factory=Vector)
collision_offset: Vector = dataclasses.field(default_factory=Vector)
active: bool = dataclasses.field(default=False)
open: bool = dataclasses.field(default=False)
unknown_6: bool = dataclasses.field(default=False)
open_close_animation_length: float = dataclasses.field(default=0.0)
unknown_8: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x3
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
animation_parameters = AnimationParameters.from_stream(data, property_size)
unnamed = ActorParameters.from_stream(data, property_size)
scan_offset = Vector.from_stream(data)
collision_size = Vector.from_stream(data)
collision_offset = Vector.from_stream(data)
active = struct.unpack('>?', data.read(1))[0]
open = struct.unpack('>?', data.read(1))[0]
unknown_6 = struct.unpack('>?', data.read(1))[0]
open_close_animation_length = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>?', data.read(1))[0]
return cls(name, position, rotation, scale, animation_parameters, unnamed, scan_offset, collision_size, collision_offset, active, open, unknown_6, open_close_animation_length, unknown_8)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x0e') # 14 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.animation_parameters.to_stream(data)
self.unnamed.to_stream(data)
self.scan_offset.to_stream(data)
self.collision_size.to_stream(data)
self.collision_offset.to_stream(data)
data.write(struct.pack('>?', self.active))
data.write(struct.pack('>?', self.open))
data.write(struct.pack('>?', self.unknown_6))
data.write(struct.pack('>f', self.open_close_animation_length))
data.write(struct.pack('>?', self.unknown_8))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
animation_parameters=AnimationParameters.from_json(data['animation_parameters']),
unnamed=ActorParameters.from_json(data['unnamed']),
scan_offset=Vector.from_json(data['scan_offset']),
collision_size=Vector.from_json(data['collision_size']),
collision_offset=Vector.from_json(data['collision_offset']),
active=data['active'],
open=data['open'],
unknown_6=data['unknown_6'],
open_close_animation_length=data['open_close_animation_length'],
unknown_8=data['unknown_8'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'animation_parameters': self.animation_parameters.to_json(),
'unnamed': self.unnamed.to_json(),
'scan_offset': self.scan_offset.to_json(),
'collision_size': self.collision_size.to_json(),
'collision_offset': self.collision_offset.to_json(),
'active': self.active,
'open': self.open,
'unknown_6': self.unknown_6,
'open_close_animation_length': self.open_close_animation_length,
'unknown_8': self.unknown_8,
}
def _dependencies_for_animation_parameters(self, asset_manager):
yield from self.animation_parameters.dependencies_for(asset_manager)
def _dependencies_for_unnamed(self, asset_manager):
yield from self.unnamed.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_animation_parameters, "animation_parameters", "AnimationParameters"),
(self._dependencies_for_unnamed, "unnamed", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Door.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Door.py | 0.768907 | 0.360377 | Door.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class CoverPoint(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
unknown_1: bool = dataclasses.field(default=False)
unknown_2: int = dataclasses.field(default=0)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x2A
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
return cls(name, position, rotation, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\t') # 9 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/CoverPoint.py | 0.765593 | 0.41745 | CoverPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
@dataclasses.dataclass()
class Switch(BaseObjectType):
name: str = dataclasses.field(default='')
active: bool = dataclasses.field(default=False)
open: bool = dataclasses.field(default=False)
close_when_used: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x56
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
active = struct.unpack('>?', data.read(1))[0]
open = struct.unpack('>?', data.read(1))[0]
close_when_used = struct.unpack('>?', data.read(1))[0]
return cls(name, active, open, close_when_used)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x04') # 4 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>?', self.active))
data.write(struct.pack('>?', self.open))
data.write(struct.pack('>?', self.close_when_used))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
active=data['active'],
open=data['open'],
close_when_used=data['close_when_used'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'active': self.active,
'open': self.open,
'close_when_used': self.close_when_used,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Switch.py | 0.6973 | 0.279718 | Switch.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.PlayerHintStruct import PlayerHintStruct
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class PlayerHint(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
active: bool = dataclasses.field(default=False)
unnamed: PlayerHintStruct = dataclasses.field(default_factory=PlayerHintStruct)
unknown: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x3E
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
active = struct.unpack('>?', data.read(1))[0]
unnamed = PlayerHintStruct.from_stream(data, property_size)
unknown = struct.unpack('>l', data.read(4))[0]
return cls(name, position, rotation, active, unnamed, unknown)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x06') # 6 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.active))
self.unnamed.to_stream(data)
data.write(struct.pack('>l', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
active=data['active'],
unnamed=PlayerHintStruct.from_json(data['unnamed']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'active': self.active,
'unnamed': self.unnamed.to_json(),
'unknown': self.unknown,
}
def _dependencies_for_unnamed(self, asset_manager):
yield from self.unnamed.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed, "unnamed", "PlayerHintStruct"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlayerHint.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/PlayerHint.py | 0.738575 | 0.33497 | PlayerHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class CameraWaypoint(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
active: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0xD
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
active = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>l', data.read(4))[0]
return cls(name, position, rotation, active, unknown_2, unknown_3)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x06') # 6 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.active))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>l', self.unknown_3))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
active=data['active'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'active': self.active,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/CameraWaypoint.py | 0.78572 | 0.425367 | CameraWaypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Oculus(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unnamed_0x0000000c: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_7: float = dataclasses.field(default=0.0)
unnamed_0x0000000e: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x6F
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unnamed_0x0000000c = DamageVulnerability.from_stream(data, property_size)
unknown_7 = struct.unpack('>f', data.read(4))[0]
unnamed_0x0000000e = DamageInfo.from_stream(data, property_size)
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unnamed_0x0000000c, unknown_7, unnamed_0x0000000e)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x0f') # 15 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
self.unnamed_0x0000000c.to_stream(data)
data.write(struct.pack('>f', self.unknown_7))
self.unnamed_0x0000000e.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unnamed_0x0000000c=DamageVulnerability.from_json(data['unnamed_0x0000000c']),
unknown_7=data['unknown_7'],
unnamed_0x0000000e=DamageInfo.from_json(data['unnamed_0x0000000e']),
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unnamed_0x0000000c': self.unnamed_0x0000000c.to_json(),
'unknown_7': self.unknown_7,
'unnamed_0x0000000e': self.unnamed_0x0000000e.to_json(),
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x0000000c(self, asset_manager):
yield from self.unnamed_0x0000000c.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x0000000e(self, asset_manager):
yield from self.unnamed_0x0000000e.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_unnamed_0x0000000c, "unnamed_0x0000000c", "DamageVulnerability"),
(self._dependencies_for_unnamed_0x0000000e, "unnamed_0x0000000e", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Oculus.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Oculus.py | 0.727104 | 0.368207 | Oculus.py | 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.prime as enums
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Pickup(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
collision_scale: Vector = dataclasses.field(default_factory=Vector)
scan_collision_offset: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000006: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
capacity: int = dataclasses.field(default=0)
amount: int = dataclasses.field(default=0)
drop_rate: float = dataclasses.field(default=0.0)
life_time: float = dataclasses.field(default=0.0)
fade_length: float = dataclasses.field(default=0.0)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation_parameters: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unnamed_0x0000000e: ActorParameters = dataclasses.field(default_factory=ActorParameters)
active: bool = dataclasses.field(default=False)
spawn_delay: float = dataclasses.field(default=0.0)
particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x11
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
collision_scale = Vector.from_stream(data)
scan_collision_offset = Vector.from_stream(data)
unnamed_0x00000006 = enums.PlayerItem.from_stream(data)
capacity = struct.unpack('>l', data.read(4))[0]
amount = struct.unpack('>l', data.read(4))[0]
drop_rate = struct.unpack('>f', data.read(4))[0]
life_time = struct.unpack('>f', data.read(4))[0]
fade_length = struct.unpack('>f', data.read(4))[0]
model = struct.unpack(">L", data.read(4))[0]
animation_parameters = AnimationParameters.from_stream(data, property_size)
unnamed_0x0000000e = ActorParameters.from_stream(data, property_size)
active = struct.unpack('>?', data.read(1))[0]
spawn_delay = struct.unpack('>f', data.read(4))[0]
particle = struct.unpack(">L", data.read(4))[0]
return cls(name, position, rotation, scale, collision_scale, scan_collision_offset, unnamed_0x00000006, capacity, amount, drop_rate, life_time, fade_length, model, animation_parameters, unnamed_0x0000000e, active, spawn_delay, particle)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x12') # 18 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.collision_scale.to_stream(data)
self.scan_collision_offset.to_stream(data)
self.unnamed_0x00000006.to_stream(data)
data.write(struct.pack('>l', self.capacity))
data.write(struct.pack('>l', self.amount))
data.write(struct.pack('>f', self.drop_rate))
data.write(struct.pack('>f', self.life_time))
data.write(struct.pack('>f', self.fade_length))
data.write(struct.pack(">L", self.model))
self.animation_parameters.to_stream(data)
self.unnamed_0x0000000e.to_stream(data)
data.write(struct.pack('>?', self.active))
data.write(struct.pack('>f', self.spawn_delay))
data.write(struct.pack(">L", self.particle))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
collision_scale=Vector.from_json(data['collision_scale']),
scan_collision_offset=Vector.from_json(data['scan_collision_offset']),
unnamed_0x00000006=enums.PlayerItem.from_json(data['unnamed_0x00000006']),
capacity=data['capacity'],
amount=data['amount'],
drop_rate=data['drop_rate'],
life_time=data['life_time'],
fade_length=data['fade_length'],
model=data['model'],
animation_parameters=AnimationParameters.from_json(data['animation_parameters']),
unnamed_0x0000000e=ActorParameters.from_json(data['unnamed_0x0000000e']),
active=data['active'],
spawn_delay=data['spawn_delay'],
particle=data['particle'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'collision_scale': self.collision_scale.to_json(),
'scan_collision_offset': self.scan_collision_offset.to_json(),
'unnamed_0x00000006': self.unnamed_0x00000006.to_json(),
'capacity': self.capacity,
'amount': self.amount,
'drop_rate': self.drop_rate,
'life_time': self.life_time,
'fade_length': self.fade_length,
'model': self.model,
'animation_parameters': self.animation_parameters.to_json(),
'unnamed_0x0000000e': self.unnamed_0x0000000e.to_json(),
'active': self.active,
'spawn_delay': self.spawn_delay,
'particle': self.particle,
}
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_animation_parameters(self, asset_manager):
yield from self.animation_parameters.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x0000000e(self, asset_manager):
yield from self.unnamed_0x0000000e.dependencies_for(asset_manager)
def _dependencies_for_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_animation_parameters, "animation_parameters", "AnimationParameters"),
(self._dependencies_for_unnamed_0x0000000e, "unnamed_0x0000000e", "ActorParameters"),
(self._dependencies_for_particle, "particle", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Pickup.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Pickup.py | 0.750553 | 0.300572 | Pickup.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
@dataclasses.dataclass()
class ActorKeyframe(BaseObjectType):
name: str = dataclasses.field(default='')
unknown_1: int = dataclasses.field(default=0)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: int = dataclasses.field(default=0)
unknown_6: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x1D
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>l', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
return cls(name, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x07') # 7 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>l', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/ActorKeyframe.py | 0.719088 | 0.244972 | ActorKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class PuddleToadGamma(BaseObjectType):
name: str = dataclasses.field(default='')
unknown_1: int = dataclasses.field(default=0)
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000005: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000006: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: Vector = dataclasses.field(default_factory=Vector)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
damage_info_1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info_2: DamageInfo = dataclasses.field(default_factory=DamageInfo)
dcln: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x34
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_1 = struct.unpack('>l', data.read(4))[0]
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000005 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000006 = ActorParameters.from_stream(data, property_size)
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = Vector.from_stream(data)
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
damage_info_1 = DamageInfo.from_stream(data, property_size)
damage_info_2 = DamageInfo.from_stream(data, property_size)
dcln = struct.unpack(">L", data.read(4))[0]
return cls(name, unknown_1, position, rotation, scale, unnamed_0x00000005, unnamed_0x00000006, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, damage_info_1, damage_info_2, dcln)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x11') # 17 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>l', self.unknown_1))
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
self.unnamed_0x00000006.to_stream(data)
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
self.unknown_5.to_stream(data)
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
self.damage_info_1.to_stream(data)
self.damage_info_2.to_stream(data)
data.write(struct.pack(">L", self.dcln))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
unknown_1=data['unknown_1'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000005=PatternedAITypedef.from_json(data['unnamed_0x00000005']),
unnamed_0x00000006=ActorParameters.from_json(data['unnamed_0x00000006']),
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=Vector.from_json(data['unknown_5']),
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
damage_info_1=DamageInfo.from_json(data['damage_info_1']),
damage_info_2=DamageInfo.from_json(data['damage_info_2']),
dcln=data['dcln'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'unknown_1': self.unknown_1,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unnamed_0x00000006': self.unnamed_0x00000006.to_json(),
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5.to_json(),
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'damage_info_1': self.damage_info_1.to_json(),
'damage_info_2': self.damage_info_2.to_json(),
'dcln': self.dcln,
}
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000006(self, asset_manager):
yield from self.unnamed_0x00000006.dependencies_for(asset_manager)
def _dependencies_for_damage_info_1(self, asset_manager):
yield from self.damage_info_1.dependencies_for(asset_manager)
def _dependencies_for_damage_info_2(self, asset_manager):
yield from self.damage_info_2.dependencies_for(asset_manager)
def _dependencies_for_dcln(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dcln)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000006, "unnamed_0x00000006", "ActorParameters"),
(self._dependencies_for_damage_info_1, "damage_info_1", "DamageInfo"),
(self._dependencies_for_damage_info_2, "damage_info_2", "DamageInfo"),
(self._dependencies_for_dcln, "dcln", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PuddleToadGamma.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/PuddleToadGamma.py | 0.712532 | 0.332026 | PuddleToadGamma.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class EnergyBall(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_1: int = dataclasses.field(default=0)
unknown_2: float = dataclasses.field(default=0.0)
damage_info_1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_3: float = dataclasses.field(default=0.0)
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
sound_id_1: int = dataclasses.field(default=0, metadata={'sound': True})
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
elsc: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
sound_id_2: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_info_2: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_6: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x8B
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unknown_1 = struct.unpack('>l', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
damage_info_1 = DamageInfo.from_stream(data, property_size)
unknown_3 = struct.unpack('>f', data.read(4))[0]
texture = struct.unpack(">L", data.read(4))[0]
sound_id_1 = struct.unpack('>l', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
elsc = struct.unpack(">L", data.read(4))[0]
sound_id_2 = struct.unpack('>l', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
damage_info_2 = DamageInfo.from_stream(data, property_size)
unknown_6 = struct.unpack('>f', data.read(4))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unknown_1, unknown_2, damage_info_1, unknown_3, texture, sound_id_1, particle_1, elsc, sound_id_2, unknown_4, unknown_5, particle_2, damage_info_2, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x14') # 20 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>l', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
self.damage_info_1.to_stream(data)
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack(">L", self.texture))
data.write(struct.pack('>l', self.sound_id_1))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.elsc))
data.write(struct.pack('>l', self.sound_id_2))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack(">L", self.particle_2))
self.damage_info_2.to_stream(data)
data.write(struct.pack('>f', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
damage_info_1=DamageInfo.from_json(data['damage_info_1']),
unknown_3=data['unknown_3'],
texture=data['texture'],
sound_id_1=data['sound_id_1'],
particle_1=data['particle_1'],
elsc=data['elsc'],
sound_id_2=data['sound_id_2'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
particle_2=data['particle_2'],
damage_info_2=DamageInfo.from_json(data['damage_info_2']),
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'damage_info_1': self.damage_info_1.to_json(),
'unknown_3': self.unknown_3,
'texture': self.texture,
'sound_id_1': self.sound_id_1,
'particle_1': self.particle_1,
'elsc': self.elsc,
'sound_id_2': self.sound_id_2,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'particle_2': self.particle_2,
'damage_info_2': self.damage_info_2.to_json(),
'unknown_6': self.unknown_6,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_damage_info_1(self, asset_manager):
yield from self.damage_info_1.dependencies_for(asset_manager)
def _dependencies_for_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture)
def _dependencies_for_sound_id_1(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_id_1)
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_elsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.elsc)
def _dependencies_for_sound_id_2(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_id_2)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_damage_info_2(self, asset_manager):
yield from self.damage_info_2.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_damage_info_1, "damage_info_1", "DamageInfo"),
(self._dependencies_for_texture, "texture", "AssetId"),
(self._dependencies_for_sound_id_1, "sound_id_1", "int"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_elsc, "elsc", "AssetId"),
(self._dependencies_for_sound_id_2, "sound_id_2", "int"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_damage_info_2, "damage_info_2", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EnergyBall.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/EnergyBall.py | 0.68679 | 0.308151 | EnergyBall.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Beetle(BaseObjectType):
name: str = dataclasses.field(default='')
unknown_1: int = dataclasses.field(default=0)
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000005: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000006: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unnamed_0x00000007: DamageInfo = dataclasses.field(default_factory=DamageInfo)
orbit_offset: Vector = dataclasses.field(default_factory=Vector)
unknown_3: float = dataclasses.field(default=0.0)
abdomen_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
armor_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
abdomen_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_4: int = dataclasses.field(default=0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x16
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_1 = struct.unpack('>l', data.read(4))[0]
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000005 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000006 = ActorParameters.from_stream(data, property_size)
unnamed_0x00000007 = DamageInfo.from_stream(data, property_size)
orbit_offset = Vector.from_stream(data)
unknown_3 = struct.unpack('>f', data.read(4))[0]
abdomen_vulnerability = DamageVulnerability.from_stream(data, property_size)
armor_vulnerability = DamageVulnerability.from_stream(data, property_size)
abdomen_model = struct.unpack(">L", data.read(4))[0]
unknown_4 = struct.unpack('>l', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
return cls(name, unknown_1, position, rotation, scale, unnamed_0x00000005, unnamed_0x00000006, unnamed_0x00000007, orbit_offset, unknown_3, abdomen_vulnerability, armor_vulnerability, abdomen_model, unknown_4, unknown_5, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x10') # 16 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>l', self.unknown_1))
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
self.unnamed_0x00000006.to_stream(data)
self.unnamed_0x00000007.to_stream(data)
self.orbit_offset.to_stream(data)
data.write(struct.pack('>f', self.unknown_3))
self.abdomen_vulnerability.to_stream(data)
self.armor_vulnerability.to_stream(data)
data.write(struct.pack(">L", self.abdomen_model))
data.write(struct.pack('>l', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
unknown_1=data['unknown_1'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000005=PatternedAITypedef.from_json(data['unnamed_0x00000005']),
unnamed_0x00000006=ActorParameters.from_json(data['unnamed_0x00000006']),
unnamed_0x00000007=DamageInfo.from_json(data['unnamed_0x00000007']),
orbit_offset=Vector.from_json(data['orbit_offset']),
unknown_3=data['unknown_3'],
abdomen_vulnerability=DamageVulnerability.from_json(data['abdomen_vulnerability']),
armor_vulnerability=DamageVulnerability.from_json(data['armor_vulnerability']),
abdomen_model=data['abdomen_model'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'unknown_1': self.unknown_1,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unnamed_0x00000006': self.unnamed_0x00000006.to_json(),
'unnamed_0x00000007': self.unnamed_0x00000007.to_json(),
'orbit_offset': self.orbit_offset.to_json(),
'unknown_3': self.unknown_3,
'abdomen_vulnerability': self.abdomen_vulnerability.to_json(),
'armor_vulnerability': self.armor_vulnerability.to_json(),
'abdomen_model': self.abdomen_model,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
}
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000006(self, asset_manager):
yield from self.unnamed_0x00000006.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000007(self, asset_manager):
yield from self.unnamed_0x00000007.dependencies_for(asset_manager)
def _dependencies_for_abdomen_vulnerability(self, asset_manager):
yield from self.abdomen_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_armor_vulnerability(self, asset_manager):
yield from self.armor_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_abdomen_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.abdomen_model)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000006, "unnamed_0x00000006", "ActorParameters"),
(self._dependencies_for_unnamed_0x00000007, "unnamed_0x00000007", "DamageInfo"),
(self._dependencies_for_abdomen_vulnerability, "abdomen_vulnerability", "DamageVulnerability"),
(self._dependencies_for_armor_vulnerability, "armor_vulnerability", "DamageVulnerability"),
(self._dependencies_for_abdomen_model, "abdomen_model", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Beetle.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Beetle.py | 0.702632 | 0.330066 | Beetle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Camera(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
unknown_1: bool = dataclasses.field(default=False)
shot_duration: float = dataclasses.field(default=0.0)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: bool = dataclasses.field(default=False)
unknown_5: bool = dataclasses.field(default=False)
unknown_6: bool = dataclasses.field(default=False)
unknown_7: bool = dataclasses.field(default=False)
unknown_8: bool = dataclasses.field(default=False)
unknown_9: bool = dataclasses.field(default=False)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: bool = dataclasses.field(default=False)
unknown_12: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0xC
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
unknown_1 = struct.unpack('>?', data.read(1))[0]
shot_duration = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>?', data.read(1))[0]
unknown_5 = struct.unpack('>?', data.read(1))[0]
unknown_6 = struct.unpack('>?', data.read(1))[0]
unknown_7 = struct.unpack('>?', data.read(1))[0]
unknown_8 = struct.unpack('>?', data.read(1))[0]
unknown_9 = struct.unpack('>?', data.read(1))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>?', data.read(1))[0]
unknown_12 = struct.unpack('>?', data.read(1))[0]
return cls(name, position, rotation, unknown_1, shot_duration, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x0f') # 15 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>f', self.shot_duration))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>?', self.unknown_4))
data.write(struct.pack('>?', self.unknown_5))
data.write(struct.pack('>?', self.unknown_6))
data.write(struct.pack('>?', self.unknown_7))
data.write(struct.pack('>?', self.unknown_8))
data.write(struct.pack('>?', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>?', self.unknown_11))
data.write(struct.pack('>?', self.unknown_12))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
unknown_1=data['unknown_1'],
shot_duration=data['shot_duration'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=data['unknown_12'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'unknown_1': self.unknown_1,
'shot_duration': self.shot_duration,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Camera.py | 0.754915 | 0.356951 | Camera.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class JellyZap(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unnamed_0x00000006: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
unknown_10: float = dataclasses.field(default=0.0)
unknown_11: float = dataclasses.field(default=0.0)
unknown_12: float = dataclasses.field(default=0.0)
unknown_13: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x54
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unnamed_0x00000006 = DamageInfo.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
unknown_10 = struct.unpack('>f', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
unknown_12 = struct.unpack('>f', data.read(4))[0]
unknown_13 = struct.unpack('>?', data.read(1))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unnamed_0x00000006, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x14') # 20 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
self.unnamed_0x00000006.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack('>f', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
data.write(struct.pack('>f', self.unknown_12))
data.write(struct.pack('>?', self.unknown_13))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unnamed_0x00000006=DamageInfo.from_json(data['unnamed_0x00000006']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=data['unknown_12'],
unknown_13=data['unknown_13'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unnamed_0x00000006': self.unnamed_0x00000006.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12,
'unknown_13': self.unknown_13,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000006(self, asset_manager):
yield from self.unnamed_0x00000006.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_unnamed_0x00000006, "unnamed_0x00000006", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for JellyZap.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/JellyZap.py | 0.728362 | 0.328893 | JellyZap.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Geemer(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_9: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_10: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x70
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>l', data.read(4))[0]
unknown_9 = struct.unpack('>l', data.read(4))[0]
unknown_10 = struct.unpack('>l', data.read(4))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x10') # 16 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>l', self.unknown_8))
data.write(struct.pack('>l', self.unknown_9))
data.write(struct.pack('>l', self.unknown_10))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unknown_8(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_8)
def _dependencies_for_unknown_9(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_9)
def _dependencies_for_unknown_10(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_10)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_unknown_8, "unknown_8", "int"),
(self._dependencies_for_unknown_9, "unknown_9", "int"),
(self._dependencies_for_unknown_10, "unknown_10", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Geemer.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Geemer.py | 0.720073 | 0.351561 | Geemer.py | 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.prime as enums
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class SpacePirate(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
aggression_check: float = dataclasses.field(default=0.0)
cover_check: float = dataclasses.field(default=0.0)
search_radius: float = dataclasses.field(default=0.0)
fallback_check: float = dataclasses.field(default=0.0)
fallback_radius: float = dataclasses.field(default=0.0)
hearing_radius: float = dataclasses.field(default=0.0)
flags: enums.Flags = dataclasses.field(default=enums.Flags(0))
unknown_8: bool = dataclasses.field(default=False)
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})
blade_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
kneel_attack_chance: float = dataclasses.field(default=0.0)
kneel_attack_shot: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
kneel_attack_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
dodge_check: float = dataclasses.field(default=0.0)
sound_impact: int = dataclasses.field(default=0, metadata={'sound': True})
average_next_shot_time: float = dataclasses.field(default=0.0)
next_shot_time_variation: float = dataclasses.field(default=0.0)
sound_alert: int = dataclasses.field(default=0, metadata={'sound': True})
gun_track_delay: float = dataclasses.field(default=0.0)
first_burst_count: int = dataclasses.field(default=0)
cloak_opacity: float = dataclasses.field(default=0.0)
max_cloak_opacity: float = dataclasses.field(default=0.0)
dodge_delay_time_min: float = dataclasses.field(default=0.0)
dodge_delay_time_max: float = dataclasses.field(default=0.0)
sound_hurled: int = dataclasses.field(default=0, metadata={'sound': True})
sound_death: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_19: float = dataclasses.field(default=0.0)
avoid_distance: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x24
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
aggression_check = struct.unpack('>f', data.read(4))[0]
cover_check = struct.unpack('>f', data.read(4))[0]
search_radius = struct.unpack('>f', data.read(4))[0]
fallback_check = struct.unpack('>f', data.read(4))[0]
fallback_radius = struct.unpack('>f', data.read(4))[0]
hearing_radius = struct.unpack('>f', data.read(4))[0]
flags = enums.Flags.from_stream(data)
unknown_8 = struct.unpack('>?', data.read(1))[0]
projectile = struct.unpack(">L", data.read(4))[0]
projectile_damage = DamageInfo.from_stream(data, property_size)
sound_projectile = struct.unpack('>l', data.read(4))[0]
blade_damage = DamageInfo.from_stream(data, property_size)
kneel_attack_chance = struct.unpack('>f', data.read(4))[0]
kneel_attack_shot = struct.unpack(">L", data.read(4))[0]
kneel_attack_damage = DamageInfo.from_stream(data, property_size)
dodge_check = struct.unpack('>f', data.read(4))[0]
sound_impact = struct.unpack('>l', data.read(4))[0]
average_next_shot_time = struct.unpack('>f', data.read(4))[0]
next_shot_time_variation = struct.unpack('>f', data.read(4))[0]
sound_alert = struct.unpack('>l', data.read(4))[0]
gun_track_delay = struct.unpack('>f', data.read(4))[0]
first_burst_count = struct.unpack('>l', data.read(4))[0]
cloak_opacity = struct.unpack('>f', data.read(4))[0]
max_cloak_opacity = struct.unpack('>f', data.read(4))[0]
dodge_delay_time_min = struct.unpack('>f', data.read(4))[0]
dodge_delay_time_max = struct.unpack('>f', data.read(4))[0]
sound_hurled = struct.unpack('>l', data.read(4))[0]
sound_death = struct.unpack('>l', data.read(4))[0]
unknown_19 = struct.unpack('>f', data.read(4))[0]
avoid_distance = struct.unpack('>f', data.read(4))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, aggression_check, cover_check, search_radius, fallback_check, fallback_radius, hearing_radius, flags, unknown_8, projectile, projectile_damage, sound_projectile, blade_damage, kneel_attack_chance, kneel_attack_shot, kneel_attack_damage, dodge_check, sound_impact, average_next_shot_time, next_shot_time_variation, sound_alert, gun_track_delay, first_burst_count, cloak_opacity, max_cloak_opacity, dodge_delay_time_min, dodge_delay_time_max, sound_hurled, sound_death, unknown_19, avoid_distance)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00$') # 36 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>f', self.aggression_check))
data.write(struct.pack('>f', self.cover_check))
data.write(struct.pack('>f', self.search_radius))
data.write(struct.pack('>f', self.fallback_check))
data.write(struct.pack('>f', self.fallback_radius))
data.write(struct.pack('>f', self.hearing_radius))
self.flags.to_stream(data)
data.write(struct.pack('>?', self.unknown_8))
data.write(struct.pack(">L", self.projectile))
self.projectile_damage.to_stream(data)
data.write(struct.pack('>l', self.sound_projectile))
self.blade_damage.to_stream(data)
data.write(struct.pack('>f', self.kneel_attack_chance))
data.write(struct.pack(">L", self.kneel_attack_shot))
self.kneel_attack_damage.to_stream(data)
data.write(struct.pack('>f', self.dodge_check))
data.write(struct.pack('>l', self.sound_impact))
data.write(struct.pack('>f', self.average_next_shot_time))
data.write(struct.pack('>f', self.next_shot_time_variation))
data.write(struct.pack('>l', self.sound_alert))
data.write(struct.pack('>f', self.gun_track_delay))
data.write(struct.pack('>l', self.first_burst_count))
data.write(struct.pack('>f', self.cloak_opacity))
data.write(struct.pack('>f', self.max_cloak_opacity))
data.write(struct.pack('>f', self.dodge_delay_time_min))
data.write(struct.pack('>f', self.dodge_delay_time_max))
data.write(struct.pack('>l', self.sound_hurled))
data.write(struct.pack('>l', self.sound_death))
data.write(struct.pack('>f', self.unknown_19))
data.write(struct.pack('>f', self.avoid_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
aggression_check=data['aggression_check'],
cover_check=data['cover_check'],
search_radius=data['search_radius'],
fallback_check=data['fallback_check'],
fallback_radius=data['fallback_radius'],
hearing_radius=data['hearing_radius'],
flags=enums.Flags.from_json(data['flags']),
unknown_8=data['unknown_8'],
projectile=data['projectile'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
sound_projectile=data['sound_projectile'],
blade_damage=DamageInfo.from_json(data['blade_damage']),
kneel_attack_chance=data['kneel_attack_chance'],
kneel_attack_shot=data['kneel_attack_shot'],
kneel_attack_damage=DamageInfo.from_json(data['kneel_attack_damage']),
dodge_check=data['dodge_check'],
sound_impact=data['sound_impact'],
average_next_shot_time=data['average_next_shot_time'],
next_shot_time_variation=data['next_shot_time_variation'],
sound_alert=data['sound_alert'],
gun_track_delay=data['gun_track_delay'],
first_burst_count=data['first_burst_count'],
cloak_opacity=data['cloak_opacity'],
max_cloak_opacity=data['max_cloak_opacity'],
dodge_delay_time_min=data['dodge_delay_time_min'],
dodge_delay_time_max=data['dodge_delay_time_max'],
sound_hurled=data['sound_hurled'],
sound_death=data['sound_death'],
unknown_19=data['unknown_19'],
avoid_distance=data['avoid_distance'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'aggression_check': self.aggression_check,
'cover_check': self.cover_check,
'search_radius': self.search_radius,
'fallback_check': self.fallback_check,
'fallback_radius': self.fallback_radius,
'hearing_radius': self.hearing_radius,
'flags': self.flags.to_json(),
'unknown_8': self.unknown_8,
'projectile': self.projectile,
'projectile_damage': self.projectile_damage.to_json(),
'sound_projectile': self.sound_projectile,
'blade_damage': self.blade_damage.to_json(),
'kneel_attack_chance': self.kneel_attack_chance,
'kneel_attack_shot': self.kneel_attack_shot,
'kneel_attack_damage': self.kneel_attack_damage.to_json(),
'dodge_check': self.dodge_check,
'sound_impact': self.sound_impact,
'average_next_shot_time': self.average_next_shot_time,
'next_shot_time_variation': self.next_shot_time_variation,
'sound_alert': self.sound_alert,
'gun_track_delay': self.gun_track_delay,
'first_burst_count': self.first_burst_count,
'cloak_opacity': self.cloak_opacity,
'max_cloak_opacity': self.max_cloak_opacity,
'dodge_delay_time_min': self.dodge_delay_time_min,
'dodge_delay_time_max': self.dodge_delay_time_max,
'sound_hurled': self.sound_hurled,
'sound_death': self.sound_death,
'unknown_19': self.unknown_19,
'avoid_distance': self.avoid_distance,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.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_blade_damage(self, asset_manager):
yield from self.blade_damage.dependencies_for(asset_manager)
def _dependencies_for_kneel_attack_shot(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.kneel_attack_shot)
def _dependencies_for_kneel_attack_damage(self, asset_manager):
yield from self.kneel_attack_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_alert(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_alert)
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_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "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_blade_damage, "blade_damage", "DamageInfo"),
(self._dependencies_for_kneel_attack_shot, "kneel_attack_shot", "AssetId"),
(self._dependencies_for_kneel_attack_damage, "kneel_attack_damage", "DamageInfo"),
(self._dependencies_for_sound_impact, "sound_impact", "int"),
(self._dependencies_for_sound_alert, "sound_alert", "int"),
(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 SpacePirate.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/SpacePirate.py | 0.704262 | 0.272781 | SpacePirate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class DebugCameraWaypoint(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
unknown_1: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x32
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
unknown_1 = struct.unpack('>l', data.read(4))[0]
return cls(name, position, rotation, unknown_1)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x04') # 4 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>l', self.unknown_1))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
unknown_1=data['unknown_1'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'unknown_1': self.unknown_1,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/DebugCameraWaypoint.py | 0.775265 | 0.41834 | DebugCameraWaypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
@dataclasses.dataclass()
class RandomRelay(BaseObjectType):
name: str = dataclasses.field(default='')
connection_count: int = dataclasses.field(default=0)
variance: int = dataclasses.field(default=0)
unknown: bool = dataclasses.field(default=False)
active: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x14
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
connection_count = struct.unpack('>l', data.read(4))[0]
variance = struct.unpack('>l', data.read(4))[0]
unknown = struct.unpack('>?', data.read(1))[0]
active = struct.unpack('>?', data.read(1))[0]
return cls(name, connection_count, variance, unknown, active)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x05') # 5 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>l', self.connection_count))
data.write(struct.pack('>l', self.variance))
data.write(struct.pack('>?', self.unknown))
data.write(struct.pack('>?', self.active))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
connection_count=data['connection_count'],
variance=data['variance'],
unknown=data['unknown'],
active=data['active'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'connection_count': self.connection_count,
'variance': self.variance,
'unknown': self.unknown,
'active': self.active,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/RandomRelay.py | 0.740925 | 0.271424 | RandomRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Midi(BaseObjectType):
name: str = dataclasses.field(default='')
unknown_1: bool = dataclasses.field(default=False)
csng: AssetId = dataclasses.field(metadata={'asset_types': ['CSNG']}, default=default_asset_id)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x60
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_1 = struct.unpack('>?', data.read(1))[0]
csng = struct.unpack(">L", data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>l', data.read(4))[0]
return cls(name, unknown_1, csng, unknown_2, unknown_3, unknown_4)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x06') # 6 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack(">L", self.csng))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>l', self.unknown_4))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
unknown_1=data['unknown_1'],
csng=data['csng'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'unknown_1': self.unknown_1,
'csng': self.csng,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
}
def _dependencies_for_csng(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.csng)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_csng, "csng", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Midi.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Midi.py | 0.668447 | 0.234418 | Midi.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class NewIntroBoss(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown: float = dataclasses.field(default=0.0)
wpsc_1: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
unnamed_0x00000008: DamageInfo = dataclasses.field(default_factory=DamageInfo)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
texture_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture_2: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0xE
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unknown = struct.unpack('>f', data.read(4))[0]
wpsc_1 = struct.unpack(">L", data.read(4))[0]
unnamed_0x00000008 = DamageInfo.from_stream(data, property_size)
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
texture_1 = struct.unpack(">L", data.read(4))[0]
texture_2 = struct.unpack(">L", data.read(4))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unknown, wpsc_1, unnamed_0x00000008, particle_1, particle_2, texture_1, texture_2)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\r') # 13 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>f', self.unknown))
data.write(struct.pack(">L", self.wpsc_1))
self.unnamed_0x00000008.to_stream(data)
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.texture_1))
data.write(struct.pack(">L", self.texture_2))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unknown=data['unknown'],
wpsc_1=data['wpsc_1'],
unnamed_0x00000008=DamageInfo.from_json(data['unnamed_0x00000008']),
particle_1=data['particle_1'],
particle_2=data['particle_2'],
texture_1=data['texture_1'],
texture_2=data['texture_2'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unknown': self.unknown,
'wpsc_1': self.wpsc_1,
'unnamed_0x00000008': self.unnamed_0x00000008.to_json(),
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'texture_1': self.texture_1,
'texture_2': self.texture_2,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_wpsc_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc_1)
def _dependencies_for_unnamed_0x00000008(self, asset_manager):
yield from self.unnamed_0x00000008.dependencies_for(asset_manager)
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_texture_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_1)
def _dependencies_for_texture_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_2)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_wpsc_1, "wpsc_1", "AssetId"),
(self._dependencies_for_unnamed_0x00000008, "unnamed_0x00000008", "DamageInfo"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_texture_1, "texture_1", "AssetId"),
(self._dependencies_for_texture_2, "texture_2", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for NewIntroBoss.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/NewIntroBoss.py | 0.709824 | 0.317426 | NewIntroBoss.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class PhazonHealingNodule(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unused: bool = dataclasses.field(default=False)
elsc: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
target_locator: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x88
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unused = struct.unpack('>?', data.read(1))[0]
elsc = struct.unpack(">L", data.read(4))[0]
target_locator = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unused, elsc, target_locator)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\t') # 9 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>?', self.unused))
data.write(struct.pack(">L", self.elsc))
data.write(self.target_locator.encode("utf-8"))
data.write(b'\x00')
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unused=data['unused'],
elsc=data['elsc'],
target_locator=data['target_locator'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unused': self.unused,
'elsc': self.elsc,
'target_locator': self.target_locator,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_elsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.elsc)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_elsc, "elsc", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PhazonHealingNodule.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/PhazonHealingNodule.py | 0.688992 | 0.326486 | PhazonHealingNodule.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class MetroidBeta(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
damage_vulnerability_1: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
damage_vulnerability_2: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: float = dataclasses.field(default=0.0)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
swhc: AssetId = dataclasses.field(metadata={'asset_types': ['SWHC']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_3: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_4: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_10: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x27
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
damage_vulnerability_1 = DamageVulnerability.from_stream(data, property_size)
damage_vulnerability_2 = DamageVulnerability.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>f', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
swhc = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
particle_3 = struct.unpack(">L", data.read(4))[0]
particle_4 = struct.unpack(">L", data.read(4))[0]
unknown_10 = struct.unpack('>?', data.read(1))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, damage_vulnerability_1, damage_vulnerability_2, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, particle_1, swhc, particle_2, particle_3, particle_4, unknown_10)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x17') # 23 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
self.damage_vulnerability_1.to_stream(data)
self.damage_vulnerability_2.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>f', self.unknown_9))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.swhc))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.particle_3))
data.write(struct.pack(">L", self.particle_4))
data.write(struct.pack('>?', self.unknown_10))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
damage_vulnerability_1=DamageVulnerability.from_json(data['damage_vulnerability_1']),
damage_vulnerability_2=DamageVulnerability.from_json(data['damage_vulnerability_2']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
particle_1=data['particle_1'],
swhc=data['swhc'],
particle_2=data['particle_2'],
particle_3=data['particle_3'],
particle_4=data['particle_4'],
unknown_10=data['unknown_10'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'damage_vulnerability_1': self.damage_vulnerability_1.to_json(),
'damage_vulnerability_2': self.damage_vulnerability_2.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'particle_1': self.particle_1,
'swhc': self.swhc,
'particle_2': self.particle_2,
'particle_3': self.particle_3,
'particle_4': self.particle_4,
'unknown_10': self.unknown_10,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_damage_vulnerability_1(self, asset_manager):
yield from self.damage_vulnerability_1.dependencies_for(asset_manager)
def _dependencies_for_damage_vulnerability_2(self, asset_manager):
yield from self.damage_vulnerability_2.dependencies_for(asset_manager)
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_swhc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.swhc)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_particle_3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_3)
def _dependencies_for_particle_4(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_4)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_damage_vulnerability_1, "damage_vulnerability_1", "DamageVulnerability"),
(self._dependencies_for_damage_vulnerability_2, "damage_vulnerability_2", "DamageVulnerability"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_swhc, "swhc", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_particle_3, "particle_3", "AssetId"),
(self._dependencies_for_particle_4, "particle_4", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MetroidBeta.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/MetroidBeta.py | 0.68342 | 0.283684 | MetroidBeta.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class FishCloudModifier(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x50
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
unknown_3 = struct.unpack('>?', data.read(1))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
return cls(name, position, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x07') # 7 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/FishCloudModifier.py | 0.743168 | 0.361785 | FishCloudModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class ActorRotate(BaseObjectType):
name: str = dataclasses.field(default='')
rotation_offset: Vector = dataclasses.field(default_factory=Vector)
time_scale_: float = dataclasses.field(default=0.0)
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
active: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x39
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
rotation_offset = Vector.from_stream(data)
time_scale_ = struct.unpack('>f', data.read(4))[0]
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>?', data.read(1))[0]
active = struct.unpack('>?', data.read(1))[0]
return cls(name, rotation_offset, time_scale_, unknown_1, unknown_2, active)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x06') # 6 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.rotation_offset.to_stream(data)
data.write(struct.pack('>f', self.time_scale_))
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>?', self.unknown_2))
data.write(struct.pack('>?', self.active))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
rotation_offset=Vector.from_json(data['rotation_offset']),
time_scale_=data['time_scale_'],
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
active=data['active'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'rotation_offset': self.rotation_offset.to_json(),
'time_scale_': self.time_scale_,
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'active': self.active,
}
def dependencies_for(self, asset_manager):
yield from [] | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/ActorRotate.py | 0.770033 | 0.374848 | ActorRotate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class IceZoomer(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000004: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_1: float = dataclasses.field(default=0.0)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: int = dataclasses.field(default=0)
unknown_8: int = dataclasses.field(default=0)
unnamed_0x0000000e: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_9: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x78
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000004 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unknown_1 = struct.unpack('>f', data.read(4))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>l', data.read(4))[0]
unknown_8 = struct.unpack('>l', data.read(4))[0]
unnamed_0x0000000e = DamageVulnerability.from_stream(data, property_size)
unknown_9 = struct.unpack('>f', data.read(4))[0]
return cls(name, position, rotation, scale, unnamed_0x00000004, unnamed_0x00000005, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, unnamed_0x0000000e, unknown_9)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x10') # 16 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000004.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>f', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>l', self.unknown_7))
data.write(struct.pack('>l', self.unknown_8))
self.unnamed_0x0000000e.to_stream(data)
data.write(struct.pack('>f', self.unknown_9))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000004=PatternedAITypedef.from_json(data['unnamed_0x00000004']),
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unnamed_0x0000000e=DamageVulnerability.from_json(data['unnamed_0x0000000e']),
unknown_9=data['unknown_9'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000004': self.unnamed_0x00000004.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unnamed_0x0000000e': self.unnamed_0x0000000e.to_json(),
'unknown_9': self.unknown_9,
}
def _dependencies_for_unnamed_0x00000004(self, asset_manager):
yield from self.unnamed_0x00000004.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x0000000e(self, asset_manager):
yield from self.unnamed_0x0000000e.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000004, "unnamed_0x00000004", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_unnamed_0x0000000e, "unnamed_0x0000000e", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IceZoomer.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/IceZoomer.py | 0.749087 | 0.363336 | IceZoomer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.prime.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.prime.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class WallCrawlerSwarm(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
active: bool = dataclasses.field(default=False)
unnamed_0x00000005: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_1: int = dataclasses.field(default=0)
animation_parameters: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_2: int = dataclasses.field(default=0)
unknown_3: int = dataclasses.field(default=0)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
always_ffffffff_1: int = dataclasses.field(default=0)
always_ffffffff_2: int = dataclasses.field(default=0)
damage_info_1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_4: float = dataclasses.field(default=0.0)
damage_info_2: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
unknown_9: int = dataclasses.field(default=0)
unknown_10: int = dataclasses.field(default=0)
unknown_11: float = dataclasses.field(default=0.0)
unknown_12: float = dataclasses.field(default=0.0)
unknown_13: float = dataclasses.field(default=0.0)
unknown_14: float = dataclasses.field(default=0.0)
unknown_15: float = dataclasses.field(default=0.0)
unknown_16: float = dataclasses.field(default=0.0)
unknown_17: float = dataclasses.field(default=0.0)
unknown_18: float = dataclasses.field(default=0.0)
unknown_19: int = dataclasses.field(default=0)
unknown_20: float = dataclasses.field(default=0.0)
unknown_21: float = dataclasses.field(default=0.0)
unknown_22: float = dataclasses.field(default=0.0)
unnamed_0x00000023: HealthInfo = dataclasses.field(default_factory=HealthInfo)
unnamed_0x00000024: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
sound_1: int = dataclasses.field(default=0, metadata={'sound': True})
sound_2: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x5A
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
active = struct.unpack('>?', data.read(1))[0]
unnamed_0x00000005 = ActorParameters.from_stream(data, property_size)
unknown_1 = struct.unpack('>l', data.read(4))[0]
animation_parameters = AnimationParameters.from_stream(data, property_size)
unknown_2 = struct.unpack('>l', data.read(4))[0]
unknown_3 = struct.unpack('>l', data.read(4))[0]
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
always_ffffffff_1 = struct.unpack('>l', data.read(4))[0]
always_ffffffff_2 = struct.unpack('>l', data.read(4))[0]
damage_info_1 = DamageInfo.from_stream(data, property_size)
unknown_4 = struct.unpack('>f', data.read(4))[0]
damage_info_2 = DamageInfo.from_stream(data, property_size)
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
unknown_9 = struct.unpack('>l', data.read(4))[0]
unknown_10 = struct.unpack('>l', data.read(4))[0]
unknown_11 = struct.unpack('>f', data.read(4))[0]
unknown_12 = struct.unpack('>f', data.read(4))[0]
unknown_13 = struct.unpack('>f', data.read(4))[0]
unknown_14 = struct.unpack('>f', data.read(4))[0]
unknown_15 = struct.unpack('>f', data.read(4))[0]
unknown_16 = struct.unpack('>f', data.read(4))[0]
unknown_17 = struct.unpack('>f', data.read(4))[0]
unknown_18 = struct.unpack('>f', data.read(4))[0]
unknown_19 = struct.unpack('>l', data.read(4))[0]
unknown_20 = struct.unpack('>f', data.read(4))[0]
unknown_21 = struct.unpack('>f', data.read(4))[0]
unknown_22 = struct.unpack('>f', data.read(4))[0]
unnamed_0x00000023 = HealthInfo.from_stream(data, property_size)
unnamed_0x00000024 = DamageVulnerability.from_stream(data, property_size)
sound_1 = struct.unpack('>l', data.read(4))[0]
sound_2 = struct.unpack('>l', data.read(4))[0]
return cls(name, position, rotation, scale, active, unnamed_0x00000005, unknown_1, animation_parameters, unknown_2, unknown_3, particle_1, particle_2, always_ffffffff_1, always_ffffffff_2, damage_info_1, unknown_4, damage_info_2, unknown_5, unknown_6, unknown_7, unknown_8, unknown_9, unknown_10, unknown_11, unknown_12, unknown_13, unknown_14, unknown_15, unknown_16, unknown_17, unknown_18, unknown_19, unknown_20, unknown_21, unknown_22, unnamed_0x00000023, unnamed_0x00000024, sound_1, sound_2)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b"\x00\x00\x00'") # 39 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
data.write(struct.pack('>?', self.active))
self.unnamed_0x00000005.to_stream(data)
data.write(struct.pack('>l', self.unknown_1))
self.animation_parameters.to_stream(data)
data.write(struct.pack('>l', self.unknown_2))
data.write(struct.pack('>l', self.unknown_3))
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack('>l', self.always_ffffffff_1))
data.write(struct.pack('>l', self.always_ffffffff_2))
self.damage_info_1.to_stream(data)
data.write(struct.pack('>f', self.unknown_4))
self.damage_info_2.to_stream(data)
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack('>l', self.unknown_9))
data.write(struct.pack('>l', self.unknown_10))
data.write(struct.pack('>f', self.unknown_11))
data.write(struct.pack('>f', self.unknown_12))
data.write(struct.pack('>f', self.unknown_13))
data.write(struct.pack('>f', self.unknown_14))
data.write(struct.pack('>f', self.unknown_15))
data.write(struct.pack('>f', self.unknown_16))
data.write(struct.pack('>f', self.unknown_17))
data.write(struct.pack('>f', self.unknown_18))
data.write(struct.pack('>l', self.unknown_19))
data.write(struct.pack('>f', self.unknown_20))
data.write(struct.pack('>f', self.unknown_21))
data.write(struct.pack('>f', self.unknown_22))
self.unnamed_0x00000023.to_stream(data)
self.unnamed_0x00000024.to_stream(data)
data.write(struct.pack('>l', self.sound_1))
data.write(struct.pack('>l', self.sound_2))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
active=data['active'],
unnamed_0x00000005=ActorParameters.from_json(data['unnamed_0x00000005']),
unknown_1=data['unknown_1'],
animation_parameters=AnimationParameters.from_json(data['animation_parameters']),
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
particle_1=data['particle_1'],
particle_2=data['particle_2'],
always_ffffffff_1=data['always_ffffffff_1'],
always_ffffffff_2=data['always_ffffffff_2'],
damage_info_1=DamageInfo.from_json(data['damage_info_1']),
unknown_4=data['unknown_4'],
damage_info_2=DamageInfo.from_json(data['damage_info_2']),
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
unknown_9=data['unknown_9'],
unknown_10=data['unknown_10'],
unknown_11=data['unknown_11'],
unknown_12=data['unknown_12'],
unknown_13=data['unknown_13'],
unknown_14=data['unknown_14'],
unknown_15=data['unknown_15'],
unknown_16=data['unknown_16'],
unknown_17=data['unknown_17'],
unknown_18=data['unknown_18'],
unknown_19=data['unknown_19'],
unknown_20=data['unknown_20'],
unknown_21=data['unknown_21'],
unknown_22=data['unknown_22'],
unnamed_0x00000023=HealthInfo.from_json(data['unnamed_0x00000023']),
unnamed_0x00000024=DamageVulnerability.from_json(data['unnamed_0x00000024']),
sound_1=data['sound_1'],
sound_2=data['sound_2'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'active': self.active,
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unknown_1': self.unknown_1,
'animation_parameters': self.animation_parameters.to_json(),
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'always_ffffffff_1': self.always_ffffffff_1,
'always_ffffffff_2': self.always_ffffffff_2,
'damage_info_1': self.damage_info_1.to_json(),
'unknown_4': self.unknown_4,
'damage_info_2': self.damage_info_2.to_json(),
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'unknown_9': self.unknown_9,
'unknown_10': self.unknown_10,
'unknown_11': self.unknown_11,
'unknown_12': self.unknown_12,
'unknown_13': self.unknown_13,
'unknown_14': self.unknown_14,
'unknown_15': self.unknown_15,
'unknown_16': self.unknown_16,
'unknown_17': self.unknown_17,
'unknown_18': self.unknown_18,
'unknown_19': self.unknown_19,
'unknown_20': self.unknown_20,
'unknown_21': self.unknown_21,
'unknown_22': self.unknown_22,
'unnamed_0x00000023': self.unnamed_0x00000023.to_json(),
'unnamed_0x00000024': self.unnamed_0x00000024.to_json(),
'sound_1': self.sound_1,
'sound_2': self.sound_2,
}
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_animation_parameters(self, asset_manager):
yield from self.animation_parameters.dependencies_for(asset_manager)
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_damage_info_1(self, asset_manager):
yield from self.damage_info_1.dependencies_for(asset_manager)
def _dependencies_for_damage_info_2(self, asset_manager):
yield from self.damage_info_2.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000023(self, asset_manager):
yield from self.unnamed_0x00000023.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000024(self, asset_manager):
yield from self.unnamed_0x00000024.dependencies_for(asset_manager)
def _dependencies_for_sound_1(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_1)
def _dependencies_for_sound_2(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_2)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "ActorParameters"),
(self._dependencies_for_animation_parameters, "animation_parameters", "AnimationParameters"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_damage_info_1, "damage_info_1", "DamageInfo"),
(self._dependencies_for_damage_info_2, "damage_info_2", "DamageInfo"),
(self._dependencies_for_unnamed_0x00000023, "unnamed_0x00000023", "HealthInfo"),
(self._dependencies_for_unnamed_0x00000024, "unnamed_0x00000024", "DamageVulnerability"),
(self._dependencies_for_sound_1, "sound_1", "int"),
(self._dependencies_for_sound_2, "sound_2", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for WallCrawlerSwarm.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/WallCrawlerSwarm.py | 0.714429 | 0.273008 | WallCrawlerSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class ElectroMagneticPulse(BaseObjectType):
name: str = dataclasses.field(default='')
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
unknown_1: bool = dataclasses.field(default=False)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
unknown_4: float = dataclasses.field(default=0.0)
unknown_5: float = dataclasses.field(default=0.0)
unknown_6: float = dataclasses.field(default=0.0)
unknown_7: float = dataclasses.field(default=0.0)
unknown_8: float = dataclasses.field(default=0.0)
particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x4A
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
unknown_1 = struct.unpack('>?', data.read(1))[0]
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
unknown_4 = struct.unpack('>f', data.read(4))[0]
unknown_5 = struct.unpack('>f', data.read(4))[0]
unknown_6 = struct.unpack('>f', data.read(4))[0]
unknown_7 = struct.unpack('>f', data.read(4))[0]
unknown_8 = struct.unpack('>f', data.read(4))[0]
particle = struct.unpack(">L", data.read(4))[0]
return cls(name, position, rotation, unknown_1, unknown_2, unknown_3, unknown_4, unknown_5, unknown_6, unknown_7, unknown_8, particle)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x0c') # 12 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
self.position.to_stream(data)
self.rotation.to_stream(data)
data.write(struct.pack('>?', self.unknown_1))
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack('>f', self.unknown_4))
data.write(struct.pack('>f', self.unknown_5))
data.write(struct.pack('>f', self.unknown_6))
data.write(struct.pack('>f', self.unknown_7))
data.write(struct.pack('>f', self.unknown_8))
data.write(struct.pack(">L", self.particle))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
unknown_4=data['unknown_4'],
unknown_5=data['unknown_5'],
unknown_6=data['unknown_6'],
unknown_7=data['unknown_7'],
unknown_8=data['unknown_8'],
particle=data['particle'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'unknown_4': self.unknown_4,
'unknown_5': self.unknown_5,
'unknown_6': self.unknown_6,
'unknown_7': self.unknown_7,
'unknown_8': self.unknown_8,
'particle': self.particle,
}
def _dependencies_for_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_particle, "particle", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ElectroMagneticPulse.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/ElectroMagneticPulse.py | 0.737158 | 0.328435 | ElectroMagneticPulse.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.prime.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.prime.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.prime.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.prime.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime.core.Vector import Vector
@dataclasses.dataclass()
class Eyeball(BaseObjectType):
name: str = dataclasses.field(default='')
unknown_1: int = dataclasses.field(default=0)
position: Vector = dataclasses.field(default_factory=Vector)
rotation: Vector = dataclasses.field(default_factory=Vector)
scale: Vector = dataclasses.field(default_factory=Vector)
unnamed_0x00000005: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unnamed_0x00000006: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_2: float = dataclasses.field(default=0.0)
unknown_3: float = dataclasses.field(default=0.0)
wpsc: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
unnamed_0x0000000a: DamageInfo = dataclasses.field(default_factory=DamageInfo)
particle_1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
texture_1: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture_2: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_4: int = dataclasses.field(default=0)
always_ffffffff_1: int = dataclasses.field(default=0)
always_ffffffff_2: int = dataclasses.field(default=0)
always_ffffffff_3: int = dataclasses.field(default=0)
laser_sound: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_6: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME
def get_name(self) -> typing.Optional[str]:
return self.name
def set_name(self, name: str) -> None:
self.name = name
@classmethod
def object_type(cls) -> int:
return 0x67
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_size = None # Atomic
property_count = struct.unpack(">L", data.read(4))[0]
name = b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
unknown_1 = struct.unpack('>l', data.read(4))[0]
position = Vector.from_stream(data)
rotation = Vector.from_stream(data)
scale = Vector.from_stream(data)
unnamed_0x00000005 = PatternedAITypedef.from_stream(data, property_size)
unnamed_0x00000006 = ActorParameters.from_stream(data, property_size)
unknown_2 = struct.unpack('>f', data.read(4))[0]
unknown_3 = struct.unpack('>f', data.read(4))[0]
wpsc = struct.unpack(">L", data.read(4))[0]
unnamed_0x0000000a = DamageInfo.from_stream(data, property_size)
particle_1 = struct.unpack(">L", data.read(4))[0]
particle_2 = struct.unpack(">L", data.read(4))[0]
texture_1 = struct.unpack(">L", data.read(4))[0]
texture_2 = struct.unpack(">L", data.read(4))[0]
unknown_4 = struct.unpack('>l', data.read(4))[0]
always_ffffffff_1 = struct.unpack('>l', data.read(4))[0]
always_ffffffff_2 = struct.unpack('>l', data.read(4))[0]
always_ffffffff_3 = struct.unpack('>l', data.read(4))[0]
laser_sound = struct.unpack('>l', data.read(4))[0]
unknown_6 = struct.unpack('>?', data.read(1))[0]
return cls(name, unknown_1, position, rotation, scale, unnamed_0x00000005, unnamed_0x00000006, unknown_2, unknown_3, wpsc, unnamed_0x0000000a, particle_1, particle_2, texture_1, texture_2, unknown_4, always_ffffffff_1, always_ffffffff_2, always_ffffffff_3, laser_sound, unknown_6)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x00\x00\x15') # 21 properties
data.write(self.name.encode("utf-8"))
data.write(b'\x00')
data.write(struct.pack('>l', self.unknown_1))
self.position.to_stream(data)
self.rotation.to_stream(data)
self.scale.to_stream(data)
self.unnamed_0x00000005.to_stream(data)
self.unnamed_0x00000006.to_stream(data)
data.write(struct.pack('>f', self.unknown_2))
data.write(struct.pack('>f', self.unknown_3))
data.write(struct.pack(">L", self.wpsc))
self.unnamed_0x0000000a.to_stream(data)
data.write(struct.pack(">L", self.particle_1))
data.write(struct.pack(">L", self.particle_2))
data.write(struct.pack(">L", self.texture_1))
data.write(struct.pack(">L", self.texture_2))
data.write(struct.pack('>l', self.unknown_4))
data.write(struct.pack('>l', self.always_ffffffff_1))
data.write(struct.pack('>l', self.always_ffffffff_2))
data.write(struct.pack('>l', self.always_ffffffff_3))
data.write(struct.pack('>l', self.laser_sound))
data.write(struct.pack('>?', self.unknown_6))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
unknown_1=data['unknown_1'],
position=Vector.from_json(data['position']),
rotation=Vector.from_json(data['rotation']),
scale=Vector.from_json(data['scale']),
unnamed_0x00000005=PatternedAITypedef.from_json(data['unnamed_0x00000005']),
unnamed_0x00000006=ActorParameters.from_json(data['unnamed_0x00000006']),
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
wpsc=data['wpsc'],
unnamed_0x0000000a=DamageInfo.from_json(data['unnamed_0x0000000a']),
particle_1=data['particle_1'],
particle_2=data['particle_2'],
texture_1=data['texture_1'],
texture_2=data['texture_2'],
unknown_4=data['unknown_4'],
always_ffffffff_1=data['always_ffffffff_1'],
always_ffffffff_2=data['always_ffffffff_2'],
always_ffffffff_3=data['always_ffffffff_3'],
laser_sound=data['laser_sound'],
unknown_6=data['unknown_6'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'unknown_1': self.unknown_1,
'position': self.position.to_json(),
'rotation': self.rotation.to_json(),
'scale': self.scale.to_json(),
'unnamed_0x00000005': self.unnamed_0x00000005.to_json(),
'unnamed_0x00000006': self.unnamed_0x00000006.to_json(),
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'wpsc': self.wpsc,
'unnamed_0x0000000a': self.unnamed_0x0000000a.to_json(),
'particle_1': self.particle_1,
'particle_2': self.particle_2,
'texture_1': self.texture_1,
'texture_2': self.texture_2,
'unknown_4': self.unknown_4,
'always_ffffffff_1': self.always_ffffffff_1,
'always_ffffffff_2': self.always_ffffffff_2,
'always_ffffffff_3': self.always_ffffffff_3,
'laser_sound': self.laser_sound,
'unknown_6': self.unknown_6,
}
def _dependencies_for_unnamed_0x00000005(self, asset_manager):
yield from self.unnamed_0x00000005.dependencies_for(asset_manager)
def _dependencies_for_unnamed_0x00000006(self, asset_manager):
yield from self.unnamed_0x00000006.dependencies_for(asset_manager)
def _dependencies_for_wpsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc)
def _dependencies_for_unnamed_0x0000000a(self, asset_manager):
yield from self.unnamed_0x0000000a.dependencies_for(asset_manager)
def _dependencies_for_particle_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_1)
def _dependencies_for_particle_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle_2)
def _dependencies_for_texture_1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_1)
def _dependencies_for_texture_2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture_2)
def _dependencies_for_laser_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.laser_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unnamed_0x00000005, "unnamed_0x00000005", "PatternedAITypedef"),
(self._dependencies_for_unnamed_0x00000006, "unnamed_0x00000006", "ActorParameters"),
(self._dependencies_for_wpsc, "wpsc", "AssetId"),
(self._dependencies_for_unnamed_0x0000000a, "unnamed_0x0000000a", "DamageInfo"),
(self._dependencies_for_particle_1, "particle_1", "AssetId"),
(self._dependencies_for_particle_2, "particle_2", "AssetId"),
(self._dependencies_for_texture_1, "texture_1", "AssetId"),
(self._dependencies_for_texture_2, "texture_2", "AssetId"),
(self._dependencies_for_laser_sound, "laser_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Eyeball.{field_name} ({field_type}): {e}"
) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime/objects/Eyeball.py | 0.68215 | 0.320622 | Eyeball.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.