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 FlyingPirateMP1(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[FlyingPirateMP1]:
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 FlyingPirateMP1(
)
_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/FlyingPirateMP1.py | 0.60288 | 0.261354 | FlyingPirateMP1.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 UIMenu(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[UIMenu]:
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 UIMenu(
)
_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/UIMenu.py | 0.603698 | 0.253653 | UIMenu.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 Credits(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[Credits]:
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 Credits(
)
_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/Credits.py | 0.607081 | 0.262765 | Credits.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 LogicGate(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[LogicGate]:
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 LogicGate(
)
_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/LogicGate.py | 0.60743 | 0.265743 | LogicGate.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 FishCloudMP1(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[FishCloudMP1]:
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 FishCloudMP1(
)
_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/FishCloudMP1.py | 0.602296 | 0.26019 | FishCloudMP1.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 RhythmMatcher(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[RhythmMatcher]:
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 RhythmMatcher(
)
_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/RhythmMatcher.py | 0.633524 | 0.271152 | RhythmMatcher.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 CinematicMP1(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[CinematicMP1]:
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 CinematicMP1(
)
_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/CinematicMP1.py | 0.604749 | 0.261667 | CinematicMP1.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 UIButton(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[UIButton]:
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 UIButton(
)
_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/UIButton.py | 0.605799 | 0.254497 | UIButton.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 SnakeWeedSwarmMP1(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[SnakeWeedSwarmMP1]:
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 SnakeWeedSwarmMP1(
)
_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/SnakeWeedSwarmMP1.py | 0.620162 | 0.265511 | SnakeWeedSwarmMP1.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 ScriptedJumpData(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[ScriptedJumpData]:
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 ScriptedJumpData(
)
_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/ScriptedJumpData.py | 0.601242 | 0.278248 | ScriptedJumpData.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 Beam(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[Beam]:
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 Beam(
)
_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/Beam.py | 0.608129 | 0.270149 | Beam.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 BloomEffect(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[BloomEffect]:
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 BloomEffect(
)
_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/BloomEffect.py | 0.618435 | 0.265476 | BloomEffect.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 GameFlowHub(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[GameFlowHub]:
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 GameFlowHub(
)
_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/GameFlowHub.py | 0.607081 | 0.274333 | GameFlowHub.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 GlobalStateMonitor(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[GlobalStateMonitor]:
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 GlobalStateMonitor(
)
_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/GlobalStateMonitor.py | 0.606032 | 0.260554 | GlobalStateMonitor.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 CreatureCoverCombatBehavior(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[CreatureCoverCombatBehavior]:
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 CreatureCoverCombatBehavior(
)
_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/CreatureCoverCombatBehavior.py | 0.619241 | 0.251085 | CreatureCoverCombatBehavior.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 AnimationVariableReal(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[AnimationVariableReal]:
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 AnimationVariableReal(
)
_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/AnimationVariableReal.py | 0.613931 | 0.25839 | AnimationVariableReal.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 MIDIRetronome(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[MIDIRetronome]:
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 MIDIRetronome(
)
_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/MIDIRetronome.py | 0.604049 | 0.255274 | MIDIRetronome.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 CameraTargetPlayer(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[CameraTargetPlayer]:
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 CameraTargetPlayer(
)
_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/CameraTargetPlayer.py | 0.641198 | 0.258121 | CameraTargetPlayer.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 AtomicAlphaMP1(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[AtomicAlphaMP1]:
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 AtomicAlphaMP1(
)
_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/AtomicAlphaMP1.py | 0.632162 | 0.263582 | AtomicAlphaMP1.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 FishCloudModifierMP1(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[FishCloudModifierMP1]:
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 FishCloudModifierMP1(
)
_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/FishCloudModifierMP1.py | 0.604165 | 0.251889 | FishCloudModifierMP1.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 FakePlayerControls(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[FakePlayerControls]:
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 FakePlayerControls(
)
_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/FakePlayerControls.py | 0.59972 | 0.24504 | FakePlayerControls.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 CreatureProjectileLauncher(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[CreatureProjectileLauncher]:
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 CreatureProjectileLauncher(
)
_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/CreatureProjectileLauncher.py | 0.601359 | 0.258706 | CreatureProjectileLauncher.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 DynamicLoadManager(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[DynamicLoadManager]:
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 DynamicLoadManager(
)
_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/DynamicLoadManager.py | 0.623377 | 0.257077 | DynamicLoadManager.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 ActionControlPoint(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[ActionControlPoint]:
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 ActionControlPoint(
)
_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/ActionControlPoint.py | 0.612078 | 0.261791 | ActionControlPoint.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 SplineMotionPhaseResponder(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[SplineMotionPhaseResponder]:
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 SplineMotionPhaseResponder(
)
_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/SplineMotionPhaseResponder.py | 0.608943 | 0.252073 | SplineMotionPhaseResponder.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 SplineMotion(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[SplineMotion]:
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 SplineMotion(
)
_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/SplineMotion.py | 0.610105 | 0.258379 | SplineMotion.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 TriggerForce(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[TriggerForce]:
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 TriggerForce(
)
_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/TriggerForce.py | 0.608943 | 0.251993 | TriggerForce.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 RumbleEmitter(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[RumbleEmitter]:
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 RumbleEmitter(
)
_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/RumbleEmitter.py | 0.609757 | 0.264887 | RumbleEmitter.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 ColorSampler(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[ColorSampler]:
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 ColorSampler(
)
_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/ColorSampler.py | 0.653348 | 0.26341 | ColorSampler.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 RoomController(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[RoomController]:
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 RoomController(
)
_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/RoomController.py | 0.605799 | 0.251728 | RoomController.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 AiJumpPointMP1(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[AiJumpPointMP1]:
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 AiJumpPointMP1(
)
_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/AiJumpPointMP1.py | 0.600657 | 0.276192 | AiJumpPointMP1.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 Skybox(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[Skybox]:
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 Skybox(
)
_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/Skybox.py | 0.622918 | 0.264216 | Skybox.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 SettingsMenuManager(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[SettingsMenuManager]:
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 SettingsMenuManager(
)
_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/SettingsMenuManager.py | 0.578091 | 0.242049 | SettingsMenuManager.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 CreatureSecondaryActions(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[CreatureSecondaryActions]:
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 CreatureSecondaryActions(
)
_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/CreatureSecondaryActions.py | 0.604282 | 0.259532 | CreatureSecondaryActions.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 SpawnPointMP1(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[SpawnPointMP1]:
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 SpawnPointMP1(
)
_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/SpawnPointMP1.py | 0.601594 | 0.27005 | SpawnPointMP1.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 EnvironmentVarQuery(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[EnvironmentVarQuery]:
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 EnvironmentVarQuery(
)
_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/EnvironmentVarQuery.py | 0.609524 | 0.258736 | EnvironmentVarQuery.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 PlayerEventListener(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[PlayerEventListener]:
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 PlayerEventListener(
)
_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/PlayerEventListener.py | 0.615897 | 0.257152 | PlayerEventListener.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 ControllerActionMP1(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[ControllerActionMP1]:
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 ControllerActionMP1(
)
_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/ControllerActionMP1.py | 0.604749 | 0.26046 | ControllerActionMP1.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 ScreenCoverageTrigger(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[ScreenCoverageTrigger]:
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 ScreenCoverageTrigger(
)
_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/ScreenCoverageTrigger.py | 0.611266 | 0.253884 | ScreenCoverageTrigger.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 StreamedAudioMP1(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[StreamedAudioMP1]:
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 StreamedAudioMP1(
)
_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/StreamedAudioMP1.py | 0.603581 | 0.268528 | StreamedAudioMP1.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 CinematicSkipHandler(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[CinematicSkipHandler]:
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 CinematicSkipHandler(
)
_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/CinematicSkipHandler.py | 0.606382 | 0.25801 | CinematicSkipHandler.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 TimerSequencePhaseResponder(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[TimerSequencePhaseResponder]:
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 TimerSequencePhaseResponder(
)
_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/TimerSequencePhaseResponder.py | 0.616359 | 0.257252 | TimerSequencePhaseResponder.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 SpindleCameraMP1(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[SpindleCameraMP1]:
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 SpindleCameraMP1(
)
_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/SpindleCameraMP1.py | 0.646795 | 0.26895 | SpindleCameraMP1.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 CreaturePatrolBehavior(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[CreaturePatrolBehavior]:
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 CreaturePatrolBehavior(
)
_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/CreaturePatrolBehavior.py | 0.604866 | 0.256686 | CreaturePatrolBehavior.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 AudioObstructionOcclusionOverride(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[AudioObstructionOcclusionOverride]:
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 AudioObstructionOcclusionOverride(
)
_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/AudioObstructionOcclusionOverride.py | 0.623721 | 0.263682 | AudioObstructionOcclusionOverride.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 NavigationPathPointOffMeshLink(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[NavigationPathPointOffMeshLink]:
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 NavigationPathPointOffMeshLink(
)
_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/NavigationPathPointOffMeshLink.py | 0.613121 | 0.26938 | NavigationPathPointOffMeshLink.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 ControlCommandMappingsDefinition(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[ControlCommandMappingsDefinition]:
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 ControlCommandMappingsDefinition(
)
_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/ControlCommandMappingsDefinition.py | 0.604516 | 0.250844 | ControlCommandMappingsDefinition.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 ControlCommandMappingNegate(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[ControlCommandMappingNegate]:
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 ControlCommandMappingNegate(
)
_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/ControlCommandMappingNegate.py | 0.606149 | 0.258361 | ControlCommandMappingNegate.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 Projectile(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[Projectile]:
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 Projectile(
)
_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/Projectile.py | 0.607081 | 0.265577 | Projectile.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 AABoxMagnet(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[AABoxMagnet]:
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 AABoxMagnet(
)
_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/AABoxMagnet.py | 0.606149 | 0.261466 | AABoxMagnet.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 MetroidPrimeStage2MP1(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[MetroidPrimeStage2MP1]:
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 MetroidPrimeStage2MP1(
)
_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/MetroidPrimeStage2MP1.py | 0.610686 | 0.26547 | MetroidPrimeStage2MP1.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 SoundPitchModifier(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[SoundPitchModifier]:
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 SoundPitchModifier(
)
_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/SoundPitchModifier.py | 0.602179 | 0.258747 | SoundPitchModifier.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 TimeDilation(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[TimeDilation]:
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 TimeDilation(
)
_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/TimeDilation.py | 0.613237 | 0.266996 | TimeDilation.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 FSMHotSwapper(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[FSMHotSwapper]:
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 FSMHotSwapper(
)
_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/FSMHotSwapper.py | 0.605216 | 0.264394 | FSMHotSwapper.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 VolumetricFogHint(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[VolumetricFogHint]:
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 VolumetricFogHint(
)
_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/VolumetricFogHint.py | 0.617167 | 0.261207 | VolumetricFogHint.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 CameraProxy(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[CameraProxy]:
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 CameraProxy(
)
_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/CameraProxy.py | 0.644001 | 0.265089 | CameraProxy.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 SwitchMP1(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[SwitchMP1]:
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 SwitchMP1(
)
_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/SwitchMP1.py | 0.617051 | 0.26129 | SwitchMP1.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 DebugMenuItemsDefinition(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[DebugMenuItemsDefinition]:
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 DebugMenuItemsDefinition(
)
_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/DebugMenuItemsDefinition.py | 0.575707 | 0.241937 | DebugMenuItemsDefinition.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 RippleMP1(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[RippleMP1]:
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 RippleMP1(
)
_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/RippleMP1.py | 0.607314 | 0.260825 | RippleMP1.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 ThermalHeatFaderMP1(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[ThermalHeatFaderMP1]:
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 ThermalHeatFaderMP1(
)
_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/ThermalHeatFaderMP1.py | 0.630457 | 0.259444 | ThermalHeatFaderMP1.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 SimpleShadow(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[SimpleShadow]:
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 SimpleShadow(
)
_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/SimpleShadow.py | 0.609757 | 0.259837 | SimpleShadow.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 SniperPoint(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[SniperPoint]:
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 SniperPoint(
)
_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/SniperPoint.py | 0.609408 | 0.270053 | SniperPoint.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 LoadUnitController(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[LoadUnitController]:
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 LoadUnitController(
)
_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/LoadUnitController.py | 0.648244 | 0.255593 | LoadUnitController.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 ModCon(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[ModCon]:
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 ModCon(
)
_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/ModCon.py | 0.608129 | 0.258162 | ModCon.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 CreatureHealth(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[CreatureHealth]:
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 CreatureHealth(
)
_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/CreatureHealth.py | 0.605916 | 0.266065 | CreatureHealth.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 FlameThrowerMP1(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[FlameThrowerMP1]:
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 FlameThrowerMP1(
)
_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/FlameThrowerMP1.py | 0.61057 | 0.256745 | FlameThrowerMP1.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 PickupDropper(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[PickupDropper]:
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 PickupDropper(
)
_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/PickupDropper.py | 0.605916 | 0.263451 | PickupDropper.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 CreatureTargeting(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[CreatureTargeting]:
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 CreatureTargeting(
)
_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/CreatureTargeting.py | 0.604399 | 0.264281 | CreatureTargeting.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 Occlusion(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[Occlusion]:
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 Occlusion(
)
_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/Occlusion.py | 0.610221 | 0.26338 | Occlusion.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 DistanceCompareGroup(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[DistanceCompareGroup]:
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 DistanceCompareGroup(
)
_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/DistanceCompareGroup.py | 0.622574 | 0.261632 | DistanceCompareGroup.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 ElectroMagneticPulseMP1(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[ElectroMagneticPulseMP1]:
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 ElectroMagneticPulseMP1(
)
_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/ElectroMagneticPulseMP1.py | 0.631935 | 0.26699 | ElectroMagneticPulseMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime_remastered as enums
from retro_data_structures.properties.prime_remastered.archetypes.ActorInformationMP1 import ActorInformationMP1
from retro_data_structures.properties.prime_remastered.archetypes.AnimSetMP1 import AnimSetMP1
from retro_data_structures.properties.prime_remastered.archetypes.MapInfoMP1 import MapInfoMP1
from retro_data_structures.properties.prime_remastered.archetypes.VectorMP1 import VectorMP1
from retro_data_structures.properties.prime_remastered.core.AssetId import AssetId, default_asset_id
import uuid
@dataclasses.dataclass()
class PickupMP1(BaseProperty):
collision_scale: VectorMP1 = dataclasses.field(default_factory=VectorMP1)
scan_collision_offset: VectorMP1 = dataclasses.field(default_factory=VectorMP1)
item: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
capacity: int = dataclasses.field(default=1)
amount: int = dataclasses.field(default=1)
drop_rate: float = dataclasses.field(default=100.0)
life_time: float = dataclasses.field(default=0.0)
fade_length: float = dataclasses.field(default=0.0)
guid_1: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
animation_parameters: AnimSetMP1 = dataclasses.field(default_factory=AnimSetMP1)
spawn_delay: float = dataclasses.field(default=0.0)
guid_2: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unk_vec_3: VectorMP1 = dataclasses.field(default_factory=VectorMP1)
map_info: MapInfoMP1 = dataclasses.field(default_factory=MapInfoMP1)
actor_info: ActorInformationMP1 = dataclasses.field(default_factory=ActorInformationMP1)
unk_bool_1: bool = dataclasses.field(default=False)
unk_bool_2: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x08\x00') # 8 properties
num_properties_written = 8
data.write(b'\xc6\x9e\xe3p') # 0x70e39ec6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.collision_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'DHd-') # 0x2d644844
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_collision_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'\xee\x94\x97\xc7') # 0xc79794ee
data.write(b'\x04\x00') # size
self.item.to_stream(data)
if self.capacity != default_override.get('capacity', 1):
num_properties_written += 1
data.write(b'\xd5\x91\xbev') # 0x76be91d5
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.capacity))
if self.amount != default_override.get('amount', 1):
num_properties_written += 1
data.write(b'\xf6\xd2\xdb\x9f') # 0x9fdbd2f6
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.amount))
if self.drop_rate != default_override.get('drop_rate', 100.0):
num_properties_written += 1
data.write(b'\xd2I\xf3\xfc') # 0xfcf349d2
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.drop_rate))
if self.life_time != default_override.get('life_time', 0.0):
num_properties_written += 1
data.write(b'}\xaf*\x7f') # 0x7f2aaf7d
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.life_time))
if self.fade_length != default_override.get('fade_length', 0.0):
num_properties_written += 1
data.write(b'+\x0f\x93\xef') # 0xef930f2b
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.fade_length))
if self.guid_1 != default_override.get('guid_1', default_asset_id):
num_properties_written += 1
data.write(b'\xb3\x9c\xe2\xbc') # 0xbce29cb3
data.write(b'\x10\x00') # size
data.write(self.guid_1.bytes_le)
data.write(b'\xb1\x11\xd9\x19') # 0x19d911b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_parameters.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if self.spawn_delay != default_override.get('spawn_delay', 0.0):
num_properties_written += 1
data.write(b'\xff^\x9f>') # 0x3e9f5eff
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.spawn_delay))
data.write(b'\x8e}\xa0\xe2') # 0xe2a07d8e
data.write(b'\x10\x00') # size
data.write(self.guid_2.bytes_le)
data.write(b'\x8aC?\x85') # 0x853f438a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unk_vec_3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'\x0b\xa88\xba') # 0xba38a80b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.map_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'\xb6\xd4\xf9h') # 0x68f9d4b6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if self.unk_bool_1 != default_override.get('unk_bool_1', False):
num_properties_written += 1
data.write(b'\xf2\xe2q\xbd') # 0xbd71e2f2
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_1))
if self.unk_bool_2 != default_override.get('unk_bool_2', False):
num_properties_written += 1
data.write(b'n\\\x16\xf2') # 0xf2165c6e
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_2))
if num_properties_written != 8:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
collision_scale=VectorMP1.from_json(data['collision_scale']),
scan_collision_offset=VectorMP1.from_json(data['scan_collision_offset']),
item=enums.PlayerItem.from_json(data['item']),
capacity=data['capacity'],
amount=data['amount'],
drop_rate=data['drop_rate'],
life_time=data['life_time'],
fade_length=data['fade_length'],
guid_1=uuid.UUID(data['guid_1']),
animation_parameters=AnimSetMP1.from_json(data['animation_parameters']),
spawn_delay=data['spawn_delay'],
guid_2=uuid.UUID(data['guid_2']),
unk_vec_3=VectorMP1.from_json(data['unk_vec_3']),
map_info=MapInfoMP1.from_json(data['map_info']),
actor_info=ActorInformationMP1.from_json(data['actor_info']),
unk_bool_1=data['unk_bool_1'],
unk_bool_2=data['unk_bool_2'],
)
def to_json(self) -> dict:
return {
'collision_scale': self.collision_scale.to_json(),
'scan_collision_offset': self.scan_collision_offset.to_json(),
'item': self.item.to_json(),
'capacity': self.capacity,
'amount': self.amount,
'drop_rate': self.drop_rate,
'life_time': self.life_time,
'fade_length': self.fade_length,
'guid_1': str(self.guid_1),
'animation_parameters': self.animation_parameters.to_json(),
'spawn_delay': self.spawn_delay,
'guid_2': str(self.guid_2),
'unk_vec_3': self.unk_vec_3.to_json(),
'map_info': self.map_info.to_json(),
'actor_info': self.actor_info.to_json(),
'unk_bool_1': self.unk_bool_1,
'unk_bool_2': self.unk_bool_2,
}
def _decode_collision_scale(data: typing.BinaryIO, property_size: int):
return VectorMP1.from_stream(data, property_size)
def _decode_scan_collision_offset(data: typing.BinaryIO, property_size: int):
return VectorMP1.from_stream(data, property_size)
def _decode_item(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_capacity(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_drop_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_fade_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_guid_1(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_animation_parameters(data: typing.BinaryIO, property_size: int):
return AnimSetMP1.from_stream(data, property_size)
def _decode_spawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_guid_2(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_vec_3(data: typing.BinaryIO, property_size: int):
return VectorMP1.from_stream(data, property_size)
def _decode_map_info(data: typing.BinaryIO, property_size: int):
return MapInfoMP1.from_stream(data, property_size)
def _decode_actor_info(data: typing.BinaryIO, property_size: int):
return ActorInformationMP1.from_stream(data, property_size)
def _decode_unk_bool_1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x70e39ec6: ('collision_scale', _decode_collision_scale),
0x2d644844: ('scan_collision_offset', _decode_scan_collision_offset),
0xc79794ee: ('item', _decode_item),
0x76be91d5: ('capacity', _decode_capacity),
0x9fdbd2f6: ('amount', _decode_amount),
0xfcf349d2: ('drop_rate', _decode_drop_rate),
0x7f2aaf7d: ('life_time', _decode_life_time),
0xef930f2b: ('fade_length', _decode_fade_length),
0xbce29cb3: ('guid_1', _decode_guid_1),
0x19d911b1: ('animation_parameters', _decode_animation_parameters),
0x3e9f5eff: ('spawn_delay', _decode_spawn_delay),
0xe2a07d8e: ('guid_2', _decode_guid_2),
0x853f438a: ('unk_vec_3', _decode_unk_vec_3),
0xba38a80b: ('map_info', _decode_map_info),
0x68f9d4b6: ('actor_info', _decode_actor_info),
0xbd71e2f2: ('unk_bool_1', _decode_unk_bool_1),
0xf2165c6e: ('unk_bool_2', _decode_unk_bool_2),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PickupMP1.py | 0.503662 | 0.263518 | PickupMP1.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 LightShafts(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[LightShafts]:
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 LightShafts(
)
_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/LightShafts.py | 0.610453 | 0.263694 | LightShafts.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 ReflectionProbe(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[ReflectionProbe]:
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 ReflectionProbe(
)
_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/ReflectionProbe.py | 0.605099 | 0.261962 | ReflectionProbe.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 RoomSettings(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[RoomSettings]:
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 RoomSettings(
)
_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/RoomSettings.py | 0.606848 | 0.25318 | RoomSettings.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 Reactivator(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[Reactivator]:
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 Reactivator(
)
_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/Reactivator.py | 0.607896 | 0.260448 | Reactivator.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 SamplerVoiceBankData(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[SamplerVoiceBankData]:
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 SamplerVoiceBankData(
)
_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/SamplerVoiceBankData.py | 0.603581 | 0.268576 | SamplerVoiceBankData.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 TimerStopwatch(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[TimerStopwatch]:
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 TimerStopwatch(
)
_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/TimerStopwatch.py | 0.614047 | 0.254 | TimerStopwatch.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 DistanceFogMP1(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[DistanceFogMP1]:
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 DistanceFogMP1(
)
_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/DistanceFogMP1.py | 0.616936 | 0.267881 | DistanceFogMP1.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 BlackboardPhaseRelay(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[BlackboardPhaseRelay]:
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 BlackboardPhaseRelay(
)
_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/BlackboardPhaseRelay.py | 0.606615 | 0.254277 | BlackboardPhaseRelay.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 ColorModulateMP1(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[ColorModulateMP1]:
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 ColorModulateMP1(
)
_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/ColorModulateMP1.py | 0.643441 | 0.261307 | ColorModulateMP1.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 CameraMP1(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[CameraMP1]:
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 CameraMP1(
)
_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/CameraMP1.py | 0.642208 | 0.265958 | CameraMP1.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 MIDIReceiver(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[MIDIReceiver]:
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 MIDIReceiver(
)
_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/MIDIReceiver.py | 0.61115 | 0.248717 | MIDIReceiver.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 GeneratorMP1(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[GeneratorMP1]:
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 GeneratorMP1(
)
_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/GeneratorMP1.py | 0.619011 | 0.257724 | GeneratorMP1.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 UISlider(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[UISlider]:
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 UISlider(
)
_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/UISlider.py | 0.598312 | 0.266196 | UISlider.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 PatternMatcher(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[PatternMatcher]:
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 PatternMatcher(
)
_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/PatternMatcher.py | 0.642881 | 0.271967 | PatternMatcher.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 WaypointMP1(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[WaypointMP1]:
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 WaypointMP1(
)
_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/WaypointMP1.py | 0.606498 | 0.264382 | WaypointMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime_remastered.archetypes.AnimSetMP1 import AnimSetMP1
from retro_data_structures.properties.prime_remastered.archetypes.VectorMP1 import VectorMP1
from retro_data_structures.properties.prime_remastered.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime_remastered.core.PooledString import PooledString
import uuid
@dataclasses.dataclass()
class WorldTeleporterTooMP1(BaseProperty):
world: AssetId = dataclasses.field(metadata={'asset_types': ['ROOM']}, default=default_asset_id)
area: AssetId = dataclasses.field(metadata={'asset_types': ['ROOM']}, default=default_asset_id)
animation_information: AnimSetMP1 = dataclasses.field(default_factory=AnimSetMP1)
player_scale: VectorMP1 = dataclasses.field(default_factory=VectorMP1)
platform: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
platform_scale: VectorMP1 = dataclasses.field(default_factory=VectorMP1)
shaft_scale: VectorMP1 = dataclasses.field(default_factory=VectorMP1)
unk_str: PooledString = dataclasses.field(default_factory=PooledString)
unk_bool1: bool = dataclasses.field(default=True)
sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
volume: int = dataclasses.field(default=127)
upward_elevator: bool = dataclasses.field(default=False)
text: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
pan: int = dataclasses.field(default=64)
unk_bool2: bool = dataclasses.field(default=False)
char_fade_in_time: float = dataclasses.field(default=0.009999999776482582)
chars_per_second: float = dataclasses.field(default=8.0)
delay_before_show: float = dataclasses.field(default=0.0)
show_text_instead_of_cutscene: bool = dataclasses.field(default=False)
unk_float1: float = dataclasses.field(default=0.0)
unk_float2: float = dataclasses.field(default=2.0)
unk_float3: float = dataclasses.field(default=3.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x06\x00') # 6 properties
num_properties_written = 6
data.write(b'\x7fQ\x9a\xd4') # 0xd49a517f
data.write(b'\x10\x00') # size
data.write(self.world.bytes_le)
data.write(b'l\xfb_\x9a') # 0x9a5ffb6c
data.write(b'\x10\x00') # size
data.write(self.area.bytes_le)
data.write(b'r\xee\xeaj') # 0x6aeaee72
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'yfS\xc2') # 0xc2536679
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if self.platform != default_override.get('platform', default_asset_id):
num_properties_written += 1
data.write(b'\x8e\x1f\xb3\xa7') # 0xa7b31f8e
data.write(b'\x10\x00') # size
data.write(self.platform.bytes_le)
data.write(b'!\xe8\xb5O') # 0x4fb5e821
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.platform_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'*\xe6:\xbb') # 0xbb3ae62a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shaft_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if self.unk_str != default_override.get('unk_str', PooledString()):
num_properties_written += 1
data.write(b',N\xd5\xb8') # 0xb8d54e2c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unk_str.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if self.unk_bool1 != default_override.get('unk_bool1', True):
num_properties_written += 1
data.write(b'\t\x1c\x93\xa6') # 0xa6931c09
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool1))
if self.sound != default_override.get('sound', default_asset_id):
num_properties_written += 1
data.write(b'#\xbb\x07T') # 0x5407bb23
data.write(b'\x10\x00') # size
data.write(self.sound.bytes_le)
if self.volume != default_override.get('volume', 127):
num_properties_written += 1
data.write(b'pR\x95\x82') # 0x82955270
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.volume))
if self.upward_elevator != default_override.get('upward_elevator', False):
num_properties_written += 1
data.write(b'\xa7>\xfa\x03') # 0x3fa3ea7
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.upward_elevator))
if self.text != default_override.get('text', default_asset_id):
num_properties_written += 1
data.write(b'\xe83\x0b\x98') # 0x980b33e8
data.write(b'\x10\x00') # size
data.write(self.text.bytes_le)
if self.pan != default_override.get('pan', 64):
num_properties_written += 1
data.write(b'\xff5\x8c\x83') # 0x838c35ff
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.pan))
if self.unk_bool2 != default_override.get('unk_bool2', False):
num_properties_written += 1
data.write(b'\xad;.\x95') # 0x952e3bad
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool2))
if self.char_fade_in_time != default_override.get('char_fade_in_time', 0.009999999776482582):
num_properties_written += 1
data.write(b'\x9d\xf0XU') # 0x5558f09d
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.char_fade_in_time))
if self.chars_per_second != default_override.get('chars_per_second', 8.0):
num_properties_written += 1
data.write(b'\xe9h\xfc\xee') # 0xeefc68e9
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.chars_per_second))
if self.delay_before_show != default_override.get('delay_before_show', 0.0):
num_properties_written += 1
data.write(b'\r\xd96\xa9') # 0xa936d90d
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.delay_before_show))
if self.show_text_instead_of_cutscene != default_override.get('show_text_instead_of_cutscene', False):
num_properties_written += 1
data.write(b'\x03\xa0h\x1b') # 0x1b68a003
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.show_text_instead_of_cutscene))
if self.unk_float1 != default_override.get('unk_float1', 0.0):
num_properties_written += 1
data.write(b'Ku\xb5S') # 0x53b5754b
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float1))
if self.unk_float2 != default_override.get('unk_float2', 2.0):
num_properties_written += 1
data.write(b'\xd4Gs\x97') # 0x977347d4
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float2))
if self.unk_float3 != default_override.get('unk_float3', 3.0):
num_properties_written += 1
data.write(b'\x03\xe85\xdc') # 0xdc35e803
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float3))
if num_properties_written != 6:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
world=uuid.UUID(data['world']),
area=uuid.UUID(data['area']),
animation_information=AnimSetMP1.from_json(data['animation_information']),
player_scale=VectorMP1.from_json(data['player_scale']),
platform=uuid.UUID(data['platform']),
platform_scale=VectorMP1.from_json(data['platform_scale']),
shaft_scale=VectorMP1.from_json(data['shaft_scale']),
unk_str=PooledString.from_json(data['unk_str']),
unk_bool1=data['unk_bool1'],
sound=uuid.UUID(data['sound']),
volume=data['volume'],
upward_elevator=data['upward_elevator'],
text=uuid.UUID(data['text']),
pan=data['pan'],
unk_bool2=data['unk_bool2'],
char_fade_in_time=data['char_fade_in_time'],
chars_per_second=data['chars_per_second'],
delay_before_show=data['delay_before_show'],
show_text_instead_of_cutscene=data['show_text_instead_of_cutscene'],
unk_float1=data['unk_float1'],
unk_float2=data['unk_float2'],
unk_float3=data['unk_float3'],
)
def to_json(self) -> dict:
return {
'world': str(self.world),
'area': str(self.area),
'animation_information': self.animation_information.to_json(),
'player_scale': self.player_scale.to_json(),
'platform': str(self.platform),
'platform_scale': self.platform_scale.to_json(),
'shaft_scale': self.shaft_scale.to_json(),
'unk_str': self.unk_str.to_json(),
'unk_bool1': self.unk_bool1,
'sound': str(self.sound),
'volume': self.volume,
'upward_elevator': self.upward_elevator,
'text': str(self.text),
'pan': self.pan,
'unk_bool2': self.unk_bool2,
'char_fade_in_time': self.char_fade_in_time,
'chars_per_second': self.chars_per_second,
'delay_before_show': self.delay_before_show,
'show_text_instead_of_cutscene': self.show_text_instead_of_cutscene,
'unk_float1': self.unk_float1,
'unk_float2': self.unk_float2,
'unk_float3': self.unk_float3,
}
def _decode_world(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_area(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimSetMP1.from_stream(data, property_size)
def _decode_player_scale(data: typing.BinaryIO, property_size: int):
return VectorMP1.from_stream(data, property_size)
def _decode_platform(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_platform_scale(data: typing.BinaryIO, property_size: int):
return VectorMP1.from_stream(data, property_size)
def _decode_shaft_scale(data: typing.BinaryIO, property_size: int):
return VectorMP1.from_stream(data, property_size)
def _decode_unk_str(data: typing.BinaryIO, property_size: int):
return PooledString.from_stream(data, property_size)
def _decode_unk_bool1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_sound(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_upward_elevator(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_text(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_unk_bool2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_char_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_chars_per_second(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_delay_before_show(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_show_text_instead_of_cutscene(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_float1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_unk_float2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_unk_float3(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd49a517f: ('world', _decode_world),
0x9a5ffb6c: ('area', _decode_area),
0x6aeaee72: ('animation_information', _decode_animation_information),
0xc2536679: ('player_scale', _decode_player_scale),
0xa7b31f8e: ('platform', _decode_platform),
0x4fb5e821: ('platform_scale', _decode_platform_scale),
0xbb3ae62a: ('shaft_scale', _decode_shaft_scale),
0xb8d54e2c: ('unk_str', _decode_unk_str),
0xa6931c09: ('unk_bool1', _decode_unk_bool1),
0x5407bb23: ('sound', _decode_sound),
0x82955270: ('volume', _decode_volume),
0x3fa3ea7: ('upward_elevator', _decode_upward_elevator),
0x980b33e8: ('text', _decode_text),
0x838c35ff: ('pan', _decode_pan),
0x952e3bad: ('unk_bool2', _decode_unk_bool2),
0x5558f09d: ('char_fade_in_time', _decode_char_fade_in_time),
0xeefc68e9: ('chars_per_second', _decode_chars_per_second),
0xa936d90d: ('delay_before_show', _decode_delay_before_show),
0x1b68a003: ('show_text_instead_of_cutscene', _decode_show_text_instead_of_cutscene),
0x53b5754b: ('unk_float1', _decode_unk_float1),
0x977347d4: ('unk_float2', _decode_unk_float2),
0xdc35e803: ('unk_float3', _decode_unk_float3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/WorldTeleporterTooMP1.py | 0.476092 | 0.290201 | WorldTeleporterTooMP1.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 InventoryTextPane(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[InventoryTextPane]:
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 InventoryTextPane(
)
_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/InventoryTextPane.py | 0.604282 | 0.25517 | InventoryTextPane.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 LightDynamic(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[LightDynamic]:
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 LightDynamic(
)
_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/LightDynamic.py | 0.640074 | 0.261095 | LightDynamic.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 BakedLightingPriorityModifierMP1(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[BakedLightingPriorityModifierMP1]:
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 BakedLightingPriorityModifierMP1(
)
_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/BakedLightingPriorityModifierMP1.py | 0.63341 | 0.260901 | BakedLightingPriorityModifierMP1.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 ReloadSetLoader(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[ReloadSetLoader]:
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 ReloadSetLoader(
)
_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/ReloadSetLoader.py | 0.601828 | 0.260337 | ReloadSetLoader.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 PlatformMP1(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[PlatformMP1]:
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 PlatformMP1(
)
_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/PlatformMP1.py | 0.607663 | 0.263665 | PlatformMP1.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 AiTarget(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[AiTarget]:
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 AiTarget(
)
_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/AiTarget.py | 0.600657 | 0.259034 | AiTarget.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 AudioSamplerProxy(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[AudioSamplerProxy]:
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 AudioSamplerProxy(
)
_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/AudioSamplerProxy.py | 0.606498 | 0.267205 | AudioSamplerProxy.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 FlaahgraPlantsMP1Runtime(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[FlaahgraPlantsMP1Runtime]:
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 FlaahgraPlantsMP1Runtime(
)
_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/FlaahgraPlantsMP1Runtime.py | 0.612426 | 0.265714 | FlaahgraPlantsMP1Runtime.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 MIDISequence(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[MIDISequence]:
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 MIDISequence(
)
_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/MIDISequence.py | 0.606032 | 0.261732 | MIDISequence.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 RelayAttackTypePayload(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[RelayAttackTypePayload]:
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 RelayAttackTypePayload(
)
_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/RelayAttackTypePayload.py | 0.606032 | 0.262836 | RelayAttackTypePayload.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 MetroidPrimeRelayMP1(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[MetroidPrimeRelayMP1]:
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 MetroidPrimeRelayMP1(
)
_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/MetroidPrimeRelayMP1.py | 0.610802 | 0.260642 | MetroidPrimeRelayMP1.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 CreatureNavigateBehavior(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[CreatureNavigateBehavior]:
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 CreatureNavigateBehavior(
)
_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/CreatureNavigateBehavior.py | 0.605916 | 0.252419 | CreatureNavigateBehavior.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.