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 |
|---|---|---|---|---|---|
# Imports
from .bip_coin_base import BipCoinBase
from .bip_coin_conf import *
from .P2PKH import P2PKH
from .eth_addr import EthAddr
from .xrp_addr import XrpAddr
class Bip44Coin(BipCoinBase):
""" Generic class for BIP-044 coins. """
def __init__(self, coin_conf, is_testnet, addr_fct):
""" Construct class.
Args:
coin_conf (class): Coin configuration class
is_testnet (bool): True if test net, false otherwise
addr_fct (class) : Address class
"""
super().__init__(coin_conf, coin_conf.BIP44_KEY_NET_VER, is_testnet, addr_fct)
class Bip44Litecoin(Bip44Coin):
""" Litecoin BIP-0044 class.
It overrides KeyNetVersions to return different main net versions depending on the configuration.
"""
def KeyNetVersions(self):
""" Get key net versions. It overrides the method in BipCoinBase.
Litecoin overrides the method because it can have 2 different main net versions.
Returns:
KeyNetVersions object: KeyNetVersions object
"""
# Get standard or alternate version depending on the configuration flag
if not self.m_is_testnet:
return self.m_key_net_ver.Main()[0] if not self.m_coin_conf.EX_KEY_ALT else self.m_key_net_ver.Main()[1]
else:
return self.m_key_net_ver.Test()
# Configuration for Bitcoin main net
Bip44BitcoinMainNet = Bip44Coin(coin_conf = BitcoinConf,
is_testnet = False,
addr_fct = P2PKH)
# Configuration for Bitcoin test net
Bip44BitcoinTestNet = Bip44Coin(coin_conf = BitcoinConf,
is_testnet = True,
addr_fct = P2PKH)
# Configuration for Litecoin main net
Bip44LitecoinMainNet = Bip44Litecoin(coin_conf = LitecoinConf,
is_testnet = False,
addr_fct = P2PKH)
# Configuration for Litecoin test net
Bip44LitecoinTestNet = Bip44Litecoin(coin_conf = LitecoinConf,
is_testnet = True,
addr_fct = P2PKH)
# Configuration for Dogecoin main net
Bip44DogecoinMainNet = Bip44Coin(coin_conf = DogecoinConf,
is_testnet = False,
addr_fct = P2PKH)
# Configuration for Dogecoin test net
Bip44DogecoinTestNet = Bip44Coin(coin_conf = DogecoinConf,
is_testnet = True,
addr_fct = P2PKH)
# Configuration for Dash main net
Bip44DashMainNet = Bip44Coin(coin_conf = DashConf,
is_testnet = False,
addr_fct = P2PKH)
# Configuration for Dash test net
Bip44DashTestNet = Bip44Coin(coin_conf = DashConf,
is_testnet = True,
addr_fct = P2PKH)
# Configuration for Ethereum main net
Bip44Ethereum = Bip44Coin(coin_conf = EthereumConf,
is_testnet = False,
addr_fct = EthAddr)
# Configuration for Ripple main net
Bip44Ripple = Bip44Coin(coin_conf = RippleConf,
is_testnet = False,
addr_fct = XrpAddr) | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip44_coins.py | 0.710929 | 0.158044 | bip44_coins.py | pypi |
# Imports
from .bip32_ex import Bip32KeyError
from .bip32_key_ser import Bip32KeySerializer
from .bip44_coins import Bip44BitcoinMainNet
from .wif import WifEncoder
from . import utils
class BipKeyBytes:
""" BIP key bytes class. It allows to get key bytes in different formats. """
def __init__(self, key_bytes):
""" Construct class.
Args:
key_bytes (bytes): Key bytes
"""
self.m_key_bytes = key_bytes
def ToBytes(self):
""" Get key bytes.
Returns:
bytes: Key bytes
"""
return self.m_key_bytes
def ToHex(self):
""" Get key bytes in hex format.
Returns:
str: Key bytes in hex format
"""
return utils.BytesToHexString(self.m_key_bytes)
class BipPublicKey:
""" BIP public key class. It allows to get a public key in different formats. """
def __init__(self, bip32_obj, coin_class = Bip44BitcoinMainNet):
""" Construct class.
Args:
bip32_obj (Bip32 object) : Bip32 object
coin_class (BipCoinBase child object, optional): BipCoinBase child object, Bip44BitcoinMainNet by default
"""
self.m_bip32_obj = bip32_obj
self.m_coin_class = coin_class
def RawCompressed(self):
""" Return raw compressed public key.
Returns:
BipKeyBytes object: BipKeyBytes object
"""
return BipKeyBytes(self.m_bip32_obj.EcdsaPublicKey().to_string("compressed"))
def RawUncompressed(self):
""" Return raw uncompressed public key.
Returns:
BipKeyBytes object: BipKeyBytes object
"""
# The first byte is the version (0x04) and it's not needed
return BipKeyBytes(self.m_bip32_obj.EcdsaPublicKey().to_string("uncompressed")[1:])
def ToExtended(self):
""" Return key in serialized extended format.
Returns:
str: Key in serialized extended format
"""
return Bip32KeySerializer(self.m_bip32_obj).SerializePublicKey()
def ToAddress(self):
""" Return address correspondent tot he public key.
Returns:
str: Address
"""
return self.m_coin_class.ComputeAddress(self)
class BipPrivateKey:
""" BIP privte key class. It allows to get a privte key in different formats. """
def __init__(self, bip32_obj, coin_class = Bip44BitcoinMainNet):
""" Construct class.
Args:
bip32_obj (Bip32 object) : Bip32 object
coin_class (BipCoinBase child object, optional): BipCoinBase child object, Bip44BitcoinMainNet by default
Raises:
Bip32KeyError: If the Bip32 object is public-only
"""
if bip32_obj.IsPublicOnly():
raise Bip32KeyError("Cannot create a private key form a public-only Bip32 object")
self.m_bip32_obj = bip32_obj
self.m_coin_class = coin_class
def Raw(self):
""" Return raw private key.
Returns:
BipKeyBytes object: BipKeyBytes object
"""
return BipKeyBytes(self.m_bip32_obj.EcdsaPrivateKey().to_string())
def ToExtended(self):
""" Return key in serialized extended format.
Returns:
str: Key in serialized extended format
"""
return Bip32KeySerializer(self.m_bip32_obj).SerializePrivateKey()
def ToWif(self):
""" Return key in WIF format.
Returns:
str: Key in WIF format
"""
wif_net_ver = self.m_coin_class.WifNetVersion()
if not wif_net_ver is None:
return WifEncoder.Encode(self.Raw().ToBytes(), wif_net_ver)
else:
return "" | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip_keys.py | 0.893536 | 0.335024 | bip_keys.py | pypi |
# It's not so easy to find this information, some references I used:
# https://github.com/libbitcoin/libbitcoin-system/wiki/Altcoin-Version-Mappings#bip44-altcoin-version-mapping-table
# https://github.com/satoshilabs/slips/blob/master/slip-0132.md
# Imports
from .bip_coin_conf_helper import *
class Bip32Conf:
""" Class container for Bip32 configuration. """
# Key net versions (xpub / xprv) - (tpub / tprv)
KEY_NET_VER = NetVersions(KeyNetVersions(b"0488b21e", b"0488ade4"),
KeyNetVersions(b"043587cf", b"04358394"))
class BitcoinConf:
""" Class container for Bitcoin configuration. """
# Names
NAMES = CoinNames("Bitcoin" , "BTC")
# Test names
TEST_NAMES = CoinNames("Bitcoin TestNet", "BTC")
# BIP44 net versions (same of BIP32)
BIP44_KEY_NET_VER = Bip32Conf.KEY_NET_VER
# BIP49 net versions (ypub / yprv) - (upub / uprv)
BIP49_KEY_NET_VER = NetVersions(KeyNetVersions(b"049d7cb2", b"049d7878"),
KeyNetVersions(b"044a5262", b"044a4e28"))
# BIP84 net versions (zpub / zprv) - (vpub / vprv)
BIP84_KEY_NET_VER = NetVersions(KeyNetVersions(b"04b24746", b"04b2430c"),
KeyNetVersions(b"045f1cf6", b"045f18bc"))
# Versions for P2PKH address
P2PKH_NET_VER = NetVersions(b"\x00", b"\x6f")
# Versions for P2SH address
P2SH_NET_VER = NetVersions(b"\x05", b"\xc4")
# Versions for P2WPKH address
P2WPKH_NET_VER = NetVersions("bc", "tb")
# WIF net version
WIF_NET_VER = NetVersions(b"\x80", b"\xef")
class LitecoinConf:
""" Class container for Litecoin configuration. """
# Names
NAMES = CoinNames("Litecoin" , "LTC")
# Test names
TEST_NAMES = CoinNames("Litecoin TestNet", "LTC")
# False for using Bitcoin net versions for extended keys (xprv/xpub and similar), true for using the alternate ones (Ltpv/Ltub and similar)
EX_KEY_ALT = False
# False for using P2SH deprecated addresses, true for the new addresses
P2SH_DEPR_ADDR = False
# BIP44 net versions
# Litecoin can have 2 different main version: same of Bitcoin or (Ltpv / Ltub), test net version is (ttub / ttpv)
BIP44_KEY_NET_VER = NetVersions((BitcoinConf.BIP44_KEY_NET_VER.Main(), KeyNetVersions(b"019da462", b"019d9cfe")),
KeyNetVersions(b"0436f6e1", b"0436ef7d"))
# BIP49 net versions
# Litecoin can have 2 different main version: same of Bitcoin or (Mtpv / Mtub), test net version is (ttub / ttpv)
BIP49_KEY_NET_VER = NetVersions((BitcoinConf.BIP49_KEY_NET_VER.Main(), KeyNetVersions(b"01b26ef6", b"01b26792")),
KeyNetVersions(b"0436f6e1", b"0436ef7d"))
# BIP84 net versions (zpub / zprv) - (ttub / ttpv)
BIP84_KEY_NET_VER = NetVersions(BitcoinConf.BIP84_KEY_NET_VER.Main(),
KeyNetVersions(b"0436f6e1", b"0436ef7d"))
# Versions for P2PKH address
P2PKH_NET_VER = NetVersions(b"\x30", b"\x6f")
# Deprecated versions for P2SH address (same of Bitcoin)
P2SH_DEPR_NET_VER = BitcoinConf.P2SH_NET_VER
# Versions for P2SH address
P2SH_NET_VER = NetVersions(b"\x32", b"\x3a")
# Versions for P2WPKH address
P2WPKH_NET_VER = NetVersions("ltc", "tltc")
# WIF net version
WIF_NET_VER = NetVersions(b"\xb0", b"\xef")
class DogecoinConf:
""" Class container for Dogecoin configuration. """
# Names
NAMES = CoinNames("Dogecoin" , "DOGE")
# Test names
TEST_NAMES = CoinNames("Dogecoin TestNet", "DOGE")
# BIP44 net versions (dgub / dgpv) - (tgub / tgpv)
BIP44_KEY_NET_VER = NetVersions(KeyNetVersions(b"02facafd", b"02fac398"),
KeyNetVersions(b"0432a9a8", b"0432a243"))
# BIP49 net versions (dgub / dgpv) - (tgub / tgpv)
BIP49_KEY_NET_VER = NetVersions(KeyNetVersions(b"02facafd", b"02fac398"),
KeyNetVersions(b"0432a9a8", b"0432a243"))
# Versions for P2PKH address
P2PKH_NET_VER = NetVersions(b"\x1e", b"\x71")
# Versions for P2SH address
P2SH_NET_VER = NetVersions(b"\x16", b"\xc4")
# WIF net version
WIF_NET_VER = NetVersions(b"\x9e", b"\xf1")
class DashConf:
""" Class container for Dash configuration. """
# Names
NAMES = CoinNames("Dash" , "DASH")
# Test names
TEST_NAMES = CoinNames("Dash TestNet", "DASH")
# BIP44 net versions (same of Bitcoin)
BIP44_KEY_NET_VER = BitcoinConf.BIP44_KEY_NET_VER
# BIP49 net versions (same of Bitcoin)
BIP49_KEY_NET_VER = BitcoinConf.BIP49_KEY_NET_VER
# Versions for P2PKH address
P2PKH_NET_VER = NetVersions(b"\x4c", b"\x8c")
# Versions for P2SH address
P2SH_NET_VER = NetVersions(b"\x10", b"\x13")
# WIF net version
WIF_NET_VER = NetVersions(b"\xcc", b"\xef")
class EthereumConf:
""" Class container for Ethereum configuration. """
# Names
NAMES = CoinNames("Ethereum", "ETH")
# BIP44 net versions (same of Bitcoin)
BIP44_KEY_NET_VER = BitcoinConf.BIP44_KEY_NET_VER
# WIF not supported
WIF_NET_VER = NetVersions()
class RippleConf:
""" Class container for Bitcoin configuration. """
# Names
NAMES = CoinNames("Ripple", "XRP")
# BIP44 net versions (same of Bitcoin)
BIP44_KEY_NET_VER = BitcoinConf.BIP44_KEY_NET_VER
# Versions for P2PKH address, test net not supported
P2PKH_NET_VER = NetVersions(b"\x00")
# WIF not supported
WIF_NET_VER = NetVersions() | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip_coin_conf.py | 0.788949 | 0.267917 | bip_coin_conf.py | pypi |
# Imports
from enum import IntEnum, unique
from .base58_ex import Base58ChecksumError
from . import utils
@unique
class Base58Alphabets(IntEnum):
""" Enumerative for Base58 alphabet. """
BITCOIN = 0,
RIPPLE = 1,
class Base58Const:
""" Class container for Base58 constants. """
# Base58 radix
RADIX = 58
# Checksum length in bytes
CHECKSUM_BYTE_LEN = 4
# Alphabets
ALPHABETS = \
{
Base58Alphabets.BITCOIN : "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
Base58Alphabets.RIPPLE : "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz",
}
class Base58Utils:
""" Class container for Base58 utility functions. """
@staticmethod
def ComputeChecksum(data_bytes):
""" Compute Base58 checksum.
Args:
data_bytes (bytes): Data bytes
Returns:
bytes: Computed checksum
"""
return utils.Sha256(utils.Sha256(data_bytes))[:Base58Const.CHECKSUM_BYTE_LEN]
class Base58Encoder:
""" Base58 encoder class. It provides methods for encoding and checksum encoding to Base58 format. """
@staticmethod
def Encode(data_bytes, alph_idx = Base58Alphabets.BITCOIN):
""" Encode bytes into a Base58 string.
Args:
data_bytes (bytes) : Data bytes
alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
Returns:
str: Base58 encoded string
Raises:
TypeError: If alphabet index is not a Base58Alphabets enumerative
"""
if not isinstance(alph_idx, Base58Alphabets):
raise TypeError("Alphabet index is not an enumerative of Base58Alphabets")
enc = ""
# Get alphabet
alphabet = Base58Const.ALPHABETS[alph_idx]
# Convert bytes to integer
val = utils.BytesToInteger(data_bytes)
# Algorithm implementation
while val > 0:
val, mod = divmod(val, Base58Const.RADIX)
enc = alphabet[mod] + enc
# Get number of leading zeros
n = len(data_bytes) - len(data_bytes.lstrip(b"\x00"))
# Add padding
return (alphabet[0] * n) + enc
@staticmethod
def CheckEncode(data_bytes, alph_idx = Base58Alphabets.BITCOIN):
""" Encode bytes into Base58 string with checksum.
Args:
data_bytes (bytes) : Data bytes
alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
Returns:
str: Base58 encoded string with checksum
Raises:
TypeError: If alphabet index is not a Base58Alphabets enumerative
"""
# Append checksum and encode all together
return Base58Encoder.Encode(data_bytes + Base58Utils.ComputeChecksum(data_bytes), alph_idx)
class Base58Decoder:
""" Base58 decoder class. It provides methods for decoding and checksum decoding Base58 format. """
@staticmethod
def Decode(data_str, alph_idx = Base58Alphabets.BITCOIN):
""" Decode bytes from a Base58 string.
Args:
data_bytes (bytes) : Data bytes
alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
Returns:
bytes: Base58 decoded bytes
Raises:
TypeError: If alphabet index is not a Base58Alphabets enumerative
"""
if not isinstance(alph_idx, Base58Alphabets):
raise TypeError("Alphabet index is not an enumerative of Base58Alphabets")
# Get alphabet
alphabet = Base58Const.ALPHABETS[alph_idx]
# Convert string to integer
val = 0
for i, c in enumerate(data_str[::-1]):
val += alphabet.index(c) * (Base58Const.RADIX ** i)
dec = bytearray()
while val > 0:
val, mod = divmod(val, 256)
dec.append(mod)
# Get padding length
pad_len = len(data_str) - len(data_str.lstrip(alphabet[0]))
# Add padding
return (b"\x00" * pad_len) + bytes(dec[::-1])
@staticmethod
def CheckDecode(data_str, alph_idx = Base58Alphabets.BITCOIN):
""" Decode bytes from a Base58 string with checksum.
Args:
data_bytes (bytes) : Data bytes
alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
Returns:
bytes: Base58 decoded bytes (checksum removed)
Raises:
ValueError: If the string is not a valid Base58 format
TypeError: If alphabet index is not a Base58Alphabets enumerative
Base58ChecksumError: If checksum is not valid
"""
# Decode string
dec_bytes = Base58Decoder.Decode(data_str, alph_idx)
# Get data and checksum bytes
data_bytes, checksum_bytes = dec_bytes[:-Base58Const.CHECKSUM_BYTE_LEN], dec_bytes[-Base58Const.CHECKSUM_BYTE_LEN:]
# Compute checksum
comp_checksum = Base58Utils.ComputeChecksum(data_bytes)
# Verify checksum
if checksum_bytes != comp_checksum:
raise Base58ChecksumError("Invalid checksum (expected %s, got %s)" % (comp_checksum, checksum_bytes))
return data_bytes | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/base58.py | 0.932407 | 0.345022 | base58.py | pypi |
# Imports
from . import utils
class CoinNames:
""" Helper class for representing coin names. """
def __init__(self, name, abbr):
""" Construct class.
Args:
name (str): Name
abbr (str): Abbreviation
"""
self.m_name = name
self.m_abbr = abbr
def Name(self):
""" Get name.
Returns :
str: Name
"""
return self.m_name
def Abbreviation(self):
""" Get abbreviation.
Returns:
str: Abbreviation
"""
return self.m_abbr
class KeyNetVersions:
""" Helper class for representing key net versions. """
def __init__(self, pub_net_ver, priv_net_ver):
""" Construct class.
Args:
pub_net_ver (bytes) : Public net version
priv_net_ver (bytes): Private net version
"""
self.m_pub_net_ver = utils.HexStringToBytes(pub_net_ver)
self.m_priv_net_ver = utils.HexStringToBytes(priv_net_ver)
def Public(self):
""" Get public net version.
Returns:
bytes: Public net version
"""
return self.m_pub_net_ver
def Private(self):
""" Get private net version.
Returns:
bytes: Private net version
"""
return self.m_priv_net_ver
class NetVersions:
""" Helper class for representing net versions. """
def __init__(self, main_net_ver = None, test_net_ver = None):
""" Construct class.
Args:
main_net_ver (object): Main net version, None by default
test_net_ver (object): Test net verions, None by default
"""
self.m_main_net_ver = main_net_ver
self.m_test_net_ver = test_net_ver
def Main(self):
""" Get main net version.
Returns:
object: Main net version
"""
return self.m_main_net_ver
def Test(self):
""" Get test net version.
Returns:
object: Test net version
"""
return self.m_test_net_ver | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip_coin_conf_helper.py | 0.884227 | 0.225353 | bip_coin_conf_helper.py | pypi |
# Imports
from .bip_coin_base import BipCoinBase
from .bip_coin_conf import *
from .P2SH import P2SH
class Bip49Coin(BipCoinBase):
""" Generic class for BIP-049 coins. """
def __init__(self, coin_conf, is_testnet, addr_fct):
""" Construct class.
Args:
coin_conf (class): Coin configuration class
is_testnet (bool): True if test net, false otherwise
addr_fct (class) : Address class
"""
super().__init__(coin_conf, coin_conf.BIP49_KEY_NET_VER, is_testnet, addr_fct)
class Bip49Litecoin(Bip49Coin):
""" Litecoin BIP-0044 class.
It overrides KeyNetVersions to return different main net versions depending on the configuration.
"""
def KeyNetVersions(self):
""" Get key net versions. It overrides the method in BipCoinBase.
Litecoin overrides the method because it can have 2 different main net versions.
Returns:
KeyNetVersions object: KeyNetVersions object
"""
# Get standard or alternate version depending on the configuration flag
if not self.m_is_testnet:
return self.m_key_net_ver.Main()[0] if not self.m_coin_conf.EX_KEY_ALT else self.m_key_net_ver.Main()[1]
else:
return self.m_key_net_ver.Test()
def ComputeAddress(self, pub_key):
""" Compute address from public key.
Litecoin overrides the method because it can have 2 different address versions.
Args:
pub_key (BipPublicKey object): BipPublicKey object
Returns:
str: Address string
"""
p2sh_ver = self.m_coin_conf.P2SH_NET_VER if not self.m_coin_conf.P2SH_DEPR_ADDR else self.m_coin_conf.P2SH_DEPR_NET_VER
addr_ver = p2sh_ver.Main() if not self.m_is_testnet else p2sh_ver.Test()
return self.m_addr_fct.ToAddress(pub_key.RawCompressed().ToBytes(), addr_ver)
# Configuration for Bitcoin main net
Bip49BitcoinMainNet = Bip49Coin(coin_conf = BitcoinConf,
is_testnet = False,
addr_fct = P2SH)
# Configuration for Bitcoin test net
Bip49BitcoinTestNet = Bip49Coin(coin_conf = BitcoinConf,
is_testnet = True,
addr_fct = P2SH)
# Configuration for Litecoin main net
Bip49LitecoinMainNet = Bip49Litecoin(coin_conf = LitecoinConf,
is_testnet = False,
addr_fct = P2SH)
# Configuration for Litecoin test net
Bip49LitecoinTestNet = Bip49Litecoin(coin_conf = LitecoinConf,
is_testnet = True,
addr_fct = P2SH)
# Configuration for Dogecoin main net
Bip49DogecoinMainNet = Bip49Coin(coin_conf = DogecoinConf,
is_testnet = False,
addr_fct = P2SH)
# Configuration for Dogecoin test net
Bip49DogecoinTestNet = Bip49Coin(coin_conf = DogecoinConf,
is_testnet = True,
addr_fct = P2SH)
# Configuration for Dash main net
Bip49DashMainNet = Bip49Coin(coin_conf = DashConf,
is_testnet = False,
addr_fct = P2SH)
# Configuration for Dash test net
Bip49DashTestNet = Bip49Coin(coin_conf = DashConf,
is_testnet = True,
addr_fct = P2SH) | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip49_coins.py | 0.82559 | 0.199366 | bip49_coins.py | pypi |
# Imports
from .P2PKH import P2PKH
from .P2SH import P2SH
from .P2WPKH import P2WPKH
from .eth_addr import EthAddr
from .xrp_addr import XrpAddr
class BipCoinBase:
""" Bip coin base class. It's the base class for BipCoin classes (e.g. Bip44Coin, Bip49Coin).
It basically wraps the coin configuration allowing to get through methods.
"""
def __init__(self, coin_conf, key_net_ver, is_testnet, addr_fct):
""" Construct class.
Args:
coin_conf (class) : Coin configuration class
key_net_ver (KeyNetVersions object): Key net versions
is_testnet (bool) : True if test net, false otherwise
addr_fct (class) : Address class
"""
self.m_coin_conf = coin_conf
self.m_key_net_ver = key_net_ver
self.m_is_testnet = is_testnet
self.m_addr_fct = addr_fct
def KeyNetVersions(self):
""" Get key net versions.
Returns:
KeyNetVersions object: KeyNetVersions object
"""
return self.m_key_net_ver.Main() if not self.m_is_testnet else self.m_key_net_ver.Test()
def WifNetVersion(self):
""" Get WIF net version.
Returns:
bytes: WIF net version bytes
None: If WIF is not supported
"""
return self.m_coin_conf.WIF_NET_VER.Main() if not self.m_is_testnet else self.m_coin_conf.WIF_NET_VER.Test()
def IsTestNet(self):
""" Get if test net
Returns:
bool: True if test net, false otherwise
"""
return self.m_is_testnet
def CoinNames(self):
""" Get coin names.
Returns:
CoinNames object: CoinNames object
"""
return self.m_coin_conf.NAMES if not self.m_is_testnet else self.m_coin_conf.TEST_NAMES
def ComputeAddress(self, pub_key):
""" Compute address from public key.
Args:
pub_key (BipPublicKey object): BipPublicKey object
Returns:
str: Address string
"""
# This if-else can be avoided by creating a child class for each address, but I leave it here for now since
# there are few different address functions.
# P2PKH
if self.m_addr_fct is P2PKH:
addr_ver = self.m_coin_conf.P2PKH_NET_VER.Main() if not self.m_is_testnet else self.m_coin_conf.P2PKH_NET_VER.Test()
return self.m_addr_fct.ToAddress(pub_key.RawCompressed().ToBytes(), addr_ver)
# P2SH
elif self.m_addr_fct is P2SH:
addr_ver = self.m_coin_conf.P2SH_NET_VER.Main() if not self.m_is_testnet else self.m_coin_conf.P2SH_NET_VER.Test()
return self.m_addr_fct.ToAddress(pub_key.RawCompressed().ToBytes(), addr_ver)
# P2WPKH
elif self.m_addr_fct is P2WPKH:
addr_ver = self.m_coin_conf.P2WPKH_NET_VER.Main() if not self.m_is_testnet else self.m_coin_conf.P2WPKH_NET_VER.Test()
return self.m_addr_fct.ToAddress(pub_key.RawCompressed().ToBytes(), addr_ver)
# EthAddr
elif self.m_addr_fct is EthAddr:
return self.m_addr_fct.ToAddress(pub_key.RawUncompressed().ToBytes())
# XrpAddr
elif self.m_addr_fct is XrpAddr:
return self.m_addr_fct.ToAddress(pub_key.RawCompressed().ToBytes())
else:
raise RuntimeError("Invalid address class") | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip_coin_base.py | 0.766206 | 0.222521 | bip_coin_base.py | pypi |
# Imports
import binascii
import hashlib
import hmac
from bisect import bisect_left
def Sha256(data_bytes):
""" Compute the SHA256 of the specified bytes.
Args:
data_bytes (bytes): Data bytes
Returns:
bytes: Computed SHA256
"""
return hashlib.sha256(data_bytes).digest()
def Sha256DigestSize():
""" Get the SHA256 digest size in bytes.
Returns:
int: SHA256 digest size in bytes
"""
return hashlib.sha256().digest_size
def HmacSha512(key_bytes, data_bytes):
""" Compute the HMAC-SHA512 of the specified bytes with the specified key.
Args:
key_bytes (bytes) : Key bytes
data_bytes (bytes): Data bytes
Returns:
bytes: Computed HMAC-SHA512
"""
return hmac.new(key_bytes, data_bytes, hashlib.sha512).digest()
def Pbkdf2HmacSha512(password_bytes, salt_bytes, itr_num):
""" Compute the PBKDF2 HMAC-SHA512 of the specified password, using the specified keys and iteration number.
Args:
password_bytes (bytes): Password bytes
salt_bytes (bytes) : Salt bytes
itr_num (int) : Iteration number
Returns:
bytes: Computed PBKDF2 HMAC-SHA512
"""
return hashlib.pbkdf2_hmac("sha512", password_bytes, salt_bytes, itr_num)
def Hash160(data_bytes):
""" Compute the Bitcoin Hash-160 of the specified bytes.
Args:
data_bytes (bytes): Data bytes
Returns:
bytes: Computed Hash-160
"""
return hashlib.new("ripemd160", hashlib.sha256(data_bytes).digest()).digest()
def BytesToInteger(data_bytes):
""" Convert the specified bytes to integer.
Args:
data_bytes (bytes): Data bytes
Returns:
int: Integer representation
"""
return int(binascii.hexlify(data_bytes), 16)
def BytesToBinaryStr(data_bytes, zero_pad = 0):
""" Convert the specified bytes to a binary string.
Args:
data_bytes (bytes) : Data bytes
zero_pad (int, optional): Zero padding, 0 if not specified
Returns:
str: Binary string
"""
return IntToBinaryStr(BytesToInteger(data_bytes), zero_pad)
def IntToBinaryStr(data_int, zero_pad = 0):
""" Convert the specified integer to a binary string.
Args:
data_int (int) : Data integer
zero_pad (int, optional): Zero padding, 0 if not specified
Returns:
str: Binary string
"""
return bin(data_int)[2:].zfill(zero_pad)
def BytesFromBinaryStr(data_str, zero_pad = 0):
""" Convert the specified binary string to bytes.
Args:
data_str (str) : Data string
zero_pad (int, optional): Zero padding, 0 if not specified
Returns:
bytes: Bytes representation
"""
return binascii.unhexlify(hex(int(data_str, 2))[2:].zfill(zero_pad))
def ListToBytes(data_list):
""" Convert the specified list to bytes
Args:
data_list (list): Data list
Returns:
bytes: Correspondent bytes representation
"""
return bytes(bytearray(data_list))
def BytesToHexString(data_bytes, encoding = "utf-8"):
""" Convert bytes to hex string.
Args:
data_bytes (str): Data bytes
encoding (str) : Encoding type
Returns:
str: Bytes converted to hex string
"""
return binascii.hexlify(data_bytes).decode(encoding)
def HexStringToBytes(data_str):
""" Convert hex string to bytes.
Args:
data_str (str): Data bytes
Returns
bytes: Hex string converted to bytes
"""
return binascii.unhexlify(data_str)
def StringEncode(data_str, encoding = "utf-8"):
""" Encode string to bytes.
Args:
data_str (str): Data string
encoding (str): Encoding type
Returns:
bytes: String encoded to bytes
"""
return data_str.encode(encoding)
def BinarySearch(arr, elem):
""" Binary search algorithm simply implemented by using the bisect library.
Args:
arr (list): list of elements
elem (any): element to be searched
Returns:
int: First index of the element, -1 if not found
"""
i = bisect_left(arr, elem)
if i != len(arr) and arr[i] == elem:
return i
else:
return -1 | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/utils.py | 0.932844 | 0.795738 | utils.py | pypi |
# Import
from .bip32_utils import Bip32Utils
class Bip32PathParserConst:
""" Class container for path parser constants. """
# Hardened characters
HARDENED_CHARS = ("'", "p")
# Master character
MASTER_CHAR = "m"
class Bip32PathParser:
""" Path parser class. It parses a BIP-0032 path and return a list of its indexes. """
@staticmethod
def Parse(path, skip_master = False):
""" Validate a path.
Args:
path (str) : Path
skip_master (bool, optional): True to skip the master in path (e.g. 0/1/2), false otherwise (e.g. m/0/1/2)
Returns:
list: List with path indexes
"""
return Bip32PathParser.__ParseElems(path.split("/"), skip_master)
@staticmethod
def __ParseElems(path_elems, skip_master):
""" Parse path elements.
Args:
path_elems (list) : Path element list
skip_master (bool, optional): True to skip the master in path (e.g. 0/1/2), false otherwise (e.g. m/0/1/2)
Returns:
list: List with path indexes
"""
path_list = []
# Check each element
for i in range(len(path_elems)):
path_elem = path_elems[i].strip()
# Skip last empty element if any
if len(path_elem) == 0 and i == len(path_elems) - 1:
continue
# If path starts from master, the first element shall be "m"
if i == 0 and not skip_master:
if path_elem != Bip32PathParserConst.MASTER_CHAR:
return []
path_list.append(Bip32PathParserConst.MASTER_CHAR)
else:
# Get index
path_idx = Bip32PathParser.__GetElemIndex(path_elem)
# Check it
if path_idx is None:
return []
# Add it to the list
path_list.append(path_idx)
return path_list
@staticmethod
def __GetElemIndex(path_elem):
""" Get index of a path element.
Args:
path_elem (str): Path element
Returns:
int: Index of the element
None: If the element is not a valid index
"""
# Get if hardened
is_hardened = len(path_elem) > 0 and path_elem[-1] in Bip32PathParserConst.HARDENED_CHARS
# If hardened, remove the last character from the string
if is_hardened:
path_elem = path_elem[:-1]
# The remaining string shall be numeric
if not path_elem.isnumeric():
return None
return int(path_elem) if not is_hardened else Bip32Utils.HardenIndex(int(path_elem)) | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip32_path.py | 0.814016 | 0.441071 | bip32_path.py | pypi |
# Imports
from .base58 import Base58Decoder, Base58Encoder
from .bip32_ex import Bip32KeyError
class Bip32KeySerConst:
""" Class container for BIP32 key serialize constants. """
# Extended key length
EXTENDED_KEY_LEN = 78
class Bip32KeyDeserializer:
""" BIP32key deserializer class. It deserializes a key. """
def __init__(self, key_str):
""" Construct class.
Args:
key_str (str): Serialized key string
"""
self.m_key_str = key_str
self.m_depth = 0
self.m_fprint = b""
self.m_index = 0
self.m_chain = b""
self.m_secret = b""
self.m_is_public = False
def DeserializeKey(self, key_net_ver):
""" Deserialize a key.
Args:
key_net_ver (KeyNetVersions object): Key net versions object
"""
# Decode key
key_bytes = Base58Decoder.CheckDecode(self.m_key_str)
# Check length
if len(key_bytes) != Bip32KeySerConst.EXTENDED_KEY_LEN:
raise Bip32KeyError("Invalid extended key (wrong length)")
# Get if key is public/private depending on net version
if key_bytes[:4] == key_net_ver.Public():
self.m_is_public = True
elif key_bytes[:4] == key_net_ver.Private():
self.m_is_public = False
else:
raise Bip32KeyError("Invalid extended key (wrong net version)")
# De-serialize key
self.m_depth = key_bytes[4]
self.m_fprint = key_bytes[5:9]
self.m_index = int.from_bytes(key_bytes[9:13], "big")
self.m_chain = key_bytes[13:45]
self.m_secret = key_bytes[45:78]
def GetKeyParts(self):
""" Get deserialized key parts.
Returns:
tuple: Deserialized key parts
"""
return self.m_depth, self.m_fprint, self.m_index, self.m_chain, self.m_secret
def IsPublic(self):
""" Get if deserialized key is public.
Returns:
bool: True if public, false otherwise
"""
return self.m_is_public
class Bip32KeySerializer:
""" BIP32key serializer class. It serializes private/public keys. """
def __init__(self, bip32_obj):
""" Construct class.
Args:
bip32_obj (Bip32 object): Bip32 object
"""
self.m_bip32_obj = bip32_obj
def SerializePublicKey(self):
""" Serialize the Bip32 object public key.
Returns:
bytes: Serialized public key
"""
return self.__SerializeKey(self.m_bip32_obj.PublicKey().RawCompressed().ToBytes(),
self.m_bip32_obj.KeyNetVersions().Public())
def SerializePrivateKey(self):
""" Serialize the Bip32 object private key.
Returns:
str: Serialized private key
"""
return self.__SerializeKey(b"\x00" + self.m_bip32_obj.PrivateKey().Raw().ToBytes(),
self.m_bip32_obj.KeyNetVersions().Private())
def __SerializeKey(self, key_bytes, key_net_ver):
""" Serialize the specified key bytes.
Args:
key_bytes (bytes) : Key bytes
key_net_ver (bytes): Key net version
Returns:
str: Serialized key
"""
# Get Bip32 data for serializing
depth = self.m_bip32_obj.Depth().to_bytes(1, "big")
fprint = self.m_bip32_obj.ParentFingerPrint()
index = self.m_bip32_obj.Index().to_bytes(4, "big")
chain = self.m_bip32_obj.Chain()
# Serialize key
ser_key = key_net_ver + depth + fprint + index + chain + key_bytes
# Encode it
return Base58Encoder.CheckEncode(ser_key) | /retro_bip_utils-1.0.5-py3-none-any.whl/retro_bip_utils/bip32_key_ser.py | 0.878445 | 0.17259 | bip32_key_ser.py | pypi |
from __future__ import annotations
import io
import math
import construct
import lzokay
from construct import Adapter, GreedyRange
class CompressedLZO(construct.Tunnel):
def __init__(self, subcon, length):
super().__init__(subcon)
self.lib = lzokay
self.length = length
def _decode(self, data, context, path):
length = construct.evaluate(self.length, context)
return self.lib.decompress(data, length)
def _encode(self, data, context, path):
return self.lib.compress(data)
class LZOSegment(construct.Subconstruct):
def __init__(self, decompressed_size):
super().__init__(CompressedLZO(construct.GreedyBytes, decompressed_size))
self.decompressed_size = decompressed_size
def _parse(self, stream, context, path):
decompressed_size = construct.evaluate(self.decompressed_size, context)
length = construct.Int16sb._parsereport(stream, context, path)
data = construct.stream_read(stream, abs(length), path)
if length > 0:
result = self.subcon._parsereport(io.BytesIO(data), context, path)
if len(result) != decompressed_size:
raise construct.StreamError(
f"Expected to decompress {decompressed_size} bytes, got {len(result)}", path
)
return result
else:
return data
def _build(self, uncompressed, stream, context, path):
stream2 = io.BytesIO()
buildret = self.subcon._build(uncompressed, stream2, context, path)
compressed_data = stream2.getvalue()
if len(compressed_data) < len(uncompressed):
construct.Int16sb._build(len(compressed_data), stream, context, path)
construct.stream_write(stream, compressed_data, len(compressed_data), path)
return buildret
else:
construct.Int16sb._build(-len(uncompressed), stream, context, path)
construct.stream_write(stream, uncompressed, len(uncompressed), path)
return buildret
class LZOCompressedBlock(Adapter):
def __init__(self, decompressed_size, segment_size=0x4000):
super().__init__(GreedyRange(LZOSegment(self._actual_segment_size)))
self.decompressed_size = decompressed_size
self.segment_size = segment_size
def _actual_segment_size(self, context):
decompressed_size = construct.evaluate(self.decompressed_size, context)
segment_size = construct.evaluate(self.segment_size, context)
previous_segments = context._index * segment_size
if previous_segments > decompressed_size:
# This segment is redundant!
raise construct.StopFieldError
elif previous_segments + segment_size > decompressed_size:
# Last segment
return decompressed_size - previous_segments
else:
# Another segment with this size
return segment_size
def _decode(self, segments, context, path):
return b"".join(segments)
def _encode(self, uncompressed, context, path):
decompressed_size = construct.evaluate(self.decompressed_size, context)
if decompressed_size != len(uncompressed):
raise ValueError(
"Decompressed size {} doesn't match size of data to compress ({}) at {}".format(
decompressed_size,
len(uncompressed),
path,
)
)
segment_size = self.segment_size
return [
uncompressed[segment_size * i : segment_size * (i + 1)]
for i in range(math.ceil(len(uncompressed) / segment_size))
]
ZlibCompressedBlock = construct.Compressed(construct.GreedyBytes, "zlib", level=9) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/compression.py | 0.680985 | 0.21463 | compression.py | pypi |
from __future__ import annotations
import itertools
import construct
from construct import Const, Construct, FocusedSeq, Optional, Rebuild, len_, stream_tell, this
def PrefixedArrayWithExtra(countfield, extrafield, subcon):
r"""
Prefixes an array with item count (as opposed to prefixed by byte count, see :class:`~construct.core.Prefixed`),
with an extra field between the count and the data.
Example::
>>> d = PrefixedArrayWithExtra(Int32ub, Int32ub, GreedyRange(Int32ul))
>>> d.parse(b"\x08abcdefgh")
[1684234849, 1751606885]
>>> d = PrefixedArrayWithExtra(Int32ub, Int32ub, Int32ul)
>>> d.parse(b"\x02abcdefgh")
[1684234849, 1751606885]
"""
macro = FocusedSeq(
"items",
"count" / Rebuild(countfield, len_(this.items)),
"extra" / extrafield,
"items" / subcon[this.count],
)
def _actualsize(self, stream, context, path):
position1 = stream_tell(stream, path)
count = countfield._parse(stream, context, path)
position2 = stream_tell(stream, path)
return (position2 - position1) + count * subcon._sizeof(context, path) + extrafield._sizeof(context, path)
macro._actualsize = _actualsize
def _emitseq(ksy, bitwise):
return [
{"id": "countfield", "type": countfield._compileprimitivetype(ksy, bitwise)},
{"id": "extra", "type": extrafield._compileprimitivetype(ksy, bitwise)},
{
"id": "data",
"type": subcon._compileprimitivetype(ksy, bitwise),
"repeat": "expr",
"repeat_expr": "countfield",
},
]
macro._emitseq = _emitseq
return macro
def BitwiseWith32Blocks(subcon):
"""
Bit level decoding in Retro's format are done from least significant bit, but in blocks of 32 bits.
"""
return construct.Restreamed(
subcon,
lambda data: bytes(reversed(construct.bytes2bits(data))),
4,
lambda data: construct.bits2bytes(bytes(reversed(data))),
32,
lambda n: n // 32,
)
def Skip(count, subcon):
return construct.Seek(count * subcon.length, 1)
class LazyPatchedForBug(construct.Lazy):
r"""
See https://github.com/construct/construct/issues/938
"""
def _parse(self, stream, context, path):
offset = stream_tell(stream, path)
def execute():
fallback = stream_tell(stream, path)
construct.stream_seek(stream, offset, 0, path)
obj = self.subcon._parsereport(stream, context, path)
construct.stream_seek(stream, fallback, 0, path)
return obj
length = self.subcon._actualsize(stream, context, path)
construct.stream_seek(stream, length, 1, path)
return execute
class ErrorWithMessage(Construct):
def __init__(self, message):
super().__init__()
self.message = message
self.flagbuildnone = True
def _parse(self, stream, context, path):
message = construct.evaluate(self.message, context)
raise construct.ExplicitError(f"Error field was activated during parsing with error {message}", path=path)
def _build(self, obj, stream, context, path):
message = construct.evaluate(self.message, context)
raise construct.ExplicitError(f"Error field was activated during building with error {message}", path=path)
def _sizeof(self, context, path):
raise construct.SizeofError("Error does not have size, because it interrupts parsing and building", path=path)
def LabeledOptional(label, subcon):
return Optional(
FocusedSeq(
"subcon",
Const(label),
"subcon" / subcon,
)
)
class UntilEof(construct.Subconstruct):
def _parse(self, stream, context, path):
obj = construct.ListContainer()
for i in itertools.count():
if construct.stream_iseof(stream):
return obj
context._index = i
e = self.subcon._parsereport(stream, context, path)
obj.append(e)
def _build(self, obj, stream, context, path):
retlist = construct.ListContainer()
for i, e in enumerate(obj):
context._index = i
buildret = self.subcon._build(e, stream, context, path)
retlist.append(buildret)
return retlist
def _sizeof(self, context, path):
raise construct.SizeofError("cannot calculate size, amount depends on actual data", path=path) | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/construct_extensions/misc.py | 0.871338 | 0.33805 | misc.py | pypi |
from __future__ import annotations
from typing import TYPE_CHECKING
from retro_data_structures.conversion.errors import UnsupportedSourceGame, UnsupportedTargetGame
from retro_data_structures.game_check import Game
if TYPE_CHECKING:
from retro_data_structures.conversion.asset_converter import AssetConverter, AssetDetails, Resource
def convert_from_prime(data: Resource, details: AssetDetails, converter: AssetConverter):
if converter.target_game != Game.ECHOES:
raise UnsupportedTargetGame(Game.PRIME, converter.target_game)
total_vertices = 0
vertex_sizes = {}
bones = {}
for i, vertex_group in enumerate(data["vertex_groups"]):
vertex_sizes[i] = vertex_group["vertex_count"]
for weight in vertex_group["weights_array"]:
bones[i] = weight["bone_id"]
weight["bone_id"] = weight["bone_id"] - 3
total_vertices += vertex_group["vertex_count"]
data["footer"]["pool_to_skin_idx"] = [None] * (-(len(data["vertex_groups"]) // -10) * 10)
for i in range(-(len(data["vertex_groups"]) // -10) * 10):
data["footer"]["pool_to_skin_idx"][i] = 0xFFFF
for i in range(len(list(set(bones.values())))):
data["footer"]["pool_to_skin_idx"][i] = i
for i, size in enumerate(vertex_sizes.values()):
data["footer"]["trailing_bytes"] += i.to_bytes(1, "big") * size
return data
def convert_from_echoes(data: Resource, details: AssetDetails, converter: AssetConverter):
if converter.target_game != Game.PRIME:
raise UnsupportedTargetGame(Game.ECHOES, converter.target_game)
total_vertices = 0
for i, vertex_group in enumerate(data["vertex_groups"]):
for weight in vertex_group["weights_array"]:
weight["bone_id"] = weight["bone_id"] + 3
total_vertices += vertex_group["vertex_count"]
data["footer"] = {
"unk_a": {"first": 0xFFFFFFFF, "other": total_vertices},
"unk_b": {"first": 0xFFFFFFFF, "other": total_vertices},
"trailing_bytes": b"",
}
return data
def convert_from_corruption(data: Resource, details: AssetDetails, converter: AssetConverter):
raise UnsupportedSourceGame(Game.CORRUPTION)
CONVERTERS = {
Game.PRIME: convert_from_prime,
Game.ECHOES: convert_from_echoes,
Game.CORRUPTION: convert_from_corruption,
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/conversion/cskr.py | 0.706494 | 0.219505 | cskr.py | pypi |
from __future__ import annotations
from typing import TYPE_CHECKING
from retro_data_structures.conversion.errors import UnsupportedSourceGame, UnsupportedTargetGame
from retro_data_structures.game_check import Game
if TYPE_CHECKING:
from retro_data_structures.conversion.asset_converter import AssetConverter, AssetDetails, Resource
_BONE_NAME_MAPPING = {
"Skeleton_Root": 1,
"root": 0,
"Electric": 6,
"WBbottom_SDK": 4,
"WBtop_SDK": 3,
"move_SDK": 2,
"snaplocators": 5,
"Missile_Launcher_SDK": 3,
"grapple_SDK": 2,
"skeleton_root": 1,
"can_SDK": 3,
"visor_SDK": 2,
"EnergyTank_SDK": 2,
"MorphBall_Pickup_SDK": 2,
"bomb_SDK": 2,
"power_SDK": 2,
"powerbombleft_SDK": 3,
"powerbombright_SDK": 2,
"Powerup_SDK": 2,
"bottom_piece": 4,
"cubes": 2,
"top_piece": 5,
"trails": 3,
"midring_SDK": 4,
"outring_SDK": 3,
"rotate_SDK": 2,
}
def _convert_particles(data, converter: AssetConverter, source_game: Game):
for poi_node in data["particle_poi_nodes"]:
poi_node["particle"]["id"] = converter.convert_id(poi_node["particle"]["id"], source_game)
def convert_from_prime(data: Resource, details: AssetDetails, converter: AssetConverter):
if converter.target_game != Game.ECHOES:
raise UnsupportedTargetGame(Game.PRIME, converter.target_game)
for particle_poi_node in data["particle_poi_nodes"]:
particle_poi_node["base"]["unk_1"] = 2
for i, poi_node in enumerate(data["particle_poi_nodes"]):
poi_node["bone_id"] = _BONE_NAME_MAPPING.get(poi_node["bone_name"], i)
poi_node["bone_name"] = None
for i, sound_poi_node in enumerate(data["sound_poi_nodes"]):
sound_poi_node["base"]["unk_1"] = 2
sound_poi_node["sound_id"] = 0x80002748
sound_poi_node["echoes"] = {"unk_a": 0, "unk_b": 7372, "unk_c": 7372, "unk_d": 0}
_convert_particles(data, converter, Game.PRIME)
return data
def convert_from_echoes(data: Resource, details: AssetDetails, converter: AssetConverter):
if converter.target_game != Game.PRIME:
raise UnsupportedTargetGame(Game.ECHOES, converter.target_game)
for particle_poi_node in data["particle_poi_nodes"]:
particle_poi_node["base"]["unk_1"] = 1
for i, poi_node in enumerate(data["particle_poi_nodes"]):
bone_name = str(poi_node["base"]["name"]).split("-", 1)
poi_node["bone_name"] = f"{bone_name[0]}" # HACK - Not sure this will always work...?
poi_node["bone_id"] = None
for i, sound_poi_node in enumerate(data["sound_poi_nodes"]):
sound_poi_node["base"]["unk_1"] = 1
sound_poi_node["sound_id"] = 0x80000074
sound_poi_node["echoes"] = None
_convert_particles(data, converter, Game.ECHOES)
return data
def convert_from_corruption(data: Resource, details: AssetDetails, converter: AssetConverter):
raise UnsupportedSourceGame(Game.CORRUPTION)
CONVERTERS = {
Game.PRIME: convert_from_prime,
Game.ECHOES: convert_from_echoes,
Game.CORRUPTION: convert_from_corruption,
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/conversion/evnt.py | 0.736021 | 0.259855 | evnt.py | pypi |
from __future__ import annotations
import dataclasses
import io
import typing
from abc import ABC
if typing.TYPE_CHECKING:
from retro_data_structures.asset_manager import AssetManager
from retro_data_structures.base_resource import AssetId, Dependency
from retro_data_structures.game_check import Game
Self = typing.TypeVar("Self", bound="BaseProperty")
class BaseProperty:
@classmethod
def game(cls) -> Game:
raise NotImplementedError
@classmethod
def from_stream(cls: type[Self], data: typing.BinaryIO, size: int | None = None) -> Self:
raise NotImplementedError
@classmethod
def from_bytes(cls: type[Self], data: bytes) -> Self:
stream = io.BytesIO(data)
return cls.from_stream(stream, len(data))
def to_stream(self, data: typing.BinaryIO) -> None:
raise NotImplementedError
def to_bytes(self) -> bytes:
stream = io.BytesIO()
self.to_stream(stream)
return stream.getvalue()
@classmethod
def from_json(cls: type[Self], data: typing.Any) -> Self:
raise NotImplementedError
def to_json(self) -> typing.Any:
raise NotImplementedError
def _is_property_mrea_or_mlvl(self, field: dataclasses.Field) -> bool:
asset_types = field.metadata.get("asset_types", [])
return any((typ in asset_types) for typ in ("MLVL", "MREA"))
def _dependencies_for_field(
self, field: dataclasses.Field, asset_manager: AssetManager
) -> typing.Iterator[Dependency]:
if issubclass(field.type, BaseProperty):
prop: BaseProperty = getattr(self, field.name)
yield from prop.dependencies_for(asset_manager)
elif issubclass(field.type, int) and "sound" in field.metadata:
sound_id: int = getattr(self, field.name)
yield from asset_manager.get_audio_group_dependency(sound_id)
elif issubclass(field.type, int) and (field.default == 0xFFFFFFFF or "asset_types" in field.metadata):
if self._is_property_mrea_or_mlvl(field):
return
asset_id: AssetId = getattr(self, field.name)
yield from asset_manager.get_dependencies_for_asset(asset_id)
def dependencies_for(self, asset_manager: AssetManager) -> typing.Iterator[Dependency]:
for field in dataclasses.fields(self):
try:
yield from self._dependencies_for_field(field, asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for {self.__class__.__name__}.{field.name} ({field.type}): {e}"
)
class BaseObjectType(BaseProperty, ABC):
@classmethod
def object_type(cls) -> str | int:
raise NotImplementedError
@classmethod
def modules(cls) -> list[str]:
return []
def get_name(self) -> str | None:
raise NotImplementedError
def set_name(self, name: str) -> None:
raise NotImplementedError | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/base_property.py | 0.823577 | 0.242385 | base_property.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class ProjectileAttackBehaviorData(BaseProperty):
attack_range_squared: float = dataclasses.field(default=0.0)
use_horizontal_range_only: bool = dataclasses.field(default=False)
projectile_interval: float = dataclasses.field(default=5.0)
projectiles_in_salvo: int = dataclasses.field(default=1)
salvo_interval: float = dataclasses.field(default=3.0)
initial_projectile_delay: float = dataclasses.field(default=0.0)
launcher_specifies_launch_transform: bool = dataclasses.field(default=False)
fire_if_target_is_behind: bool = dataclasses.field(default=True)
fire_if_target_is_tar_inhibited: bool = dataclasses.field(default=True)
stop_while_firing: bool = dataclasses.field(default=False)
enforce_attack_requirements_at_launch_time: bool = dataclasses.field(default=False)
enforce_range_requirement_at_launch_time: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\xde[\xfca') # 0xde5bfc61
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_range_squared))
data.write(b'|\x16\xe2i') # 0x7c16e269
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_horizontal_range_only))
data.write(b'\xd4\x90<\x98') # 0xd4903c98
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_interval))
data.write(b'")\xb3~') # 0x2229b37e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.projectiles_in_salvo))
data.write(b'\x19\xd7\xae\x87') # 0x19d7ae87
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.salvo_interval))
data.write(b'\xfc\x9cw\xd8') # 0xfc9c77d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_projectile_delay))
data.write(b'\xbb\xd4U\xd6') # 0xbbd455d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.launcher_specifies_launch_transform))
data.write(b'\xafE"v') # 0xaf452276
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fire_if_target_is_behind))
data.write(b'\xf1\x00LR') # 0xf1004c52
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fire_if_target_is_tar_inhibited))
data.write(b'\xa1\x9d\xb1\xdf') # 0xa19db1df
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stop_while_firing))
data.write(b'\xf5\xa5<\xc1') # 0xf5a53cc1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enforce_attack_requirements_at_launch_time))
data.write(b'\x9d\x06\xb0\xfe') # 0x9d06b0fe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enforce_range_requirement_at_launch_time))
@classmethod
def from_json(cls, data: dict):
return cls(
attack_range_squared=data['attack_range_squared'],
use_horizontal_range_only=data['use_horizontal_range_only'],
projectile_interval=data['projectile_interval'],
projectiles_in_salvo=data['projectiles_in_salvo'],
salvo_interval=data['salvo_interval'],
initial_projectile_delay=data['initial_projectile_delay'],
launcher_specifies_launch_transform=data['launcher_specifies_launch_transform'],
fire_if_target_is_behind=data['fire_if_target_is_behind'],
fire_if_target_is_tar_inhibited=data['fire_if_target_is_tar_inhibited'],
stop_while_firing=data['stop_while_firing'],
enforce_attack_requirements_at_launch_time=data['enforce_attack_requirements_at_launch_time'],
enforce_range_requirement_at_launch_time=data['enforce_range_requirement_at_launch_time'],
)
def to_json(self) -> dict:
return {
'attack_range_squared': self.attack_range_squared,
'use_horizontal_range_only': self.use_horizontal_range_only,
'projectile_interval': self.projectile_interval,
'projectiles_in_salvo': self.projectiles_in_salvo,
'salvo_interval': self.salvo_interval,
'initial_projectile_delay': self.initial_projectile_delay,
'launcher_specifies_launch_transform': self.launcher_specifies_launch_transform,
'fire_if_target_is_behind': self.fire_if_target_is_behind,
'fire_if_target_is_tar_inhibited': self.fire_if_target_is_tar_inhibited,
'stop_while_firing': self.stop_while_firing,
'enforce_attack_requirements_at_launch_time': self.enforce_attack_requirements_at_launch_time,
'enforce_range_requirement_at_launch_time': self.enforce_range_requirement_at_launch_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0xde5bfc61, 0x7c16e269, 0xd4903c98, 0x2229b37e, 0x19d7ae87, 0xfc9c77d8, 0xbbd455d6, 0xaf452276, 0xf1004c52, 0xa19db1df, 0xf5a53cc1, 0x9d06b0fe)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ProjectileAttackBehaviorData]:
if property_count != 12:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?LHfLHlLHfLHfLH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(99))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33]) != _FAST_IDS:
data.seek(before)
return None
return ProjectileAttackBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
)
def _decode_attack_range_squared(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_horizontal_range_only(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_projectile_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectiles_in_salvo(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_salvo_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_projectile_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_launcher_specifies_launch_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fire_if_target_is_behind(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fire_if_target_is_tar_inhibited(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_stop_while_firing(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enforce_attack_requirements_at_launch_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enforce_range_requirement_at_launch_time(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]]] = {
0xde5bfc61: ('attack_range_squared', _decode_attack_range_squared),
0x7c16e269: ('use_horizontal_range_only', _decode_use_horizontal_range_only),
0xd4903c98: ('projectile_interval', _decode_projectile_interval),
0x2229b37e: ('projectiles_in_salvo', _decode_projectiles_in_salvo),
0x19d7ae87: ('salvo_interval', _decode_salvo_interval),
0xfc9c77d8: ('initial_projectile_delay', _decode_initial_projectile_delay),
0xbbd455d6: ('launcher_specifies_launch_transform', _decode_launcher_specifies_launch_transform),
0xaf452276: ('fire_if_target_is_behind', _decode_fire_if_target_is_behind),
0xf1004c52: ('fire_if_target_is_tar_inhibited', _decode_fire_if_target_is_tar_inhibited),
0xa19db1df: ('stop_while_firing', _decode_stop_while_firing),
0xf5a53cc1: ('enforce_attack_requirements_at_launch_time', _decode_enforce_attack_requirements_at_launch_time),
0x9d06b0fe: ('enforce_range_requirement_at_launch_time', _decode_enforce_range_requirement_at_launch_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileAttackBehaviorData.py | 0.604516 | 0.263691 | ProjectileAttackBehaviorData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class IslandAreaStruct(BaseProperty):
cost: int = dataclasses.field(default=0)
purchase_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
comment_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'_\xed\\\x9d') # 0x5fed5c9d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.cost))
data.write(b'\x0c[M\xe6') # 0xc5b4de6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.purchase_text))
data.write(b'\x01At5') # 0x1417435
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.comment_text))
@classmethod
def from_json(cls, data: dict):
return cls(
cost=data['cost'],
purchase_text=data['purchase_text'],
comment_text=data['comment_text'],
)
def to_json(self) -> dict:
return {
'cost': self.cost,
'purchase_text': self.purchase_text,
'comment_text': self.comment_text,
}
_FAST_FORMAT = None
_FAST_IDS = (0x5fed5c9d, 0xc5b4de6, 0x1417435)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[IslandAreaStruct]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(38))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return IslandAreaStruct(
dec[2],
dec[5],
dec[8],
)
def _decode_cost(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_purchase_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_comment_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5fed5c9d: ('cost', _decode_cost),
0xc5b4de6: ('purchase_text', _decode_purchase_text),
0x1417435: ('comment_text', _decode_comment_text),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/IslandAreaStruct.py | 0.601125 | 0.262931 | IslandAreaStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerPeriodicAdditiveAnimationData(BaseProperty):
random_delay_minimum: float = dataclasses.field(default=3.0)
random_delay_maximum: float = dataclasses.field(default=6.0)
animation: int = dataclasses.field(default=0)
visibility_key: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'n22\x95') # 0x6e323295
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_delay_minimum))
data.write(b'\xfeA"\x7f') # 0xfe41227f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_delay_maximum))
data.write(b'\xaa\xcd\xb1\x1c') # 0xaacdb11c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation))
data.write(b'\x15\xdb\xa7A') # 0x15dba741
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.visibility_key.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
random_delay_minimum=data['random_delay_minimum'],
random_delay_maximum=data['random_delay_maximum'],
animation=data['animation'],
visibility_key=data['visibility_key'],
)
def to_json(self) -> dict:
return {
'random_delay_minimum': self.random_delay_minimum,
'random_delay_maximum': self.random_delay_maximum,
'animation': self.animation,
'visibility_key': self.visibility_key,
}
def _decode_random_delay_minimum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_delay_maximum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_visibility_key(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6e323295: ('random_delay_minimum', _decode_random_delay_minimum),
0xfe41227f: ('random_delay_maximum', _decode_random_delay_maximum),
0xaacdb11c: ('animation', _decode_animation),
0x15dba741: ('visibility_key', _decode_visibility_key),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerPeriodicAdditiveAnimationData.py | 0.694613 | 0.293003 | PlayerPeriodicAdditiveAnimationData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerMultiKillRewardSoundData(BaseProperty):
count1: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count3: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count4: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count5: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count6: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count7: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
count8: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\x97\xe7\xd7b') # 0x97e7d762
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count1))
data.write(b'\x11s\xa5\xcc') # 0x1173a5cc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count2))
data.write(b'\xda/vi') # 0xda2f7669
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count3))
data.write(b'\xc7*F\xd1') # 0xc72a46d1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count4))
data.write(b'\x0cv\x95t') # 0xc769574
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count5))
data.write(b'\x8a\xe2\xe7\xda') # 0x8ae2e7da
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count6))
data.write(b'A\xbe4\x7f') # 0x41be347f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count7))
data.write(b'\xb0\xe8\x86\xaa') # 0xb0e886aa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.count8))
@classmethod
def from_json(cls, data: dict):
return cls(
count1=data['count1'],
count2=data['count2'],
count3=data['count3'],
count4=data['count4'],
count5=data['count5'],
count6=data['count6'],
count7=data['count7'],
count8=data['count8'],
)
def to_json(self) -> dict:
return {
'count1': self.count1,
'count2': self.count2,
'count3': self.count3,
'count4': self.count4,
'count5': self.count5,
'count6': self.count6,
'count7': self.count7,
'count8': self.count8,
}
_FAST_FORMAT = None
_FAST_IDS = (0x97e7d762, 0x1173a5cc, 0xda2f7669, 0xc72a46d1, 0xc769574, 0x8ae2e7da, 0x41be347f, 0xb0e886aa)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerMultiKillRewardSoundData]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(112))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21]) != _FAST_IDS:
data.seek(before)
return None
return PlayerMultiKillRewardSoundData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_count1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count4(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count5(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count6(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count7(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_count8(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x97e7d762: ('count1', _decode_count1),
0x1173a5cc: ('count2', _decode_count2),
0xda2f7669: ('count3', _decode_count3),
0xc72a46d1: ('count4', _decode_count4),
0xc769574: ('count5', _decode_count5),
0x8ae2e7da: ('count6', _decode_count6),
0x41be347f: ('count7', _decode_count7),
0xb0e886aa: ('count8', _decode_count8),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMultiKillRewardSoundData.py | 0.598312 | 0.227116 | PlayerMultiKillRewardSoundData.py | 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.dkc_returns.archetypes.UnknownStruct55 import UnknownStruct55
@dataclasses.dataclass()
class UnknownStruct192(BaseProperty):
unknown: bool = dataclasses.field(default=False)
unknown_struct55_0x6ed124ef: UnknownStruct55 = dataclasses.field(default_factory=UnknownStruct55)
unknown_struct55_0x5b3c92bc: UnknownStruct55 = dataclasses.field(default_factory=UnknownStruct55)
unknown_struct55_0xfeb702b2: UnknownStruct55 = dataclasses.field(default_factory=UnknownStruct55)
unknown_struct55_0x30e7fe1a: UnknownStruct55 = dataclasses.field(default_factory=UnknownStruct55)
unknown_struct55_0x956c6e14: UnknownStruct55 = dataclasses.field(default_factory=UnknownStruct55)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xa6\xde\xd8t') # 0xa6ded874
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'n\xd1$\xef') # 0x6ed124ef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct55_0x6ed124ef.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[<\x92\xbc') # 0x5b3c92bc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct55_0x5b3c92bc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe\xb7\x02\xb2') # 0xfeb702b2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct55_0xfeb702b2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'0\xe7\xfe\x1a') # 0x30e7fe1a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct55_0x30e7fe1a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95ln\x14') # 0x956c6e14
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct55_0x956c6e14.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
unknown_struct55_0x6ed124ef=UnknownStruct55.from_json(data['unknown_struct55_0x6ed124ef']),
unknown_struct55_0x5b3c92bc=UnknownStruct55.from_json(data['unknown_struct55_0x5b3c92bc']),
unknown_struct55_0xfeb702b2=UnknownStruct55.from_json(data['unknown_struct55_0xfeb702b2']),
unknown_struct55_0x30e7fe1a=UnknownStruct55.from_json(data['unknown_struct55_0x30e7fe1a']),
unknown_struct55_0x956c6e14=UnknownStruct55.from_json(data['unknown_struct55_0x956c6e14']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'unknown_struct55_0x6ed124ef': self.unknown_struct55_0x6ed124ef.to_json(),
'unknown_struct55_0x5b3c92bc': self.unknown_struct55_0x5b3c92bc.to_json(),
'unknown_struct55_0xfeb702b2': self.unknown_struct55_0xfeb702b2.to_json(),
'unknown_struct55_0x30e7fe1a': self.unknown_struct55_0x30e7fe1a.to_json(),
'unknown_struct55_0x956c6e14': self.unknown_struct55_0x956c6e14.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct55_0x6ed124ef(data: typing.BinaryIO, property_size: int):
return UnknownStruct55.from_stream(data, property_size)
def _decode_unknown_struct55_0x5b3c92bc(data: typing.BinaryIO, property_size: int):
return UnknownStruct55.from_stream(data, property_size)
def _decode_unknown_struct55_0xfeb702b2(data: typing.BinaryIO, property_size: int):
return UnknownStruct55.from_stream(data, property_size)
def _decode_unknown_struct55_0x30e7fe1a(data: typing.BinaryIO, property_size: int):
return UnknownStruct55.from_stream(data, property_size)
def _decode_unknown_struct55_0x956c6e14(data: typing.BinaryIO, property_size: int):
return UnknownStruct55.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa6ded874: ('unknown', _decode_unknown),
0x6ed124ef: ('unknown_struct55_0x6ed124ef', _decode_unknown_struct55_0x6ed124ef),
0x5b3c92bc: ('unknown_struct55_0x5b3c92bc', _decode_unknown_struct55_0x5b3c92bc),
0xfeb702b2: ('unknown_struct55_0xfeb702b2', _decode_unknown_struct55_0xfeb702b2),
0x30e7fe1a: ('unknown_struct55_0x30e7fe1a', _decode_unknown_struct55_0x30e7fe1a),
0x956c6e14: ('unknown_struct55_0x956c6e14', _decode_unknown_struct55_0x956c6e14),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct192.py | 0.553867 | 0.303164 | UnknownStruct192.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct202 import UnknownStruct202
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct203 import UnknownStruct203
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct204 import UnknownStruct204
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct206 import UnknownStruct206
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct207 import UnknownStruct207
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct208(BaseProperty):
boss_type: enums.BossType = dataclasses.field(default=enums.BossType.Unknown1)
unknown_struct202: UnknownStruct202 = dataclasses.field(default_factory=UnknownStruct202)
unknown_struct203: UnknownStruct203 = dataclasses.field(default_factory=UnknownStruct203)
unknown_struct204: UnknownStruct204 = dataclasses.field(default_factory=UnknownStruct204)
fire_beam_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_struct206: UnknownStruct206 = dataclasses.field(default_factory=UnknownStruct206)
unknown_struct207: UnknownStruct207 = dataclasses.field(default_factory=UnknownStruct207)
gravity: float = dataclasses.field(default=55.0)
terminal_velocity: float = dataclasses.field(default=35.0)
unknown_0x880adc23: int = dataclasses.field(default=10)
unknown_0x5d1de4ae: float = dataclasses.field(default=3.0)
unknown_0x59f65627: float = dataclasses.field(default=1.0)
spit_distance: float = dataclasses.field(default=12.0)
spit_height: float = dataclasses.field(default=5.0)
unknown_0x1e3cbfc2: float = dataclasses.field(default=0.5)
unknown_0xee382651: float = dataclasses.field(default=0.5)
unknown_0xc4043234: float = dataclasses.field(default=6.0)
caud_0x06b3ef54: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0xc4dbea19: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x13') # 19 properties
data.write(b'\x92\x98_\xff') # 0x92985fff
data.write(b'\x00\x04') # size
self.boss_type.to_stream(data)
data.write(b'\x03\x9c\xe0\x9a') # 0x39ce09a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct202.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xef>M\xa5') # 0xef3e4da5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct203.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\xc4\xc4L') # 0x45c4c44c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct204.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9e\x8f\x96\x96') # 0x9e8f9696
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fire_beam_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcd\x9d\xe8\xcc') # 0xcd9de8cc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct206.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'0|\xe7\xe4') # 0x307ce7e4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct207.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xab\x95f\xa2') # 0xab9566a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.terminal_velocity))
data.write(b'\x88\n\xdc#') # 0x880adc23
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x880adc23))
data.write(b']\x1d\xe4\xae') # 0x5d1de4ae
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5d1de4ae))
data.write(b"Y\xf6V'") # 0x59f65627
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x59f65627))
data.write(b'\x04@\x8eG') # 0x4408e47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_distance))
data.write(b'\xa5K\xe65') # 0xa54be635
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_height))
data.write(b'\x1e<\xbf\xc2') # 0x1e3cbfc2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1e3cbfc2))
data.write(b'\xee8&Q') # 0xee382651
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xee382651))
data.write(b'\xc4\x0424') # 0xc4043234
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc4043234))
data.write(b'\x06\xb3\xefT') # 0x6b3ef54
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x06b3ef54))
data.write(b'\xc4\xdb\xea\x19') # 0xc4dbea19
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xc4dbea19))
@classmethod
def from_json(cls, data: dict):
return cls(
boss_type=enums.BossType.from_json(data['boss_type']),
unknown_struct202=UnknownStruct202.from_json(data['unknown_struct202']),
unknown_struct203=UnknownStruct203.from_json(data['unknown_struct203']),
unknown_struct204=UnknownStruct204.from_json(data['unknown_struct204']),
fire_beam_damage=DamageInfo.from_json(data['fire_beam_damage']),
unknown_struct206=UnknownStruct206.from_json(data['unknown_struct206']),
unknown_struct207=UnknownStruct207.from_json(data['unknown_struct207']),
gravity=data['gravity'],
terminal_velocity=data['terminal_velocity'],
unknown_0x880adc23=data['unknown_0x880adc23'],
unknown_0x5d1de4ae=data['unknown_0x5d1de4ae'],
unknown_0x59f65627=data['unknown_0x59f65627'],
spit_distance=data['spit_distance'],
spit_height=data['spit_height'],
unknown_0x1e3cbfc2=data['unknown_0x1e3cbfc2'],
unknown_0xee382651=data['unknown_0xee382651'],
unknown_0xc4043234=data['unknown_0xc4043234'],
caud_0x06b3ef54=data['caud_0x06b3ef54'],
caud_0xc4dbea19=data['caud_0xc4dbea19'],
)
def to_json(self) -> dict:
return {
'boss_type': self.boss_type.to_json(),
'unknown_struct202': self.unknown_struct202.to_json(),
'unknown_struct203': self.unknown_struct203.to_json(),
'unknown_struct204': self.unknown_struct204.to_json(),
'fire_beam_damage': self.fire_beam_damage.to_json(),
'unknown_struct206': self.unknown_struct206.to_json(),
'unknown_struct207': self.unknown_struct207.to_json(),
'gravity': self.gravity,
'terminal_velocity': self.terminal_velocity,
'unknown_0x880adc23': self.unknown_0x880adc23,
'unknown_0x5d1de4ae': self.unknown_0x5d1de4ae,
'unknown_0x59f65627': self.unknown_0x59f65627,
'spit_distance': self.spit_distance,
'spit_height': self.spit_height,
'unknown_0x1e3cbfc2': self.unknown_0x1e3cbfc2,
'unknown_0xee382651': self.unknown_0xee382651,
'unknown_0xc4043234': self.unknown_0xc4043234,
'caud_0x06b3ef54': self.caud_0x06b3ef54,
'caud_0xc4dbea19': self.caud_0xc4dbea19,
}
def _decode_boss_type(data: typing.BinaryIO, property_size: int):
return enums.BossType.from_stream(data)
def _decode_unknown_struct202(data: typing.BinaryIO, property_size: int):
return UnknownStruct202.from_stream(data, property_size)
def _decode_unknown_struct203(data: typing.BinaryIO, property_size: int):
return UnknownStruct203.from_stream(data, property_size)
def _decode_unknown_struct204(data: typing.BinaryIO, property_size: int):
return UnknownStruct204.from_stream(data, property_size)
def _decode_fire_beam_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown_struct206(data: typing.BinaryIO, property_size: int):
return UnknownStruct206.from_stream(data, property_size)
def _decode_unknown_struct207(data: typing.BinaryIO, property_size: int):
return UnknownStruct207.from_stream(data, property_size)
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_terminal_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x880adc23(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x5d1de4ae(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x59f65627(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1e3cbfc2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xee382651(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc4043234(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_caud_0x06b3ef54(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0xc4dbea19(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x92985fff: ('boss_type', _decode_boss_type),
0x39ce09a: ('unknown_struct202', _decode_unknown_struct202),
0xef3e4da5: ('unknown_struct203', _decode_unknown_struct203),
0x45c4c44c: ('unknown_struct204', _decode_unknown_struct204),
0x9e8f9696: ('fire_beam_damage', _decode_fire_beam_damage),
0xcd9de8cc: ('unknown_struct206', _decode_unknown_struct206),
0x307ce7e4: ('unknown_struct207', _decode_unknown_struct207),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xab9566a2: ('terminal_velocity', _decode_terminal_velocity),
0x880adc23: ('unknown_0x880adc23', _decode_unknown_0x880adc23),
0x5d1de4ae: ('unknown_0x5d1de4ae', _decode_unknown_0x5d1de4ae),
0x59f65627: ('unknown_0x59f65627', _decode_unknown_0x59f65627),
0x4408e47: ('spit_distance', _decode_spit_distance),
0xa54be635: ('spit_height', _decode_spit_height),
0x1e3cbfc2: ('unknown_0x1e3cbfc2', _decode_unknown_0x1e3cbfc2),
0xee382651: ('unknown_0xee382651', _decode_unknown_0xee382651),
0xc4043234: ('unknown_0xc4043234', _decode_unknown_0xc4043234),
0x6b3ef54: ('caud_0x06b3ef54', _decode_caud_0x06b3ef54),
0xc4dbea19: ('caud_0xc4dbea19', _decode_caud_0xc4dbea19),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct208.py | 0.557725 | 0.236351 | UnknownStruct208.py | 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.dkc_returns.archetypes.MaterialType import MaterialType
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PeanutMaterialEffects(BaseProperty):
material: MaterialType = dataclasses.field(default_factory=MaterialType)
bounce_effect: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
deflection_effect: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xd7.\t\xe1') # 0xd72e09e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[`!O') # 0x5b60214f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_effect))
data.write(b'\xa2r\xad\xe0') # 0xa272ade0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.deflection_effect))
@classmethod
def from_json(cls, data: dict):
return cls(
material=MaterialType.from_json(data['material']),
bounce_effect=data['bounce_effect'],
deflection_effect=data['deflection_effect'],
)
def to_json(self) -> dict:
return {
'material': self.material.to_json(),
'bounce_effect': self.bounce_effect,
'deflection_effect': self.deflection_effect,
}
def _decode_material(data: typing.BinaryIO, property_size: int):
return MaterialType.from_stream(data, property_size)
def _decode_bounce_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_deflection_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd72e09e1: ('material', _decode_material),
0x5b60214f: ('bounce_effect', _decode_bounce_effect),
0xa272ade0: ('deflection_effect', _decode_deflection_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PeanutMaterialEffects.py | 0.641198 | 0.24416 | PeanutMaterialEffects.py | 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.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class ScaleSplines(BaseProperty):
x_scale: Spline = dataclasses.field(default_factory=Spline)
y_scale: Spline = dataclasses.field(default_factory=Spline)
z_scale: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xf47\xa6/') # 0xf437a62f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'o\x92\xea@') # 0x6f92ea40
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18\x0c8\xb0') # 0x180c38b0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_scale=Spline.from_json(data['x_scale']),
y_scale=Spline.from_json(data['y_scale']),
z_scale=Spline.from_json(data['z_scale']),
)
def to_json(self) -> dict:
return {
'x_scale': self.x_scale.to_json(),
'y_scale': self.y_scale.to_json(),
'z_scale': self.z_scale.to_json(),
}
def _decode_x_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf437a62f: ('x_scale', _decode_x_scale),
0x6f92ea40: ('y_scale', _decode_y_scale),
0x180c38b0: ('z_scale', _decode_z_scale),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ScaleSplines.py | 0.632276 | 0.31488 | ScaleSplines.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class VolcanoBossBodyPartStructC(BaseProperty):
unknown_0x64543b0c: int = dataclasses.field(default=0)
unknown_0x1e67101c: int = dataclasses.field(default=0)
unknown_0xcb515e2a: int = dataclasses.field(default=0)
unknown_0xc762476c: int = dataclasses.field(default=0)
unknown_0xb6641bf0: int = dataclasses.field(default=0)
unknown_0x217a54b9: int = dataclasses.field(default=0)
unknown_0x8b30d933: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'dT;\x0c') # 0x64543b0c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x64543b0c))
data.write(b'\x1eg\x10\x1c') # 0x1e67101c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x1e67101c))
data.write(b'\xcbQ^*') # 0xcb515e2a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xcb515e2a))
data.write(b'\xc7bGl') # 0xc762476c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc762476c))
data.write(b'\xb6d\x1b\xf0') # 0xb6641bf0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xb6641bf0))
data.write(b'!zT\xb9') # 0x217a54b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x217a54b9))
data.write(b'\x8b0\xd93') # 0x8b30d933
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8b30d933))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x64543b0c=data['unknown_0x64543b0c'],
unknown_0x1e67101c=data['unknown_0x1e67101c'],
unknown_0xcb515e2a=data['unknown_0xcb515e2a'],
unknown_0xc762476c=data['unknown_0xc762476c'],
unknown_0xb6641bf0=data['unknown_0xb6641bf0'],
unknown_0x217a54b9=data['unknown_0x217a54b9'],
unknown_0x8b30d933=data['unknown_0x8b30d933'],
)
def to_json(self) -> dict:
return {
'unknown_0x64543b0c': self.unknown_0x64543b0c,
'unknown_0x1e67101c': self.unknown_0x1e67101c,
'unknown_0xcb515e2a': self.unknown_0xcb515e2a,
'unknown_0xc762476c': self.unknown_0xc762476c,
'unknown_0xb6641bf0': self.unknown_0xb6641bf0,
'unknown_0x217a54b9': self.unknown_0x217a54b9,
'unknown_0x8b30d933': self.unknown_0x8b30d933,
}
_FAST_FORMAT = None
_FAST_IDS = (0x64543b0c, 0x1e67101c, 0xcb515e2a, 0xc762476c, 0xb6641bf0, 0x217a54b9, 0x8b30d933)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VolcanoBossBodyPartStructC]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHlLHlLHlLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return VolcanoBossBodyPartStructC(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_unknown_0x64543b0c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x1e67101c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xcb515e2a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc762476c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xb6641bf0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x217a54b9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x8b30d933(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x64543b0c: ('unknown_0x64543b0c', _decode_unknown_0x64543b0c),
0x1e67101c: ('unknown_0x1e67101c', _decode_unknown_0x1e67101c),
0xcb515e2a: ('unknown_0xcb515e2a', _decode_unknown_0xcb515e2a),
0xc762476c: ('unknown_0xc762476c', _decode_unknown_0xc762476c),
0xb6641bf0: ('unknown_0xb6641bf0', _decode_unknown_0xb6641bf0),
0x217a54b9: ('unknown_0x217a54b9', _decode_unknown_0x217a54b9),
0x8b30d933: ('unknown_0x8b30d933', _decode_unknown_0x8b30d933),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VolcanoBossBodyPartStructC.py | 0.562657 | 0.263209 | VolcanoBossBodyPartStructC.py | 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.dkc_returns.archetypes.DebrisPropertiesOrientationEnum import DebrisPropertiesOrientationEnum
from retro_data_structures.properties.dkc_returns.archetypes.PeanutMaterialEffects import PeanutMaterialEffects
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct17 import UnknownStruct17
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class PeanutProperties(BaseProperty):
sort_position_in_world: bool = dataclasses.field(default=False)
initial_direction: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=1.0))
speed: float = dataclasses.field(default=5.0)
spin_speed: Vector = dataclasses.field(default_factory=lambda: Vector(x=-1.0, y=-1.0, z=-1.0))
lifetime: float = dataclasses.field(default=2.0)
fade_out_start_percentage: float = dataclasses.field(default=80.0)
gravity: float = dataclasses.field(default=25.0)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
created_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
particle_system1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_system1_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system1_uses_global_translation: bool = dataclasses.field(default=False)
particle_system1_uses_global_orientation: bool = dataclasses.field(default=False)
particle_system1_wait_for_particles_to_die: bool = dataclasses.field(default=True)
particle_system1_orientation: DebrisPropertiesOrientationEnum = dataclasses.field(default_factory=DebrisPropertiesOrientationEnum)
bounce_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
bounce_particle_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
bounce_effect_transform: UnknownStruct17 = dataclasses.field(default_factory=UnknownStruct17)
peanut_burn_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
peanut_kill_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
peanut_deflection_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
stun_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
fixed_bounce_speed_x: float = dataclasses.field(default=1.0)
fixed_bounce_speed_y: float = dataclasses.field(default=1.0)
num_material_effects: int = dataclasses.field(default=0)
material_effects1: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects2: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects3: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects4: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects5: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects6: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects7: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
material_effects8: PeanutMaterialEffects = dataclasses.field(default_factory=PeanutMaterialEffects)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00"') # 34 properties
data.write(b'\x97\xabv)') # 0x97ab7629
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sort_position_in_world))
data.write(b'\x01\xa0\xdf\xe6') # 0x1a0dfe6
data.write(b'\x00\x0c') # size
self.initial_direction.to_stream(data)
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'^\xb1~\x07') # 0x5eb17e07
data.write(b'\x00\x0c') # size
self.spin_speed.to_stream(data)
data.write(b'2\xdcg\xf6') # 0x32dc67f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lifetime))
data.write(b'cS\xc4\t') # 0x6353c409
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_start_percentage))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x93\xf8\xe0\xb0') # 0x93f8e0b0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.created_sound))
data.write(b'\xf1\x92Uv') # 0xf1925576
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_sound))
data.write(b'G\x8d\n\xa3') # 0x478d0aa3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle_system1))
data.write(b'\x19\xa6\xf7\x1f') # 0x19a6f71f
data.write(b'\x00\x0c') # size
self.particle_system1_scale.to_stream(data)
data.write(b';\x03\xa0\x1e') # 0x3b03a01e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_uses_global_translation))
data.write(b'\xdb\x1f\xa6\x1c') # 0xdb1fa61c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_uses_global_orientation))
data.write(b';\xdd/\xed') # 0x3bdd2fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_wait_for_particles_to_die))
data.write(b'\xf5\xddF\x90') # 0xf5dd4690
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.particle_system1_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!|7\xc2') # 0x217c37c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_particle_effect))
data.write(b'`\xd6\xbf\x8e') # 0x60d6bf8e
data.write(b'\x00\x0c') # size
self.bounce_particle_scale.to_stream(data)
data.write(b'\xceY\xeb\xff') # 0xce59ebff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bounce_effect_transform.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe9;\x1a/') # 0xe93b1a2f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.peanut_burn_effect))
data.write(b'q\xd4\x94\xf4') # 0x71d494f4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.peanut_kill_effect))
data.write(b'\xbd\x1aB\xaf') # 0xbd1a42af
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.peanut_deflection_effect))
data.write(b'\x08\x00\x0e\xc9') # 0x8000ec9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stun_sound))
data.write(b'\x9b\xd9C&') # 0x9bd94326
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_bounce_speed_x))
data.write(b'P\x85\x90\x83') # 0x50859083
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_bounce_speed_y))
data.write(b'\x05\xa7\x97y') # 0x5a79779
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_material_effects))
data.write(b'\xe8\xd2k\xae') # 0xe8d26bae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1\xaa\xc6\xee') # 0xd1aac6ee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\x82\xa2.') # 0xc682a22e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa3[\x9cn') # 0xa35b9c6e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4s\xf8\xae') # 0xb473f8ae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d\x0bU\xee') # 0x8d0b55ee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9a#1.') # 0x9a23312e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'F\xb9)n') # 0x46b9296e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_effects8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
sort_position_in_world=data['sort_position_in_world'],
initial_direction=Vector.from_json(data['initial_direction']),
speed=data['speed'],
spin_speed=Vector.from_json(data['spin_speed']),
lifetime=data['lifetime'],
fade_out_start_percentage=data['fade_out_start_percentage'],
gravity=data['gravity'],
model=data['model'],
created_sound=data['created_sound'],
bounce_sound=data['bounce_sound'],
particle_system1=data['particle_system1'],
particle_system1_scale=Vector.from_json(data['particle_system1_scale']),
particle_system1_uses_global_translation=data['particle_system1_uses_global_translation'],
particle_system1_uses_global_orientation=data['particle_system1_uses_global_orientation'],
particle_system1_wait_for_particles_to_die=data['particle_system1_wait_for_particles_to_die'],
particle_system1_orientation=DebrisPropertiesOrientationEnum.from_json(data['particle_system1_orientation']),
bounce_particle_effect=data['bounce_particle_effect'],
bounce_particle_scale=Vector.from_json(data['bounce_particle_scale']),
bounce_effect_transform=UnknownStruct17.from_json(data['bounce_effect_transform']),
peanut_burn_effect=data['peanut_burn_effect'],
peanut_kill_effect=data['peanut_kill_effect'],
peanut_deflection_effect=data['peanut_deflection_effect'],
stun_sound=data['stun_sound'],
fixed_bounce_speed_x=data['fixed_bounce_speed_x'],
fixed_bounce_speed_y=data['fixed_bounce_speed_y'],
num_material_effects=data['num_material_effects'],
material_effects1=PeanutMaterialEffects.from_json(data['material_effects1']),
material_effects2=PeanutMaterialEffects.from_json(data['material_effects2']),
material_effects3=PeanutMaterialEffects.from_json(data['material_effects3']),
material_effects4=PeanutMaterialEffects.from_json(data['material_effects4']),
material_effects5=PeanutMaterialEffects.from_json(data['material_effects5']),
material_effects6=PeanutMaterialEffects.from_json(data['material_effects6']),
material_effects7=PeanutMaterialEffects.from_json(data['material_effects7']),
material_effects8=PeanutMaterialEffects.from_json(data['material_effects8']),
)
def to_json(self) -> dict:
return {
'sort_position_in_world': self.sort_position_in_world,
'initial_direction': self.initial_direction.to_json(),
'speed': self.speed,
'spin_speed': self.spin_speed.to_json(),
'lifetime': self.lifetime,
'fade_out_start_percentage': self.fade_out_start_percentage,
'gravity': self.gravity,
'model': self.model,
'created_sound': self.created_sound,
'bounce_sound': self.bounce_sound,
'particle_system1': self.particle_system1,
'particle_system1_scale': self.particle_system1_scale.to_json(),
'particle_system1_uses_global_translation': self.particle_system1_uses_global_translation,
'particle_system1_uses_global_orientation': self.particle_system1_uses_global_orientation,
'particle_system1_wait_for_particles_to_die': self.particle_system1_wait_for_particles_to_die,
'particle_system1_orientation': self.particle_system1_orientation.to_json(),
'bounce_particle_effect': self.bounce_particle_effect,
'bounce_particle_scale': self.bounce_particle_scale.to_json(),
'bounce_effect_transform': self.bounce_effect_transform.to_json(),
'peanut_burn_effect': self.peanut_burn_effect,
'peanut_kill_effect': self.peanut_kill_effect,
'peanut_deflection_effect': self.peanut_deflection_effect,
'stun_sound': self.stun_sound,
'fixed_bounce_speed_x': self.fixed_bounce_speed_x,
'fixed_bounce_speed_y': self.fixed_bounce_speed_y,
'num_material_effects': self.num_material_effects,
'material_effects1': self.material_effects1.to_json(),
'material_effects2': self.material_effects2.to_json(),
'material_effects3': self.material_effects3.to_json(),
'material_effects4': self.material_effects4.to_json(),
'material_effects5': self.material_effects5.to_json(),
'material_effects6': self.material_effects6.to_json(),
'material_effects7': self.material_effects7.to_json(),
'material_effects8': self.material_effects8.to_json(),
}
def _decode_sort_position_in_world(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_initial_direction(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spin_speed(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_lifetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_created_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_particle_system1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_particle_system1_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system1_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_uses_global_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_orientation(data: typing.BinaryIO, property_size: int):
return DebrisPropertiesOrientationEnum.from_stream(data, property_size)
def _decode_bounce_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bounce_particle_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_bounce_effect_transform(data: typing.BinaryIO, property_size: int):
return UnknownStruct17.from_stream(data, property_size)
def _decode_peanut_burn_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_peanut_kill_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_peanut_deflection_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stun_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_fixed_bounce_speed_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fixed_bounce_speed_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_num_material_effects(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_material_effects1(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects2(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects3(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects4(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects5(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects6(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects7(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
def _decode_material_effects8(data: typing.BinaryIO, property_size: int):
return PeanutMaterialEffects.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x97ab7629: ('sort_position_in_world', _decode_sort_position_in_world),
0x1a0dfe6: ('initial_direction', _decode_initial_direction),
0x6392404e: ('speed', _decode_speed),
0x5eb17e07: ('spin_speed', _decode_spin_speed),
0x32dc67f6: ('lifetime', _decode_lifetime),
0x6353c409: ('fade_out_start_percentage', _decode_fade_out_start_percentage),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xc27ffa8f: ('model', _decode_model),
0x93f8e0b0: ('created_sound', _decode_created_sound),
0xf1925576: ('bounce_sound', _decode_bounce_sound),
0x478d0aa3: ('particle_system1', _decode_particle_system1),
0x19a6f71f: ('particle_system1_scale', _decode_particle_system1_scale),
0x3b03a01e: ('particle_system1_uses_global_translation', _decode_particle_system1_uses_global_translation),
0xdb1fa61c: ('particle_system1_uses_global_orientation', _decode_particle_system1_uses_global_orientation),
0x3bdd2fed: ('particle_system1_wait_for_particles_to_die', _decode_particle_system1_wait_for_particles_to_die),
0xf5dd4690: ('particle_system1_orientation', _decode_particle_system1_orientation),
0x217c37c2: ('bounce_particle_effect', _decode_bounce_particle_effect),
0x60d6bf8e: ('bounce_particle_scale', _decode_bounce_particle_scale),
0xce59ebff: ('bounce_effect_transform', _decode_bounce_effect_transform),
0xe93b1a2f: ('peanut_burn_effect', _decode_peanut_burn_effect),
0x71d494f4: ('peanut_kill_effect', _decode_peanut_kill_effect),
0xbd1a42af: ('peanut_deflection_effect', _decode_peanut_deflection_effect),
0x8000ec9: ('stun_sound', _decode_stun_sound),
0x9bd94326: ('fixed_bounce_speed_x', _decode_fixed_bounce_speed_x),
0x50859083: ('fixed_bounce_speed_y', _decode_fixed_bounce_speed_y),
0x5a79779: ('num_material_effects', _decode_num_material_effects),
0xe8d26bae: ('material_effects1', _decode_material_effects1),
0xd1aac6ee: ('material_effects2', _decode_material_effects2),
0xc682a22e: ('material_effects3', _decode_material_effects3),
0xa35b9c6e: ('material_effects4', _decode_material_effects4),
0xb473f8ae: ('material_effects5', _decode_material_effects5),
0x8d0b55ee: ('material_effects6', _decode_material_effects6),
0x9a23312e: ('material_effects7', _decode_material_effects7),
0x46b9296e: ('material_effects8', _decode_material_effects8),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PeanutProperties.py | 0.601477 | 0.174903 | PeanutProperties.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.LightParameters import LightParameters
@dataclasses.dataclass()
class ActorParameters(BaseProperty):
lighting: LightParameters = dataclasses.field(default_factory=LightParameters)
use_global_render_time: bool = dataclasses.field(default=True)
fade_in_time: float = dataclasses.field(default=1.0)
fade_out_time: float = dataclasses.field(default=1.0)
force_render_unsorted: bool = dataclasses.field(default=False)
takes_projected_shadow: bool = dataclasses.field(default=True)
actor_material_type: enums.UnknownEnum1 = dataclasses.field(default=enums.UnknownEnum1.Unknown1)
is_camera_blocker: bool = dataclasses.field(default=False)
is_camera_target: bool = dataclasses.field(default=False)
deactivate_on_death: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\xb0(\xdb\x0e') # 0xb028db0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14\x99\x80<') # 0x1499803c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_global_render_time))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'y\x92c\xf1') # 0x799263f1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_render_unsorted))
data.write(b'\xed:n\x87') # 0xed3a6e87
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.takes_projected_shadow))
data.write(b'\xe3\x15\xeer') # 0xe315ee72
data.write(b'\x00\x04') # size
self.actor_material_type.to_stream(data)
data.write(b'm\xa8b\x00') # 0x6da86200
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_camera_blocker))
data.write(b'\x1b\xca\xb7\\') # 0x1bcab75c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_camera_target))
data.write(b'\x10\x1e\xa3>') # 0x101ea33e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.deactivate_on_death))
@classmethod
def from_json(cls, data: dict):
return cls(
lighting=LightParameters.from_json(data['lighting']),
use_global_render_time=data['use_global_render_time'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
force_render_unsorted=data['force_render_unsorted'],
takes_projected_shadow=data['takes_projected_shadow'],
actor_material_type=enums.UnknownEnum1.from_json(data['actor_material_type']),
is_camera_blocker=data['is_camera_blocker'],
is_camera_target=data['is_camera_target'],
deactivate_on_death=data['deactivate_on_death'],
)
def to_json(self) -> dict:
return {
'lighting': self.lighting.to_json(),
'use_global_render_time': self.use_global_render_time,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'force_render_unsorted': self.force_render_unsorted,
'takes_projected_shadow': self.takes_projected_shadow,
'actor_material_type': self.actor_material_type.to_json(),
'is_camera_blocker': self.is_camera_blocker,
'is_camera_target': self.is_camera_target,
'deactivate_on_death': self.deactivate_on_death,
}
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightParameters.from_stream(data, property_size)
def _decode_use_global_render_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_force_render_unsorted(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_takes_projected_shadow(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_actor_material_type(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum1.from_stream(data)
def _decode_is_camera_blocker(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_camera_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_deactivate_on_death(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]]] = {
0xb028db0e: ('lighting', _decode_lighting),
0x1499803c: ('use_global_render_time', _decode_use_global_render_time),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0x799263f1: ('force_render_unsorted', _decode_force_render_unsorted),
0xed3a6e87: ('takes_projected_shadow', _decode_takes_projected_shadow),
0xe315ee72: ('actor_material_type', _decode_actor_material_type),
0x6da86200: ('is_camera_blocker', _decode_is_camera_blocker),
0x1bcab75c: ('is_camera_target', _decode_is_camera_target),
0x101ea33e: ('deactivate_on_death', _decode_deactivate_on_death),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ActorParameters.py | 0.637369 | 0.308946 | ActorParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.MoleTrainManagerStructA import MoleTrainManagerStructA
@dataclasses.dataclass()
class UnknownStruct237(BaseProperty):
sequence_count: int = dataclasses.field(default=1)
mole_train_manager_struct_a_0x62e1522a: MoleTrainManagerStructA = dataclasses.field(default_factory=MoleTrainManagerStructA)
mole_train_manager_struct_a_0xd1757fe9: MoleTrainManagerStructA = dataclasses.field(default_factory=MoleTrainManagerStructA)
mole_train_manager_struct_a_0xbff964a8: MoleTrainManagerStructA = dataclasses.field(default_factory=MoleTrainManagerStructA)
mole_train_manager_struct_a_0x6d2c222e: MoleTrainManagerStructA = dataclasses.field(default_factory=MoleTrainManagerStructA)
mole_train_manager_struct_a_0x03a0396f: MoleTrainManagerStructA = dataclasses.field(default_factory=MoleTrainManagerStructA)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'e\xec\xebz') # 0x65eceb7a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sequence_count))
data.write(b'b\xe1R*') # 0x62e1522a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_a_0x62e1522a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1u\x7f\xe9') # 0xd1757fe9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_a_0xd1757fe9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\xf9d\xa8') # 0xbff964a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_a_0xbff964a8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'm,".') # 0x6d2c222e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_a_0x6d2c222e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x03\xa09o') # 0x3a0396f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_a_0x03a0396f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
sequence_count=data['sequence_count'],
mole_train_manager_struct_a_0x62e1522a=MoleTrainManagerStructA.from_json(data['mole_train_manager_struct_a_0x62e1522a']),
mole_train_manager_struct_a_0xd1757fe9=MoleTrainManagerStructA.from_json(data['mole_train_manager_struct_a_0xd1757fe9']),
mole_train_manager_struct_a_0xbff964a8=MoleTrainManagerStructA.from_json(data['mole_train_manager_struct_a_0xbff964a8']),
mole_train_manager_struct_a_0x6d2c222e=MoleTrainManagerStructA.from_json(data['mole_train_manager_struct_a_0x6d2c222e']),
mole_train_manager_struct_a_0x03a0396f=MoleTrainManagerStructA.from_json(data['mole_train_manager_struct_a_0x03a0396f']),
)
def to_json(self) -> dict:
return {
'sequence_count': self.sequence_count,
'mole_train_manager_struct_a_0x62e1522a': self.mole_train_manager_struct_a_0x62e1522a.to_json(),
'mole_train_manager_struct_a_0xd1757fe9': self.mole_train_manager_struct_a_0xd1757fe9.to_json(),
'mole_train_manager_struct_a_0xbff964a8': self.mole_train_manager_struct_a_0xbff964a8.to_json(),
'mole_train_manager_struct_a_0x6d2c222e': self.mole_train_manager_struct_a_0x6d2c222e.to_json(),
'mole_train_manager_struct_a_0x03a0396f': self.mole_train_manager_struct_a_0x03a0396f.to_json(),
}
def _decode_sequence_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mole_train_manager_struct_a_0x62e1522a(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructA.from_stream(data, property_size)
def _decode_mole_train_manager_struct_a_0xd1757fe9(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructA.from_stream(data, property_size)
def _decode_mole_train_manager_struct_a_0xbff964a8(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructA.from_stream(data, property_size)
def _decode_mole_train_manager_struct_a_0x6d2c222e(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructA.from_stream(data, property_size)
def _decode_mole_train_manager_struct_a_0x03a0396f(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructA.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x65eceb7a: ('sequence_count', _decode_sequence_count),
0x62e1522a: ('mole_train_manager_struct_a_0x62e1522a', _decode_mole_train_manager_struct_a_0x62e1522a),
0xd1757fe9: ('mole_train_manager_struct_a_0xd1757fe9', _decode_mole_train_manager_struct_a_0xd1757fe9),
0xbff964a8: ('mole_train_manager_struct_a_0xbff964a8', _decode_mole_train_manager_struct_a_0xbff964a8),
0x6d2c222e: ('mole_train_manager_struct_a_0x6d2c222e', _decode_mole_train_manager_struct_a_0x6d2c222e),
0x3a0396f: ('mole_train_manager_struct_a_0x03a0396f', _decode_mole_train_manager_struct_a_0x03a0396f),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct237.py | 0.528533 | 0.282598 | UnknownStruct237.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class PlayerOffscreenIndicatorTextData(BaseProperty):
text_render_mode: enums.UnknownEnum3 = dataclasses.field(default=enums.UnknownEnum3.Unknown1)
default_font: AssetId = dataclasses.field(metadata={'asset_types': ['FONT']}, default=default_asset_id)
foreground_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
geometry_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
gradient_start: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
gradient_end: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x9f\x1b\xd4m') # 0x9f1bd46d
data.write(b'\x00\x04') # size
self.text_render_mode.to_stream(data)
data.write(b'\r\xb9\xf8\xb6') # 0xdb9f8b6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.default_font))
data.write(b'?9\xe65') # 0x3f39e635
data.write(b'\x00\x10') # size
self.foreground_color.to_stream(data)
data.write(b'`\xd7\x85i') # 0x60d78569
data.write(b'\x00\x10') # size
self.outline_color.to_stream(data)
data.write(b'Y\x08\xef9') # 0x5908ef39
data.write(b'\x00\x10') # size
self.geometry_color.to_stream(data)
data.write(b'\xfb\xb7\xbeE') # 0xfbb7be45
data.write(b'\x00\x10') # size
self.gradient_start.to_stream(data)
data.write(b'\x0f\xbc\xe3\xfb') # 0xfbce3fb
data.write(b'\x00\x10') # size
self.gradient_end.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
text_render_mode=enums.UnknownEnum3.from_json(data['text_render_mode']),
default_font=data['default_font'],
foreground_color=Color.from_json(data['foreground_color']),
outline_color=Color.from_json(data['outline_color']),
geometry_color=Color.from_json(data['geometry_color']),
gradient_start=Color.from_json(data['gradient_start']),
gradient_end=Color.from_json(data['gradient_end']),
)
def to_json(self) -> dict:
return {
'text_render_mode': self.text_render_mode.to_json(),
'default_font': self.default_font,
'foreground_color': self.foreground_color.to_json(),
'outline_color': self.outline_color.to_json(),
'geometry_color': self.geometry_color.to_json(),
'gradient_start': self.gradient_start.to_json(),
'gradient_end': self.gradient_end.to_json(),
}
def _decode_text_render_mode(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum3.from_stream(data)
def _decode_default_font(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_foreground_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_geometry_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_gradient_start(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_gradient_end(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9f1bd46d: ('text_render_mode', _decode_text_render_mode),
0xdb9f8b6: ('default_font', _decode_default_font),
0x3f39e635: ('foreground_color', _decode_foreground_color),
0x60d78569: ('outline_color', _decode_outline_color),
0x5908ef39: ('geometry_color', _decode_geometry_color),
0xfbb7be45: ('gradient_start', _decode_gradient_start),
0xfbce3fb: ('gradient_end', _decode_gradient_end),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerOffscreenIndicatorTextData.py | 0.679179 | 0.230931 | PlayerOffscreenIndicatorTextData.py | 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.dkc_returns.archetypes.UnknownStruct26 import UnknownStruct26
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct35(BaseProperty):
unknown_struct26_0xbdd1a035: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x8aa2bfe5: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0xca0d2611: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x731756f6: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x83fa2328: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x2f82f98c: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0xbcb5dac7: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x6126e3a3: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\xbd\xd1\xa05') # 0xbdd1a035
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xbdd1a035.to_stream(data, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=0.35686299204826355, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.7019609808921814, b=0.0, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8a\xa2\xbf\xe5') # 0x8aa2bfe5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x8aa2bfe5.to_stream(data, default_override={'text_gradient_start_color': Color(r=1.0, g=0.9019610285758972, b=0.11764699965715408, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.5450980067253113, b=0.11764699965715408, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xca\r&\x11') # 0xca0d2611
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xca0d2611.to_stream(data, default_override={'text_gradient_start_color': Color(r=0.6274510025978088, g=1.0, b=0.47843098640441895, a=0.0), 'text_gradient_end_color': Color(r=0.1294119954109192, g=0.549019992351532, b=0.5098040103912354, a=0.0), 'text_outline_color': Color(r=0.031373001635074615, g=0.17647099494934082, b=0.031373001635074615, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\x17V\xf6') # 0x731756f6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x731756f6.to_stream(data, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=1.0, a=0.0), 'text_gradient_end_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.0), 'text_outline_color': Color(r=0.0, g=0.0, b=0.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x83\xfa#(') # 0x83fa2328
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x83fa2328.to_stream(data, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=0.35686299204826355, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.7019609808921814, b=0.0, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/\x82\xf9\x8c') # 0x2f82f98c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x2f82f98c.to_stream(data, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=0.35686299204826355, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.7019609808921814, b=0.0, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\xb5\xda\xc7') # 0xbcb5dac7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xbcb5dac7.to_stream(data, default_override={'text_gradient_start_color': Color(r=1.0, g=0.9019610285758972, b=0.11764699965715408, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.5450980067253113, b=0.11764699965715408, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a&\xe3\xa3') # 0x6126e3a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x6126e3a3.to_stream(data, default_override={'text_gradient_start_color': Color(r=0.0, g=0.0, b=0.0, a=0.0), 'text_gradient_end_color': Color(r=0.0, g=0.0, b=0.0, a=0.0), 'text_outline_color': Color(r=1.0, g=1.0, b=1.0, a=0.0)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct26_0xbdd1a035=UnknownStruct26.from_json(data['unknown_struct26_0xbdd1a035']),
unknown_struct26_0x8aa2bfe5=UnknownStruct26.from_json(data['unknown_struct26_0x8aa2bfe5']),
unknown_struct26_0xca0d2611=UnknownStruct26.from_json(data['unknown_struct26_0xca0d2611']),
unknown_struct26_0x731756f6=UnknownStruct26.from_json(data['unknown_struct26_0x731756f6']),
unknown_struct26_0x83fa2328=UnknownStruct26.from_json(data['unknown_struct26_0x83fa2328']),
unknown_struct26_0x2f82f98c=UnknownStruct26.from_json(data['unknown_struct26_0x2f82f98c']),
unknown_struct26_0xbcb5dac7=UnknownStruct26.from_json(data['unknown_struct26_0xbcb5dac7']),
unknown_struct26_0x6126e3a3=UnknownStruct26.from_json(data['unknown_struct26_0x6126e3a3']),
)
def to_json(self) -> dict:
return {
'unknown_struct26_0xbdd1a035': self.unknown_struct26_0xbdd1a035.to_json(),
'unknown_struct26_0x8aa2bfe5': self.unknown_struct26_0x8aa2bfe5.to_json(),
'unknown_struct26_0xca0d2611': self.unknown_struct26_0xca0d2611.to_json(),
'unknown_struct26_0x731756f6': self.unknown_struct26_0x731756f6.to_json(),
'unknown_struct26_0x83fa2328': self.unknown_struct26_0x83fa2328.to_json(),
'unknown_struct26_0x2f82f98c': self.unknown_struct26_0x2f82f98c.to_json(),
'unknown_struct26_0xbcb5dac7': self.unknown_struct26_0xbcb5dac7.to_json(),
'unknown_struct26_0x6126e3a3': self.unknown_struct26_0x6126e3a3.to_json(),
}
def _decode_unknown_struct26_0xbdd1a035(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=0.35686299204826355, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.7019609808921814, b=0.0, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
def _decode_unknown_struct26_0x8aa2bfe5(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=1.0, g=0.9019610285758972, b=0.11764699965715408, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.5450980067253113, b=0.11764699965715408, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
def _decode_unknown_struct26_0xca0d2611(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=0.6274510025978088, g=1.0, b=0.47843098640441895, a=0.0), 'text_gradient_end_color': Color(r=0.1294119954109192, g=0.549019992351532, b=0.5098040103912354, a=0.0), 'text_outline_color': Color(r=0.031373001635074615, g=0.17647099494934082, b=0.031373001635074615, a=0.0)})
def _decode_unknown_struct26_0x731756f6(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=1.0, a=0.0), 'text_gradient_end_color': Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.0), 'text_outline_color': Color(r=0.0, g=0.0, b=0.0, a=0.0)})
def _decode_unknown_struct26_0x83fa2328(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=0.35686299204826355, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.7019609808921814, b=0.0, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
def _decode_unknown_struct26_0x2f82f98c(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=1.0, g=1.0, b=0.35686299204826355, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.7019609808921814, b=0.0, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
def _decode_unknown_struct26_0xbcb5dac7(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=1.0, g=0.9019610285758972, b=0.11764699965715408, a=0.0), 'text_gradient_end_color': Color(r=1.0, g=0.5450980067253113, b=0.11764699965715408, a=0.0), 'text_outline_color': Color(r=0.7019609808921814, g=0.0, b=0.0, a=0.0)})
def _decode_unknown_struct26_0x6126e3a3(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size, default_override={'text_gradient_start_color': Color(r=0.0, g=0.0, b=0.0, a=0.0), 'text_gradient_end_color': Color(r=0.0, g=0.0, b=0.0, a=0.0), 'text_outline_color': Color(r=1.0, g=1.0, b=1.0, a=0.0)})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbdd1a035: ('unknown_struct26_0xbdd1a035', _decode_unknown_struct26_0xbdd1a035),
0x8aa2bfe5: ('unknown_struct26_0x8aa2bfe5', _decode_unknown_struct26_0x8aa2bfe5),
0xca0d2611: ('unknown_struct26_0xca0d2611', _decode_unknown_struct26_0xca0d2611),
0x731756f6: ('unknown_struct26_0x731756f6', _decode_unknown_struct26_0x731756f6),
0x83fa2328: ('unknown_struct26_0x83fa2328', _decode_unknown_struct26_0x83fa2328),
0x2f82f98c: ('unknown_struct26_0x2f82f98c', _decode_unknown_struct26_0x2f82f98c),
0xbcb5dac7: ('unknown_struct26_0xbcb5dac7', _decode_unknown_struct26_0xbcb5dac7),
0x6126e3a3: ('unknown_struct26_0x6126e3a3', _decode_unknown_struct26_0x6126e3a3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct35.py | 0.573559 | 0.194425 | UnknownStruct35.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct155(BaseProperty):
unknown_0xac6cbf9d: float = dataclasses.field(default=0.0)
start_duration: float = dataclasses.field(default=0.25)
unknown_0x65d00bdd: float = dataclasses.field(default=0.25)
unknown_0xf8f69c42: float = dataclasses.field(default=0.25)
unknown_0x3e89443d: float = dataclasses.field(default=0.25)
unknown_0xccc8bdd4: float = dataclasses.field(default=0.25)
unknown_0xcc04105e: float = dataclasses.field(default=0.25)
unknown_0x945c9764: float = dataclasses.field(default=0.25)
unknown_0x9a4be38b: float = dataclasses.field(default=0.25)
unknown_0xb844a839: float = dataclasses.field(default=0.25)
puzzle_display_duration: float = dataclasses.field(default=0.25)
unknown_0xbae63352: float = dataclasses.field(default=0.25)
puzzle_done_duration: float = dataclasses.field(default=0.25)
unknown_0xde68f38f: float = dataclasses.field(default=0.25)
unknown_0xdee65317: float = dataclasses.field(default=0.25)
unknown_0xf0c51c84: float = dataclasses.field(default=0.25)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x10') # 16 properties
data.write(b'\xacl\xbf\x9d') # 0xac6cbf9d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xac6cbf9d))
data.write(b'@\x1a8#') # 0x401a3823
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_duration))
data.write(b'e\xd0\x0b\xdd') # 0x65d00bdd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x65d00bdd))
data.write(b'\xf8\xf6\x9cB') # 0xf8f69c42
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf8f69c42))
data.write(b'>\x89D=') # 0x3e89443d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3e89443d))
data.write(b'\xcc\xc8\xbd\xd4') # 0xccc8bdd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xccc8bdd4))
data.write(b'\xcc\x04\x10^') # 0xcc04105e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcc04105e))
data.write(b'\x94\\\x97d') # 0x945c9764
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x945c9764))
data.write(b'\x9aK\xe3\x8b') # 0x9a4be38b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9a4be38b))
data.write(b'\xb8D\xa89') # 0xb844a839
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb844a839))
data.write(b'\xee`*\xbc') # 0xee602abc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.puzzle_display_duration))
data.write(b'\xba\xe63R') # 0xbae63352
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbae63352))
data.write(b'\x95\x1c\xadp') # 0x951cad70
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.puzzle_done_duration))
data.write(b'\xdeh\xf3\x8f') # 0xde68f38f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xde68f38f))
data.write(b'\xde\xe6S\x17') # 0xdee65317
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xdee65317))
data.write(b'\xf0\xc5\x1c\x84') # 0xf0c51c84
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf0c51c84))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xac6cbf9d=data['unknown_0xac6cbf9d'],
start_duration=data['start_duration'],
unknown_0x65d00bdd=data['unknown_0x65d00bdd'],
unknown_0xf8f69c42=data['unknown_0xf8f69c42'],
unknown_0x3e89443d=data['unknown_0x3e89443d'],
unknown_0xccc8bdd4=data['unknown_0xccc8bdd4'],
unknown_0xcc04105e=data['unknown_0xcc04105e'],
unknown_0x945c9764=data['unknown_0x945c9764'],
unknown_0x9a4be38b=data['unknown_0x9a4be38b'],
unknown_0xb844a839=data['unknown_0xb844a839'],
puzzle_display_duration=data['puzzle_display_duration'],
unknown_0xbae63352=data['unknown_0xbae63352'],
puzzle_done_duration=data['puzzle_done_duration'],
unknown_0xde68f38f=data['unknown_0xde68f38f'],
unknown_0xdee65317=data['unknown_0xdee65317'],
unknown_0xf0c51c84=data['unknown_0xf0c51c84'],
)
def to_json(self) -> dict:
return {
'unknown_0xac6cbf9d': self.unknown_0xac6cbf9d,
'start_duration': self.start_duration,
'unknown_0x65d00bdd': self.unknown_0x65d00bdd,
'unknown_0xf8f69c42': self.unknown_0xf8f69c42,
'unknown_0x3e89443d': self.unknown_0x3e89443d,
'unknown_0xccc8bdd4': self.unknown_0xccc8bdd4,
'unknown_0xcc04105e': self.unknown_0xcc04105e,
'unknown_0x945c9764': self.unknown_0x945c9764,
'unknown_0x9a4be38b': self.unknown_0x9a4be38b,
'unknown_0xb844a839': self.unknown_0xb844a839,
'puzzle_display_duration': self.puzzle_display_duration,
'unknown_0xbae63352': self.unknown_0xbae63352,
'puzzle_done_duration': self.puzzle_done_duration,
'unknown_0xde68f38f': self.unknown_0xde68f38f,
'unknown_0xdee65317': self.unknown_0xdee65317,
'unknown_0xf0c51c84': self.unknown_0xf0c51c84,
}
_FAST_FORMAT = None
_FAST_IDS = (0xac6cbf9d, 0x401a3823, 0x65d00bdd, 0xf8f69c42, 0x3e89443d, 0xccc8bdd4, 0xcc04105e, 0x945c9764, 0x9a4be38b, 0xb844a839, 0xee602abc, 0xbae63352, 0x951cad70, 0xde68f38f, 0xdee65317, 0xf0c51c84)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct155]:
if property_count != 16:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(160))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33], dec[36], dec[39], dec[42], dec[45]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct155(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
dec[38],
dec[41],
dec[44],
dec[47],
)
def _decode_unknown_0xac6cbf9d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x65d00bdd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf8f69c42(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3e89443d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xccc8bdd4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcc04105e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x945c9764(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9a4be38b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb844a839(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_puzzle_display_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbae63352(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_puzzle_done_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xde68f38f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xdee65317(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf0c51c84(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]]] = {
0xac6cbf9d: ('unknown_0xac6cbf9d', _decode_unknown_0xac6cbf9d),
0x401a3823: ('start_duration', _decode_start_duration),
0x65d00bdd: ('unknown_0x65d00bdd', _decode_unknown_0x65d00bdd),
0xf8f69c42: ('unknown_0xf8f69c42', _decode_unknown_0xf8f69c42),
0x3e89443d: ('unknown_0x3e89443d', _decode_unknown_0x3e89443d),
0xccc8bdd4: ('unknown_0xccc8bdd4', _decode_unknown_0xccc8bdd4),
0xcc04105e: ('unknown_0xcc04105e', _decode_unknown_0xcc04105e),
0x945c9764: ('unknown_0x945c9764', _decode_unknown_0x945c9764),
0x9a4be38b: ('unknown_0x9a4be38b', _decode_unknown_0x9a4be38b),
0xb844a839: ('unknown_0xb844a839', _decode_unknown_0xb844a839),
0xee602abc: ('puzzle_display_duration', _decode_puzzle_display_duration),
0xbae63352: ('unknown_0xbae63352', _decode_unknown_0xbae63352),
0x951cad70: ('puzzle_done_duration', _decode_puzzle_done_duration),
0xde68f38f: ('unknown_0xde68f38f', _decode_unknown_0xde68f38f),
0xdee65317: ('unknown_0xdee65317', _decode_unknown_0xdee65317),
0xf0c51c84: ('unknown_0xf0c51c84', _decode_unknown_0xf0c51c84),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct155.py | 0.620507 | 0.264376 | UnknownStruct155.py | 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.dkc_returns.archetypes.UnknownStruct7 import UnknownStruct7
@dataclasses.dataclass()
class UnknownStruct8(BaseProperty):
num_attachments: int = dataclasses.field(default=0)
unknown: bool = dataclasses.field(default=False)
attachment1: UnknownStruct7 = dataclasses.field(default_factory=UnknownStruct7)
attachment2: UnknownStruct7 = dataclasses.field(default_factory=UnknownStruct7)
attachment3: UnknownStruct7 = dataclasses.field(default_factory=UnknownStruct7)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xc2\xadW5') # 0xc2ad5735
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_attachments))
data.write(b'cQ\xa0I') # 0x6351a049
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\xda\xa9\xd4\xbe') # 0xdaa9d4be
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attachment1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3a`L') # 0xf361604c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attachment2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']\t\xf1\xdd') # 0x5d09f1dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attachment3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
num_attachments=data['num_attachments'],
unknown=data['unknown'],
attachment1=UnknownStruct7.from_json(data['attachment1']),
attachment2=UnknownStruct7.from_json(data['attachment2']),
attachment3=UnknownStruct7.from_json(data['attachment3']),
)
def to_json(self) -> dict:
return {
'num_attachments': self.num_attachments,
'unknown': self.unknown,
'attachment1': self.attachment1.to_json(),
'attachment2': self.attachment2.to_json(),
'attachment3': self.attachment3.to_json(),
}
def _decode_num_attachments(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_attachment1(data: typing.BinaryIO, property_size: int):
return UnknownStruct7.from_stream(data, property_size)
def _decode_attachment2(data: typing.BinaryIO, property_size: int):
return UnknownStruct7.from_stream(data, property_size)
def _decode_attachment3(data: typing.BinaryIO, property_size: int):
return UnknownStruct7.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc2ad5735: ('num_attachments', _decode_num_attachments),
0x6351a049: ('unknown', _decode_unknown),
0xdaa9d4be: ('attachment1', _decode_attachment1),
0xf361604c: ('attachment2', _decode_attachment2),
0x5d09f1dd: ('attachment3', _decode_attachment3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct8.py | 0.628635 | 0.321487 | UnknownStruct8.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct194(BaseProperty):
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
@classmethod
def from_json(cls, data: dict):
return cls(
model=data['model'],
)
def to_json(self) -> dict:
return {
'model': self.model,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc27ffa8f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct194]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(14))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct194(
dec[2],
)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc27ffa8f: ('model', _decode_model),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct194.py | 0.618665 | 0.240507 | UnknownStruct194.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SwingLineBehaviorData(BaseProperty):
attach_to_line_locator_name: str = dataclasses.field(default='')
line_end_point_locator_name: str = dataclasses.field(default='')
swing_line_additive_length: float = dataclasses.field(default=5.0)
swing_line_dist_backwards: float = dataclasses.field(default=0.44999998807907104)
swing_line_type: enums.SwingLineType = dataclasses.field(default=enums.SwingLineType.Unknown1)
swing_line_max_angle: float = dataclasses.field(default=60.0)
swing_line_length: float = dataclasses.field(default=2.5)
time_apex_to_apex: float = dataclasses.field(default=2.0)
start_position_time_scale: float = dataclasses.field(default=1.0)
orient_creature_with_line: bool = dataclasses.field(default=True)
jettison_line_scale_speed: float = dataclasses.field(default=12.0)
death_line_action: enums.DeathLineAction = dataclasses.field(default=enums.DeathLineAction.Unknown1)
curve_line_additive_scale: float = dataclasses.field(default=1.0)
curve_line_ramp_in_speed: float = dataclasses.field(default=3.0)
curve_line_ramp_out_speed: float = dataclasses.field(default=2.0)
curve_line_depart_apex_angle_to_ramp_in: float = dataclasses.field(default=20.0)
curve_line_approach_apex_angle_to_ramp_out: float = dataclasses.field(default=10.0)
curve_line_middle: bool = dataclasses.field(default=True)
dwell_dist_from_anchor: float = dataclasses.field(default=0.0)
dwell_time: float = dataclasses.field(default=3.0)
climb_down_distance: float = dataclasses.field(default=4.0)
climb_down_speed: float = dataclasses.field(default=1.5)
drop_at_line_end: bool = dataclasses.field(default=False)
drop_to_ground_rule: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
hang_around_time: float = dataclasses.field(default=2.0)
climb_up_speed: float = dataclasses.field(default=1.5)
end_of_line_jiggle_scale: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1b') # 27 properties
data.write(b'\xa1:+\xf2') # 0xa13a2bf2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.attach_to_line_locator_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\xed\xcf\x89') # 0xf9edcf89
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.line_end_point_locator_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\x9c\x90t') # 0x589c9074
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_line_additive_length))
data.write(b'\x85c\xee*') # 0x8563ee2a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_line_dist_backwards))
data.write(b'\x174\xf8\x91') # 0x1734f891
data.write(b'\x00\x04') # size
self.swing_line_type.to_stream(data)
data.write(b'\xc0.\xfb\xe3') # 0xc02efbe3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_line_max_angle))
data.write(b'\xee\x89\n(') # 0xee890a28
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_line_length))
data.write(b"\xbb\xe1'\x1e") # 0xbbe1271e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_apex_to_apex))
data.write(b'\xf6\x13\x10-') # 0xf613102d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_position_time_scale))
data.write(b'5\xbaR\xb1') # 0x35ba52b1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orient_creature_with_line))
data.write(b'\xe3^\xd2\x18') # 0xe35ed218
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jettison_line_scale_speed))
data.write(b' 7\xe5\x11') # 0x2037e511
data.write(b'\x00\x04') # size
self.death_line_action.to_stream(data)
data.write(b')d\n-') # 0x29640a2d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.curve_line_additive_scale))
data.write(b'\x84h\xbe\xb1') # 0x8468beb1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.curve_line_ramp_in_speed))
data.write(b'U\xee;\xf9') # 0x55ee3bf9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.curve_line_ramp_out_speed))
data.write(b'\xf8\xb1\xd1\x83') # 0xf8b1d183
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.curve_line_depart_apex_angle_to_ramp_in))
data.write(b"\xe1'\xb1\x13") # 0xe127b113
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.curve_line_approach_apex_angle_to_ramp_out))
data.write(b'C\xcaFS') # 0x43ca4653
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.curve_line_middle))
data.write(b'\xb3|\x98\x90') # 0xb37c9890
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dwell_dist_from_anchor))
data.write(b'\xcd\xf7\xce\xb9') # 0xcdf7ceb9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dwell_time))
data.write(b'\xe9\x08L\x1f') # 0xe9084c1f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_down_distance))
data.write(b'\xa4zp7') # 0xa47a7037
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_down_speed))
data.write(b':\xa6A\x11') # 0x3aa64111
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.drop_at_line_end))
data.write(b'O\xa9\xf7\xc2') # 0x4fa9f7c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.drop_to_ground_rule))
data.write(b'\xf5\xbe\xe5\x8e') # 0xf5bee58e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hang_around_time))
data.write(b'\xe2v\x04\xbe') # 0xe27604be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_up_speed))
data.write(b'\xaf\xe0\x0e\xf0') # 0xafe00ef0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.end_of_line_jiggle_scale))
@classmethod
def from_json(cls, data: dict):
return cls(
attach_to_line_locator_name=data['attach_to_line_locator_name'],
line_end_point_locator_name=data['line_end_point_locator_name'],
swing_line_additive_length=data['swing_line_additive_length'],
swing_line_dist_backwards=data['swing_line_dist_backwards'],
swing_line_type=enums.SwingLineType.from_json(data['swing_line_type']),
swing_line_max_angle=data['swing_line_max_angle'],
swing_line_length=data['swing_line_length'],
time_apex_to_apex=data['time_apex_to_apex'],
start_position_time_scale=data['start_position_time_scale'],
orient_creature_with_line=data['orient_creature_with_line'],
jettison_line_scale_speed=data['jettison_line_scale_speed'],
death_line_action=enums.DeathLineAction.from_json(data['death_line_action']),
curve_line_additive_scale=data['curve_line_additive_scale'],
curve_line_ramp_in_speed=data['curve_line_ramp_in_speed'],
curve_line_ramp_out_speed=data['curve_line_ramp_out_speed'],
curve_line_depart_apex_angle_to_ramp_in=data['curve_line_depart_apex_angle_to_ramp_in'],
curve_line_approach_apex_angle_to_ramp_out=data['curve_line_approach_apex_angle_to_ramp_out'],
curve_line_middle=data['curve_line_middle'],
dwell_dist_from_anchor=data['dwell_dist_from_anchor'],
dwell_time=data['dwell_time'],
climb_down_distance=data['climb_down_distance'],
climb_down_speed=data['climb_down_speed'],
drop_at_line_end=data['drop_at_line_end'],
drop_to_ground_rule=data['drop_to_ground_rule'],
hang_around_time=data['hang_around_time'],
climb_up_speed=data['climb_up_speed'],
end_of_line_jiggle_scale=data['end_of_line_jiggle_scale'],
)
def to_json(self) -> dict:
return {
'attach_to_line_locator_name': self.attach_to_line_locator_name,
'line_end_point_locator_name': self.line_end_point_locator_name,
'swing_line_additive_length': self.swing_line_additive_length,
'swing_line_dist_backwards': self.swing_line_dist_backwards,
'swing_line_type': self.swing_line_type.to_json(),
'swing_line_max_angle': self.swing_line_max_angle,
'swing_line_length': self.swing_line_length,
'time_apex_to_apex': self.time_apex_to_apex,
'start_position_time_scale': self.start_position_time_scale,
'orient_creature_with_line': self.orient_creature_with_line,
'jettison_line_scale_speed': self.jettison_line_scale_speed,
'death_line_action': self.death_line_action.to_json(),
'curve_line_additive_scale': self.curve_line_additive_scale,
'curve_line_ramp_in_speed': self.curve_line_ramp_in_speed,
'curve_line_ramp_out_speed': self.curve_line_ramp_out_speed,
'curve_line_depart_apex_angle_to_ramp_in': self.curve_line_depart_apex_angle_to_ramp_in,
'curve_line_approach_apex_angle_to_ramp_out': self.curve_line_approach_apex_angle_to_ramp_out,
'curve_line_middle': self.curve_line_middle,
'dwell_dist_from_anchor': self.dwell_dist_from_anchor,
'dwell_time': self.dwell_time,
'climb_down_distance': self.climb_down_distance,
'climb_down_speed': self.climb_down_speed,
'drop_at_line_end': self.drop_at_line_end,
'drop_to_ground_rule': self.drop_to_ground_rule,
'hang_around_time': self.hang_around_time,
'climb_up_speed': self.climb_up_speed,
'end_of_line_jiggle_scale': self.end_of_line_jiggle_scale,
}
def _decode_attach_to_line_locator_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_line_end_point_locator_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_swing_line_additive_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_line_dist_backwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_line_type(data: typing.BinaryIO, property_size: int):
return enums.SwingLineType.from_stream(data)
def _decode_swing_line_max_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_line_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_apex_to_apex(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_position_time_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_orient_creature_with_line(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_jettison_line_scale_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_line_action(data: typing.BinaryIO, property_size: int):
return enums.DeathLineAction.from_stream(data)
def _decode_curve_line_additive_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_curve_line_ramp_in_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_curve_line_ramp_out_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_curve_line_depart_apex_angle_to_ramp_in(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_curve_line_approach_apex_angle_to_ramp_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_curve_line_middle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_dwell_dist_from_anchor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dwell_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_down_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_down_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drop_at_line_end(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_drop_to_ground_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_hang_around_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_up_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_end_of_line_jiggle_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa13a2bf2: ('attach_to_line_locator_name', _decode_attach_to_line_locator_name),
0xf9edcf89: ('line_end_point_locator_name', _decode_line_end_point_locator_name),
0x589c9074: ('swing_line_additive_length', _decode_swing_line_additive_length),
0x8563ee2a: ('swing_line_dist_backwards', _decode_swing_line_dist_backwards),
0x1734f891: ('swing_line_type', _decode_swing_line_type),
0xc02efbe3: ('swing_line_max_angle', _decode_swing_line_max_angle),
0xee890a28: ('swing_line_length', _decode_swing_line_length),
0xbbe1271e: ('time_apex_to_apex', _decode_time_apex_to_apex),
0xf613102d: ('start_position_time_scale', _decode_start_position_time_scale),
0x35ba52b1: ('orient_creature_with_line', _decode_orient_creature_with_line),
0xe35ed218: ('jettison_line_scale_speed', _decode_jettison_line_scale_speed),
0x2037e511: ('death_line_action', _decode_death_line_action),
0x29640a2d: ('curve_line_additive_scale', _decode_curve_line_additive_scale),
0x8468beb1: ('curve_line_ramp_in_speed', _decode_curve_line_ramp_in_speed),
0x55ee3bf9: ('curve_line_ramp_out_speed', _decode_curve_line_ramp_out_speed),
0xf8b1d183: ('curve_line_depart_apex_angle_to_ramp_in', _decode_curve_line_depart_apex_angle_to_ramp_in),
0xe127b113: ('curve_line_approach_apex_angle_to_ramp_out', _decode_curve_line_approach_apex_angle_to_ramp_out),
0x43ca4653: ('curve_line_middle', _decode_curve_line_middle),
0xb37c9890: ('dwell_dist_from_anchor', _decode_dwell_dist_from_anchor),
0xcdf7ceb9: ('dwell_time', _decode_dwell_time),
0xe9084c1f: ('climb_down_distance', _decode_climb_down_distance),
0xa47a7037: ('climb_down_speed', _decode_climb_down_speed),
0x3aa64111: ('drop_at_line_end', _decode_drop_at_line_end),
0x4fa9f7c2: ('drop_to_ground_rule', _decode_drop_to_ground_rule),
0xf5bee58e: ('hang_around_time', _decode_hang_around_time),
0xe27604be: ('climb_up_speed', _decode_climb_up_speed),
0xafe00ef0: ('end_of_line_jiggle_scale', _decode_end_of_line_jiggle_scale),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SwingLineBehaviorData.py | 0.613584 | 0.248899 | SwingLineBehaviorData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class GenericCreatureStructC(BaseProperty):
collision_actor_name: str = dataclasses.field(default='')
contact_rule: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
send_state_message: bool = dataclasses.field(default=False)
min_time_between_messages: float = dataclasses.field(default=1.0)
non_solid: bool = dataclasses.field(default=False)
use_for_creature_touch_bounds: bool = dataclasses.field(default=True)
potential_shadow_receiver: bool = dataclasses.field(default=False)
use_creature_damage_vulnerability: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'l\x80_V') # 0x6c805f56
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.collision_actor_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd2\x9a\xaa\xe6') # 0xd29aaae6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rule))
data.write(b'K\xab\xa4\xa6') # 0x4baba4a6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.send_state_message))
data.write(b'n\x92\xd6a') # 0x6e92d661
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_time_between_messages))
data.write(b'h\xf4\x84\xe7') # 0x68f484e7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.non_solid))
data.write(b'\xe1=\xe8#') # 0xe13de823
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_for_creature_touch_bounds))
data.write(b'\x99&\x0fT') # 0x99260f54
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.potential_shadow_receiver))
data.write(b'\x8f\xbd\xc1\x12') # 0x8fbdc112
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_creature_damage_vulnerability))
@classmethod
def from_json(cls, data: dict):
return cls(
collision_actor_name=data['collision_actor_name'],
contact_rule=data['contact_rule'],
send_state_message=data['send_state_message'],
min_time_between_messages=data['min_time_between_messages'],
non_solid=data['non_solid'],
use_for_creature_touch_bounds=data['use_for_creature_touch_bounds'],
potential_shadow_receiver=data['potential_shadow_receiver'],
use_creature_damage_vulnerability=data['use_creature_damage_vulnerability'],
)
def to_json(self) -> dict:
return {
'collision_actor_name': self.collision_actor_name,
'contact_rule': self.contact_rule,
'send_state_message': self.send_state_message,
'min_time_between_messages': self.min_time_between_messages,
'non_solid': self.non_solid,
'use_for_creature_touch_bounds': self.use_for_creature_touch_bounds,
'potential_shadow_receiver': self.potential_shadow_receiver,
'use_creature_damage_vulnerability': self.use_creature_damage_vulnerability,
}
def _decode_collision_actor_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_contact_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_send_state_message(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_min_time_between_messages(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_non_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_for_creature_touch_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_potential_shadow_receiver(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_creature_damage_vulnerability(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]]] = {
0x6c805f56: ('collision_actor_name', _decode_collision_actor_name),
0xd29aaae6: ('contact_rule', _decode_contact_rule),
0x4baba4a6: ('send_state_message', _decode_send_state_message),
0x6e92d661: ('min_time_between_messages', _decode_min_time_between_messages),
0x68f484e7: ('non_solid', _decode_non_solid),
0xe13de823: ('use_for_creature_touch_bounds', _decode_use_for_creature_touch_bounds),
0x99260f54: ('potential_shadow_receiver', _decode_potential_shadow_receiver),
0x8fbdc112: ('use_creature_damage_vulnerability', _decode_use_creature_damage_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GenericCreatureStructC.py | 0.643889 | 0.262245 | GenericCreatureStructC.py | 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.dkc_returns.archetypes.GenericCreatureStructE import GenericCreatureStructE
@dataclasses.dataclass()
class Animations(BaseProperty):
number_of_animations: int = dataclasses.field(default=0)
animation01: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation02: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation03: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation04: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation05: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation06: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation07: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation08: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation09: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation10: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation11: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation12: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation13: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation14: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation15: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
animation16: GenericCreatureStructE = dataclasses.field(default_factory=GenericCreatureStructE)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x11') # 17 properties
data.write(b'h*\xa3\xc9') # 0x682aa3c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_animations))
data.write(b'\x12J2\xa3') # 0x124a32a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation01.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\xeb\x17\xbb') # 0x56eb17bb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation02.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'j\x8b\xf4\xb3') # 0x6a8bf4b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation03.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\xa9]\x8b') # 0xdfa95d8b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation04.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe3\xc9\xbe\x83') # 0xe3c9be83
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7h\x9b\x9b') # 0xa7689b9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation06.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9b\x08x\x93') # 0x9b087893
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation07.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\\\xcf\xaa') # 0x165ccfaa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation08.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*<,\xa2') # 0x2a3c2ca2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation09.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' \xcd9z') # 0x20cd397a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation10.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\xad\xdar') # 0x1cadda72
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation11.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\x0c\xffj') # 0x580cff6a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation12.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'dl\x1cb') # 0x646c1c62
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1N\xb5Z') # 0xd14eb55a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation14.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed.VR') # 0xed2e5652
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation15.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa9\x8fsJ') # 0xa98f734a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation16.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_animations=data['number_of_animations'],
animation01=GenericCreatureStructE.from_json(data['animation01']),
animation02=GenericCreatureStructE.from_json(data['animation02']),
animation03=GenericCreatureStructE.from_json(data['animation03']),
animation04=GenericCreatureStructE.from_json(data['animation04']),
animation05=GenericCreatureStructE.from_json(data['animation05']),
animation06=GenericCreatureStructE.from_json(data['animation06']),
animation07=GenericCreatureStructE.from_json(data['animation07']),
animation08=GenericCreatureStructE.from_json(data['animation08']),
animation09=GenericCreatureStructE.from_json(data['animation09']),
animation10=GenericCreatureStructE.from_json(data['animation10']),
animation11=GenericCreatureStructE.from_json(data['animation11']),
animation12=GenericCreatureStructE.from_json(data['animation12']),
animation13=GenericCreatureStructE.from_json(data['animation13']),
animation14=GenericCreatureStructE.from_json(data['animation14']),
animation15=GenericCreatureStructE.from_json(data['animation15']),
animation16=GenericCreatureStructE.from_json(data['animation16']),
)
def to_json(self) -> dict:
return {
'number_of_animations': self.number_of_animations,
'animation01': self.animation01.to_json(),
'animation02': self.animation02.to_json(),
'animation03': self.animation03.to_json(),
'animation04': self.animation04.to_json(),
'animation05': self.animation05.to_json(),
'animation06': self.animation06.to_json(),
'animation07': self.animation07.to_json(),
'animation08': self.animation08.to_json(),
'animation09': self.animation09.to_json(),
'animation10': self.animation10.to_json(),
'animation11': self.animation11.to_json(),
'animation12': self.animation12.to_json(),
'animation13': self.animation13.to_json(),
'animation14': self.animation14.to_json(),
'animation15': self.animation15.to_json(),
'animation16': self.animation16.to_json(),
}
def _decode_number_of_animations(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_animation01(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation02(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation03(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation04(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation05(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation06(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation07(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation08(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation09(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation10(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation11(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation12(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation13(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation14(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation15(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
def _decode_animation16(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructE.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x682aa3c9: ('number_of_animations', _decode_number_of_animations),
0x124a32a3: ('animation01', _decode_animation01),
0x56eb17bb: ('animation02', _decode_animation02),
0x6a8bf4b3: ('animation03', _decode_animation03),
0xdfa95d8b: ('animation04', _decode_animation04),
0xe3c9be83: ('animation05', _decode_animation05),
0xa7689b9b: ('animation06', _decode_animation06),
0x9b087893: ('animation07', _decode_animation07),
0x165ccfaa: ('animation08', _decode_animation08),
0x2a3c2ca2: ('animation09', _decode_animation09),
0x20cd397a: ('animation10', _decode_animation10),
0x1cadda72: ('animation11', _decode_animation11),
0x580cff6a: ('animation12', _decode_animation12),
0x646c1c62: ('animation13', _decode_animation13),
0xd14eb55a: ('animation14', _decode_animation14),
0xed2e5652: ('animation15', _decode_animation15),
0xa98f734a: ('animation16', _decode_animation16),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/Animations.py | 0.483648 | 0.263777 | Animations.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct65(BaseProperty):
unknown: Spline = dataclasses.field(default_factory=Spline)
effect_mode: enums.EffectMode = dataclasses.field(default=enums.EffectMode.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xdc\xbf\xa4\xe6') # 0xdcbfa4e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\x10\xeb\x13') # 0x1610eb13
data.write(b'\x00\x04') # size
self.effect_mode.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=Spline.from_json(data['unknown']),
effect_mode=enums.EffectMode.from_json(data['effect_mode']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown.to_json(),
'effect_mode': self.effect_mode.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_effect_mode(data: typing.BinaryIO, property_size: int):
return enums.EffectMode.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xdcbfa4e6: ('unknown', _decode_unknown),
0x1610eb13: ('effect_mode', _decode_effect_mode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct65.py | 0.630116 | 0.267268 | UnknownStruct65.py | 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.dkc_returns.archetypes.UnknownStruct272 import UnknownStruct272
@dataclasses.dataclass()
class TrainTrackManagerStructB(BaseProperty):
debug_name: str = dataclasses.field(default='')
chain_string: str = dataclasses.field(default='')
unknown_struct272: UnknownStruct272 = dataclasses.field(default_factory=UnknownStruct272)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xbd\x0b~\xde') # 0xbd0b7ede
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.debug_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\xab\x02I') # 0xfcab0249
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.chain_string.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1w\r?') # 0x31770d3f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct272.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
debug_name=data['debug_name'],
chain_string=data['chain_string'],
unknown_struct272=UnknownStruct272.from_json(data['unknown_struct272']),
)
def to_json(self) -> dict:
return {
'debug_name': self.debug_name,
'chain_string': self.chain_string,
'unknown_struct272': self.unknown_struct272.to_json(),
}
def _decode_debug_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_chain_string(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_struct272(data: typing.BinaryIO, property_size: int):
return UnknownStruct272.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbd0b7ede: ('debug_name', _decode_debug_name),
0xfcab0249: ('chain_string', _decode_chain_string),
0x31770d3f: ('unknown_struct272', _decode_unknown_struct272),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TrainTrackManagerStructB.py | 0.567218 | 0.305056 | TrainTrackManagerStructB.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class OneShotBehaviorData(BaseProperty):
initial_delay_time: float = dataclasses.field(default=1.0)
repeat: bool = dataclasses.field(default=True)
delay_time: float = dataclasses.field(default=1.0)
number_of_animations: int = dataclasses.field(default=0)
animation01: int = dataclasses.field(default=0)
animation02: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\x93"GP') # 0x93224750
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_delay_time))
data.write(b'y\x81\x84\xbb') # 0x798184bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.repeat))
data.write(b'\x8e\x16\xe0\x12') # 0x8e16e012
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_time))
data.write(b'h*\xa3\xc9') # 0x682aa3c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_animations))
data.write(b'\x85\x14%v') # 0x85142576
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation01))
data.write(b'&B\xa3\xdf') # 0x2642a3df
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation02))
@classmethod
def from_json(cls, data: dict):
return cls(
initial_delay_time=data['initial_delay_time'],
repeat=data['repeat'],
delay_time=data['delay_time'],
number_of_animations=data['number_of_animations'],
animation01=data['animation01'],
animation02=data['animation02'],
)
def to_json(self) -> dict:
return {
'initial_delay_time': self.initial_delay_time,
'repeat': self.repeat,
'delay_time': self.delay_time,
'number_of_animations': self.number_of_animations,
'animation01': self.animation01,
'animation02': self.animation02,
}
_FAST_FORMAT = None
_FAST_IDS = (0x93224750, 0x798184bb, 0x8e16e012, 0x682aa3c9, 0x85142576, 0x2642a3df)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OneShotBehaviorData]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?LHfLHlLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(57))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return OneShotBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_initial_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_repeat(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_number_of_animations(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_animation01(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_animation02(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x93224750: ('initial_delay_time', _decode_initial_delay_time),
0x798184bb: ('repeat', _decode_repeat),
0x8e16e012: ('delay_time', _decode_delay_time),
0x682aa3c9: ('number_of_animations', _decode_number_of_animations),
0x85142576: ('animation01', _decode_animation01),
0x2642a3df: ('animation02', _decode_animation02),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OneShotBehaviorData.py | 0.607314 | 0.294367 | OneShotBehaviorData.py | 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.dkc_returns.archetypes.JungleBossStructC import JungleBossStructC
@dataclasses.dataclass()
class UnknownStruct205(BaseProperty):
number_of_sets: int = dataclasses.field(default=1)
jungle_boss_struct_c_0x6e3800d3: JungleBossStructC = dataclasses.field(default_factory=JungleBossStructC)
jungle_boss_struct_c_0xbda31c28: JungleBossStructC = dataclasses.field(default_factory=JungleBossStructC)
jungle_boss_struct_c_0xf32a1781: JungleBossStructC = dataclasses.field(default_factory=JungleBossStructC)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b"\xfc\x82'\xa7") # 0xfc8227a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_sets))
data.write(b'n8\x00\xd3') # 0x6e3800d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_c_0x6e3800d3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbd\xa3\x1c(') # 0xbda31c28
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_c_0xbda31c28.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3*\x17\x81') # 0xf32a1781
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_c_0xf32a1781.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_sets=data['number_of_sets'],
jungle_boss_struct_c_0x6e3800d3=JungleBossStructC.from_json(data['jungle_boss_struct_c_0x6e3800d3']),
jungle_boss_struct_c_0xbda31c28=JungleBossStructC.from_json(data['jungle_boss_struct_c_0xbda31c28']),
jungle_boss_struct_c_0xf32a1781=JungleBossStructC.from_json(data['jungle_boss_struct_c_0xf32a1781']),
)
def to_json(self) -> dict:
return {
'number_of_sets': self.number_of_sets,
'jungle_boss_struct_c_0x6e3800d3': self.jungle_boss_struct_c_0x6e3800d3.to_json(),
'jungle_boss_struct_c_0xbda31c28': self.jungle_boss_struct_c_0xbda31c28.to_json(),
'jungle_boss_struct_c_0xf32a1781': self.jungle_boss_struct_c_0xf32a1781.to_json(),
}
def _decode_number_of_sets(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_jungle_boss_struct_c_0x6e3800d3(data: typing.BinaryIO, property_size: int):
return JungleBossStructC.from_stream(data, property_size)
def _decode_jungle_boss_struct_c_0xbda31c28(data: typing.BinaryIO, property_size: int):
return JungleBossStructC.from_stream(data, property_size)
def _decode_jungle_boss_struct_c_0xf32a1781(data: typing.BinaryIO, property_size: int):
return JungleBossStructC.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfc8227a7: ('number_of_sets', _decode_number_of_sets),
0x6e3800d3: ('jungle_boss_struct_c_0x6e3800d3', _decode_jungle_boss_struct_c_0x6e3800d3),
0xbda31c28: ('jungle_boss_struct_c_0xbda31c28', _decode_jungle_boss_struct_c_0xbda31c28),
0xf32a1781: ('jungle_boss_struct_c_0xf32a1781', _decode_jungle_boss_struct_c_0xf32a1781),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct205.py | 0.558207 | 0.303609 | UnknownStruct205.py | 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.dkc_returns as enums
@dataclasses.dataclass()
class VolcanoBossBodyPartStructD(BaseProperty):
unknown_0x0f099933: enums.Unknown = dataclasses.field(default=enums.Unknown.Unknown7)
unknown_0xe8a3c283: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x0f\t\x993') # 0xf099933
data.write(b'\x00\x04') # size
self.unknown_0x0f099933.to_stream(data)
data.write(b'\xe8\xa3\xc2\x83') # 0xe8a3c283
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xe8a3c283.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x0f099933=enums.Unknown.from_json(data['unknown_0x0f099933']),
unknown_0xe8a3c283=data['unknown_0xe8a3c283'],
)
def to_json(self) -> dict:
return {
'unknown_0x0f099933': self.unknown_0x0f099933.to_json(),
'unknown_0xe8a3c283': self.unknown_0xe8a3c283,
}
def _decode_unknown_0x0f099933(data: typing.BinaryIO, property_size: int):
return enums.Unknown.from_stream(data)
def _decode_unknown_0xe8a3c283(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf099933: ('unknown_0x0f099933', _decode_unknown_0x0f099933),
0xe8a3c283: ('unknown_0xe8a3c283', _decode_unknown_0xe8a3c283),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VolcanoBossBodyPartStructD.py | 0.568416 | 0.282196 | VolcanoBossBodyPartStructD.py | 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.dkc_returns.archetypes.UnknownStruct26 import UnknownStruct26
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct157(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
bonus_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct26_0x4ed7e487: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x35521a04: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x6a598a9b: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x860139ad: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b'\x1a\x9f\xcch') # 0x1a9fcc68
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bonus_string))
data.write(b'N\xd7\xe4\x87') # 0x4ed7e487
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x4ed7e487.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'5R\x1a\x04') # 0x35521a04
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x35521a04.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'jY\x8a\x9b') # 0x6a598a9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x6a598a9b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\x019\xad') # 0x860139ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x860139ad.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
gui_frame=data['gui_frame'],
bonus_string=data['bonus_string'],
unknown_struct26_0x4ed7e487=UnknownStruct26.from_json(data['unknown_struct26_0x4ed7e487']),
unknown_struct26_0x35521a04=UnknownStruct26.from_json(data['unknown_struct26_0x35521a04']),
unknown_struct26_0x6a598a9b=UnknownStruct26.from_json(data['unknown_struct26_0x6a598a9b']),
unknown_struct26_0x860139ad=UnknownStruct26.from_json(data['unknown_struct26_0x860139ad']),
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'bonus_string': self.bonus_string,
'unknown_struct26_0x4ed7e487': self.unknown_struct26_0x4ed7e487.to_json(),
'unknown_struct26_0x35521a04': self.unknown_struct26_0x35521a04.to_json(),
'unknown_struct26_0x6a598a9b': self.unknown_struct26_0x6a598a9b.to_json(),
'unknown_struct26_0x860139ad': self.unknown_struct26_0x860139ad.to_json(),
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bonus_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct26_0x4ed7e487(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x35521a04(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x6a598a9b(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x860139ad(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0x1a9fcc68: ('bonus_string', _decode_bonus_string),
0x4ed7e487: ('unknown_struct26_0x4ed7e487', _decode_unknown_struct26_0x4ed7e487),
0x35521a04: ('unknown_struct26_0x35521a04', _decode_unknown_struct26_0x35521a04),
0x6a598a9b: ('unknown_struct26_0x6a598a9b', _decode_unknown_struct26_0x6a598a9b),
0x860139ad: ('unknown_struct26_0x860139ad', _decode_unknown_struct26_0x860139ad),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct157.py | 0.59514 | 0.227802 | UnknownStruct157.py | 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.dkc_returns as enums
@dataclasses.dataclass()
class GenericCreatureStructD(BaseProperty):
message: enums.Message = dataclasses.field(default=enums.Message.Unknown10)
behavior: enums.Behavior = dataclasses.field(default=enums.Behavior.Unknown1)
set: enums.Set = dataclasses.field(default=enums.Set.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x13\x83Mo') # 0x13834d6f
data.write(b'\x00\x04') # size
self.message.to_stream(data)
data.write(b'\xd1\x82\x15\xaa') # 0xd18215aa
data.write(b'\x00\x04') # size
self.behavior.to_stream(data)
data.write(b'\x0b?z\x00') # 0xb3f7a00
data.write(b'\x00\x04') # size
self.set.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
message=enums.Message.from_json(data['message']),
behavior=enums.Behavior.from_json(data['behavior']),
set=enums.Set.from_json(data['set']),
)
def to_json(self) -> dict:
return {
'message': self.message.to_json(),
'behavior': self.behavior.to_json(),
'set': self.set.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x13834d6f, 0xd18215aa, 0xb3f7a00)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[GenericCreatureStructD]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHLLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return GenericCreatureStructD(
enums.Message(dec[2]),
enums.Behavior(dec[5]),
enums.Set(dec[8]),
)
def _decode_message(data: typing.BinaryIO, property_size: int):
return enums.Message.from_stream(data)
def _decode_behavior(data: typing.BinaryIO, property_size: int):
return enums.Behavior.from_stream(data)
def _decode_set(data: typing.BinaryIO, property_size: int):
return enums.Set.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x13834d6f: ('message', _decode_message),
0xd18215aa: ('behavior', _decode_behavior),
0xb3f7a00: ('set', _decode_set),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GenericCreatureStructD.py | 0.637144 | 0.274484 | GenericCreatureStructD.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct49(BaseProperty):
speed: float = dataclasses.field(default=9.0)
acceleration: float = dataclasses.field(default=20.0)
deceleration: float = dataclasses.field(default=9.0)
roll_speed: float = dataclasses.field(default=270.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x9e\xc4\xfc\x10') # 0x9ec4fc10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deceleration))
data.write(b'\xc9\xd3t\xd2') # 0xc9d374d2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
speed=data['speed'],
acceleration=data['acceleration'],
deceleration=data['deceleration'],
roll_speed=data['roll_speed'],
)
def to_json(self) -> dict:
return {
'speed': self.speed,
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'roll_speed': self.roll_speed,
}
_FAST_FORMAT = None
_FAST_IDS = (0x6392404e, 0x39fb7978, 0x9ec4fc10, 0xc9d374d2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct49]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct49(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6392404e: ('speed', _decode_speed),
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0xc9d374d2: ('roll_speed', _decode_roll_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct49.py | 0.723212 | 0.327319 | UnknownStruct49.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class TrainTrackManagerStructA(BaseProperty):
weight: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xff\xb03\x00') # 0xffb03300
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.weight))
@classmethod
def from_json(cls, data: dict):
return cls(
weight=data['weight'],
)
def to_json(self) -> dict:
return {
'weight': self.weight,
}
_FAST_FORMAT = None
_FAST_IDS = (0xffb03300)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TrainTrackManagerStructA]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return TrainTrackManagerStructA(
dec[2],
)
def _decode_weight(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]]] = {
0xffb03300: ('weight', _decode_weight),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TrainTrackManagerStructA.py | 0.645902 | 0.310374 | TrainTrackManagerStructA.py | 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.dkc_returns.archetypes.DamageEffectData import DamageEffectData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct187(BaseProperty):
unknown: int = dataclasses.field(default=1)
impact_stun_radius: float = dataclasses.field(default=5.0)
impact_stun_velocity: float = dataclasses.field(default=8.0)
impact_stun_duration: float = dataclasses.field(default=1.0)
shock_wave_ring_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_effect_data: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\xd4:\xac"') # 0xd43aac22
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impact_stun_radius))
data.write(b'Y\xcc\xac\x1b') # 0x59ccac1b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impact_stun_velocity))
data.write(b'\xd0mX\xa7') # 0xd06d58a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impact_stun_duration))
data.write(b'\xd3\xc19\x0e') # 0xd3c1390e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.shock_wave_ring_effect))
data.write(b'\xae4/\x0f') # 0xae342f0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
impact_stun_radius=data['impact_stun_radius'],
impact_stun_velocity=data['impact_stun_velocity'],
impact_stun_duration=data['impact_stun_duration'],
shock_wave_ring_effect=data['shock_wave_ring_effect'],
damage_effect_data=DamageEffectData.from_json(data['damage_effect_data']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'impact_stun_radius': self.impact_stun_radius,
'impact_stun_velocity': self.impact_stun_velocity,
'impact_stun_duration': self.impact_stun_duration,
'shock_wave_ring_effect': self.shock_wave_ring_effect,
'damage_effect_data': self.damage_effect_data.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_impact_stun_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impact_stun_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impact_stun_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shock_wave_ring_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_damage_effect_data(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8a58a7f8: ('unknown', _decode_unknown),
0xd43aac22: ('impact_stun_radius', _decode_impact_stun_radius),
0x59ccac1b: ('impact_stun_velocity', _decode_impact_stun_velocity),
0xd06d58a7: ('impact_stun_duration', _decode_impact_stun_duration),
0xd3c1390e: ('shock_wave_ring_effect', _decode_shock_wave_ring_effect),
0xae342f0f: ('damage_effect_data', _decode_damage_effect_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct187.py | 0.623606 | 0.246431 | UnknownStruct187.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class RagDollData(BaseProperty):
gravity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=-50.0))
rag_doll_density: float = dataclasses.field(default=8000.0)
air_density: float = dataclasses.field(default=1.2000000476837158)
restitution_multiplier: float = dataclasses.field(default=0.125)
friction_multiplier: float = dataclasses.field(default=0.8500000238418579)
unknown_0x91936b5e: float = dataclasses.field(default=1.0)
unknown_0x81d40910: float = dataclasses.field(default=3000.0)
static_speed: float = dataclasses.field(default=0.5)
max_time: float = dataclasses.field(default=5.0)
sound_impact: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0xce5d16c3: bool = dataclasses.field(default=False)
damp_rotation: bool = dataclasses.field(default=False)
ignore_max_time: bool = dataclasses.field(default=True)
ignore_dock_collision: bool = dataclasses.field(default=False)
ignore_all_collision: bool = dataclasses.field(default=True)
collision_type: int = dataclasses.field(default=2418955086) # Choice
collision_plane_normal: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=1.0))
collision_plane_constant: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x12') # 18 properties
data.write(b'\x9e#\\a') # 0x9e235c61
data.write(b'\x00\x0c') # size
self.gravity.to_stream(data)
data.write(b'j\xb04\x1a') # 0x6ab0341a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rag_doll_density))
data.write(b'C\xc0"$') # 0x43c02224
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_density))
data.write(b'Dj3\xf5') # 0x446a33f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.restitution_multiplier))
data.write(b'\x08\xb31\xce') # 0x8b331ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.friction_multiplier))
data.write(b'\x91\x93k^') # 0x91936b5e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x91936b5e))
data.write(b'\x81\xd4\t\x10') # 0x81d40910
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x81d40910))
data.write(b'\x16@~\xd9') # 0x16407ed9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.static_speed))
data.write(b'\x03\xe7\xb2\xb4') # 0x3e7b2b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_time))
data.write(b'\xe1\x90\xf7}') # 0xe190f77d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_impact))
data.write(b'\xce]\x16\xc3') # 0xce5d16c3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xce5d16c3))
data.write(b'\xa9\x9a\x0e3') # 0xa99a0e33
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.damp_rotation))
data.write(b'\xe7\xb8\x8dQ') # 0xe7b88d51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_max_time))
data.write(b'}\xe2\xe6\xba') # 0x7de2e6ba
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_dock_collision))
data.write(b'\xe1\x10|J') # 0xe1107c4a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_all_collision))
data.write(b'\xb6t\xea=') # 0xb674ea3d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.collision_type))
data.write(b'\x96\xbb0*') # 0x96bb302a
data.write(b'\x00\x0c') # size
self.collision_plane_normal.to_stream(data)
data.write(b'D\x14\xd9\x9c') # 0x4414d99c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_plane_constant))
@classmethod
def from_json(cls, data: dict):
return cls(
gravity=Vector.from_json(data['gravity']),
rag_doll_density=data['rag_doll_density'],
air_density=data['air_density'],
restitution_multiplier=data['restitution_multiplier'],
friction_multiplier=data['friction_multiplier'],
unknown_0x91936b5e=data['unknown_0x91936b5e'],
unknown_0x81d40910=data['unknown_0x81d40910'],
static_speed=data['static_speed'],
max_time=data['max_time'],
sound_impact=data['sound_impact'],
unknown_0xce5d16c3=data['unknown_0xce5d16c3'],
damp_rotation=data['damp_rotation'],
ignore_max_time=data['ignore_max_time'],
ignore_dock_collision=data['ignore_dock_collision'],
ignore_all_collision=data['ignore_all_collision'],
collision_type=data['collision_type'],
collision_plane_normal=Vector.from_json(data['collision_plane_normal']),
collision_plane_constant=data['collision_plane_constant'],
)
def to_json(self) -> dict:
return {
'gravity': self.gravity.to_json(),
'rag_doll_density': self.rag_doll_density,
'air_density': self.air_density,
'restitution_multiplier': self.restitution_multiplier,
'friction_multiplier': self.friction_multiplier,
'unknown_0x91936b5e': self.unknown_0x91936b5e,
'unknown_0x81d40910': self.unknown_0x81d40910,
'static_speed': self.static_speed,
'max_time': self.max_time,
'sound_impact': self.sound_impact,
'unknown_0xce5d16c3': self.unknown_0xce5d16c3,
'damp_rotation': self.damp_rotation,
'ignore_max_time': self.ignore_max_time,
'ignore_dock_collision': self.ignore_dock_collision,
'ignore_all_collision': self.ignore_all_collision,
'collision_type': self.collision_type,
'collision_plane_normal': self.collision_plane_normal.to_json(),
'collision_plane_constant': self.collision_plane_constant,
}
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_rag_doll_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_air_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_restitution_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_friction_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x91936b5e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x81d40910(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_static_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_impact(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xce5d16c3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damp_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_max_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_dock_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_all_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_collision_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_collision_plane_normal(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_plane_constant(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]]] = {
0x9e235c61: ('gravity', _decode_gravity),
0x6ab0341a: ('rag_doll_density', _decode_rag_doll_density),
0x43c02224: ('air_density', _decode_air_density),
0x446a33f5: ('restitution_multiplier', _decode_restitution_multiplier),
0x8b331ce: ('friction_multiplier', _decode_friction_multiplier),
0x91936b5e: ('unknown_0x91936b5e', _decode_unknown_0x91936b5e),
0x81d40910: ('unknown_0x81d40910', _decode_unknown_0x81d40910),
0x16407ed9: ('static_speed', _decode_static_speed),
0x3e7b2b4: ('max_time', _decode_max_time),
0xe190f77d: ('sound_impact', _decode_sound_impact),
0xce5d16c3: ('unknown_0xce5d16c3', _decode_unknown_0xce5d16c3),
0xa99a0e33: ('damp_rotation', _decode_damp_rotation),
0xe7b88d51: ('ignore_max_time', _decode_ignore_max_time),
0x7de2e6ba: ('ignore_dock_collision', _decode_ignore_dock_collision),
0xe1107c4a: ('ignore_all_collision', _decode_ignore_all_collision),
0xb674ea3d: ('collision_type', _decode_collision_type),
0x96bb302a: ('collision_plane_normal', _decode_collision_plane_normal),
0x4414d99c: ('collision_plane_constant', _decode_collision_plane_constant),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RagDollData.py | 0.583559 | 0.355579 | RagDollData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerTireInteractionData(BaseProperty):
pre_tire_jump_buffer: float = dataclasses.field(default=0.10000000149011612)
pre_tire_jump_buffer_sd: float = dataclasses.field(default=0.20000000298023224)
programmatic_turn_speed: float = dataclasses.field(default=450.0)
bump_into_tire_wall_min_speed: float = dataclasses.field(default=3.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'>eA\x0c') # 0x3e65410c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pre_tire_jump_buffer))
data.write(b'xM\x14?') # 0x784d143f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pre_tire_jump_buffer_sd))
data.write(b'\xcf\x03\xcb\x0c') # 0xcf03cb0c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.programmatic_turn_speed))
data.write(b':2\xdf\xcb') # 0x3a32dfcb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bump_into_tire_wall_min_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
pre_tire_jump_buffer=data['pre_tire_jump_buffer'],
pre_tire_jump_buffer_sd=data['pre_tire_jump_buffer_sd'],
programmatic_turn_speed=data['programmatic_turn_speed'],
bump_into_tire_wall_min_speed=data['bump_into_tire_wall_min_speed'],
)
def to_json(self) -> dict:
return {
'pre_tire_jump_buffer': self.pre_tire_jump_buffer,
'pre_tire_jump_buffer_sd': self.pre_tire_jump_buffer_sd,
'programmatic_turn_speed': self.programmatic_turn_speed,
'bump_into_tire_wall_min_speed': self.bump_into_tire_wall_min_speed,
}
_FAST_FORMAT = None
_FAST_IDS = (0x3e65410c, 0x784d143f, 0xcf03cb0c, 0x3a32dfcb)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerTireInteractionData]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return PlayerTireInteractionData(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_pre_tire_jump_buffer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pre_tire_jump_buffer_sd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_programmatic_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bump_into_tire_wall_min_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x3e65410c: ('pre_tire_jump_buffer', _decode_pre_tire_jump_buffer),
0x784d143f: ('pre_tire_jump_buffer_sd', _decode_pre_tire_jump_buffer_sd),
0xcf03cb0c: ('programmatic_turn_speed', _decode_programmatic_turn_speed),
0x3a32dfcb: ('bump_into_tire_wall_min_speed', _decode_bump_into_tire_wall_min_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerTireInteractionData.py | 0.633977 | 0.371878 | PlayerTireInteractionData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerBasicMovementData(BaseProperty):
use5_cycle_locomotion_set: bool = dataclasses.field(default=False)
fidget_delay_minimum: float = dataclasses.field(default=20.0)
fidget_delay_maximum: float = dataclasses.field(default=40.0)
allow_edge_fidgets: bool = dataclasses.field(default=True)
max_perch_angle: float = dataclasses.field(default=30.0)
max_perch_movement_speed: float = dataclasses.field(default=3.0)
off_balance_perch_fraction_threshold: float = dataclasses.field(default=0.949999988079071)
min_perch_distance_from_edge: float = dataclasses.field(default=0.0)
bump_into_wall_speed: float = dataclasses.field(default=8.899999618530273)
bump_into_wall_knockback_amount: float = dataclasses.field(default=0.5)
bump_into_wall_knockback_time: float = dataclasses.field(default=0.5)
wall_hit_response_default_min_velocity: float = dataclasses.field(default=4.0)
wall_hit_response_medium_min_velocity: float = dataclasses.field(default=8.0)
wall_hit_response_heavy_min_velocity: float = dataclasses.field(default=12.0)
wall_hit_response_default_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
wall_hit_response_medium_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
wall_hit_response_heavy_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
collision_response_default_min_velocity: float = dataclasses.field(default=15.0)
collision_response_medium_min_velocity: float = dataclasses.field(default=22.0)
collision_response_heavy_min_velocity: float = dataclasses.field(default=28.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x14') # 20 properties
data.write(b'\xa6\xb7]\x03') # 0xa6b75d03
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use5_cycle_locomotion_set))
data.write(b'\x13u)\n') # 0x1375290a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fidget_delay_minimum))
data.write(b'\x83\x069\xe0') # 0x830639e0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fidget_delay_maximum))
data.write(b'\xa3b3V') # 0xa3623356
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_edge_fidgets))
data.write(b'D?\xb4\xe4') # 0x443fb4e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_perch_angle))
data.write(b'-o\x84H') # 0x2d6f8448
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_perch_movement_speed))
data.write(b'\x0e:\xf7Q') # 0xe3af751
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.off_balance_perch_fraction_threshold))
data.write(b'\x959\xca\xb4') # 0x9539cab4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_perch_distance_from_edge))
data.write(b'\x03\xc1 \xfc') # 0x3c120fc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bump_into_wall_speed))
data.write(b'\xdd\xe4\xdal') # 0xdde4da6c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bump_into_wall_knockback_amount))
data.write(b'\xa6\x93\x8c\x8e') # 0xa6938c8e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bump_into_wall_knockback_time))
data.write(b'74g[') # 0x3734675b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_hit_response_default_min_velocity))
data.write(b'R(:"') # 0x52283a22
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_hit_response_medium_min_velocity))
data.write(b'\xd1?\xcd\x0e') # 0xd13fcd0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_hit_response_heavy_min_velocity))
data.write(b'\xfd\x15\x0b?') # 0xfd150b3f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.wall_hit_response_default_effect))
data.write(b'\x8c\x04\x1cM') # 0x8c041c4d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.wall_hit_response_medium_effect))
data.write(b'\xf0f\xf7G') # 0xf066f747
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.wall_hit_response_heavy_effect))
data.write(b'r\xf4\xa5\x96') # 0x72f4a596
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_response_default_min_velocity))
data.write(b'M\xb6\x82\x0f') # 0x4db6820f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_response_medium_min_velocity))
data.write(b'\x95\x04\x8e\xdd') # 0x95048edd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_response_heavy_min_velocity))
@classmethod
def from_json(cls, data: dict):
return cls(
use5_cycle_locomotion_set=data['use5_cycle_locomotion_set'],
fidget_delay_minimum=data['fidget_delay_minimum'],
fidget_delay_maximum=data['fidget_delay_maximum'],
allow_edge_fidgets=data['allow_edge_fidgets'],
max_perch_angle=data['max_perch_angle'],
max_perch_movement_speed=data['max_perch_movement_speed'],
off_balance_perch_fraction_threshold=data['off_balance_perch_fraction_threshold'],
min_perch_distance_from_edge=data['min_perch_distance_from_edge'],
bump_into_wall_speed=data['bump_into_wall_speed'],
bump_into_wall_knockback_amount=data['bump_into_wall_knockback_amount'],
bump_into_wall_knockback_time=data['bump_into_wall_knockback_time'],
wall_hit_response_default_min_velocity=data['wall_hit_response_default_min_velocity'],
wall_hit_response_medium_min_velocity=data['wall_hit_response_medium_min_velocity'],
wall_hit_response_heavy_min_velocity=data['wall_hit_response_heavy_min_velocity'],
wall_hit_response_default_effect=data['wall_hit_response_default_effect'],
wall_hit_response_medium_effect=data['wall_hit_response_medium_effect'],
wall_hit_response_heavy_effect=data['wall_hit_response_heavy_effect'],
collision_response_default_min_velocity=data['collision_response_default_min_velocity'],
collision_response_medium_min_velocity=data['collision_response_medium_min_velocity'],
collision_response_heavy_min_velocity=data['collision_response_heavy_min_velocity'],
)
def to_json(self) -> dict:
return {
'use5_cycle_locomotion_set': self.use5_cycle_locomotion_set,
'fidget_delay_minimum': self.fidget_delay_minimum,
'fidget_delay_maximum': self.fidget_delay_maximum,
'allow_edge_fidgets': self.allow_edge_fidgets,
'max_perch_angle': self.max_perch_angle,
'max_perch_movement_speed': self.max_perch_movement_speed,
'off_balance_perch_fraction_threshold': self.off_balance_perch_fraction_threshold,
'min_perch_distance_from_edge': self.min_perch_distance_from_edge,
'bump_into_wall_speed': self.bump_into_wall_speed,
'bump_into_wall_knockback_amount': self.bump_into_wall_knockback_amount,
'bump_into_wall_knockback_time': self.bump_into_wall_knockback_time,
'wall_hit_response_default_min_velocity': self.wall_hit_response_default_min_velocity,
'wall_hit_response_medium_min_velocity': self.wall_hit_response_medium_min_velocity,
'wall_hit_response_heavy_min_velocity': self.wall_hit_response_heavy_min_velocity,
'wall_hit_response_default_effect': self.wall_hit_response_default_effect,
'wall_hit_response_medium_effect': self.wall_hit_response_medium_effect,
'wall_hit_response_heavy_effect': self.wall_hit_response_heavy_effect,
'collision_response_default_min_velocity': self.collision_response_default_min_velocity,
'collision_response_medium_min_velocity': self.collision_response_medium_min_velocity,
'collision_response_heavy_min_velocity': self.collision_response_heavy_min_velocity,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa6b75d03, 0x1375290a, 0x830639e0, 0xa3623356, 0x443fb4e4, 0x2d6f8448, 0xe3af751, 0x9539cab4, 0x3c120fc, 0xdde4da6c, 0xa6938c8e, 0x3734675b, 0x52283a22, 0xd13fcd0e, 0xfd150b3f, 0x8c041c4d, 0xf066f747, 0x72f4a596, 0x4db6820f, 0x95048edd)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerBasicMovementData]:
if property_count != 20:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHfLH?LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHQLHQLHQLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(206))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33], dec[36], dec[39], dec[42], dec[45], dec[48], dec[51], dec[54], dec[57]) != _FAST_IDS:
data.seek(before)
return None
return PlayerBasicMovementData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
dec[38],
dec[41],
dec[44],
dec[47],
dec[50],
dec[53],
dec[56],
dec[59],
)
def _decode_use5_cycle_locomotion_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fidget_delay_minimum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fidget_delay_maximum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_allow_edge_fidgets(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_perch_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_perch_movement_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_off_balance_perch_fraction_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_perch_distance_from_edge(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bump_into_wall_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bump_into_wall_knockback_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bump_into_wall_knockback_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_hit_response_default_min_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_hit_response_medium_min_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_hit_response_heavy_min_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_hit_response_default_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_wall_hit_response_medium_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_wall_hit_response_heavy_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_response_default_min_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_response_medium_min_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_response_heavy_min_velocity(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]]] = {
0xa6b75d03: ('use5_cycle_locomotion_set', _decode_use5_cycle_locomotion_set),
0x1375290a: ('fidget_delay_minimum', _decode_fidget_delay_minimum),
0x830639e0: ('fidget_delay_maximum', _decode_fidget_delay_maximum),
0xa3623356: ('allow_edge_fidgets', _decode_allow_edge_fidgets),
0x443fb4e4: ('max_perch_angle', _decode_max_perch_angle),
0x2d6f8448: ('max_perch_movement_speed', _decode_max_perch_movement_speed),
0xe3af751: ('off_balance_perch_fraction_threshold', _decode_off_balance_perch_fraction_threshold),
0x9539cab4: ('min_perch_distance_from_edge', _decode_min_perch_distance_from_edge),
0x3c120fc: ('bump_into_wall_speed', _decode_bump_into_wall_speed),
0xdde4da6c: ('bump_into_wall_knockback_amount', _decode_bump_into_wall_knockback_amount),
0xa6938c8e: ('bump_into_wall_knockback_time', _decode_bump_into_wall_knockback_time),
0x3734675b: ('wall_hit_response_default_min_velocity', _decode_wall_hit_response_default_min_velocity),
0x52283a22: ('wall_hit_response_medium_min_velocity', _decode_wall_hit_response_medium_min_velocity),
0xd13fcd0e: ('wall_hit_response_heavy_min_velocity', _decode_wall_hit_response_heavy_min_velocity),
0xfd150b3f: ('wall_hit_response_default_effect', _decode_wall_hit_response_default_effect),
0x8c041c4d: ('wall_hit_response_medium_effect', _decode_wall_hit_response_medium_effect),
0xf066f747: ('wall_hit_response_heavy_effect', _decode_wall_hit_response_heavy_effect),
0x72f4a596: ('collision_response_default_min_velocity', _decode_collision_response_default_min_velocity),
0x4db6820f: ('collision_response_medium_min_velocity', _decode_collision_response_medium_min_velocity),
0x95048edd: ('collision_response_heavy_min_velocity', _decode_collision_response_heavy_min_velocity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerBasicMovementData.py | 0.646125 | 0.238772 | PlayerBasicMovementData.py | 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.dkc_returns.archetypes.RevolutionControl import RevolutionControl
@dataclasses.dataclass()
class MiscControls(BaseProperty):
unknown_0x439f3678: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xbf8653ed: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x9ca552b4: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x88b5fd4d: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xb63c1d0b: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x1d88ee3e: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
skip_cinematic: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xd9cf3e97: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xb7346005: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x76299df7: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x2c2b2b0e: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'C\x9f6x') # 0x439f3678
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x439f3678.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x86S\xed') # 0xbf8653ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xbf8653ed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9c\xa5R\xb4') # 0x9ca552b4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x9ca552b4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x88\xb5\xfdM') # 0x88b5fd4d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x88b5fd4d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6<\x1d\x0b') # 0xb63c1d0b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb63c1d0b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\x88\xee>') # 0x1d88ee3e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1d88ee3e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\xa3\xe0}') # 0x19a3e07d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.skip_cinematic.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd9\xcf>\x97') # 0xd9cf3e97
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xd9cf3e97.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb74`\x05') # 0xb7346005
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb7346005.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v)\x9d\xf7') # 0x76299df7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x76299df7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b',++\x0e') # 0x2c2b2b0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x2c2b2b0e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x439f3678=RevolutionControl.from_json(data['unknown_0x439f3678']),
unknown_0xbf8653ed=RevolutionControl.from_json(data['unknown_0xbf8653ed']),
unknown_0x9ca552b4=RevolutionControl.from_json(data['unknown_0x9ca552b4']),
unknown_0x88b5fd4d=RevolutionControl.from_json(data['unknown_0x88b5fd4d']),
unknown_0xb63c1d0b=RevolutionControl.from_json(data['unknown_0xb63c1d0b']),
unknown_0x1d88ee3e=RevolutionControl.from_json(data['unknown_0x1d88ee3e']),
skip_cinematic=RevolutionControl.from_json(data['skip_cinematic']),
unknown_0xd9cf3e97=RevolutionControl.from_json(data['unknown_0xd9cf3e97']),
unknown_0xb7346005=RevolutionControl.from_json(data['unknown_0xb7346005']),
unknown_0x76299df7=RevolutionControl.from_json(data['unknown_0x76299df7']),
unknown_0x2c2b2b0e=RevolutionControl.from_json(data['unknown_0x2c2b2b0e']),
)
def to_json(self) -> dict:
return {
'unknown_0x439f3678': self.unknown_0x439f3678.to_json(),
'unknown_0xbf8653ed': self.unknown_0xbf8653ed.to_json(),
'unknown_0x9ca552b4': self.unknown_0x9ca552b4.to_json(),
'unknown_0x88b5fd4d': self.unknown_0x88b5fd4d.to_json(),
'unknown_0xb63c1d0b': self.unknown_0xb63c1d0b.to_json(),
'unknown_0x1d88ee3e': self.unknown_0x1d88ee3e.to_json(),
'skip_cinematic': self.skip_cinematic.to_json(),
'unknown_0xd9cf3e97': self.unknown_0xd9cf3e97.to_json(),
'unknown_0xb7346005': self.unknown_0xb7346005.to_json(),
'unknown_0x76299df7': self.unknown_0x76299df7.to_json(),
'unknown_0x2c2b2b0e': self.unknown_0x2c2b2b0e.to_json(),
}
def _decode_unknown_0x439f3678(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xbf8653ed(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x9ca552b4(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x88b5fd4d(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xb63c1d0b(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x1d88ee3e(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_skip_cinematic(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xd9cf3e97(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xb7346005(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x76299df7(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x2c2b2b0e(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x439f3678: ('unknown_0x439f3678', _decode_unknown_0x439f3678),
0xbf8653ed: ('unknown_0xbf8653ed', _decode_unknown_0xbf8653ed),
0x9ca552b4: ('unknown_0x9ca552b4', _decode_unknown_0x9ca552b4),
0x88b5fd4d: ('unknown_0x88b5fd4d', _decode_unknown_0x88b5fd4d),
0xb63c1d0b: ('unknown_0xb63c1d0b', _decode_unknown_0xb63c1d0b),
0x1d88ee3e: ('unknown_0x1d88ee3e', _decode_unknown_0x1d88ee3e),
0x19a3e07d: ('skip_cinematic', _decode_skip_cinematic),
0xd9cf3e97: ('unknown_0xd9cf3e97', _decode_unknown_0xd9cf3e97),
0xb7346005: ('unknown_0xb7346005', _decode_unknown_0xb7346005),
0x76299df7: ('unknown_0x76299df7', _decode_unknown_0x76299df7),
0x2c2b2b0e: ('unknown_0x2c2b2b0e', _decode_unknown_0x2c2b2b0e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MiscControls.py | 0.477311 | 0.30905 | MiscControls.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class CameraManagerData(BaseProperty):
auto_on: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'.\x14F\xf0') # 0x2e1446f0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_on))
@classmethod
def from_json(cls, data: dict):
return cls(
auto_on=data['auto_on'],
)
def to_json(self) -> dict:
return {
'auto_on': self.auto_on,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2e1446f0)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraManagerData]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(7))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return CameraManagerData(
dec[2],
)
def _decode_auto_on(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2e1446f0: ('auto_on', _decode_auto_on),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraManagerData.py | 0.639286 | 0.323153 | CameraManagerData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerBopAnimThresholds(BaseProperty):
animation_count: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'9\xe9\xfa5') # 0x39e9fa35
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation_count))
@classmethod
def from_json(cls, data: dict):
return cls(
animation_count=data['animation_count'],
)
def to_json(self) -> dict:
return {
'animation_count': self.animation_count,
}
_FAST_FORMAT = None
_FAST_IDS = (0x39e9fa35)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerBopAnimThresholds]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return PlayerBopAnimThresholds(
dec[2],
)
def _decode_animation_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x39e9fa35: ('animation_count', _decode_animation_count),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerBopAnimThresholds.py | 0.633977 | 0.297636 | PlayerBopAnimThresholds.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct279(BaseProperty):
unknown_0x8a58a7f8: int = dataclasses.field(default=1)
unknown_0x6f51c96b: float = dataclasses.field(default=2.0)
unknown_0x72d0dc87: float = dataclasses.field(default=30.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'oQ\xc9k') # 0x6f51c96b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6f51c96b))
data.write(b'r\xd0\xdc\x87') # 0x72d0dc87
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72d0dc87))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
unknown_0x6f51c96b=data['unknown_0x6f51c96b'],
unknown_0x72d0dc87=data['unknown_0x72d0dc87'],
)
def to_json(self) -> dict:
return {
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'unknown_0x6f51c96b': self.unknown_0x6f51c96b,
'unknown_0x72d0dc87': self.unknown_0x72d0dc87,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8a58a7f8, 0x6f51c96b, 0x72d0dc87)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct279]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct279(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6f51c96b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x72d0dc87(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]]] = {
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0x6f51c96b: ('unknown_0x6f51c96b', _decode_unknown_0x6f51c96b),
0x72d0dc87: ('unknown_0x72d0dc87', _decode_unknown_0x72d0dc87),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct279.py | 0.625324 | 0.274938 | UnknownStruct279.py | 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.dkc_returns.archetypes.MaterialSoundPair import MaterialSoundPair
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class KongSlideData(BaseProperty):
slope_detection_angle: float = dataclasses.field(default=20.0)
slide_no_jump_angle: float = dataclasses.field(default=70.0)
slide_detection_angle: float = dataclasses.field(default=54.0)
scramble_detection_angle: float = dataclasses.field(default=20.0)
scramble_speed: float = dataclasses.field(default=4.0)
tar_scramble_speed: float = dataclasses.field(default=4.0)
slide_breaking_speed: float = dataclasses.field(default=7.0)
max_slide_speed: float = dataclasses.field(default=15.0)
scramble_recovery_acceleration: float = dataclasses.field(default=40.0)
slide_speedup_acceleration: float = dataclasses.field(default=40.0)
slide_slowdown_acceleration: float = dataclasses.field(default=20.0)
planar_slide_recovery_speed: float = dataclasses.field(default=0.10000000149011612)
slide_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
slide_sound_ratio_change_factor: float = dataclasses.field(default=0.5)
slide_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
slide_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
slide_sound_volume: Spline = dataclasses.field(default_factory=Spline)
num_material_sounds: int = dataclasses.field(default=0)
material_sound0: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound1: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound2: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound3: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound4: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound5: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound6: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound7: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound8: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
material_sound9: MaterialSoundPair = dataclasses.field(default_factory=MaterialSoundPair)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1c') # 28 properties
data.write(b'N}\xef~') # 0x4e7def7e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slope_detection_angle))
data.write(b'\x18\xaa\\t') # 0x18aa5c74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_no_jump_angle))
data.write(b'e\x91\xa3\xa9') # 0x6591a3a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_detection_angle))
data.write(b'\x8f\x7f\xddo') # 0x8f7fdd6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scramble_detection_angle))
data.write(b'C\x84\x99\x00') # 0x43849900
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scramble_speed))
data.write(b'\x8e~\xa4\xfc') # 0x8e7ea4fc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tar_scramble_speed))
data.write(b'\x8f;\x93(') # 0x8f3b9328
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_breaking_speed))
data.write(b'Ln\xc5\x11') # 0x4c6ec511
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_slide_speed))
data.write(b's5\x08M') # 0x7335084d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scramble_recovery_acceleration))
data.write(b'v\x00\xa6\xc5') # 0x7600a6c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_speedup_acceleration))
data.write(b'\x8fs\xe7=') # 0x8f73e73d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_slowdown_acceleration))
data.write(b'\xce\x00x\x90') # 0xce007890
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.planar_slide_recovery_speed))
data.write(b'+y\xea\x93') # 0x2b79ea93
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.slide_sound))
data.write(b'\xba0\xaa\xca') # 0xba30aaca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_sound_ratio_change_factor))
data.write(b'\xd9\xcaP\xc2') # 0xd9ca50c2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.slide_sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x84\x95\x1e\xc7') # 0x84951ec7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.slide_sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'jxR_') # 0x6a78525f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.slide_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd7\xc1\x91A') # 0xd7c19141
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_material_sounds))
data.write(b'Wm\x99F') # 0x576d9946
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8?/\xa7') # 0xb83f2fa7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'R\xb9\xf2\xc5') # 0x52b9f2c5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbd\xebD$') # 0xbdeb4424
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\xc5N@') # 0x5cc54e40
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\x97\xf8\xa1') # 0xb397f8a1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\x11%\xc3') # 0x591125c3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6C\x93"') # 0xb6439322
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@<7J') # 0x403c374a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xafn\x81\xab') # 0xaf6e81ab
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sound9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
slope_detection_angle=data['slope_detection_angle'],
slide_no_jump_angle=data['slide_no_jump_angle'],
slide_detection_angle=data['slide_detection_angle'],
scramble_detection_angle=data['scramble_detection_angle'],
scramble_speed=data['scramble_speed'],
tar_scramble_speed=data['tar_scramble_speed'],
slide_breaking_speed=data['slide_breaking_speed'],
max_slide_speed=data['max_slide_speed'],
scramble_recovery_acceleration=data['scramble_recovery_acceleration'],
slide_speedup_acceleration=data['slide_speedup_acceleration'],
slide_slowdown_acceleration=data['slide_slowdown_acceleration'],
planar_slide_recovery_speed=data['planar_slide_recovery_speed'],
slide_sound=data['slide_sound'],
slide_sound_ratio_change_factor=data['slide_sound_ratio_change_factor'],
slide_sound_low_pass_filter=Spline.from_json(data['slide_sound_low_pass_filter']),
slide_sound_pitch=Spline.from_json(data['slide_sound_pitch']),
slide_sound_volume=Spline.from_json(data['slide_sound_volume']),
num_material_sounds=data['num_material_sounds'],
material_sound0=MaterialSoundPair.from_json(data['material_sound0']),
material_sound1=MaterialSoundPair.from_json(data['material_sound1']),
material_sound2=MaterialSoundPair.from_json(data['material_sound2']),
material_sound3=MaterialSoundPair.from_json(data['material_sound3']),
material_sound4=MaterialSoundPair.from_json(data['material_sound4']),
material_sound5=MaterialSoundPair.from_json(data['material_sound5']),
material_sound6=MaterialSoundPair.from_json(data['material_sound6']),
material_sound7=MaterialSoundPair.from_json(data['material_sound7']),
material_sound8=MaterialSoundPair.from_json(data['material_sound8']),
material_sound9=MaterialSoundPair.from_json(data['material_sound9']),
)
def to_json(self) -> dict:
return {
'slope_detection_angle': self.slope_detection_angle,
'slide_no_jump_angle': self.slide_no_jump_angle,
'slide_detection_angle': self.slide_detection_angle,
'scramble_detection_angle': self.scramble_detection_angle,
'scramble_speed': self.scramble_speed,
'tar_scramble_speed': self.tar_scramble_speed,
'slide_breaking_speed': self.slide_breaking_speed,
'max_slide_speed': self.max_slide_speed,
'scramble_recovery_acceleration': self.scramble_recovery_acceleration,
'slide_speedup_acceleration': self.slide_speedup_acceleration,
'slide_slowdown_acceleration': self.slide_slowdown_acceleration,
'planar_slide_recovery_speed': self.planar_slide_recovery_speed,
'slide_sound': self.slide_sound,
'slide_sound_ratio_change_factor': self.slide_sound_ratio_change_factor,
'slide_sound_low_pass_filter': self.slide_sound_low_pass_filter.to_json(),
'slide_sound_pitch': self.slide_sound_pitch.to_json(),
'slide_sound_volume': self.slide_sound_volume.to_json(),
'num_material_sounds': self.num_material_sounds,
'material_sound0': self.material_sound0.to_json(),
'material_sound1': self.material_sound1.to_json(),
'material_sound2': self.material_sound2.to_json(),
'material_sound3': self.material_sound3.to_json(),
'material_sound4': self.material_sound4.to_json(),
'material_sound5': self.material_sound5.to_json(),
'material_sound6': self.material_sound6.to_json(),
'material_sound7': self.material_sound7.to_json(),
'material_sound8': self.material_sound8.to_json(),
'material_sound9': self.material_sound9.to_json(),
}
def _decode_slope_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_no_jump_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scramble_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scramble_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tar_scramble_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_breaking_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_slide_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scramble_recovery_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_speedup_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_slowdown_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_planar_slide_recovery_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_slide_sound_ratio_change_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_slide_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_slide_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_num_material_sounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_material_sound0(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound1(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound2(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound3(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound4(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound5(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound6(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound7(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound8(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
def _decode_material_sound9(data: typing.BinaryIO, property_size: int):
return MaterialSoundPair.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4e7def7e: ('slope_detection_angle', _decode_slope_detection_angle),
0x18aa5c74: ('slide_no_jump_angle', _decode_slide_no_jump_angle),
0x6591a3a9: ('slide_detection_angle', _decode_slide_detection_angle),
0x8f7fdd6f: ('scramble_detection_angle', _decode_scramble_detection_angle),
0x43849900: ('scramble_speed', _decode_scramble_speed),
0x8e7ea4fc: ('tar_scramble_speed', _decode_tar_scramble_speed),
0x8f3b9328: ('slide_breaking_speed', _decode_slide_breaking_speed),
0x4c6ec511: ('max_slide_speed', _decode_max_slide_speed),
0x7335084d: ('scramble_recovery_acceleration', _decode_scramble_recovery_acceleration),
0x7600a6c5: ('slide_speedup_acceleration', _decode_slide_speedup_acceleration),
0x8f73e73d: ('slide_slowdown_acceleration', _decode_slide_slowdown_acceleration),
0xce007890: ('planar_slide_recovery_speed', _decode_planar_slide_recovery_speed),
0x2b79ea93: ('slide_sound', _decode_slide_sound),
0xba30aaca: ('slide_sound_ratio_change_factor', _decode_slide_sound_ratio_change_factor),
0xd9ca50c2: ('slide_sound_low_pass_filter', _decode_slide_sound_low_pass_filter),
0x84951ec7: ('slide_sound_pitch', _decode_slide_sound_pitch),
0x6a78525f: ('slide_sound_volume', _decode_slide_sound_volume),
0xd7c19141: ('num_material_sounds', _decode_num_material_sounds),
0x576d9946: ('material_sound0', _decode_material_sound0),
0xb83f2fa7: ('material_sound1', _decode_material_sound1),
0x52b9f2c5: ('material_sound2', _decode_material_sound2),
0xbdeb4424: ('material_sound3', _decode_material_sound3),
0x5cc54e40: ('material_sound4', _decode_material_sound4),
0xb397f8a1: ('material_sound5', _decode_material_sound5),
0x591125c3: ('material_sound6', _decode_material_sound6),
0xb6439322: ('material_sound7', _decode_material_sound7),
0x403c374a: ('material_sound8', _decode_material_sound8),
0xaf6e81ab: ('material_sound9', _decode_material_sound9),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongSlideData.py | 0.670177 | 0.201302 | KongSlideData.py | 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.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct30 import UnknownStruct30
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct31 import UnknownStruct31
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct169(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
audio: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
video: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
controllers: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
select: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD', 'STRG']}, default=default_asset_id)
select_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_struct31: UnknownStruct31 = dataclasses.field(default_factory=UnknownStruct31)
unknown_struct30: UnknownStruct30 = dataclasses.field(default_factory=UnknownStruct30)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\r') # 13 properties
data.write(b'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b's\xe2\x81\x9b') # 0x73e2819b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\xa0\x99\xca4') # 0xa099ca34
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.audio))
data.write(b'\xe8\xbf\x8b\xb4') # 0xe8bf8bb4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.video))
data.write(b'\xefY\xeaO') # 0xef59ea4f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.controllers))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'\x8e\xd6R\x83') # 0x8ed65283
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select))
data.write(b'\xa4\rA\x0e') # 0xa40d410e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_core))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
data.write(b'\x07\xba\xa1\x1b') # 0x7baa11b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct31.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb/\xf7\x02') # 0xcb2ff702
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct30.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
gui_frame=data['gui_frame'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
title=data['title'],
audio=data['audio'],
video=data['video'],
controllers=data['controllers'],
back=data['back'],
back_core=data['back_core'],
select=data['select'],
select_core=data['select_core'],
text_background=data['text_background'],
unknown_struct31=UnknownStruct31.from_json(data['unknown_struct31']),
unknown_struct30=UnknownStruct30.from_json(data['unknown_struct30']),
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'title': self.title,
'audio': self.audio,
'video': self.video,
'controllers': self.controllers,
'back': self.back,
'back_core': self.back_core,
'select': self.select,
'select_core': self.select_core,
'text_background': self.text_background,
'unknown_struct31': self.unknown_struct31.to_json(),
'unknown_struct30': self.unknown_struct30.to_json(),
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_audio(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_video(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_controllers(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct31(data: typing.BinaryIO, property_size: int):
return UnknownStruct31.from_stream(data, property_size)
def _decode_unknown_struct30(data: typing.BinaryIO, property_size: int):
return UnknownStruct30.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xa4f20c17: ('title', _decode_title),
0xa099ca34: ('audio', _decode_audio),
0xe8bf8bb4: ('video', _decode_video),
0xef59ea4f: ('controllers', _decode_controllers),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x8ed65283: ('select', _decode_select),
0xa40d410e: ('select_core', _decode_select_core),
0xe119319b: ('text_background', _decode_text_background),
0x7baa11b: ('unknown_struct31', _decode_unknown_struct31),
0xcb2ff702: ('unknown_struct30', _decode_unknown_struct30),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct169.py | 0.492676 | 0.180612 | UnknownStruct169.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct16(BaseProperty):
max_delay: float = dataclasses.field(default=0.0)
delay: float = dataclasses.field(default=0.0)
feedback: float = dataclasses.field(default=0.0)
unknown: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xf5\xb6\xbfl') # 0xf5b6bf6c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_delay))
data.write(b'\x14\xff\xf3\x9c') # 0x14fff39c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay))
data.write(b'\x1d\xa3{\r') # 0x1da37b0d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.feedback))
data.write(b'\x11\xbc^z') # 0x11bc5e7a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
max_delay=data['max_delay'],
delay=data['delay'],
feedback=data['feedback'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'max_delay': self.max_delay,
'delay': self.delay,
'feedback': self.feedback,
'unknown': self.unknown,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf5b6bf6c, 0x14fff39c, 0x1da37b0d, 0x11bc5e7a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct16]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct16(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_max_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_feedback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf5b6bf6c: ('max_delay', _decode_max_delay),
0x14fff39c: ('delay', _decode_delay),
0x1da37b0d: ('feedback', _decode_feedback),
0x11bc5e7a: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct16.py | 0.638159 | 0.300271 | UnknownStruct16.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct233(BaseProperty):
unknown: float = dataclasses.field(default=1.0)
bomb_locator: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x9c\xcdJ\x05') # 0x9ccd4a05
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xa1\xaf\xdb?') # 0xa1afdb3f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.bomb_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
bomb_locator=data['bomb_locator'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'bomb_locator': self.bomb_locator,
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bomb_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9ccd4a05: ('unknown', _decode_unknown),
0xa1afdb3f: ('bomb_locator', _decode_bomb_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct233.py | 0.608594 | 0.296349 | UnknownStruct233.py | 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.dkc_returns as enums
@dataclasses.dataclass()
class TidalWaveData(BaseProperty):
adjust_each_frame: bool = dataclasses.field(default=False)
offset_using: enums.OffsetUsing = dataclasses.field(default=enums.OffsetUsing.Unknown1)
offset_plane: enums.OffsetPlane = dataclasses.field(default=enums.OffsetPlane.Unknown1)
offset_u_coord: bool = dataclasses.field(default=True)
offset_v_coord: bool = dataclasses.field(default=True)
scale_using: enums.ScaleUsing = dataclasses.field(default=enums.ScaleUsing.Unknown1)
scale_plane: enums.ScalePlane = dataclasses.field(default=enums.ScalePlane.Unknown1)
scale_u_coord: bool = dataclasses.field(default=True)
scale_v_coord: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\xb4x?\x01') # 0xb4783f01
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.adjust_each_frame))
data.write(b'\xd3\x81\xe6>') # 0xd381e63e
data.write(b'\x00\x04') # size
self.offset_using.to_stream(data)
data.write(b'u\xa2\x9d\xf1') # 0x75a29df1
data.write(b'\x00\x04') # size
self.offset_plane.to_stream(data)
data.write(b'\xcc\xb52\xdb') # 0xccb532db
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.offset_u_coord))
data.write(b"'\x82\x89\xd8") # 0x278289d8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.offset_v_coord))
data.write(b'*\xc2\x1a\x04') # 0x2ac21a04
data.write(b'\x00\x04') # size
self.scale_using.to_stream(data)
data.write(b'\x8c\xe1a\xcb') # 0x8ce161cb
data.write(b'\x00\x04') # size
self.scale_plane.to_stream(data)
data.write(b'\n@\xa8\x95') # 0xa40a895
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scale_u_coord))
data.write(b'\xe1w\x13\x96') # 0xe1771396
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scale_v_coord))
@classmethod
def from_json(cls, data: dict):
return cls(
adjust_each_frame=data['adjust_each_frame'],
offset_using=enums.OffsetUsing.from_json(data['offset_using']),
offset_plane=enums.OffsetPlane.from_json(data['offset_plane']),
offset_u_coord=data['offset_u_coord'],
offset_v_coord=data['offset_v_coord'],
scale_using=enums.ScaleUsing.from_json(data['scale_using']),
scale_plane=enums.ScalePlane.from_json(data['scale_plane']),
scale_u_coord=data['scale_u_coord'],
scale_v_coord=data['scale_v_coord'],
)
def to_json(self) -> dict:
return {
'adjust_each_frame': self.adjust_each_frame,
'offset_using': self.offset_using.to_json(),
'offset_plane': self.offset_plane.to_json(),
'offset_u_coord': self.offset_u_coord,
'offset_v_coord': self.offset_v_coord,
'scale_using': self.scale_using.to_json(),
'scale_plane': self.scale_plane.to_json(),
'scale_u_coord': self.scale_u_coord,
'scale_v_coord': self.scale_v_coord,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb4783f01, 0xd381e63e, 0x75a29df1, 0xccb532db, 0x278289d8, 0x2ac21a04, 0x8ce161cb, 0xa40a895, 0xe1771396)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TidalWaveData]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHLLHLLH?LH?LHLLHLLH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(75))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24]) != _FAST_IDS:
data.seek(before)
return None
return TidalWaveData(
dec[2],
enums.OffsetUsing(dec[5]),
enums.OffsetPlane(dec[8]),
dec[11],
dec[14],
enums.ScaleUsing(dec[17]),
enums.ScalePlane(dec[20]),
dec[23],
dec[26],
)
def _decode_adjust_each_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_offset_using(data: typing.BinaryIO, property_size: int):
return enums.OffsetUsing.from_stream(data)
def _decode_offset_plane(data: typing.BinaryIO, property_size: int):
return enums.OffsetPlane.from_stream(data)
def _decode_offset_u_coord(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_offset_v_coord(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_using(data: typing.BinaryIO, property_size: int):
return enums.ScaleUsing.from_stream(data)
def _decode_scale_plane(data: typing.BinaryIO, property_size: int):
return enums.ScalePlane.from_stream(data)
def _decode_scale_u_coord(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_v_coord(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]]] = {
0xb4783f01: ('adjust_each_frame', _decode_adjust_each_frame),
0xd381e63e: ('offset_using', _decode_offset_using),
0x75a29df1: ('offset_plane', _decode_offset_plane),
0xccb532db: ('offset_u_coord', _decode_offset_u_coord),
0x278289d8: ('offset_v_coord', _decode_offset_v_coord),
0x2ac21a04: ('scale_using', _decode_scale_using),
0x8ce161cb: ('scale_plane', _decode_scale_plane),
0xa40a895: ('scale_u_coord', _decode_scale_u_coord),
0xe1771396: ('scale_v_coord', _decode_scale_v_coord),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TidalWaveData.py | 0.626696 | 0.358718 | TidalWaveData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SuspensionBridgeStruct(BaseProperty):
player: bool = dataclasses.field(default=True)
ai: bool = dataclasses.field(default=False)
creature: bool = dataclasses.field(default=False)
damage_effect: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xd5i\x92d') # 0xd5699264
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player))
data.write(b'\xab\x1fT#') # 0xab1f5423
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ai))
data.write(b'\xec\xf80\xee') # 0xecf830ee
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.creature))
data.write(b'\xe9\xd2\xffI') # 0xe9d2ff49
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.damage_effect))
@classmethod
def from_json(cls, data: dict):
return cls(
player=data['player'],
ai=data['ai'],
creature=data['creature'],
damage_effect=data['damage_effect'],
)
def to_json(self) -> dict:
return {
'player': self.player,
'ai': self.ai,
'creature': self.creature,
'damage_effect': self.damage_effect,
}
_FAST_FORMAT = None
_FAST_IDS = (0xd5699264, 0xab1f5423, 0xecf830ee, 0xe9d2ff49)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SuspensionBridgeStruct]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(28))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return SuspensionBridgeStruct(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ai(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_creature(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damage_effect(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]]] = {
0xd5699264: ('player', _decode_player),
0xab1f5423: ('ai', _decode_ai),
0xecf830ee: ('creature', _decode_creature),
0xe9d2ff49: ('damage_effect', _decode_damage_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SuspensionBridgeStruct.py | 0.601359 | 0.315354 | SuspensionBridgeStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct61(BaseProperty):
number_of_bombs: int = dataclasses.field(default=6)
horizontal_spread: float = dataclasses.field(default=20.0)
unknown_0xf228ec53: float = dataclasses.field(default=15.0)
unknown_0xd91227f1: float = dataclasses.field(default=20.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xf8\xd8\xd9v') # 0xf8d8d976
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_bombs))
data.write(b'\x8c)\xe9\x1c') # 0x8c29e91c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horizontal_spread))
data.write(b'\xf2(\xecS') # 0xf228ec53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf228ec53))
data.write(b"\xd9\x12'\xf1") # 0xd91227f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd91227f1))
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_bombs=data['number_of_bombs'],
horizontal_spread=data['horizontal_spread'],
unknown_0xf228ec53=data['unknown_0xf228ec53'],
unknown_0xd91227f1=data['unknown_0xd91227f1'],
)
def to_json(self) -> dict:
return {
'number_of_bombs': self.number_of_bombs,
'horizontal_spread': self.horizontal_spread,
'unknown_0xf228ec53': self.unknown_0xf228ec53,
'unknown_0xd91227f1': self.unknown_0xd91227f1,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf8d8d976, 0x8c29e91c, 0xf228ec53, 0xd91227f1)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct61]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct61(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_number_of_bombs(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_horizontal_spread(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf228ec53(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd91227f1(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]]] = {
0xf8d8d976: ('number_of_bombs', _decode_number_of_bombs),
0x8c29e91c: ('horizontal_spread', _decode_horizontal_spread),
0xf228ec53: ('unknown_0xf228ec53', _decode_unknown_0xf228ec53),
0xd91227f1: ('unknown_0xd91227f1', _decode_unknown_0xd91227f1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct61.py | 0.613121 | 0.275388 | UnknownStruct61.py | 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.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct298(BaseProperty):
scale_spline: Spline = dataclasses.field(default_factory=Spline)
auto_start: bool = dataclasses.field(default=True)
duration: float = dataclasses.field(default=12.0)
unknown_0x396861d0: float = dataclasses.field(default=12.0)
max_distance: float = dataclasses.field(default=55.0)
unknown_0x73bef3cb: int = dataclasses.field(default=4)
unknown_0xb7074f38: float = dataclasses.field(default=0.0)
unknown_0x30a1847b: float = dataclasses.field(default=3.0)
unknown_0x633bdfff: float = dataclasses.field(default=6.0)
unknown_0xe49d14bc: float = dataclasses.field(default=9.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'g"U\xf7') # 0x672255f7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scale_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'9ha\xd0') # 0x396861d0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x396861d0))
data.write(b'%\xb7\xc9\xb2') # 0x25b7c9b2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_distance))
data.write(b's\xbe\xf3\xcb') # 0x73bef3cb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x73bef3cb))
data.write(b'\xb7\x07O8') # 0xb7074f38
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb7074f38))
data.write(b'0\xa1\x84{') # 0x30a1847b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x30a1847b))
data.write(b'c;\xdf\xff') # 0x633bdfff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x633bdfff))
data.write(b'\xe4\x9d\x14\xbc') # 0xe49d14bc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe49d14bc))
@classmethod
def from_json(cls, data: dict):
return cls(
scale_spline=Spline.from_json(data['scale_spline']),
auto_start=data['auto_start'],
duration=data['duration'],
unknown_0x396861d0=data['unknown_0x396861d0'],
max_distance=data['max_distance'],
unknown_0x73bef3cb=data['unknown_0x73bef3cb'],
unknown_0xb7074f38=data['unknown_0xb7074f38'],
unknown_0x30a1847b=data['unknown_0x30a1847b'],
unknown_0x633bdfff=data['unknown_0x633bdfff'],
unknown_0xe49d14bc=data['unknown_0xe49d14bc'],
)
def to_json(self) -> dict:
return {
'scale_spline': self.scale_spline.to_json(),
'auto_start': self.auto_start,
'duration': self.duration,
'unknown_0x396861d0': self.unknown_0x396861d0,
'max_distance': self.max_distance,
'unknown_0x73bef3cb': self.unknown_0x73bef3cb,
'unknown_0xb7074f38': self.unknown_0xb7074f38,
'unknown_0x30a1847b': self.unknown_0x30a1847b,
'unknown_0x633bdfff': self.unknown_0x633bdfff,
'unknown_0xe49d14bc': self.unknown_0xe49d14bc,
}
def _decode_scale_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x396861d0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x73bef3cb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xb7074f38(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x30a1847b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x633bdfff(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe49d14bc(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]]] = {
0x672255f7: ('scale_spline', _decode_scale_spline),
0x3217dff8: ('auto_start', _decode_auto_start),
0x8b51e23f: ('duration', _decode_duration),
0x396861d0: ('unknown_0x396861d0', _decode_unknown_0x396861d0),
0x25b7c9b2: ('max_distance', _decode_max_distance),
0x73bef3cb: ('unknown_0x73bef3cb', _decode_unknown_0x73bef3cb),
0xb7074f38: ('unknown_0xb7074f38', _decode_unknown_0xb7074f38),
0x30a1847b: ('unknown_0x30a1847b', _decode_unknown_0x30a1847b),
0x633bdfff: ('unknown_0x633bdfff', _decode_unknown_0x633bdfff),
0xe49d14bc: ('unknown_0xe49d14bc', _decode_unknown_0xe49d14bc),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct298.py | 0.637595 | 0.265214 | UnknownStruct298.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct273(BaseProperty):
unknown_0x0eafc768: int = dataclasses.field(default=1)
unknown_0x03223140: int = dataclasses.field(default=1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x0e\xaf\xc7h') # 0xeafc768
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x0eafc768))
data.write(b'\x03"1@') # 0x3223140
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x03223140))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x0eafc768=data['unknown_0x0eafc768'],
unknown_0x03223140=data['unknown_0x03223140'],
)
def to_json(self) -> dict:
return {
'unknown_0x0eafc768': self.unknown_0x0eafc768,
'unknown_0x03223140': self.unknown_0x03223140,
}
_FAST_FORMAT = None
_FAST_IDS = (0xeafc768, 0x3223140)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct273]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct273(
dec[2],
dec[5],
)
def _decode_unknown_0x0eafc768(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x03223140(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xeafc768: ('unknown_0x0eafc768', _decode_unknown_0x0eafc768),
0x3223140: ('unknown_0x03223140', _decode_unknown_0x03223140),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct273.py | 0.614163 | 0.295973 | UnknownStruct273.py | 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.dkc_returns.archetypes.DamageInfo import DamageInfo
@dataclasses.dataclass()
class UnknownStruct244(BaseProperty):
can_be_blown_out: bool = dataclasses.field(default=False)
contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_duration: float = dataclasses.field(default=1.0)
unknown_0xd258286d: str = dataclasses.field(default='')
unknown_0xe22dd9bb: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xd5As8') # 0xd5417338
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_blown_out))
data.write(b'\xd7VAn') # 0xd756416e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd5\xe7\xb1\x1e') # 0xd5e7b11e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_duration))
data.write(b'\xd2X(m') # 0xd258286d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xd258286d.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2-\xd9\xbb') # 0xe22dd9bb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xe22dd9bb.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
can_be_blown_out=data['can_be_blown_out'],
contact_damage=DamageInfo.from_json(data['contact_damage']),
damage_duration=data['damage_duration'],
unknown_0xd258286d=data['unknown_0xd258286d'],
unknown_0xe22dd9bb=data['unknown_0xe22dd9bb'],
)
def to_json(self) -> dict:
return {
'can_be_blown_out': self.can_be_blown_out,
'contact_damage': self.contact_damage.to_json(),
'damage_duration': self.damage_duration,
'unknown_0xd258286d': self.unknown_0xd258286d,
'unknown_0xe22dd9bb': self.unknown_0xe22dd9bb,
}
def _decode_can_be_blown_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_contact_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_damage_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd258286d(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0xe22dd9bb(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd5417338: ('can_be_blown_out', _decode_can_be_blown_out),
0xd756416e: ('contact_damage', _decode_contact_damage),
0xd5e7b11e: ('damage_duration', _decode_damage_duration),
0xd258286d: ('unknown_0xd258286d', _decode_unknown_0xd258286d),
0xe22dd9bb: ('unknown_0xe22dd9bb', _decode_unknown_0xe22dd9bb),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct244.py | 0.615088 | 0.278978 | UnknownStruct244.py | 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.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct198(BaseProperty):
x_motion: Spline = dataclasses.field(default_factory=Spline)
y_motion: Spline = dataclasses.field(default_factory=Spline)
z_motion: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x97\xf6\xeay') # 0x97f6ea79
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J`3\xfc') # 0x4a6033fc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7\xaa_2') # 0xf7aa5f32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_motion=Spline.from_json(data['x_motion']),
y_motion=Spline.from_json(data['y_motion']),
z_motion=Spline.from_json(data['z_motion']),
)
def to_json(self) -> dict:
return {
'x_motion': self.x_motion.to_json(),
'y_motion': self.y_motion.to_json(),
'z_motion': self.z_motion.to_json(),
}
def _decode_x_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x97f6ea79: ('x_motion', _decode_x_motion),
0x4a6033fc: ('y_motion', _decode_y_motion),
0xf7aa5f32: ('z_motion', _decode_z_motion),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct198.py | 0.658418 | 0.304242 | UnknownStruct198.py | 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.dkc_returns.archetypes.MultiModelActorStruct import MultiModelActorStruct
@dataclasses.dataclass()
class MultiModelInformation(BaseProperty):
unknown: int = dataclasses.field(default=0)
use_fade: bool = dataclasses.field(default=False)
fade_time: float = dataclasses.field(default=0.0)
multi_model_actor_struct_0x681c4457: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0xc674d5c6: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x3b8d2db3: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x95e5bc22: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0xbc2d08d0: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x12459941: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x9caffe7b: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x32c76fea: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x681aaa77: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'd9\xf4\x87') # 0x6439f487
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\xe2Z\x15\xc1') # 0xe25a15c1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_fade))
data.write(b'\xd4\x12LL') # 0xd4124c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_time))
data.write(b'h\x1cDW') # 0x681c4457
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x681c4457.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6t\xd5\xc6') # 0xc674d5c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0xc674d5c6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\x8d-\xb3') # 0x3b8d2db3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x3b8d2db3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xe5\xbc"') # 0x95e5bc22
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x95e5bc22.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc-\x08\xd0') # 0xbc2d08d0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0xbc2d08d0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12E\x99A') # 0x12459941
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x12459941.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9c\xaf\xfe{') # 0x9caffe7b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x9caffe7b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'2\xc7o\xea') # 0x32c76fea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x32c76fea.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h\x1a\xaaw') # 0x681aaa77
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x681aaa77.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
use_fade=data['use_fade'],
fade_time=data['fade_time'],
multi_model_actor_struct_0x681c4457=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x681c4457']),
multi_model_actor_struct_0xc674d5c6=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0xc674d5c6']),
multi_model_actor_struct_0x3b8d2db3=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x3b8d2db3']),
multi_model_actor_struct_0x95e5bc22=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x95e5bc22']),
multi_model_actor_struct_0xbc2d08d0=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0xbc2d08d0']),
multi_model_actor_struct_0x12459941=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x12459941']),
multi_model_actor_struct_0x9caffe7b=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x9caffe7b']),
multi_model_actor_struct_0x32c76fea=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x32c76fea']),
multi_model_actor_struct_0x681aaa77=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x681aaa77']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'use_fade': self.use_fade,
'fade_time': self.fade_time,
'multi_model_actor_struct_0x681c4457': self.multi_model_actor_struct_0x681c4457.to_json(),
'multi_model_actor_struct_0xc674d5c6': self.multi_model_actor_struct_0xc674d5c6.to_json(),
'multi_model_actor_struct_0x3b8d2db3': self.multi_model_actor_struct_0x3b8d2db3.to_json(),
'multi_model_actor_struct_0x95e5bc22': self.multi_model_actor_struct_0x95e5bc22.to_json(),
'multi_model_actor_struct_0xbc2d08d0': self.multi_model_actor_struct_0xbc2d08d0.to_json(),
'multi_model_actor_struct_0x12459941': self.multi_model_actor_struct_0x12459941.to_json(),
'multi_model_actor_struct_0x9caffe7b': self.multi_model_actor_struct_0x9caffe7b.to_json(),
'multi_model_actor_struct_0x32c76fea': self.multi_model_actor_struct_0x32c76fea.to_json(),
'multi_model_actor_struct_0x681aaa77': self.multi_model_actor_struct_0x681aaa77.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_use_fade(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_multi_model_actor_struct_0x681c4457(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0xc674d5c6(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x3b8d2db3(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x95e5bc22(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0xbc2d08d0(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x12459941(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x9caffe7b(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x32c76fea(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x681aaa77(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6439f487: ('unknown', _decode_unknown),
0xe25a15c1: ('use_fade', _decode_use_fade),
0xd4124c4c: ('fade_time', _decode_fade_time),
0x681c4457: ('multi_model_actor_struct_0x681c4457', _decode_multi_model_actor_struct_0x681c4457),
0xc674d5c6: ('multi_model_actor_struct_0xc674d5c6', _decode_multi_model_actor_struct_0xc674d5c6),
0x3b8d2db3: ('multi_model_actor_struct_0x3b8d2db3', _decode_multi_model_actor_struct_0x3b8d2db3),
0x95e5bc22: ('multi_model_actor_struct_0x95e5bc22', _decode_multi_model_actor_struct_0x95e5bc22),
0xbc2d08d0: ('multi_model_actor_struct_0xbc2d08d0', _decode_multi_model_actor_struct_0xbc2d08d0),
0x12459941: ('multi_model_actor_struct_0x12459941', _decode_multi_model_actor_struct_0x12459941),
0x9caffe7b: ('multi_model_actor_struct_0x9caffe7b', _decode_multi_model_actor_struct_0x9caffe7b),
0x32c76fea: ('multi_model_actor_struct_0x32c76fea', _decode_multi_model_actor_struct_0x32c76fea),
0x681aaa77: ('multi_model_actor_struct_0x681aaa77', _decode_multi_model_actor_struct_0x681aaa77),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MultiModelInformation.py | 0.515864 | 0.18838 | MultiModelInformation.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct14 import UnknownStruct14
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct15 import UnknownStruct15
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct69 import UnknownStruct69
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct70 import UnknownStruct70
@dataclasses.dataclass()
class UnknownStruct71(BaseProperty):
vertical_type: enums.VerticalType = dataclasses.field(default=enums.VerticalType.Unknown1)
unknown_struct69: UnknownStruct69 = dataclasses.field(default_factory=UnknownStruct69)
unknown_struct15: UnknownStruct15 = dataclasses.field(default_factory=UnknownStruct15)
unknown_struct70: UnknownStruct70 = dataclasses.field(default_factory=UnknownStruct70)
unknown_struct14: UnknownStruct14 = dataclasses.field(default_factory=UnknownStruct14)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xadP\xd8\x93') # 0xad50d893
data.write(b'\x00\x04') # size
self.vertical_type.to_stream(data)
data.write(b'\xcf\xfe\x15\xa0') # 0xcffe15a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct69.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7\xc8\xc0F') # 0x37c8c046
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct15.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'wK\xa9\x05') # 0x774ba905
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct70.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x02\xb7\x92C') # 0x2b79243
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct14.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
vertical_type=enums.VerticalType.from_json(data['vertical_type']),
unknown_struct69=UnknownStruct69.from_json(data['unknown_struct69']),
unknown_struct15=UnknownStruct15.from_json(data['unknown_struct15']),
unknown_struct70=UnknownStruct70.from_json(data['unknown_struct70']),
unknown_struct14=UnknownStruct14.from_json(data['unknown_struct14']),
)
def to_json(self) -> dict:
return {
'vertical_type': self.vertical_type.to_json(),
'unknown_struct69': self.unknown_struct69.to_json(),
'unknown_struct15': self.unknown_struct15.to_json(),
'unknown_struct70': self.unknown_struct70.to_json(),
'unknown_struct14': self.unknown_struct14.to_json(),
}
def _decode_vertical_type(data: typing.BinaryIO, property_size: int):
return enums.VerticalType.from_stream(data)
def _decode_unknown_struct69(data: typing.BinaryIO, property_size: int):
return UnknownStruct69.from_stream(data, property_size)
def _decode_unknown_struct15(data: typing.BinaryIO, property_size: int):
return UnknownStruct15.from_stream(data, property_size)
def _decode_unknown_struct70(data: typing.BinaryIO, property_size: int):
return UnknownStruct70.from_stream(data, property_size)
def _decode_unknown_struct14(data: typing.BinaryIO, property_size: int):
return UnknownStruct14.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xad50d893: ('vertical_type', _decode_vertical_type),
0xcffe15a0: ('unknown_struct69', _decode_unknown_struct69),
0x37c8c046: ('unknown_struct15', _decode_unknown_struct15),
0x774ba905: ('unknown_struct70', _decode_unknown_struct70),
0x2b79243: ('unknown_struct14', _decode_unknown_struct14),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct71.py | 0.574514 | 0.265547 | UnknownStruct71.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SquawkProxyData(BaseProperty):
auto_player_detection_far_radius: float = dataclasses.field(default=0.0)
auto_player_detection_near_radius: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xcdQ\x13\xdc') # 0xcd5113dc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.auto_player_detection_far_radius))
data.write(b'\xc7\x06\xd7\x90') # 0xc706d790
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.auto_player_detection_near_radius))
@classmethod
def from_json(cls, data: dict):
return cls(
auto_player_detection_far_radius=data['auto_player_detection_far_radius'],
auto_player_detection_near_radius=data['auto_player_detection_near_radius'],
)
def to_json(self) -> dict:
return {
'auto_player_detection_far_radius': self.auto_player_detection_far_radius,
'auto_player_detection_near_radius': self.auto_player_detection_near_radius,
}
_FAST_FORMAT = None
_FAST_IDS = (0xcd5113dc, 0xc706d790)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SquawkProxyData]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return SquawkProxyData(
dec[2],
dec[5],
)
def _decode_auto_player_detection_far_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_player_detection_near_radius(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]]] = {
0xcd5113dc: ('auto_player_detection_far_radius', _decode_auto_player_detection_far_radius),
0xc706d790: ('auto_player_detection_near_radius', _decode_auto_player_detection_near_radius),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SquawkProxyData.py | 0.660501 | 0.387198 | SquawkProxyData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MultiModelActorStruct(BaseProperty):
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
fade_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\xd4\x12LL') # 0xd4124c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_time))
@classmethod
def from_json(cls, data: dict):
return cls(
model=data['model'],
fade_time=data['fade_time'],
)
def to_json(self) -> dict:
return {
'model': self.model,
'fade_time': self.fade_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc27ffa8f, 0xd4124c4c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MultiModelActorStruct]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(24))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return MultiModelActorStruct(
dec[2],
dec[5],
)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc27ffa8f: ('model', _decode_model),
0xd4124c4c: ('fade_time', _decode_fade_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MultiModelActorStruct.py | 0.640186 | 0.23579 | MultiModelActorStruct.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct19(BaseProperty):
caud_0xa28b199d: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x003e7991: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xa2\x8b\x19\x9d') # 0xa28b199d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xa28b199d))
data.write(b'\x00>y\x91') # 0x3e7991
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x003e7991))
@classmethod
def from_json(cls, data: dict):
return cls(
caud_0xa28b199d=data['caud_0xa28b199d'],
caud_0x003e7991=data['caud_0x003e7991'],
)
def to_json(self) -> dict:
return {
'caud_0xa28b199d': self.caud_0xa28b199d,
'caud_0x003e7991': self.caud_0x003e7991,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa28b199d, 0x3e7991)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct19]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(28))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct19(
dec[2],
dec[5],
)
def _decode_caud_0xa28b199d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x003e7991(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa28b199d: ('caud_0xa28b199d', _decode_caud_0xa28b199d),
0x3e7991: ('caud_0x003e7991', _decode_caud_0x003e7991),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct19.py | 0.584627 | 0.2683 | UnknownStruct19.py | 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.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class OffsetInterpolant(BaseProperty):
x_offset: Spline = dataclasses.field(default_factory=Spline)
y_offset: Spline = dataclasses.field(default_factory=Spline)
z_offset: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'H[\x0c\x11') # 0x485b0c11
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xcd\xd5\x94') # 0x95cdd594
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x07\xb9Z') # 0x2807b95a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_offset=Spline.from_json(data['x_offset']),
y_offset=Spline.from_json(data['y_offset']),
z_offset=Spline.from_json(data['z_offset']),
)
def to_json(self) -> dict:
return {
'x_offset': self.x_offset.to_json(),
'y_offset': self.y_offset.to_json(),
'z_offset': self.z_offset.to_json(),
}
def _decode_x_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x485b0c11: ('x_offset', _decode_x_offset),
0x95cdd594: ('y_offset', _decode_y_offset),
0x2807b95a: ('z_offset', _decode_z_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OffsetInterpolant.py | 0.670177 | 0.323567 | OffsetInterpolant.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct7(BaseProperty):
attach_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
attach_locator: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'T\x05\xf7\x08') # 0x5405f708
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.attach_model))
data.write(b'kb\xe4\x19') # 0x6b62e419
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.attach_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
attach_model=data['attach_model'],
attach_locator=data['attach_locator'],
)
def to_json(self) -> dict:
return {
'attach_model': self.attach_model,
'attach_locator': self.attach_locator,
}
def _decode_attach_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_attach_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5405f708: ('attach_model', _decode_attach_model),
0x6b62e419: ('attach_locator', _decode_attach_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct7.py | 0.579638 | 0.254092 | UnknownStruct7.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.LocomotionContextEnum import LocomotionContextEnum
from retro_data_structures.properties.dkc_returns.archetypes.TrackPlayer import TrackPlayer
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct10 import UnknownStruct10
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct9 import UnknownStruct9
@dataclasses.dataclass()
class AnimGridModifierData(BaseProperty):
unknown: int = dataclasses.field(default=0)
enabled_by_default: bool = dataclasses.field(default=True)
mirror_when_facing_left: bool = dataclasses.field(default=False)
enable_interval_timer: bool = dataclasses.field(default=False)
minimum_interval_time: float = dataclasses.field(default=0.0)
maximum_interval_time: float = dataclasses.field(default=0.0)
override_locomotion_context_during_interval: bool = dataclasses.field(default=False)
unknown_struct3: LocomotionContextEnum = dataclasses.field(default_factory=LocomotionContextEnum)
looping: enums.Looping = dataclasses.field(default=enums.Looping.Unknown1)
logic_type: enums.LogicType = dataclasses.field(default=enums.LogicType.Unknown1)
unknown_struct9: UnknownStruct9 = dataclasses.field(default_factory=UnknownStruct9)
track_player: TrackPlayer = dataclasses.field(default_factory=TrackPlayer)
unknown_struct10: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\r') # 13 properties
data.write(b'\xa1&h\x97') # 0xa1266897
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'{\xe6yG') # 0x7be67947
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enabled_by_default))
data.write(b'n\xf6o\xaa') # 0x6ef66faa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.mirror_when_facing_left))
data.write(b'D2\xcc\xd6') # 0x4432ccd6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_interval_timer))
data.write(b'\xf0\xccs\xc9') # 0xf0cc73c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_interval_time))
data.write(b'+s .') # 0x2b73202e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_interval_time))
data.write(b'\xcf\xc6r\x0e') # 0xcfc6720e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override_locomotion_context_during_interval))
data.write(b'\x90\x0f\xb9\x9c') # 0x900fb99c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'ot\xf8/') # 0x6f74f82f
data.write(b'\x00\x04') # size
self.looping.to_stream(data)
data.write(b'a\x1f\x9fA') # 0x611f9f41
data.write(b'\x00\x04') # size
self.logic_type.to_stream(data)
data.write(b'B\xa7\x92,') # 0x42a7922c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6~\xf9\x9e') # 0xe67ef99e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.track_player.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'xs\xef\xd9') # 0x7873efd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
enabled_by_default=data['enabled_by_default'],
mirror_when_facing_left=data['mirror_when_facing_left'],
enable_interval_timer=data['enable_interval_timer'],
minimum_interval_time=data['minimum_interval_time'],
maximum_interval_time=data['maximum_interval_time'],
override_locomotion_context_during_interval=data['override_locomotion_context_during_interval'],
unknown_struct3=LocomotionContextEnum.from_json(data['unknown_struct3']),
looping=enums.Looping.from_json(data['looping']),
logic_type=enums.LogicType.from_json(data['logic_type']),
unknown_struct9=UnknownStruct9.from_json(data['unknown_struct9']),
track_player=TrackPlayer.from_json(data['track_player']),
unknown_struct10=UnknownStruct10.from_json(data['unknown_struct10']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'enabled_by_default': self.enabled_by_default,
'mirror_when_facing_left': self.mirror_when_facing_left,
'enable_interval_timer': self.enable_interval_timer,
'minimum_interval_time': self.minimum_interval_time,
'maximum_interval_time': self.maximum_interval_time,
'override_locomotion_context_during_interval': self.override_locomotion_context_during_interval,
'unknown_struct3': self.unknown_struct3.to_json(),
'looping': self.looping.to_json(),
'logic_type': self.logic_type.to_json(),
'unknown_struct9': self.unknown_struct9.to_json(),
'track_player': self.track_player.to_json(),
'unknown_struct10': self.unknown_struct10.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_enabled_by_default(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_mirror_when_facing_left(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_interval_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_interval_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_interval_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_override_locomotion_context_during_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct3(data: typing.BinaryIO, property_size: int):
return LocomotionContextEnum.from_stream(data, property_size)
def _decode_looping(data: typing.BinaryIO, property_size: int):
return enums.Looping.from_stream(data)
def _decode_logic_type(data: typing.BinaryIO, property_size: int):
return enums.LogicType.from_stream(data)
def _decode_unknown_struct9(data: typing.BinaryIO, property_size: int):
return UnknownStruct9.from_stream(data, property_size)
def _decode_track_player(data: typing.BinaryIO, property_size: int):
return TrackPlayer.from_stream(data, property_size)
def _decode_unknown_struct10(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa1266897: ('unknown', _decode_unknown),
0x7be67947: ('enabled_by_default', _decode_enabled_by_default),
0x6ef66faa: ('mirror_when_facing_left', _decode_mirror_when_facing_left),
0x4432ccd6: ('enable_interval_timer', _decode_enable_interval_timer),
0xf0cc73c9: ('minimum_interval_time', _decode_minimum_interval_time),
0x2b73202e: ('maximum_interval_time', _decode_maximum_interval_time),
0xcfc6720e: ('override_locomotion_context_during_interval', _decode_override_locomotion_context_during_interval),
0x900fb99c: ('unknown_struct3', _decode_unknown_struct3),
0x6f74f82f: ('looping', _decode_looping),
0x611f9f41: ('logic_type', _decode_logic_type),
0x42a7922c: ('unknown_struct9', _decode_unknown_struct9),
0xe67ef99e: ('track_player', _decode_track_player),
0x7873efd9: ('unknown_struct10', _decode_unknown_struct10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/AnimGridModifierData.py | 0.632049 | 0.237013 | AnimGridModifierData.py | 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.dkc_returns as enums
@dataclasses.dataclass()
class UnknownStruct197(BaseProperty):
physics_target_type: enums.PhysicsTargetType = dataclasses.field(default=enums.PhysicsTargetType.Unknown2)
unknown_0xef531185: float = dataclasses.field(default=0.0)
unknown_0x0e6e350f: int = dataclasses.field(default=3294124709) # Choice
gravity: float = dataclasses.field(default=1.0)
arc_height: float = dataclasses.field(default=10.0)
flight_time: float = dataclasses.field(default=3.0)
only_target_active: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'8\xf2\x06a') # 0x38f20661
data.write(b'\x00\x04') # size
self.physics_target_type.to_stream(data)
data.write(b'\xefS\x11\x85') # 0xef531185
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xef531185))
data.write(b'\x0en5\x0f') # 0xe6e350f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x0e6e350f))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'!P\xaa\x96') # 0x2150aa96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.arc_height))
data.write(b'\xfb\xd9\xfb\x93') # 0xfbd9fb93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flight_time))
data.write(b'\x03d\xf0\xb8') # 0x364f0b8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.only_target_active))
@classmethod
def from_json(cls, data: dict):
return cls(
physics_target_type=enums.PhysicsTargetType.from_json(data['physics_target_type']),
unknown_0xef531185=data['unknown_0xef531185'],
unknown_0x0e6e350f=data['unknown_0x0e6e350f'],
gravity=data['gravity'],
arc_height=data['arc_height'],
flight_time=data['flight_time'],
only_target_active=data['only_target_active'],
)
def to_json(self) -> dict:
return {
'physics_target_type': self.physics_target_type.to_json(),
'unknown_0xef531185': self.unknown_0xef531185,
'unknown_0x0e6e350f': self.unknown_0x0e6e350f,
'gravity': self.gravity,
'arc_height': self.arc_height,
'flight_time': self.flight_time,
'only_target_active': self.only_target_active,
}
_FAST_FORMAT = None
_FAST_IDS = (0x38f20661, 0xef531185, 0xe6e350f, 0x2f2ae3e5, 0x2150aa96, 0xfbd9fb93, 0x364f0b8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct197]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHLLHfLHfLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(67))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct197(
enums.PhysicsTargetType(dec[2]),
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_physics_target_type(data: typing.BinaryIO, property_size: int):
return enums.PhysicsTargetType.from_stream(data)
def _decode_unknown_0xef531185(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0e6e350f(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_arc_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_only_target_active(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]]] = {
0x38f20661: ('physics_target_type', _decode_physics_target_type),
0xef531185: ('unknown_0xef531185', _decode_unknown_0xef531185),
0xe6e350f: ('unknown_0x0e6e350f', _decode_unknown_0x0e6e350f),
0x2f2ae3e5: ('gravity', _decode_gravity),
0x2150aa96: ('arc_height', _decode_arc_height),
0xfbd9fb93: ('flight_time', _decode_flight_time),
0x364f0b8: ('only_target_active', _decode_only_target_active),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct197.py | 0.679179 | 0.313834 | UnknownStruct197.py | 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.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct177(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
add_drop: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
summary: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
options: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
quit: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
quit_confirm: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
select: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD', 'STRG']}, default=default_asset_id)
select_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
return_: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
return_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b's\xe2\x81\x9b') # 0x73e2819b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8\xb7\xdb\xd5') # 0xc8b7dbd5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.add_drop))
data.write(b'F\x996\x81') # 0x46993681
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.summary))
data.write(b'\xac\xe4\x06~') # 0xace4067e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.options))
data.write(b'\xd2\x7f\xca0') # 0xd27fca30
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.quit))
data.write(b'\xb8Z\xefG') # 0xb85aef47
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.quit_confirm))
data.write(b'\x8e\xd6R\x83') # 0x8ed65283
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select))
data.write(b'\xa4\rA\x0e') # 0xa40d410e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_core))
data.write(b'G\x1f\xea\x86') # 0x471fea86
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.return_))
data.write(b'\xa0\x1e\x08\x87') # 0xa01e0887
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.return_core))
@classmethod
def from_json(cls, data: dict):
return cls(
gui_frame=data['gui_frame'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
add_drop=data['add_drop'],
summary=data['summary'],
options=data['options'],
quit=data['quit'],
quit_confirm=data['quit_confirm'],
select=data['select'],
select_core=data['select_core'],
return_=data['return_'],
return_core=data['return_core'],
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'add_drop': self.add_drop,
'summary': self.summary,
'options': self.options,
'quit': self.quit,
'quit_confirm': self.quit_confirm,
'select': self.select,
'select_core': self.select_core,
'return_': self.return_,
'return_core': self.return_core,
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_add_drop(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_summary(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_options(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_quit(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_quit_confirm(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_return_(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_return_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xc8b7dbd5: ('add_drop', _decode_add_drop),
0x46993681: ('summary', _decode_summary),
0xace4067e: ('options', _decode_options),
0xd27fca30: ('quit', _decode_quit),
0xb85aef47: ('quit_confirm', _decode_quit_confirm),
0x8ed65283: ('select', _decode_select),
0xa40d410e: ('select_core', _decode_select_core),
0x471fea86: ('return_', _decode_return_),
0xa01e0887: ('return_core', _decode_return_core),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct177.py | 0.570212 | 0.183703 | UnknownStruct177.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct92(BaseProperty):
unknown: bool = dataclasses.field(default=True)
auto_start_light: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'](\x96\x13') # 0x5d289613
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\xae\xdf\xa0\x91') # 0xaedfa091
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start_light))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
auto_start_light=data['auto_start_light'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'auto_start_light': self.auto_start_light,
}
_FAST_FORMAT = None
_FAST_IDS = (0x5d289613, 0xaedfa091)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct92]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(14))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct92(
dec[2],
dec[5],
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start_light(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]]] = {
0x5d289613: ('unknown', _decode_unknown),
0xaedfa091: ('auto_start_light', _decode_auto_start_light),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct92.py | 0.651909 | 0.322526 | UnknownStruct92.py | 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.dkc_returns.archetypes.MineCartMaterialSounds import MineCartMaterialSounds
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class MineCartData(BaseProperty):
collision_height_with_driver: float = dataclasses.field(default=2.0)
wheel_diameter: float = dataclasses.field(default=0.699999988079071)
airbourne_wheel_friction: float = dataclasses.field(default=1.2000000476837158)
acceleration: float = dataclasses.field(default=20.0)
deceleration: float = dataclasses.field(default=30.0)
deceleration_to_minimum_speed: float = dataclasses.field(default=30.0)
gravity_acceleration_multiplier: float = dataclasses.field(default=0.5)
initial_speed: float = dataclasses.field(default=0.0)
minimum_speed: float = dataclasses.field(default=14.0)
maximum_speed: float = dataclasses.field(default=40.0)
roll_forwards: bool = dataclasses.field(default=True)
travel_at_minimum_speed: bool = dataclasses.field(default=False)
maximum_speed_limit_enabled: bool = dataclasses.field(default=True)
can_jump: bool = dataclasses.field(default=True)
allow_platform_advancement: bool = dataclasses.field(default=True)
allow_player_collision: bool = dataclasses.field(default=False)
wait_for_all_players: bool = dataclasses.field(default=True)
eligible_for_render_sorting: bool = dataclasses.field(default=True)
jump_up_pitch: float = dataclasses.field(default=35.0)
jump_down_pitch: float = dataclasses.field(default=35.0)
minimum_jump_angle_up_slope: float = dataclasses.field(default=35.0)
start_rolling: bool = dataclasses.field(default=False)
initial_disable_controls_time: float = dataclasses.field(default=0.20000000298023224)
pitch_acceleration_air: float = dataclasses.field(default=3.0)
pitch_acceleration_ground: float = dataclasses.field(default=15.0)
sound_enabled: bool = dataclasses.field(default=True)
rolling_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rolling_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
rolling_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
rolling_sound_volume: Spline = dataclasses.field(default_factory=Spline)
rolling_sound2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rolling_sound2_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
rolling_sound2_pitch: Spline = dataclasses.field(default_factory=Spline)
rolling_sound2_volume: Spline = dataclasses.field(default_factory=Spline)
jump_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
land_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
num_material_sounds: int = dataclasses.field(default=0)
material_sounds1: MineCartMaterialSounds = dataclasses.field(default_factory=MineCartMaterialSounds)
material_sounds2: MineCartMaterialSounds = dataclasses.field(default_factory=MineCartMaterialSounds)
material_sounds3: MineCartMaterialSounds = dataclasses.field(default_factory=MineCartMaterialSounds)
material_sounds4: MineCartMaterialSounds = dataclasses.field(default_factory=MineCartMaterialSounds)
material_sounds5: MineCartMaterialSounds = dataclasses.field(default_factory=MineCartMaterialSounds)
material_sounds6: MineCartMaterialSounds = dataclasses.field(default_factory=MineCartMaterialSounds)
maximum_land_sound_volume_speed: float = dataclasses.field(default=30.0)
lean_back_vertical_speed_threshold: float = dataclasses.field(default=6.0)
lean_forward_vertical_speed_threshold: float = dataclasses.field(default=-6.0)
crash_velocity_damping: float = dataclasses.field(default=0.6600000262260437)
vertical_crash_velocity: float = dataclasses.field(default=20.0)
eol_speed: float = dataclasses.field(default=16.5)
eol_hurl_distance: Vector = dataclasses.field(default_factory=lambda: Vector(x=15.0, y=0.0, z=6.0))
sync_catch_time1: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x003') # 51 properties
data.write(b'[\xc9%\x1c') # 0x5bc9251c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_height_with_driver))
data.write(b'?\x19\xed\xde') # 0x3f19edde
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wheel_diameter))
data.write(b'\xfe\xe1W\xd3') # 0xfee157d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.airbourne_wheel_friction))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x9e\xc4\xfc\x10') # 0x9ec4fc10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deceleration))
data.write(b'\x0cZ\x9c\xca') # 0xc5a9cca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deceleration_to_minimum_speed))
data.write(b'fj\xbe\x89') # 0x666abe89
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity_acceleration_multiplier))
data.write(b'\xcb\x14\xd9|') # 0xcb14d97c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_speed))
data.write(b'\x01\x85&>') # 0x185263e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_speed))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
data.write(b'<\x02v\xdf') # 0x3c0276df
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.roll_forwards))
data.write(b'\x7fc\x98\x8a') # 0x7f63988a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.travel_at_minimum_speed))
data.write(b'Y\xe0]~') # 0x59e05d7e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.maximum_speed_limit_enabled))
data.write(b'N&0\xe9') # 0x4e2630e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_jump))
data.write(b'\xe5w\xb6\x1b') # 0xe577b61b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_platform_advancement))
data.write(b'\xdf\xdaS\x00') # 0xdfda5300
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_player_collision))
data.write(b'\xcd`\xf1\x8d') # 0xcd60f18d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wait_for_all_players))
data.write(b'\x91\xff\xef\xed') # 0x91ffefed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.eligible_for_render_sorting))
data.write(b'\x17\xcb<X') # 0x17cb3c58
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_up_pitch))
data.write(b'\x85\xf7L\x0e') # 0x85f74c0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_down_pitch))
data.write(b'-dI:') # 0x2d64493a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_jump_angle_up_slope))
data.write(b'\xdc\xe9\xb3{') # 0xdce9b37b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_rolling))
data.write(b'\xae\xf4i\xe8') # 0xaef469e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_disable_controls_time))
data.write(b'jJ~F') # 0x6a4a7e46
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch_acceleration_air))
data.write(b'y2\x0f\x08') # 0x79320f08
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch_acceleration_ground))
data.write(b'\xe8Q!\xc7') # 0xe85121c7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_enabled))
data.write(b'6\xb1\xad\xd6') # 0x36b1add6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rolling_sound))
data.write(b'\xef\xe4y\x8f') # 0xefe4798f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x96\xd4\xf7\x8b') # 0x96d4f78b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\x00\x1e\r') # 0x15001e0d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe3\xa61\x00') # 0xe3a63100
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rolling_sound2))
data.write(b';\x01l\xfa') # 0x3b016cfa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound2_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xc9ZU') # 0xc95a55
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound2_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b't\xfd\xfcs') # 0x74fdfc73
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound2_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xe6`\xaf') # 0xebe660af
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.jump_sound))
data.write(b'\x0e+\x82\xec') # 0xe2b82ec
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.land_sound))
data.write(b'\xd7\xc1\x91A') # 0xd7c19141
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_material_sounds))
data.write(b'\x8e\x1a\x08\xaf') # 0x8e1a08af
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sounds1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\xff1\x92') # 0xf8ff3192
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sounds2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c\x8c\xdbF') # 0x638cdb46
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sounds3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x155C\xe8') # 0x153543e8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sounds4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8eF\xa9<') # 0x8e46a93c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sounds5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\xa3\x90\x01') # 0xf8a39001
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material_sounds6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'm\xbc\x05!') # 0x6dbc0521
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_land_sound_volume_speed))
data.write(b'c\xc4\x1bt') # 0x63c41b74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lean_back_vertical_speed_threshold))
data.write(b'\xfb\xce_\xea') # 0xfbce5fea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lean_forward_vertical_speed_threshold))
data.write(b'6\x84E\x0b') # 0x3684450b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.crash_velocity_damping))
data.write(b'4\xf4\x13\xe7') # 0x34f413e7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vertical_crash_velocity))
data.write(b'\xb1k\xef\xab') # 0xb16befab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.eol_speed))
data.write(b'\rf\x9d\xb3') # 0xd669db3
data.write(b'\x00\x0c') # size
self.eol_hurl_distance.to_stream(data)
data.write(b'\xdc\xf4g\xfa') # 0xdcf467fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.sync_catch_time1))
@classmethod
def from_json(cls, data: dict):
return cls(
collision_height_with_driver=data['collision_height_with_driver'],
wheel_diameter=data['wheel_diameter'],
airbourne_wheel_friction=data['airbourne_wheel_friction'],
acceleration=data['acceleration'],
deceleration=data['deceleration'],
deceleration_to_minimum_speed=data['deceleration_to_minimum_speed'],
gravity_acceleration_multiplier=data['gravity_acceleration_multiplier'],
initial_speed=data['initial_speed'],
minimum_speed=data['minimum_speed'],
maximum_speed=data['maximum_speed'],
roll_forwards=data['roll_forwards'],
travel_at_minimum_speed=data['travel_at_minimum_speed'],
maximum_speed_limit_enabled=data['maximum_speed_limit_enabled'],
can_jump=data['can_jump'],
allow_platform_advancement=data['allow_platform_advancement'],
allow_player_collision=data['allow_player_collision'],
wait_for_all_players=data['wait_for_all_players'],
eligible_for_render_sorting=data['eligible_for_render_sorting'],
jump_up_pitch=data['jump_up_pitch'],
jump_down_pitch=data['jump_down_pitch'],
minimum_jump_angle_up_slope=data['minimum_jump_angle_up_slope'],
start_rolling=data['start_rolling'],
initial_disable_controls_time=data['initial_disable_controls_time'],
pitch_acceleration_air=data['pitch_acceleration_air'],
pitch_acceleration_ground=data['pitch_acceleration_ground'],
sound_enabled=data['sound_enabled'],
rolling_sound=data['rolling_sound'],
rolling_sound_low_pass_filter=Spline.from_json(data['rolling_sound_low_pass_filter']),
rolling_sound_pitch=Spline.from_json(data['rolling_sound_pitch']),
rolling_sound_volume=Spline.from_json(data['rolling_sound_volume']),
rolling_sound2=data['rolling_sound2'],
rolling_sound2_low_pass_filter=Spline.from_json(data['rolling_sound2_low_pass_filter']),
rolling_sound2_pitch=Spline.from_json(data['rolling_sound2_pitch']),
rolling_sound2_volume=Spline.from_json(data['rolling_sound2_volume']),
jump_sound=data['jump_sound'],
land_sound=data['land_sound'],
num_material_sounds=data['num_material_sounds'],
material_sounds1=MineCartMaterialSounds.from_json(data['material_sounds1']),
material_sounds2=MineCartMaterialSounds.from_json(data['material_sounds2']),
material_sounds3=MineCartMaterialSounds.from_json(data['material_sounds3']),
material_sounds4=MineCartMaterialSounds.from_json(data['material_sounds4']),
material_sounds5=MineCartMaterialSounds.from_json(data['material_sounds5']),
material_sounds6=MineCartMaterialSounds.from_json(data['material_sounds6']),
maximum_land_sound_volume_speed=data['maximum_land_sound_volume_speed'],
lean_back_vertical_speed_threshold=data['lean_back_vertical_speed_threshold'],
lean_forward_vertical_speed_threshold=data['lean_forward_vertical_speed_threshold'],
crash_velocity_damping=data['crash_velocity_damping'],
vertical_crash_velocity=data['vertical_crash_velocity'],
eol_speed=data['eol_speed'],
eol_hurl_distance=Vector.from_json(data['eol_hurl_distance']),
sync_catch_time1=data['sync_catch_time1'],
)
def to_json(self) -> dict:
return {
'collision_height_with_driver': self.collision_height_with_driver,
'wheel_diameter': self.wheel_diameter,
'airbourne_wheel_friction': self.airbourne_wheel_friction,
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'deceleration_to_minimum_speed': self.deceleration_to_minimum_speed,
'gravity_acceleration_multiplier': self.gravity_acceleration_multiplier,
'initial_speed': self.initial_speed,
'minimum_speed': self.minimum_speed,
'maximum_speed': self.maximum_speed,
'roll_forwards': self.roll_forwards,
'travel_at_minimum_speed': self.travel_at_minimum_speed,
'maximum_speed_limit_enabled': self.maximum_speed_limit_enabled,
'can_jump': self.can_jump,
'allow_platform_advancement': self.allow_platform_advancement,
'allow_player_collision': self.allow_player_collision,
'wait_for_all_players': self.wait_for_all_players,
'eligible_for_render_sorting': self.eligible_for_render_sorting,
'jump_up_pitch': self.jump_up_pitch,
'jump_down_pitch': self.jump_down_pitch,
'minimum_jump_angle_up_slope': self.minimum_jump_angle_up_slope,
'start_rolling': self.start_rolling,
'initial_disable_controls_time': self.initial_disable_controls_time,
'pitch_acceleration_air': self.pitch_acceleration_air,
'pitch_acceleration_ground': self.pitch_acceleration_ground,
'sound_enabled': self.sound_enabled,
'rolling_sound': self.rolling_sound,
'rolling_sound_low_pass_filter': self.rolling_sound_low_pass_filter.to_json(),
'rolling_sound_pitch': self.rolling_sound_pitch.to_json(),
'rolling_sound_volume': self.rolling_sound_volume.to_json(),
'rolling_sound2': self.rolling_sound2,
'rolling_sound2_low_pass_filter': self.rolling_sound2_low_pass_filter.to_json(),
'rolling_sound2_pitch': self.rolling_sound2_pitch.to_json(),
'rolling_sound2_volume': self.rolling_sound2_volume.to_json(),
'jump_sound': self.jump_sound,
'land_sound': self.land_sound,
'num_material_sounds': self.num_material_sounds,
'material_sounds1': self.material_sounds1.to_json(),
'material_sounds2': self.material_sounds2.to_json(),
'material_sounds3': self.material_sounds3.to_json(),
'material_sounds4': self.material_sounds4.to_json(),
'material_sounds5': self.material_sounds5.to_json(),
'material_sounds6': self.material_sounds6.to_json(),
'maximum_land_sound_volume_speed': self.maximum_land_sound_volume_speed,
'lean_back_vertical_speed_threshold': self.lean_back_vertical_speed_threshold,
'lean_forward_vertical_speed_threshold': self.lean_forward_vertical_speed_threshold,
'crash_velocity_damping': self.crash_velocity_damping,
'vertical_crash_velocity': self.vertical_crash_velocity,
'eol_speed': self.eol_speed,
'eol_hurl_distance': self.eol_hurl_distance.to_json(),
'sync_catch_time1': self.sync_catch_time1,
}
def _decode_collision_height_with_driver(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wheel_diameter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_airbourne_wheel_friction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration_to_minimum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity_acceleration_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_forwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_travel_at_minimum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_maximum_speed_limit_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_jump(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_platform_advancement(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_player_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wait_for_all_players(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_eligible_for_render_sorting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_jump_up_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_down_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_jump_angle_up_slope(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_rolling(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_initial_disable_controls_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pitch_acceleration_air(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pitch_acceleration_ground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rolling_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rolling_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rolling_sound2_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound2_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound2_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_jump_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_land_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_num_material_sounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_material_sounds1(data: typing.BinaryIO, property_size: int):
return MineCartMaterialSounds.from_stream(data, property_size)
def _decode_material_sounds2(data: typing.BinaryIO, property_size: int):
return MineCartMaterialSounds.from_stream(data, property_size)
def _decode_material_sounds3(data: typing.BinaryIO, property_size: int):
return MineCartMaterialSounds.from_stream(data, property_size)
def _decode_material_sounds4(data: typing.BinaryIO, property_size: int):
return MineCartMaterialSounds.from_stream(data, property_size)
def _decode_material_sounds5(data: typing.BinaryIO, property_size: int):
return MineCartMaterialSounds.from_stream(data, property_size)
def _decode_material_sounds6(data: typing.BinaryIO, property_size: int):
return MineCartMaterialSounds.from_stream(data, property_size)
def _decode_maximum_land_sound_volume_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lean_back_vertical_speed_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lean_forward_vertical_speed_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_crash_velocity_damping(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vertical_crash_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_eol_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_eol_hurl_distance(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_sync_catch_time1(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]]] = {
0x5bc9251c: ('collision_height_with_driver', _decode_collision_height_with_driver),
0x3f19edde: ('wheel_diameter', _decode_wheel_diameter),
0xfee157d3: ('airbourne_wheel_friction', _decode_airbourne_wheel_friction),
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0xc5a9cca: ('deceleration_to_minimum_speed', _decode_deceleration_to_minimum_speed),
0x666abe89: ('gravity_acceleration_multiplier', _decode_gravity_acceleration_multiplier),
0xcb14d97c: ('initial_speed', _decode_initial_speed),
0x185263e: ('minimum_speed', _decode_minimum_speed),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
0x3c0276df: ('roll_forwards', _decode_roll_forwards),
0x7f63988a: ('travel_at_minimum_speed', _decode_travel_at_minimum_speed),
0x59e05d7e: ('maximum_speed_limit_enabled', _decode_maximum_speed_limit_enabled),
0x4e2630e9: ('can_jump', _decode_can_jump),
0xe577b61b: ('allow_platform_advancement', _decode_allow_platform_advancement),
0xdfda5300: ('allow_player_collision', _decode_allow_player_collision),
0xcd60f18d: ('wait_for_all_players', _decode_wait_for_all_players),
0x91ffefed: ('eligible_for_render_sorting', _decode_eligible_for_render_sorting),
0x17cb3c58: ('jump_up_pitch', _decode_jump_up_pitch),
0x85f74c0e: ('jump_down_pitch', _decode_jump_down_pitch),
0x2d64493a: ('minimum_jump_angle_up_slope', _decode_minimum_jump_angle_up_slope),
0xdce9b37b: ('start_rolling', _decode_start_rolling),
0xaef469e8: ('initial_disable_controls_time', _decode_initial_disable_controls_time),
0x6a4a7e46: ('pitch_acceleration_air', _decode_pitch_acceleration_air),
0x79320f08: ('pitch_acceleration_ground', _decode_pitch_acceleration_ground),
0xe85121c7: ('sound_enabled', _decode_sound_enabled),
0x36b1add6: ('rolling_sound', _decode_rolling_sound),
0xefe4798f: ('rolling_sound_low_pass_filter', _decode_rolling_sound_low_pass_filter),
0x96d4f78b: ('rolling_sound_pitch', _decode_rolling_sound_pitch),
0x15001e0d: ('rolling_sound_volume', _decode_rolling_sound_volume),
0xe3a63100: ('rolling_sound2', _decode_rolling_sound2),
0x3b016cfa: ('rolling_sound2_low_pass_filter', _decode_rolling_sound2_low_pass_filter),
0xc95a55: ('rolling_sound2_pitch', _decode_rolling_sound2_pitch),
0x74fdfc73: ('rolling_sound2_volume', _decode_rolling_sound2_volume),
0xebe660af: ('jump_sound', _decode_jump_sound),
0xe2b82ec: ('land_sound', _decode_land_sound),
0xd7c19141: ('num_material_sounds', _decode_num_material_sounds),
0x8e1a08af: ('material_sounds1', _decode_material_sounds1),
0xf8ff3192: ('material_sounds2', _decode_material_sounds2),
0x638cdb46: ('material_sounds3', _decode_material_sounds3),
0x153543e8: ('material_sounds4', _decode_material_sounds4),
0x8e46a93c: ('material_sounds5', _decode_material_sounds5),
0xf8a39001: ('material_sounds6', _decode_material_sounds6),
0x6dbc0521: ('maximum_land_sound_volume_speed', _decode_maximum_land_sound_volume_speed),
0x63c41b74: ('lean_back_vertical_speed_threshold', _decode_lean_back_vertical_speed_threshold),
0xfbce5fea: ('lean_forward_vertical_speed_threshold', _decode_lean_forward_vertical_speed_threshold),
0x3684450b: ('crash_velocity_damping', _decode_crash_velocity_damping),
0x34f413e7: ('vertical_crash_velocity', _decode_vertical_crash_velocity),
0xb16befab: ('eol_speed', _decode_eol_speed),
0xd669db3: ('eol_hurl_distance', _decode_eol_hurl_distance),
0xdcf467fa: ('sync_catch_time1', _decode_sync_catch_time1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MineCartData.py | 0.744192 | 0.202148 | MineCartData.py | 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.dkc_returns.archetypes.UnknownStruct230 import UnknownStruct230
@dataclasses.dataclass()
class UnknownStruct231(BaseProperty):
unknown_0xbb3c732e: bool = dataclasses.field(default=True)
unknown_0x44749ab7: bool = dataclasses.field(default=False)
unknown_0xd7f4ea7f: bool = dataclasses.field(default=True)
unknown_0x46997d8a: bool = dataclasses.field(default=True)
unknown_0xa7a8c42a: float = dataclasses.field(default=3.5)
unknown_struct230: UnknownStruct230 = dataclasses.field(default_factory=UnknownStruct230)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xbb<s.') # 0xbb3c732e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbb3c732e))
data.write(b'Dt\x9a\xb7') # 0x44749ab7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x44749ab7))
data.write(b'\xd7\xf4\xea\x7f') # 0xd7f4ea7f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd7f4ea7f))
data.write(b'F\x99}\x8a') # 0x46997d8a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x46997d8a))
data.write(b'\xa7\xa8\xc4*') # 0xa7a8c42a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa7a8c42a))
data.write(b'\xe39VU') # 0xe3395655
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct230.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xbb3c732e=data['unknown_0xbb3c732e'],
unknown_0x44749ab7=data['unknown_0x44749ab7'],
unknown_0xd7f4ea7f=data['unknown_0xd7f4ea7f'],
unknown_0x46997d8a=data['unknown_0x46997d8a'],
unknown_0xa7a8c42a=data['unknown_0xa7a8c42a'],
unknown_struct230=UnknownStruct230.from_json(data['unknown_struct230']),
)
def to_json(self) -> dict:
return {
'unknown_0xbb3c732e': self.unknown_0xbb3c732e,
'unknown_0x44749ab7': self.unknown_0x44749ab7,
'unknown_0xd7f4ea7f': self.unknown_0xd7f4ea7f,
'unknown_0x46997d8a': self.unknown_0x46997d8a,
'unknown_0xa7a8c42a': self.unknown_0xa7a8c42a,
'unknown_struct230': self.unknown_struct230.to_json(),
}
def _decode_unknown_0xbb3c732e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x44749ab7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xd7f4ea7f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x46997d8a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa7a8c42a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct230(data: typing.BinaryIO, property_size: int):
return UnknownStruct230.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbb3c732e: ('unknown_0xbb3c732e', _decode_unknown_0xbb3c732e),
0x44749ab7: ('unknown_0x44749ab7', _decode_unknown_0x44749ab7),
0xd7f4ea7f: ('unknown_0xd7f4ea7f', _decode_unknown_0xd7f4ea7f),
0x46997d8a: ('unknown_0x46997d8a', _decode_unknown_0x46997d8a),
0xa7a8c42a: ('unknown_0xa7a8c42a', _decode_unknown_0xa7a8c42a),
0xe3395655: ('unknown_struct230', _decode_unknown_struct230),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct231.py | 0.599602 | 0.23814 | UnknownStruct231.py | 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.dkc_returns as enums
@dataclasses.dataclass()
class DamageInfo(BaseProperty):
di_damage_type: enums.DI_DamageType = dataclasses.field(default=enums.DI_DamageType.Unknown1)
di_damage: float = dataclasses.field(default=0.0)
di_radius: float = dataclasses.field(default=0.0)
di_knock_back_speed: float = dataclasses.field(default=4.0)
di_hurl_height: float = dataclasses.field(default=6.0)
di_hurl_distance: float = dataclasses.field(default=12.0)
di_effect_intensity: int = dataclasses.field(default=0)
di_default_contact_rule: enums.DI_DefaultContactRule = dataclasses.field(default=enums.DI_DefaultContactRule.Unknown2)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'e\xc4\xfbJ') # 0x65c4fb4a
data.write(b'\x00\x04') # size
self.di_damage_type.to_stream(data)
data.write(b'\xf2\xd0&\x13') # 0xf2d02613
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_damage))
data.write(b'\xee\x1b\xe9\x14') # 0xee1be914
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_radius))
data.write(b'&\x00\x19y') # 0x26001979
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_knock_back_speed))
data.write(b'\x99\n\x16)') # 0x990a1629
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_hurl_height))
data.write(b'_\x8a\x1dG') # 0x5f8a1d47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_hurl_distance))
data.write(b'\x13\x1dp\x1b') # 0x131d701b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.di_effect_intensity))
data.write(b'\x82f\xb5)') # 0x8266b529
data.write(b'\x00\x04') # size
self.di_default_contact_rule.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
di_damage_type=enums.DI_DamageType.from_json(data['di_damage_type']),
di_damage=data['di_damage'],
di_radius=data['di_radius'],
di_knock_back_speed=data['di_knock_back_speed'],
di_hurl_height=data['di_hurl_height'],
di_hurl_distance=data['di_hurl_distance'],
di_effect_intensity=data['di_effect_intensity'],
di_default_contact_rule=enums.DI_DefaultContactRule.from_json(data['di_default_contact_rule']),
)
def to_json(self) -> dict:
return {
'di_damage_type': self.di_damage_type.to_json(),
'di_damage': self.di_damage,
'di_radius': self.di_radius,
'di_knock_back_speed': self.di_knock_back_speed,
'di_hurl_height': self.di_hurl_height,
'di_hurl_distance': self.di_hurl_distance,
'di_effect_intensity': self.di_effect_intensity,
'di_default_contact_rule': self.di_default_contact_rule.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x65c4fb4a, 0xf2d02613, 0xee1be914, 0x26001979, 0x990a1629, 0x5f8a1d47, 0x131d701b, 0x8266b529)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DamageInfo]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHfLHfLHfLHlLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(80))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21]) != _FAST_IDS:
data.seek(before)
return None
return DamageInfo(
enums.DI_DamageType(dec[2]),
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
enums.DI_DefaultContactRule(dec[23]),
)
def _decode_di_damage_type(data: typing.BinaryIO, property_size: int):
return enums.DI_DamageType.from_stream(data)
def _decode_di_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_knock_back_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_hurl_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_hurl_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_effect_intensity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_di_default_contact_rule(data: typing.BinaryIO, property_size: int):
return enums.DI_DefaultContactRule.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x65c4fb4a: ('di_damage_type', _decode_di_damage_type),
0xf2d02613: ('di_damage', _decode_di_damage),
0xee1be914: ('di_radius', _decode_di_radius),
0x26001979: ('di_knock_back_speed', _decode_di_knock_back_speed),
0x990a1629: ('di_hurl_height', _decode_di_hurl_height),
0x5f8a1d47: ('di_hurl_distance', _decode_di_hurl_distance),
0x131d701b: ('di_effect_intensity', _decode_di_effect_intensity),
0x8266b529: ('di_default_contact_rule', _decode_di_default_contact_rule),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DamageInfo.py | 0.644337 | 0.246012 | DamageInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.InterpolationMethod import InterpolationMethod
@dataclasses.dataclass()
class OrientationInterpolationMethod(BaseProperty):
orientation_type: enums.OrientationType = dataclasses.field(default=enums.OrientationType.Unknown3)
orientation_control: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\\r\xa9d') # 0x5c72a964
data.write(b'\x00\x04') # size
self.orientation_type.to_stream(data)
data.write(b'\x86T\xb0\x81') # 0x8654b081
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_control.to_stream(data, default_override={'interpolation_control_type': enums.InterpolationControlType.Unknown5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
orientation_type=enums.OrientationType.from_json(data['orientation_type']),
orientation_control=InterpolationMethod.from_json(data['orientation_control']),
)
def to_json(self) -> dict:
return {
'orientation_type': self.orientation_type.to_json(),
'orientation_control': self.orientation_control.to_json(),
}
def _decode_orientation_type(data: typing.BinaryIO, property_size: int):
return enums.OrientationType.from_stream(data)
def _decode_orientation_control(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size, default_override={'interpolation_control_type': enums.InterpolationControlType.Unknown5})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5c72a964: ('orientation_type', _decode_orientation_type),
0x8654b081: ('orientation_control', _decode_orientation_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OrientationInterpolationMethod.py | 0.680772 | 0.305238 | OrientationInterpolationMethod.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct292(BaseProperty):
gem_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0xa826bd98: str = dataclasses.field(default='')
unknown_0x46cc2fd0: float = dataclasses.field(default=1.5)
unknown_0x82b6dc81: float = dataclasses.field(default=0.699999988079071)
ground_pound_relapse_multiplier: float = dataclasses.field(default=1.0)
ground_pound_window: float = dataclasses.field(default=0.20000000298023224)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0xebf3b81d: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\xc5\xce\x83\xaf') # 0xc5ce83af
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gem_model))
data.write(b'\xa8&\xbd\x98') # 0xa826bd98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xa826bd98.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'F\xcc/\xd0') # 0x46cc2fd0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x46cc2fd0))
data.write(b'\x82\xb6\xdc\x81') # 0x82b6dc81
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x82b6dc81))
data.write(b'hn\x03\x0b') # 0x686e030b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_relapse_multiplier))
data.write(b'h\xd7\x87\xb4') # 0x68d787b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_window))
data.write(b'h\x13~\xa7') # 0x68137ea7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.part))
data.write(b'\xeb\xf3\xb8\x1d') # 0xebf3b81d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xebf3b81d))
@classmethod
def from_json(cls, data: dict):
return cls(
gem_model=data['gem_model'],
unknown_0xa826bd98=data['unknown_0xa826bd98'],
unknown_0x46cc2fd0=data['unknown_0x46cc2fd0'],
unknown_0x82b6dc81=data['unknown_0x82b6dc81'],
ground_pound_relapse_multiplier=data['ground_pound_relapse_multiplier'],
ground_pound_window=data['ground_pound_window'],
part=data['part'],
unknown_0xebf3b81d=data['unknown_0xebf3b81d'],
)
def to_json(self) -> dict:
return {
'gem_model': self.gem_model,
'unknown_0xa826bd98': self.unknown_0xa826bd98,
'unknown_0x46cc2fd0': self.unknown_0x46cc2fd0,
'unknown_0x82b6dc81': self.unknown_0x82b6dc81,
'ground_pound_relapse_multiplier': self.ground_pound_relapse_multiplier,
'ground_pound_window': self.ground_pound_window,
'part': self.part,
'unknown_0xebf3b81d': self.unknown_0xebf3b81d,
}
def _decode_gem_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xa826bd98(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x46cc2fd0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x82b6dc81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_pound_relapse_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_pound_window(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xebf3b81d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc5ce83af: ('gem_model', _decode_gem_model),
0xa826bd98: ('unknown_0xa826bd98', _decode_unknown_0xa826bd98),
0x46cc2fd0: ('unknown_0x46cc2fd0', _decode_unknown_0x46cc2fd0),
0x82b6dc81: ('unknown_0x82b6dc81', _decode_unknown_0x82b6dc81),
0x686e030b: ('ground_pound_relapse_multiplier', _decode_ground_pound_relapse_multiplier),
0x68d787b4: ('ground_pound_window', _decode_ground_pound_window),
0x68137ea7: ('part', _decode_part),
0xebf3b81d: ('unknown_0xebf3b81d', _decode_unknown_0xebf3b81d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct292.py | 0.59843 | 0.22531 | UnknownStruct292.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct115(BaseProperty):
target_idle_range: float = dataclasses.field(default=5.0)
unknown_0x0a42c7af: float = dataclasses.field(default=1.0)
max_patrol_distance: float = dataclasses.field(default=5.0)
chase_speed: float = dataclasses.field(default=5.0)
patrol_speed: float = dataclasses.field(default=5.0)
unknown_0x6cce17a9: float = dataclasses.field(default=1.0)
unknown_0xaad0b493: float = dataclasses.field(default=10.0)
unknown_0xe1cf6014: float = dataclasses.field(default=40.0)
unknown_0x29a27cb9: float = dataclasses.field(default=8.0)
unknown_0x3311ba2b: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\x80-27') # 0x802d3237
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_idle_range))
data.write(b'\nB\xc7\xaf') # 0xa42c7af
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0a42c7af))
data.write(b'[\xbbn\xc9') # 0x5bbb6ec9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_patrol_distance))
data.write(b'\x92\xfb\xc1a') # 0x92fbc161
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chase_speed))
data.write(b'v\\7\x15') # 0x765c3715
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.patrol_speed))
data.write(b'l\xce\x17\xa9') # 0x6cce17a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6cce17a9))
data.write(b'\xaa\xd0\xb4\x93') # 0xaad0b493
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xaad0b493))
data.write(b'\xe1\xcf`\x14') # 0xe1cf6014
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe1cf6014))
data.write(b')\xa2|\xb9') # 0x29a27cb9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x29a27cb9))
data.write(b'3\x11\xba+') # 0x3311ba2b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x3311ba2b))
@classmethod
def from_json(cls, data: dict):
return cls(
target_idle_range=data['target_idle_range'],
unknown_0x0a42c7af=data['unknown_0x0a42c7af'],
max_patrol_distance=data['max_patrol_distance'],
chase_speed=data['chase_speed'],
patrol_speed=data['patrol_speed'],
unknown_0x6cce17a9=data['unknown_0x6cce17a9'],
unknown_0xaad0b493=data['unknown_0xaad0b493'],
unknown_0xe1cf6014=data['unknown_0xe1cf6014'],
unknown_0x29a27cb9=data['unknown_0x29a27cb9'],
unknown_0x3311ba2b=data['unknown_0x3311ba2b'],
)
def to_json(self) -> dict:
return {
'target_idle_range': self.target_idle_range,
'unknown_0x0a42c7af': self.unknown_0x0a42c7af,
'max_patrol_distance': self.max_patrol_distance,
'chase_speed': self.chase_speed,
'patrol_speed': self.patrol_speed,
'unknown_0x6cce17a9': self.unknown_0x6cce17a9,
'unknown_0xaad0b493': self.unknown_0xaad0b493,
'unknown_0xe1cf6014': self.unknown_0xe1cf6014,
'unknown_0x29a27cb9': self.unknown_0x29a27cb9,
'unknown_0x3311ba2b': self.unknown_0x3311ba2b,
}
_FAST_FORMAT = None
_FAST_IDS = (0x802d3237, 0xa42c7af, 0x5bbb6ec9, 0x92fbc161, 0x765c3715, 0x6cce17a9, 0xaad0b493, 0xe1cf6014, 0x29a27cb9, 0x3311ba2b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct115]:
if property_count != 10:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(104))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct115(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
)
def _decode_target_idle_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0a42c7af(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_patrol_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chase_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_patrol_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6cce17a9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xaad0b493(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe1cf6014(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x29a27cb9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3311ba2b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x802d3237: ('target_idle_range', _decode_target_idle_range),
0xa42c7af: ('unknown_0x0a42c7af', _decode_unknown_0x0a42c7af),
0x5bbb6ec9: ('max_patrol_distance', _decode_max_patrol_distance),
0x92fbc161: ('chase_speed', _decode_chase_speed),
0x765c3715: ('patrol_speed', _decode_patrol_speed),
0x6cce17a9: ('unknown_0x6cce17a9', _decode_unknown_0x6cce17a9),
0xaad0b493: ('unknown_0xaad0b493', _decode_unknown_0xaad0b493),
0xe1cf6014: ('unknown_0xe1cf6014', _decode_unknown_0xe1cf6014),
0x29a27cb9: ('unknown_0x29a27cb9', _decode_unknown_0x29a27cb9),
0x3311ba2b: ('unknown_0x3311ba2b', _decode_unknown_0x3311ba2b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct115.py | 0.612773 | 0.218815 | UnknownStruct115.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
from retro_data_structures.properties.dkc_returns.archetypes.PathDetermination import PathDetermination
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct13 import UnknownStruct13
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class PathPosition(BaseProperty):
flags_path_position: int = dataclasses.field(default=0)
initial_position: enums.InitialPosition = dataclasses.field(default=enums.InitialPosition.Unknown1)
path_determination: PathDetermination = dataclasses.field(default_factory=PathDetermination)
distance: float = dataclasses.field(default=4.0)
dampen_distance: float = dataclasses.field(default=3.0)
convergence: Convergence = dataclasses.field(default_factory=Convergence)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
unknown: Spline = dataclasses.field(default_factory=Spline)
unknown_struct13: UnknownStruct13 = dataclasses.field(default_factory=UnknownStruct13)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'%\x9d2y') # 0x259d3279
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_path_position))
data.write(b'4\x0eL\xa3') # 0x340e4ca3
data.write(b'\x00\x04') # size
self.initial_position.to_stream(data)
data.write(b'\n\xed\\}') # 0xaed5c7d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_determination.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'2\xf85\xec') # 0x32f835ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dampen_distance))
data.write(b'\x95\x91\x08\xa5') # 0x959108a5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\x86\x1f}') # 0x12861f7d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0e\x1f \x94') # 0xe1f2094
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
flags_path_position=data['flags_path_position'],
initial_position=enums.InitialPosition.from_json(data['initial_position']),
path_determination=PathDetermination.from_json(data['path_determination']),
distance=data['distance'],
dampen_distance=data['dampen_distance'],
convergence=Convergence.from_json(data['convergence']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
unknown=Spline.from_json(data['unknown']),
unknown_struct13=UnknownStruct13.from_json(data['unknown_struct13']),
)
def to_json(self) -> dict:
return {
'flags_path_position': self.flags_path_position,
'initial_position': self.initial_position.to_json(),
'path_determination': self.path_determination.to_json(),
'distance': self.distance,
'dampen_distance': self.dampen_distance,
'convergence': self.convergence.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'unknown': self.unknown.to_json(),
'unknown_struct13': self.unknown_struct13.to_json(),
}
def _decode_flags_path_position(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_initial_position(data: typing.BinaryIO, property_size: int):
return enums.InitialPosition.from_stream(data)
def _decode_path_determination(data: typing.BinaryIO, property_size: int):
return PathDetermination.from_stream(data, property_size)
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dampen_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_convergence(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_struct13(data: typing.BinaryIO, property_size: int):
return UnknownStruct13.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x259d3279: ('flags_path_position', _decode_flags_path_position),
0x340e4ca3: ('initial_position', _decode_initial_position),
0xaed5c7d: ('path_determination', _decode_path_determination),
0xc3bf43be: ('distance', _decode_distance),
0x32f835ec: ('dampen_distance', _decode_dampen_distance),
0x959108a5: ('convergence', _decode_convergence),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0x12861f7d: ('unknown', _decode_unknown),
0xe1f2094: ('unknown_struct13', _decode_unknown_struct13),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PathPosition.py | 0.648911 | 0.240953 | PathPosition.py | 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.dkc_returns.archetypes.VolcanoBossBodyPartStructA import VolcanoBossBodyPartStructA
@dataclasses.dataclass()
class JungleBossStructD(BaseProperty):
volcano_boss_body_part_struct_a_0x12d98dc2: VolcanoBossBodyPartStructA = dataclasses.field(default_factory=VolcanoBossBodyPartStructA)
volcano_boss_body_part_struct_a_0xc0f12817: VolcanoBossBodyPartStructA = dataclasses.field(default_factory=VolcanoBossBodyPartStructA)
volcano_boss_body_part_struct_a_0xf8019f49: VolcanoBossBodyPartStructA = dataclasses.field(default_factory=VolcanoBossBodyPartStructA)
unknown: float = dataclasses.field(default=50.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x12\xd9\x8d\xc2') # 0x12d98dc2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_a_0x12d98dc2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\xf1(\x17') # 0xc0f12817
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_a_0xc0f12817.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\x01\x9fI') # 0xf8019f49
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_a_0xf8019f49.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\xf1\xe5z') # 0x4af1e57a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
volcano_boss_body_part_struct_a_0x12d98dc2=VolcanoBossBodyPartStructA.from_json(data['volcano_boss_body_part_struct_a_0x12d98dc2']),
volcano_boss_body_part_struct_a_0xc0f12817=VolcanoBossBodyPartStructA.from_json(data['volcano_boss_body_part_struct_a_0xc0f12817']),
volcano_boss_body_part_struct_a_0xf8019f49=VolcanoBossBodyPartStructA.from_json(data['volcano_boss_body_part_struct_a_0xf8019f49']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'volcano_boss_body_part_struct_a_0x12d98dc2': self.volcano_boss_body_part_struct_a_0x12d98dc2.to_json(),
'volcano_boss_body_part_struct_a_0xc0f12817': self.volcano_boss_body_part_struct_a_0xc0f12817.to_json(),
'volcano_boss_body_part_struct_a_0xf8019f49': self.volcano_boss_body_part_struct_a_0xf8019f49.to_json(),
'unknown': self.unknown,
}
def _decode_volcano_boss_body_part_struct_a_0x12d98dc2(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructA.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_a_0xc0f12817(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructA.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_a_0xf8019f49(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructA.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x12d98dc2: ('volcano_boss_body_part_struct_a_0x12d98dc2', _decode_volcano_boss_body_part_struct_a_0x12d98dc2),
0xc0f12817: ('volcano_boss_body_part_struct_a_0xc0f12817', _decode_volcano_boss_body_part_struct_a_0xc0f12817),
0xf8019f49: ('volcano_boss_body_part_struct_a_0xf8019f49', _decode_volcano_boss_body_part_struct_a_0xf8019f49),
0x4af1e57a: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/JungleBossStructD.py | 0.581065 | 0.317175 | JungleBossStructD.py | 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.dkc_returns.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class RambiCrateData(BaseProperty):
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0xa2dc645a: int = dataclasses.field(default=0)
unknown_0x456b0545: int = dataclasses.field(default=0)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0xfa8ca261: float = dataclasses.field(default=15.0)
min_reactivate_distance: float = dataclasses.field(default=5.0)
max_reactivate_distance: float = dataclasses.field(default=10.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2\xdcdZ') # 0xa2dc645a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xa2dc645a))
data.write(b'Ek\x05E') # 0x456b0545
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x456b0545))
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa\x8c\xa2a') # 0xfa8ca261
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfa8ca261))
data.write(b'\xc5Uf\xdb') # 0xc55566db
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_reactivate_distance))
data.write(b'&\x08\xd8\x01') # 0x2608d801
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_reactivate_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
animation=AnimationParameters.from_json(data['animation']),
unknown_0xa2dc645a=data['unknown_0xa2dc645a'],
unknown_0x456b0545=data['unknown_0x456b0545'],
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
unknown_0xfa8ca261=data['unknown_0xfa8ca261'],
min_reactivate_distance=data['min_reactivate_distance'],
max_reactivate_distance=data['max_reactivate_distance'],
)
def to_json(self) -> dict:
return {
'animation': self.animation.to_json(),
'unknown_0xa2dc645a': self.unknown_0xa2dc645a,
'unknown_0x456b0545': self.unknown_0x456b0545,
'vulnerability': self.vulnerability.to_json(),
'unknown_0xfa8ca261': self.unknown_0xfa8ca261,
'min_reactivate_distance': self.min_reactivate_distance,
'max_reactivate_distance': self.max_reactivate_distance,
}
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0xa2dc645a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x456b0545(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0xfa8ca261(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_reactivate_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_reactivate_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa3d63f44: ('animation', _decode_animation),
0xa2dc645a: ('unknown_0xa2dc645a', _decode_unknown_0xa2dc645a),
0x456b0545: ('unknown_0x456b0545', _decode_unknown_0x456b0545),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xfa8ca261: ('unknown_0xfa8ca261', _decode_unknown_0xfa8ca261),
0xc55566db: ('min_reactivate_distance', _decode_min_reactivate_distance),
0x2608d801: ('max_reactivate_distance', _decode_max_reactivate_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RambiCrateData.py | 0.649023 | 0.263392 | RambiCrateData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct242(BaseProperty):
song_file: AssetId = dataclasses.field(metadata={'asset_types': ['STRM']}, default=default_asset_id)
dvd_file: str = dataclasses.field(default='')
start_faded_out: bool = dataclasses.field(default=False)
fade_in_time: float = dataclasses.field(default=0.05000000074505806)
fade_out_time: float = dataclasses.field(default=0.25)
volume: float = dataclasses.field(default=-6.0)
pan: float = dataclasses.field(default=0.0)
positional: bool = dataclasses.field(default=False)
min_audible_distance: float = dataclasses.field(default=2.0)
max_audible_distance: float = dataclasses.field(default=75.0)
fall_off: float = dataclasses.field(default=0.0)
use_room_acoustics: bool = dataclasses.field(default=True)
start_sample: int = dataclasses.field(default=0)
is_default_retronome_music: bool = dataclasses.field(default=False)
sound_group_names: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x9d\x1ag\xa8') # 0x9d1a67a8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.song_file))
data.write(b'\xb4\x17\x06J') # 0xb417064a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.dvd_file.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb%\n\x0b') # 0xeb250a0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_faded_out))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'\xdfCS\xa3') # 0xdf4353a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan))
data.write(b'n\x0e\x81\xf8') # 0x6e0e81f8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.positional))
data.write(b'%\xd4y\x8a') # 0x25d4798a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_audible_distance))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'rS\x18g') # 0x72531867
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fall_off))
data.write(b'\x85psT') # 0x85707354
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_room_acoustics))
data.write(b'\xe8\x8f\xf3w') # 0xe88ff377
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.start_sample))
data.write(b'\x07\x94\xc3\xeb') # 0x794c3eb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_default_retronome_music))
data.write(b'\xc8q\xbd\x1b') # 0xc871bd1b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.sound_group_names.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
song_file=data['song_file'],
dvd_file=data['dvd_file'],
start_faded_out=data['start_faded_out'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
volume=data['volume'],
pan=data['pan'],
positional=data['positional'],
min_audible_distance=data['min_audible_distance'],
max_audible_distance=data['max_audible_distance'],
fall_off=data['fall_off'],
use_room_acoustics=data['use_room_acoustics'],
start_sample=data['start_sample'],
is_default_retronome_music=data['is_default_retronome_music'],
sound_group_names=data['sound_group_names'],
)
def to_json(self) -> dict:
return {
'song_file': self.song_file,
'dvd_file': self.dvd_file,
'start_faded_out': self.start_faded_out,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'volume': self.volume,
'pan': self.pan,
'positional': self.positional,
'min_audible_distance': self.min_audible_distance,
'max_audible_distance': self.max_audible_distance,
'fall_off': self.fall_off,
'use_room_acoustics': self.use_room_acoustics,
'start_sample': self.start_sample,
'is_default_retronome_music': self.is_default_retronome_music,
'sound_group_names': self.sound_group_names,
}
def _decode_song_file(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dvd_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_start_faded_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_positional(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_min_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fall_off(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_room_acoustics(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_sample(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_default_retronome_music(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_group_names(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9d1a67a8: ('song_file', _decode_song_file),
0xb417064a: ('dvd_file', _decode_dvd_file),
0xeb250a0b: ('start_faded_out', _decode_start_faded_out),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0xc7a7f189: ('volume', _decode_volume),
0xdf4353a3: ('pan', _decode_pan),
0x6e0e81f8: ('positional', _decode_positional),
0x25d4798a: ('min_audible_distance', _decode_min_audible_distance),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x72531867: ('fall_off', _decode_fall_off),
0x85707354: ('use_room_acoustics', _decode_use_room_acoustics),
0xe88ff377: ('start_sample', _decode_start_sample),
0x794c3eb: ('is_default_retronome_music', _decode_is_default_retronome_music),
0xc871bd1b: ('sound_group_names', _decode_sound_group_names),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct242.py | 0.596316 | 0.276324 | UnknownStruct242.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class JungleBossStructC(BaseProperty):
unknown_0xcb349144: int = dataclasses.field(default=3)
spawn_delay_time: float = dataclasses.field(default=1.0)
unknown_0x0ecc390f: float = dataclasses.field(default=0.0)
unknown_0xc4cfb8de: float = dataclasses.field(default=35.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xcb4\x91D') # 0xcb349144
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xcb349144))
data.write(b'\xc8@\x1f\xce') # 0xc8401fce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spawn_delay_time))
data.write(b'\x0e\xcc9\x0f') # 0xecc390f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0ecc390f))
data.write(b'\xc4\xcf\xb8\xde') # 0xc4cfb8de
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc4cfb8de))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xcb349144=data['unknown_0xcb349144'],
spawn_delay_time=data['spawn_delay_time'],
unknown_0x0ecc390f=data['unknown_0x0ecc390f'],
unknown_0xc4cfb8de=data['unknown_0xc4cfb8de'],
)
def to_json(self) -> dict:
return {
'unknown_0xcb349144': self.unknown_0xcb349144,
'spawn_delay_time': self.spawn_delay_time,
'unknown_0x0ecc390f': self.unknown_0x0ecc390f,
'unknown_0xc4cfb8de': self.unknown_0xc4cfb8de,
}
_FAST_FORMAT = None
_FAST_IDS = (0xcb349144, 0xc8401fce, 0xecc390f, 0xc4cfb8de)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[JungleBossStructC]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return JungleBossStructC(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_unknown_0xcb349144(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spawn_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0ecc390f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc4cfb8de(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]]] = {
0xcb349144: ('unknown_0xcb349144', _decode_unknown_0xcb349144),
0xc8401fce: ('spawn_delay_time', _decode_spawn_delay_time),
0xecc390f: ('unknown_0x0ecc390f', _decode_unknown_0x0ecc390f),
0xc4cfb8de: ('unknown_0xc4cfb8de', _decode_unknown_0xc4cfb8de),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/JungleBossStructC.py | 0.601242 | 0.291141 | JungleBossStructC.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct116(BaseProperty):
unknown: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x16\x93\x01\xc8') # 0x169301c8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
}
_FAST_FORMAT = None
_FAST_IDS = (0x169301c8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct116]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct116(
dec[2],
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x169301c8: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct116.py | 0.64713 | 0.288284 | UnknownStruct116.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerSlaveData(BaseProperty):
disable_grab_detach_duration: float = dataclasses.field(default=1.0)
grab_detached_disallow_time: float = dataclasses.field(default=0.30000001192092896)
unknown_0x2c60dd92: int = dataclasses.field(default=0)
unknown_0xc739d41a: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xe4\x88\xb8\x9e') # 0xe488b89e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_grab_detach_duration))
data.write(b'\xd2-\xa5|') # 0xd22da57c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grab_detached_disallow_time))
data.write(b',`\xdd\x92') # 0x2c60dd92
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2c60dd92))
data.write(b'\xc79\xd4\x1a') # 0xc739d41a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc739d41a))
@classmethod
def from_json(cls, data: dict):
return cls(
disable_grab_detach_duration=data['disable_grab_detach_duration'],
grab_detached_disallow_time=data['grab_detached_disallow_time'],
unknown_0x2c60dd92=data['unknown_0x2c60dd92'],
unknown_0xc739d41a=data['unknown_0xc739d41a'],
)
def to_json(self) -> dict:
return {
'disable_grab_detach_duration': self.disable_grab_detach_duration,
'grab_detached_disallow_time': self.grab_detached_disallow_time,
'unknown_0x2c60dd92': self.unknown_0x2c60dd92,
'unknown_0xc739d41a': self.unknown_0xc739d41a,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe488b89e, 0xd22da57c, 0x2c60dd92, 0xc739d41a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerSlaveData]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return PlayerSlaveData(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_disable_grab_detach_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grab_detached_disallow_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2c60dd92(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc739d41a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe488b89e: ('disable_grab_detach_duration', _decode_disable_grab_detach_duration),
0xd22da57c: ('grab_detached_disallow_time', _decode_grab_detached_disallow_time),
0x2c60dd92: ('unknown_0x2c60dd92', _decode_unknown_0x2c60dd92),
0xc739d41a: ('unknown_0xc739d41a', _decode_unknown_0xc739d41a),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerSlaveData.py | 0.591723 | 0.265059 | PlayerSlaveData.py | 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.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct180(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
hidden_name: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_arrow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_arrow_pressed: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
right_arrow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
right_arrow_pressed: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
return_: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
return_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b's\xe2\x81\x9b') # 0x73e2819b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'x\xa2\xb4\xb0') # 0x78a2b4b0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hidden_name))
data.write(b'1L\xdc$') # 0x314cdc24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_arrow))
data.write(b'\xb4Q\x0e\xfe') # 0xb4510efe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_arrow_pressed))
data.write(b'\xd1\x91\x83G') # 0xd1918347
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_arrow))
data.write(b'T\xcd\x18t') # 0x54cd1874
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_arrow_pressed))
data.write(b'G\x1f\xea\x86') # 0x471fea86
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.return_))
data.write(b'\xa0\x1e\x08\x87') # 0xa01e0887
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.return_core))
@classmethod
def from_json(cls, data: dict):
return cls(
gui_frame=data['gui_frame'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
title=data['title'],
hidden_name=data['hidden_name'],
left_arrow=data['left_arrow'],
left_arrow_pressed=data['left_arrow_pressed'],
right_arrow=data['right_arrow'],
right_arrow_pressed=data['right_arrow_pressed'],
return_=data['return_'],
return_core=data['return_core'],
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'title': self.title,
'hidden_name': self.hidden_name,
'left_arrow': self.left_arrow,
'left_arrow_pressed': self.left_arrow_pressed,
'right_arrow': self.right_arrow,
'right_arrow_pressed': self.right_arrow_pressed,
'return_': self.return_,
'return_core': self.return_core,
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_hidden_name(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_arrow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_arrow_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_arrow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_arrow_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_return_(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_return_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xa4f20c17: ('title', _decode_title),
0x78a2b4b0: ('hidden_name', _decode_hidden_name),
0x314cdc24: ('left_arrow', _decode_left_arrow),
0xb4510efe: ('left_arrow_pressed', _decode_left_arrow_pressed),
0xd1918347: ('right_arrow', _decode_right_arrow),
0x54cd1874: ('right_arrow_pressed', _decode_right_arrow_pressed),
0x471fea86: ('return_', _decode_return_),
0xa01e0887: ('return_core', _decode_return_core),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct180.py | 0.630799 | 0.16807 | UnknownStruct180.py | 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.dkc_returns.archetypes.LayerToggle import LayerToggle
@dataclasses.dataclass()
class UnknownStruct24(BaseProperty):
num_layers: int = dataclasses.field(default=0)
layer_switch_0x5a8b108c: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0xc12e5ce3: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0xb6b08e13: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0x2d15c27c: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0x598d2bf3: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0xc228679c: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0xb5b6b56c: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0x2e13f903: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0x5c876672: LayerToggle = dataclasses.field(default_factory=LayerToggle)
layer_switch_0xc7222a1d: LayerToggle = dataclasses.field(default_factory=LayerToggle)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\xe2\xb2\xc8V') # 0xe2b2c856
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_layers))
data.write(b'Z\x8b\x10\x8c') # 0x5a8b108c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0x5a8b108c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc1.\\\xe3') # 0xc12e5ce3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0xc12e5ce3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6\xb0\x8e\x13') # 0xb6b08e13
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0xb6b08e13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-\x15\xc2|') # 0x2d15c27c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0x2d15c27c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\x8d+\xf3') # 0x598d2bf3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0x598d2bf3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2(g\x9c') # 0xc228679c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0xc228679c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb5\xb6\xb5l') # 0xb5b6b56c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0xb5b6b56c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'.\x13\xf9\x03') # 0x2e13f903
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0x2e13f903.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\x87fr') # 0x5c876672
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0x5c876672.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7"*\x1d') # 0xc7222a1d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_switch_0xc7222a1d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
num_layers=data['num_layers'],
layer_switch_0x5a8b108c=LayerToggle.from_json(data['layer_switch_0x5a8b108c']),
layer_switch_0xc12e5ce3=LayerToggle.from_json(data['layer_switch_0xc12e5ce3']),
layer_switch_0xb6b08e13=LayerToggle.from_json(data['layer_switch_0xb6b08e13']),
layer_switch_0x2d15c27c=LayerToggle.from_json(data['layer_switch_0x2d15c27c']),
layer_switch_0x598d2bf3=LayerToggle.from_json(data['layer_switch_0x598d2bf3']),
layer_switch_0xc228679c=LayerToggle.from_json(data['layer_switch_0xc228679c']),
layer_switch_0xb5b6b56c=LayerToggle.from_json(data['layer_switch_0xb5b6b56c']),
layer_switch_0x2e13f903=LayerToggle.from_json(data['layer_switch_0x2e13f903']),
layer_switch_0x5c876672=LayerToggle.from_json(data['layer_switch_0x5c876672']),
layer_switch_0xc7222a1d=LayerToggle.from_json(data['layer_switch_0xc7222a1d']),
)
def to_json(self) -> dict:
return {
'num_layers': self.num_layers,
'layer_switch_0x5a8b108c': self.layer_switch_0x5a8b108c.to_json(),
'layer_switch_0xc12e5ce3': self.layer_switch_0xc12e5ce3.to_json(),
'layer_switch_0xb6b08e13': self.layer_switch_0xb6b08e13.to_json(),
'layer_switch_0x2d15c27c': self.layer_switch_0x2d15c27c.to_json(),
'layer_switch_0x598d2bf3': self.layer_switch_0x598d2bf3.to_json(),
'layer_switch_0xc228679c': self.layer_switch_0xc228679c.to_json(),
'layer_switch_0xb5b6b56c': self.layer_switch_0xb5b6b56c.to_json(),
'layer_switch_0x2e13f903': self.layer_switch_0x2e13f903.to_json(),
'layer_switch_0x5c876672': self.layer_switch_0x5c876672.to_json(),
'layer_switch_0xc7222a1d': self.layer_switch_0xc7222a1d.to_json(),
}
def _decode_num_layers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_layer_switch_0x5a8b108c(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0xc12e5ce3(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0xb6b08e13(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0x2d15c27c(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0x598d2bf3(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0xc228679c(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0xb5b6b56c(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0x2e13f903(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0x5c876672(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
def _decode_layer_switch_0xc7222a1d(data: typing.BinaryIO, property_size: int):
return LayerToggle.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe2b2c856: ('num_layers', _decode_num_layers),
0x5a8b108c: ('layer_switch_0x5a8b108c', _decode_layer_switch_0x5a8b108c),
0xc12e5ce3: ('layer_switch_0xc12e5ce3', _decode_layer_switch_0xc12e5ce3),
0xb6b08e13: ('layer_switch_0xb6b08e13', _decode_layer_switch_0xb6b08e13),
0x2d15c27c: ('layer_switch_0x2d15c27c', _decode_layer_switch_0x2d15c27c),
0x598d2bf3: ('layer_switch_0x598d2bf3', _decode_layer_switch_0x598d2bf3),
0xc228679c: ('layer_switch_0xc228679c', _decode_layer_switch_0xc228679c),
0xb5b6b56c: ('layer_switch_0xb5b6b56c', _decode_layer_switch_0xb5b6b56c),
0x2e13f903: ('layer_switch_0x2e13f903', _decode_layer_switch_0x2e13f903),
0x5c876672: ('layer_switch_0x5c876672', _decode_layer_switch_0x5c876672),
0xc7222a1d: ('layer_switch_0xc7222a1d', _decode_layer_switch_0xc7222a1d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct24.py | 0.519278 | 0.314958 | UnknownStruct24.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.TrainTrackManagerStructB import TrainTrackManagerStructB
@dataclasses.dataclass()
class UnknownStruct275(BaseProperty):
unknown: int = dataclasses.field(default=0)
train_track_manager_struct_b_0xfc8fbdb7: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x2f14a14c: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x619daae5: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x53539efb: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x1dda9552: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xce4189a9: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x80c88200: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xabdde195: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xe554ea3c: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x61e5d2a4: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x2f6cd90d: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xfcf7c5f6: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xb27ece5f: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x80b0fa41: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xce39f1e8: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x1da2ed13: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x532be6ba: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x783e852f: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x36b78e86: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x4b59622c: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x05d06985: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xd64b757e: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x98c27ed7: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xaa0c4ac9: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xe4854160: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x371e5d9b: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x79975632: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x528235a7: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x1c0b3e0e: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xe41df06b: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0xaa94fbc2: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
train_track_manager_struct_b_0x790fe739: TrainTrackManagerStructB = dataclasses.field(default_factory=TrainTrackManagerStructB)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00!') # 33 properties
data.write(b'\x979^\xea') # 0x97395eea
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\xfc\x8f\xbd\xb7') # 0xfc8fbdb7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xfc8fbdb7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/\x14\xa1L') # 0x2f14a14c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x2f14a14c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\x9d\xaa\xe5') # 0x619daae5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x619daae5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'SS\x9e\xfb') # 0x53539efb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x53539efb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\xda\x95R') # 0x1dda9552
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x1dda9552.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xceA\x89\xa9') # 0xce4189a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xce4189a9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x80\xc8\x82\x00') # 0x80c88200
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x80c88200.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xab\xdd\xe1\x95') # 0xabdde195
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xabdde195.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe5T\xea<') # 0xe554ea3c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xe554ea3c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\xe5\xd2\xa4') # 0x61e5d2a4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x61e5d2a4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/l\xd9\r') # 0x2f6cd90d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x2f6cd90d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\xf7\xc5\xf6') # 0xfcf7c5f6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xfcf7c5f6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2~\xce_') # 0xb27ece5f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xb27ece5f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x80\xb0\xfaA') # 0x80b0fa41
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x80b0fa41.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xce9\xf1\xe8') # 0xce39f1e8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xce39f1e8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\xa2\xed\x13') # 0x1da2ed13
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x1da2ed13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S+\xe6\xba') # 0x532be6ba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x532be6ba.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x>\x85/') # 0x783e852f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x783e852f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xb7\x8e\x86') # 0x36b78e86
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x36b78e86.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'KYb,') # 0x4b59622c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x4b59622c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05\xd0i\x85') # 0x5d06985
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x05d06985.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd6Ku~') # 0xd64b757e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xd64b757e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x98\xc2~\xd7') # 0x98c27ed7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x98c27ed7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\x0cJ\xc9') # 0xaa0c4ac9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xaa0c4ac9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4\x85A`') # 0xe4854160
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xe4854160.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7\x1e]\x9b') # 0x371e5d9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x371e5d9b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'y\x97V2') # 0x79975632
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x79975632.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'R\x825\xa7') # 0x528235a7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x528235a7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\x0b>\x0e') # 0x1c0b3e0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x1c0b3e0e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4\x1d\xf0k') # 0xe41df06b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xe41df06b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\x94\xfb\xc2') # 0xaa94fbc2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0xaa94fbc2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'y\x0f\xe79') # 0x790fe739
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.train_track_manager_struct_b_0x790fe739.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
train_track_manager_struct_b_0xfc8fbdb7=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xfc8fbdb7']),
train_track_manager_struct_b_0x2f14a14c=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x2f14a14c']),
train_track_manager_struct_b_0x619daae5=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x619daae5']),
train_track_manager_struct_b_0x53539efb=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x53539efb']),
train_track_manager_struct_b_0x1dda9552=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x1dda9552']),
train_track_manager_struct_b_0xce4189a9=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xce4189a9']),
train_track_manager_struct_b_0x80c88200=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x80c88200']),
train_track_manager_struct_b_0xabdde195=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xabdde195']),
train_track_manager_struct_b_0xe554ea3c=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xe554ea3c']),
train_track_manager_struct_b_0x61e5d2a4=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x61e5d2a4']),
train_track_manager_struct_b_0x2f6cd90d=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x2f6cd90d']),
train_track_manager_struct_b_0xfcf7c5f6=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xfcf7c5f6']),
train_track_manager_struct_b_0xb27ece5f=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xb27ece5f']),
train_track_manager_struct_b_0x80b0fa41=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x80b0fa41']),
train_track_manager_struct_b_0xce39f1e8=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xce39f1e8']),
train_track_manager_struct_b_0x1da2ed13=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x1da2ed13']),
train_track_manager_struct_b_0x532be6ba=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x532be6ba']),
train_track_manager_struct_b_0x783e852f=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x783e852f']),
train_track_manager_struct_b_0x36b78e86=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x36b78e86']),
train_track_manager_struct_b_0x4b59622c=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x4b59622c']),
train_track_manager_struct_b_0x05d06985=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x05d06985']),
train_track_manager_struct_b_0xd64b757e=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xd64b757e']),
train_track_manager_struct_b_0x98c27ed7=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x98c27ed7']),
train_track_manager_struct_b_0xaa0c4ac9=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xaa0c4ac9']),
train_track_manager_struct_b_0xe4854160=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xe4854160']),
train_track_manager_struct_b_0x371e5d9b=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x371e5d9b']),
train_track_manager_struct_b_0x79975632=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x79975632']),
train_track_manager_struct_b_0x528235a7=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x528235a7']),
train_track_manager_struct_b_0x1c0b3e0e=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x1c0b3e0e']),
train_track_manager_struct_b_0xe41df06b=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xe41df06b']),
train_track_manager_struct_b_0xaa94fbc2=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0xaa94fbc2']),
train_track_manager_struct_b_0x790fe739=TrainTrackManagerStructB.from_json(data['train_track_manager_struct_b_0x790fe739']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'train_track_manager_struct_b_0xfc8fbdb7': self.train_track_manager_struct_b_0xfc8fbdb7.to_json(),
'train_track_manager_struct_b_0x2f14a14c': self.train_track_manager_struct_b_0x2f14a14c.to_json(),
'train_track_manager_struct_b_0x619daae5': self.train_track_manager_struct_b_0x619daae5.to_json(),
'train_track_manager_struct_b_0x53539efb': self.train_track_manager_struct_b_0x53539efb.to_json(),
'train_track_manager_struct_b_0x1dda9552': self.train_track_manager_struct_b_0x1dda9552.to_json(),
'train_track_manager_struct_b_0xce4189a9': self.train_track_manager_struct_b_0xce4189a9.to_json(),
'train_track_manager_struct_b_0x80c88200': self.train_track_manager_struct_b_0x80c88200.to_json(),
'train_track_manager_struct_b_0xabdde195': self.train_track_manager_struct_b_0xabdde195.to_json(),
'train_track_manager_struct_b_0xe554ea3c': self.train_track_manager_struct_b_0xe554ea3c.to_json(),
'train_track_manager_struct_b_0x61e5d2a4': self.train_track_manager_struct_b_0x61e5d2a4.to_json(),
'train_track_manager_struct_b_0x2f6cd90d': self.train_track_manager_struct_b_0x2f6cd90d.to_json(),
'train_track_manager_struct_b_0xfcf7c5f6': self.train_track_manager_struct_b_0xfcf7c5f6.to_json(),
'train_track_manager_struct_b_0xb27ece5f': self.train_track_manager_struct_b_0xb27ece5f.to_json(),
'train_track_manager_struct_b_0x80b0fa41': self.train_track_manager_struct_b_0x80b0fa41.to_json(),
'train_track_manager_struct_b_0xce39f1e8': self.train_track_manager_struct_b_0xce39f1e8.to_json(),
'train_track_manager_struct_b_0x1da2ed13': self.train_track_manager_struct_b_0x1da2ed13.to_json(),
'train_track_manager_struct_b_0x532be6ba': self.train_track_manager_struct_b_0x532be6ba.to_json(),
'train_track_manager_struct_b_0x783e852f': self.train_track_manager_struct_b_0x783e852f.to_json(),
'train_track_manager_struct_b_0x36b78e86': self.train_track_manager_struct_b_0x36b78e86.to_json(),
'train_track_manager_struct_b_0x4b59622c': self.train_track_manager_struct_b_0x4b59622c.to_json(),
'train_track_manager_struct_b_0x05d06985': self.train_track_manager_struct_b_0x05d06985.to_json(),
'train_track_manager_struct_b_0xd64b757e': self.train_track_manager_struct_b_0xd64b757e.to_json(),
'train_track_manager_struct_b_0x98c27ed7': self.train_track_manager_struct_b_0x98c27ed7.to_json(),
'train_track_manager_struct_b_0xaa0c4ac9': self.train_track_manager_struct_b_0xaa0c4ac9.to_json(),
'train_track_manager_struct_b_0xe4854160': self.train_track_manager_struct_b_0xe4854160.to_json(),
'train_track_manager_struct_b_0x371e5d9b': self.train_track_manager_struct_b_0x371e5d9b.to_json(),
'train_track_manager_struct_b_0x79975632': self.train_track_manager_struct_b_0x79975632.to_json(),
'train_track_manager_struct_b_0x528235a7': self.train_track_manager_struct_b_0x528235a7.to_json(),
'train_track_manager_struct_b_0x1c0b3e0e': self.train_track_manager_struct_b_0x1c0b3e0e.to_json(),
'train_track_manager_struct_b_0xe41df06b': self.train_track_manager_struct_b_0xe41df06b.to_json(),
'train_track_manager_struct_b_0xaa94fbc2': self.train_track_manager_struct_b_0xaa94fbc2.to_json(),
'train_track_manager_struct_b_0x790fe739': self.train_track_manager_struct_b_0x790fe739.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_train_track_manager_struct_b_0xfc8fbdb7(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x2f14a14c(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x619daae5(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x53539efb(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x1dda9552(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xce4189a9(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x80c88200(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xabdde195(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xe554ea3c(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x61e5d2a4(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x2f6cd90d(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xfcf7c5f6(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xb27ece5f(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x80b0fa41(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xce39f1e8(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x1da2ed13(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x532be6ba(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x783e852f(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x36b78e86(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x4b59622c(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x05d06985(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xd64b757e(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x98c27ed7(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xaa0c4ac9(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xe4854160(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x371e5d9b(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x79975632(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x528235a7(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x1c0b3e0e(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xe41df06b(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0xaa94fbc2(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
def _decode_train_track_manager_struct_b_0x790fe739(data: typing.BinaryIO, property_size: int):
return TrainTrackManagerStructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x97395eea: ('unknown', _decode_unknown),
0xfc8fbdb7: ('train_track_manager_struct_b_0xfc8fbdb7', _decode_train_track_manager_struct_b_0xfc8fbdb7),
0x2f14a14c: ('train_track_manager_struct_b_0x2f14a14c', _decode_train_track_manager_struct_b_0x2f14a14c),
0x619daae5: ('train_track_manager_struct_b_0x619daae5', _decode_train_track_manager_struct_b_0x619daae5),
0x53539efb: ('train_track_manager_struct_b_0x53539efb', _decode_train_track_manager_struct_b_0x53539efb),
0x1dda9552: ('train_track_manager_struct_b_0x1dda9552', _decode_train_track_manager_struct_b_0x1dda9552),
0xce4189a9: ('train_track_manager_struct_b_0xce4189a9', _decode_train_track_manager_struct_b_0xce4189a9),
0x80c88200: ('train_track_manager_struct_b_0x80c88200', _decode_train_track_manager_struct_b_0x80c88200),
0xabdde195: ('train_track_manager_struct_b_0xabdde195', _decode_train_track_manager_struct_b_0xabdde195),
0xe554ea3c: ('train_track_manager_struct_b_0xe554ea3c', _decode_train_track_manager_struct_b_0xe554ea3c),
0x61e5d2a4: ('train_track_manager_struct_b_0x61e5d2a4', _decode_train_track_manager_struct_b_0x61e5d2a4),
0x2f6cd90d: ('train_track_manager_struct_b_0x2f6cd90d', _decode_train_track_manager_struct_b_0x2f6cd90d),
0xfcf7c5f6: ('train_track_manager_struct_b_0xfcf7c5f6', _decode_train_track_manager_struct_b_0xfcf7c5f6),
0xb27ece5f: ('train_track_manager_struct_b_0xb27ece5f', _decode_train_track_manager_struct_b_0xb27ece5f),
0x80b0fa41: ('train_track_manager_struct_b_0x80b0fa41', _decode_train_track_manager_struct_b_0x80b0fa41),
0xce39f1e8: ('train_track_manager_struct_b_0xce39f1e8', _decode_train_track_manager_struct_b_0xce39f1e8),
0x1da2ed13: ('train_track_manager_struct_b_0x1da2ed13', _decode_train_track_manager_struct_b_0x1da2ed13),
0x532be6ba: ('train_track_manager_struct_b_0x532be6ba', _decode_train_track_manager_struct_b_0x532be6ba),
0x783e852f: ('train_track_manager_struct_b_0x783e852f', _decode_train_track_manager_struct_b_0x783e852f),
0x36b78e86: ('train_track_manager_struct_b_0x36b78e86', _decode_train_track_manager_struct_b_0x36b78e86),
0x4b59622c: ('train_track_manager_struct_b_0x4b59622c', _decode_train_track_manager_struct_b_0x4b59622c),
0x5d06985: ('train_track_manager_struct_b_0x05d06985', _decode_train_track_manager_struct_b_0x05d06985),
0xd64b757e: ('train_track_manager_struct_b_0xd64b757e', _decode_train_track_manager_struct_b_0xd64b757e),
0x98c27ed7: ('train_track_manager_struct_b_0x98c27ed7', _decode_train_track_manager_struct_b_0x98c27ed7),
0xaa0c4ac9: ('train_track_manager_struct_b_0xaa0c4ac9', _decode_train_track_manager_struct_b_0xaa0c4ac9),
0xe4854160: ('train_track_manager_struct_b_0xe4854160', _decode_train_track_manager_struct_b_0xe4854160),
0x371e5d9b: ('train_track_manager_struct_b_0x371e5d9b', _decode_train_track_manager_struct_b_0x371e5d9b),
0x79975632: ('train_track_manager_struct_b_0x79975632', _decode_train_track_manager_struct_b_0x79975632),
0x528235a7: ('train_track_manager_struct_b_0x528235a7', _decode_train_track_manager_struct_b_0x528235a7),
0x1c0b3e0e: ('train_track_manager_struct_b_0x1c0b3e0e', _decode_train_track_manager_struct_b_0x1c0b3e0e),
0xe41df06b: ('train_track_manager_struct_b_0xe41df06b', _decode_train_track_manager_struct_b_0xe41df06b),
0xaa94fbc2: ('train_track_manager_struct_b_0xaa94fbc2', _decode_train_track_manager_struct_b_0xaa94fbc2),
0x790fe739: ('train_track_manager_struct_b_0x790fe739', _decode_train_track_manager_struct_b_0x790fe739),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct275.py | 0.584983 | 0.187988 | UnknownStruct275.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class StunnedByGroundPoundBehaviorData(BaseProperty):
ground_pound_distance_vertical_multiplier: float = dataclasses.field(default=0.5)
stun_duration: float = dataclasses.field(default=3.0)
can_un_stun: bool = dataclasses.field(default=False)
minimum_stunned_time: float = dataclasses.field(default=0.33000001311302185)
re_stun_delay: float = dataclasses.field(default=0.0)
apply_boost_after_un_stun: bool = dataclasses.field(default=False)
apply_boost_after_stun: bool = dataclasses.field(default=False)
boost_duration: float = dataclasses.field(default=5.0)
boost_speed_modifier: float = dataclasses.field(default=1.0)
stun_only_when_on_ground: bool = dataclasses.field(default=False)
knockback_instead_of_stun: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'b\xf0\xcf\xfc') # 0x62f0cffc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_distance_vertical_multiplier))
data.write(b'-\x8d\xb3\x1d') # 0x2d8db31d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_duration))
data.write(b'@\xa3r\xb6') # 0x40a372b6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_un_stun))
data.write(b'\x1a\xc8\x13\xb9') # 0x1ac813b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_stunned_time))
data.write(b'\xba\xe2u^') # 0xbae2755e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.re_stun_delay))
data.write(b'\x0cC\x13D') # 0xc431344
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_boost_after_un_stun))
data.write(b'\x19wy\xd1') # 0x197779d1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_boost_after_stun))
data.write(b'\xbaIr\xfe') # 0xba4972fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_duration))
data.write(b'\x85\xd3\x9c\xb7') # 0x85d39cb7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_speed_modifier))
data.write(b'8q\x13%') # 0x38711325
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stun_only_when_on_ground))
data.write(b'\xe3\x8ar=') # 0xe38a723d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.knockback_instead_of_stun))
@classmethod
def from_json(cls, data: dict):
return cls(
ground_pound_distance_vertical_multiplier=data['ground_pound_distance_vertical_multiplier'],
stun_duration=data['stun_duration'],
can_un_stun=data['can_un_stun'],
minimum_stunned_time=data['minimum_stunned_time'],
re_stun_delay=data['re_stun_delay'],
apply_boost_after_un_stun=data['apply_boost_after_un_stun'],
apply_boost_after_stun=data['apply_boost_after_stun'],
boost_duration=data['boost_duration'],
boost_speed_modifier=data['boost_speed_modifier'],
stun_only_when_on_ground=data['stun_only_when_on_ground'],
knockback_instead_of_stun=data['knockback_instead_of_stun'],
)
def to_json(self) -> dict:
return {
'ground_pound_distance_vertical_multiplier': self.ground_pound_distance_vertical_multiplier,
'stun_duration': self.stun_duration,
'can_un_stun': self.can_un_stun,
'minimum_stunned_time': self.minimum_stunned_time,
're_stun_delay': self.re_stun_delay,
'apply_boost_after_un_stun': self.apply_boost_after_un_stun,
'apply_boost_after_stun': self.apply_boost_after_stun,
'boost_duration': self.boost_duration,
'boost_speed_modifier': self.boost_speed_modifier,
'stun_only_when_on_ground': self.stun_only_when_on_ground,
'knockback_instead_of_stun': self.knockback_instead_of_stun,
}
_FAST_FORMAT = None
_FAST_IDS = (0x62f0cffc, 0x2d8db31d, 0x40a372b6, 0x1ac813b9, 0xbae2755e, 0xc431344, 0x197779d1, 0xba4972fe, 0x85d39cb7, 0x38711325, 0xe38a723d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[StunnedByGroundPoundBehaviorData]:
if property_count != 11:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLH?LHfLHfLH?LH?LHfLHfLH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(95))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30]) != _FAST_IDS:
data.seek(before)
return None
return StunnedByGroundPoundBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
)
def _decode_ground_pound_distance_vertical_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_can_un_stun(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_stunned_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_re_stun_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_apply_boost_after_un_stun(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_apply_boost_after_stun(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_boost_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_speed_modifier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_only_when_on_ground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_knockback_instead_of_stun(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]]] = {
0x62f0cffc: ('ground_pound_distance_vertical_multiplier', _decode_ground_pound_distance_vertical_multiplier),
0x2d8db31d: ('stun_duration', _decode_stun_duration),
0x40a372b6: ('can_un_stun', _decode_can_un_stun),
0x1ac813b9: ('minimum_stunned_time', _decode_minimum_stunned_time),
0xbae2755e: ('re_stun_delay', _decode_re_stun_delay),
0xc431344: ('apply_boost_after_un_stun', _decode_apply_boost_after_un_stun),
0x197779d1: ('apply_boost_after_stun', _decode_apply_boost_after_stun),
0xba4972fe: ('boost_duration', _decode_boost_duration),
0x85d39cb7: ('boost_speed_modifier', _decode_boost_speed_modifier),
0x38711325: ('stun_only_when_on_ground', _decode_stun_only_when_on_ground),
0xe38a723d: ('knockback_instead_of_stun', _decode_knockback_instead_of_stun),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/StunnedByGroundPoundBehaviorData.py | 0.592313 | 0.246874 | StunnedByGroundPoundBehaviorData.py | 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.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct31(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
music: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
sound_fx: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_arrow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
right_arrow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_arrow_pressed: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
right_arrow_pressed: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
appear_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
disappear_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
in_place_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
up_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
down_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
cancel_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
inc_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
dec_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
error_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x14') # 20 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'\xbb\x19\xd2\xf3') # 0xbb19d2f3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.music))
data.write(b'\xdf\x08\x0e\xa1') # 0xdf080ea1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_fx))
data.write(b'1L\xdc$') # 0x314cdc24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_arrow))
data.write(b'\xd1\x91\x83G') # 0xd1918347
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_arrow))
data.write(b'\xb4Q\x0e\xfe') # 0xb4510efe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_arrow_pressed))
data.write(b'T\xcd\x18t') # 0x54cd1874
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_arrow_pressed))
data.write(b'\xc0,#O') # 0xc02c234f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.appear_sound))
data.write(b'm&~\x88') # 0x6d267e88
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.disappear_sound))
data.write(b'/\x90\xd2W') # 0x2f90d257
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.in_place_sound))
data.write(b'g\xf8}\x00') # 0x67f87d00
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.up_sound))
data.write(b'\xb4\x8a\x1f\x83') # 0xb48a1f83
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.down_sound))
data.write(b'H_ \x08') # 0x485f2008
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cancel_sound))
data.write(b'{\xeeVn') # 0x7bee566e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.inc_sound))
data.write(b'MP\x92\x1e') # 0x4d50921e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dec_sound))
data.write(b'EY\xa4\xfd') # 0x4559a4fd
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.error_sound))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title=data['title'],
back=data['back'],
back_core=data['back_core'],
music=data['music'],
sound_fx=data['sound_fx'],
left_arrow=data['left_arrow'],
right_arrow=data['right_arrow'],
left_arrow_pressed=data['left_arrow_pressed'],
right_arrow_pressed=data['right_arrow_pressed'],
appear_sound=data['appear_sound'],
disappear_sound=data['disappear_sound'],
in_place_sound=data['in_place_sound'],
up_sound=data['up_sound'],
down_sound=data['down_sound'],
cancel_sound=data['cancel_sound'],
inc_sound=data['inc_sound'],
dec_sound=data['dec_sound'],
error_sound=data['error_sound'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title': self.title,
'back': self.back,
'back_core': self.back_core,
'music': self.music,
'sound_fx': self.sound_fx,
'left_arrow': self.left_arrow,
'right_arrow': self.right_arrow,
'left_arrow_pressed': self.left_arrow_pressed,
'right_arrow_pressed': self.right_arrow_pressed,
'appear_sound': self.appear_sound,
'disappear_sound': self.disappear_sound,
'in_place_sound': self.in_place_sound,
'up_sound': self.up_sound,
'down_sound': self.down_sound,
'cancel_sound': self.cancel_sound,
'inc_sound': self.inc_sound,
'dec_sound': self.dec_sound,
'error_sound': self.error_sound,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_music(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound_fx(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_arrow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_arrow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_arrow_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_arrow_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_appear_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_disappear_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_in_place_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_up_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_down_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cancel_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_inc_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dec_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_error_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0xa4f20c17: ('title', _decode_title),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0xbb19d2f3: ('music', _decode_music),
0xdf080ea1: ('sound_fx', _decode_sound_fx),
0x314cdc24: ('left_arrow', _decode_left_arrow),
0xd1918347: ('right_arrow', _decode_right_arrow),
0xb4510efe: ('left_arrow_pressed', _decode_left_arrow_pressed),
0x54cd1874: ('right_arrow_pressed', _decode_right_arrow_pressed),
0xc02c234f: ('appear_sound', _decode_appear_sound),
0x6d267e88: ('disappear_sound', _decode_disappear_sound),
0x2f90d257: ('in_place_sound', _decode_in_place_sound),
0x67f87d00: ('up_sound', _decode_up_sound),
0xb48a1f83: ('down_sound', _decode_down_sound),
0x485f2008: ('cancel_sound', _decode_cancel_sound),
0x7bee566e: ('inc_sound', _decode_inc_sound),
0x4d50921e: ('dec_sound', _decode_dec_sound),
0x4559a4fd: ('error_sound', _decode_error_sound),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct31.py | 0.555797 | 0.154058 | UnknownStruct31.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class UnknownStruct246(BaseProperty):
priority: enums.Priority = dataclasses.field(default=enums.Priority.Unknown6)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x0b\xe7\xca\x9e') # 0xbe7ca9e
data.write(b'\x00\x04') # size
self.priority.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
priority=enums.Priority.from_json(data['priority']),
)
def to_json(self) -> dict:
return {
'priority': self.priority.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0xbe7ca9e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct246]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct246(
enums.Priority(dec[2]),
)
def _decode_priority(data: typing.BinaryIO, property_size: int):
return enums.Priority.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbe7ca9e: ('priority', _decode_priority),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct246.py | 0.689096 | 0.282724 | UnknownStruct246.py | 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.dkc_returns.archetypes.InterpolationMethod import InterpolationMethod
from retro_data_structures.properties.dkc_returns.archetypes.NonSlowdown import NonSlowdown
@dataclasses.dataclass()
class MotionInterpolationMethod(BaseProperty):
motion_type: int = dataclasses.field(default=1102650983) # Choice
non_slowdown: NonSlowdown = dataclasses.field(default_factory=NonSlowdown)
motion_control: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x94\x8a\xf5q') # 0x948af571
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.motion_type))
data.write(b'y\xdeK\xa5') # 0x79de4ba5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.non_slowdown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x7f\x9fE') # 0x287f9f45
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
motion_type=data['motion_type'],
non_slowdown=NonSlowdown.from_json(data['non_slowdown']),
motion_control=InterpolationMethod.from_json(data['motion_control']),
)
def to_json(self) -> dict:
return {
'motion_type': self.motion_type,
'non_slowdown': self.non_slowdown.to_json(),
'motion_control': self.motion_control.to_json(),
}
def _decode_motion_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_non_slowdown(data: typing.BinaryIO, property_size: int):
return NonSlowdown.from_stream(data, property_size)
def _decode_motion_control(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x948af571: ('motion_type', _decode_motion_type),
0x79de4ba5: ('non_slowdown', _decode_non_slowdown),
0x287f9f45: ('motion_control', _decode_motion_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MotionInterpolationMethod.py | 0.639736 | 0.264875 | MotionInterpolationMethod.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.TouchAttackDirectionEnum import TouchAttackDirectionEnum
@dataclasses.dataclass()
class TouchAttackBehaviorData(BaseProperty):
contact_top: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
contact_bottom: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
contact_front: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
contact_back: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xff\n\x98\xa3') # 0xff0a98a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_top.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\nb\xc6P') # 0xa62c650
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_bottom.to_stream(data, default_override={'attack_direction': enums.AttackDirection.Unknown2})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95NP\xd4') # 0x954e50d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_front.to_stream(data, default_override={'attack_direction': enums.AttackDirection.Unknown5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'"\x9dy\xfe') # 0x229d79fe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_back.to_stream(data, default_override={'attack_direction': enums.AttackDirection.Unknown6})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
contact_top=TouchAttackDirectionEnum.from_json(data['contact_top']),
contact_bottom=TouchAttackDirectionEnum.from_json(data['contact_bottom']),
contact_front=TouchAttackDirectionEnum.from_json(data['contact_front']),
contact_back=TouchAttackDirectionEnum.from_json(data['contact_back']),
)
def to_json(self) -> dict:
return {
'contact_top': self.contact_top.to_json(),
'contact_bottom': self.contact_bottom.to_json(),
'contact_front': self.contact_front.to_json(),
'contact_back': self.contact_back.to_json(),
}
def _decode_contact_top(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size)
def _decode_contact_bottom(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size, default_override={'attack_direction': enums.AttackDirection.Unknown2})
def _decode_contact_front(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size, default_override={'attack_direction': enums.AttackDirection.Unknown5})
def _decode_contact_back(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size, default_override={'attack_direction': enums.AttackDirection.Unknown6})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xff0a98a3: ('contact_top', _decode_contact_top),
0xa62c650: ('contact_bottom', _decode_contact_bottom),
0x954e50d4: ('contact_front', _decode_contact_front),
0x229d79fe: ('contact_back', _decode_contact_back),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TouchAttackBehaviorData.py | 0.631026 | 0.248728 | TouchAttackBehaviorData.py | 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.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct297(BaseProperty):
lift_velocity: float = dataclasses.field(default=15.0)
horizontal_acceleration: float = dataclasses.field(default=35.0)
horizontal_deceleration: float = dataclasses.field(default=3.0)
max_horizontal_velocity: float = dataclasses.field(default=12.5)
boost_acceleration: float = dataclasses.field(default=20.0)
max_boost_speed: float = dataclasses.field(default=15.0)
boost_deceleration: float = dataclasses.field(default=20.0)
max_boost_deceleration_speed: float = dataclasses.field(default=-9.0)
initial_disable_controls_time: float = dataclasses.field(default=0.800000011920929)
bounce_disable_controls_time: float = dataclasses.field(default=0.800000011920929)
horizontal_padding: float = dataclasses.field(default=0.20000000298023224)
bounce_k: float = dataclasses.field(default=0.800000011920929)
screen_top_percentage: float = dataclasses.field(default=10.0)
screen_top_kill_constant: float = dataclasses.field(default=0.949999988079071)
maximum_lean_delta: float = dataclasses.field(default=360.0)
maximum_lean_degrees: float = dataclasses.field(default=30.0)
max_barrel_rotation: float = dataclasses.field(default=35.0)
anim_input_rate: float = dataclasses.field(default=4.0)
boost_anim_threshold: float = dataclasses.field(default=10.0)
boost_into_acceleration: float = dataclasses.field(default=4.0)
boost_out_of_acceleration: float = dataclasses.field(default=4.0)
exhaust_effect_scalar: float = dataclasses.field(default=1.0)
engine_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
engine_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
engine_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
engine_sound_volume: Spline = dataclasses.field(default_factory=Spline)
engine_sound2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
engine_sound2_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
engine_sound2_pitch: Spline = dataclasses.field(default_factory=Spline)
engine_sound2_volume: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1e') # 30 properties
data.write(b'{\x08\x82\x0f') # 0x7b08820f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lift_velocity))
data.write(b'\x07Vz\x08') # 0x7567a08
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horizontal_acceleration))
data.write(b'\xa0i\xff`') # 0xa069ff60
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horizontal_deceleration))
data.write(b'\xd5k\x05\xf2') # 0xd56b05f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_horizontal_velocity))
data.write(b'\xd9\xdc\xd0\x88') # 0xd9dcd088
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_acceleration))
data.write(b'z\x8bd\xc8') # 0x7a8b64c8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_boost_speed))
data.write(b'~\xe3U\xe0') # 0x7ee355e0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_deceleration))
data.write(b'\x1a\xa3\xa4\x19') # 0x1aa3a419
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_boost_deceleration_speed))
data.write(b'\xae\xf4i\xe8') # 0xaef469e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_disable_controls_time))
data.write(b'G\xdf\xa4\x87') # 0x47dfa487
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_disable_controls_time))
data.write(b'\xbf/\x07\x9b') # 0xbf2f079b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horizontal_padding))
data.write(b'\xf2m\xf1\xd6') # 0xf26df1d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_k))
data.write(b'LVc9') # 0x4c566339
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.screen_top_percentage))
data.write(b'\xce\x95.\x91') # 0xce952e91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.screen_top_kill_constant))
data.write(b'\xa7w6=') # 0xa777363d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_lean_delta))
data.write(b'\xad\rE\xfa') # 0xad0d45fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_lean_degrees))
data.write(b'\xae\xe0\x8et') # 0xaee08e74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_barrel_rotation))
data.write(b'\xe5\xebci') # 0xe5eb6369
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.anim_input_rate))
data.write(b'\xb8\xf2=i') # 0xb8f23d69
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_anim_threshold))
data.write(b'c7\xd1\x94') # 0x6337d194
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_into_acceleration))
data.write(b'\x96#\xe4K') # 0x9623e44b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_out_of_acceleration))
data.write(b'"\xdf\x00\x96') # 0x22df0096
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.exhaust_effect_scalar))
data.write(b'\xd1\x90\x89\x9c') # 0xd190899c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.engine_sound))
data.write(b'\x827T5') # 0x82375435
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8uY;') # 0xb875593b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdeO\x0c/') # 0xde4f0c2f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'uH\xb8\xaa') # 0x7548b8aa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.engine_sound2))
data.write(b'\x10\xd8\xe5E') # 0x10d8e545
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound2_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\x86Hw') # 0xcb864877
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound2_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1V\xf2\x85') # 0xa156f285
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound2_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
lift_velocity=data['lift_velocity'],
horizontal_acceleration=data['horizontal_acceleration'],
horizontal_deceleration=data['horizontal_deceleration'],
max_horizontal_velocity=data['max_horizontal_velocity'],
boost_acceleration=data['boost_acceleration'],
max_boost_speed=data['max_boost_speed'],
boost_deceleration=data['boost_deceleration'],
max_boost_deceleration_speed=data['max_boost_deceleration_speed'],
initial_disable_controls_time=data['initial_disable_controls_time'],
bounce_disable_controls_time=data['bounce_disable_controls_time'],
horizontal_padding=data['horizontal_padding'],
bounce_k=data['bounce_k'],
screen_top_percentage=data['screen_top_percentage'],
screen_top_kill_constant=data['screen_top_kill_constant'],
maximum_lean_delta=data['maximum_lean_delta'],
maximum_lean_degrees=data['maximum_lean_degrees'],
max_barrel_rotation=data['max_barrel_rotation'],
anim_input_rate=data['anim_input_rate'],
boost_anim_threshold=data['boost_anim_threshold'],
boost_into_acceleration=data['boost_into_acceleration'],
boost_out_of_acceleration=data['boost_out_of_acceleration'],
exhaust_effect_scalar=data['exhaust_effect_scalar'],
engine_sound=data['engine_sound'],
engine_sound_low_pass_filter=Spline.from_json(data['engine_sound_low_pass_filter']),
engine_sound_pitch=Spline.from_json(data['engine_sound_pitch']),
engine_sound_volume=Spline.from_json(data['engine_sound_volume']),
engine_sound2=data['engine_sound2'],
engine_sound2_low_pass_filter=Spline.from_json(data['engine_sound2_low_pass_filter']),
engine_sound2_pitch=Spline.from_json(data['engine_sound2_pitch']),
engine_sound2_volume=Spline.from_json(data['engine_sound2_volume']),
)
def to_json(self) -> dict:
return {
'lift_velocity': self.lift_velocity,
'horizontal_acceleration': self.horizontal_acceleration,
'horizontal_deceleration': self.horizontal_deceleration,
'max_horizontal_velocity': self.max_horizontal_velocity,
'boost_acceleration': self.boost_acceleration,
'max_boost_speed': self.max_boost_speed,
'boost_deceleration': self.boost_deceleration,
'max_boost_deceleration_speed': self.max_boost_deceleration_speed,
'initial_disable_controls_time': self.initial_disable_controls_time,
'bounce_disable_controls_time': self.bounce_disable_controls_time,
'horizontal_padding': self.horizontal_padding,
'bounce_k': self.bounce_k,
'screen_top_percentage': self.screen_top_percentage,
'screen_top_kill_constant': self.screen_top_kill_constant,
'maximum_lean_delta': self.maximum_lean_delta,
'maximum_lean_degrees': self.maximum_lean_degrees,
'max_barrel_rotation': self.max_barrel_rotation,
'anim_input_rate': self.anim_input_rate,
'boost_anim_threshold': self.boost_anim_threshold,
'boost_into_acceleration': self.boost_into_acceleration,
'boost_out_of_acceleration': self.boost_out_of_acceleration,
'exhaust_effect_scalar': self.exhaust_effect_scalar,
'engine_sound': self.engine_sound,
'engine_sound_low_pass_filter': self.engine_sound_low_pass_filter.to_json(),
'engine_sound_pitch': self.engine_sound_pitch.to_json(),
'engine_sound_volume': self.engine_sound_volume.to_json(),
'engine_sound2': self.engine_sound2,
'engine_sound2_low_pass_filter': self.engine_sound2_low_pass_filter.to_json(),
'engine_sound2_pitch': self.engine_sound2_pitch.to_json(),
'engine_sound2_volume': self.engine_sound2_volume.to_json(),
}
def _decode_lift_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horizontal_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horizontal_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_horizontal_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_boost_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_boost_deceleration_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_disable_controls_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_disable_controls_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horizontal_padding(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_k(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_screen_top_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_screen_top_kill_constant(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_lean_delta(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_lean_degrees(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_barrel_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_anim_input_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_anim_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_into_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_out_of_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_exhaust_effect_scalar(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_engine_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_engine_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_engine_sound2_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound2_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound2_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7b08820f: ('lift_velocity', _decode_lift_velocity),
0x7567a08: ('horizontal_acceleration', _decode_horizontal_acceleration),
0xa069ff60: ('horizontal_deceleration', _decode_horizontal_deceleration),
0xd56b05f2: ('max_horizontal_velocity', _decode_max_horizontal_velocity),
0xd9dcd088: ('boost_acceleration', _decode_boost_acceleration),
0x7a8b64c8: ('max_boost_speed', _decode_max_boost_speed),
0x7ee355e0: ('boost_deceleration', _decode_boost_deceleration),
0x1aa3a419: ('max_boost_deceleration_speed', _decode_max_boost_deceleration_speed),
0xaef469e8: ('initial_disable_controls_time', _decode_initial_disable_controls_time),
0x47dfa487: ('bounce_disable_controls_time', _decode_bounce_disable_controls_time),
0xbf2f079b: ('horizontal_padding', _decode_horizontal_padding),
0xf26df1d6: ('bounce_k', _decode_bounce_k),
0x4c566339: ('screen_top_percentage', _decode_screen_top_percentage),
0xce952e91: ('screen_top_kill_constant', _decode_screen_top_kill_constant),
0xa777363d: ('maximum_lean_delta', _decode_maximum_lean_delta),
0xad0d45fa: ('maximum_lean_degrees', _decode_maximum_lean_degrees),
0xaee08e74: ('max_barrel_rotation', _decode_max_barrel_rotation),
0xe5eb6369: ('anim_input_rate', _decode_anim_input_rate),
0xb8f23d69: ('boost_anim_threshold', _decode_boost_anim_threshold),
0x6337d194: ('boost_into_acceleration', _decode_boost_into_acceleration),
0x9623e44b: ('boost_out_of_acceleration', _decode_boost_out_of_acceleration),
0x22df0096: ('exhaust_effect_scalar', _decode_exhaust_effect_scalar),
0xd190899c: ('engine_sound', _decode_engine_sound),
0x82375435: ('engine_sound_low_pass_filter', _decode_engine_sound_low_pass_filter),
0xb875593b: ('engine_sound_pitch', _decode_engine_sound_pitch),
0xde4f0c2f: ('engine_sound_volume', _decode_engine_sound_volume),
0x7548b8aa: ('engine_sound2', _decode_engine_sound2),
0x10d8e545: ('engine_sound2_low_pass_filter', _decode_engine_sound2_low_pass_filter),
0xcb864877: ('engine_sound2_pitch', _decode_engine_sound2_pitch),
0xa156f285: ('engine_sound2_volume', _decode_engine_sound2_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct297.py | 0.636579 | 0.188193 | UnknownStruct297.py | 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.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.PathDeterminationMethodType import PathDeterminationMethodType
@dataclasses.dataclass()
class PathDetermination(BaseProperty):
path_link_type: enums.PathLinkType = dataclasses.field(default=enums.PathLinkType.Unknown3)
path_determination_method_type: PathDeterminationMethodType = dataclasses.field(default_factory=PathDeterminationMethodType)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'U\x95B\xab') # 0x559542ab
data.write(b'\x00\x04') # size
self.path_link_type.to_stream(data)
data.write(b'API\x0c') # 0x4150490c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_determination_method_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
path_link_type=enums.PathLinkType.from_json(data['path_link_type']),
path_determination_method_type=PathDeterminationMethodType.from_json(data['path_determination_method_type']),
)
def to_json(self) -> dict:
return {
'path_link_type': self.path_link_type.to_json(),
'path_determination_method_type': self.path_determination_method_type.to_json(),
}
def _decode_path_link_type(data: typing.BinaryIO, property_size: int):
return enums.PathLinkType.from_stream(data)
def _decode_path_determination_method_type(data: typing.BinaryIO, property_size: int):
return PathDeterminationMethodType.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x559542ab: ('path_link_type', _decode_path_link_type),
0x4150490c: ('path_determination_method_type', _decode_path_determination_method_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PathDetermination.py | 0.61231 | 0.305354 | PathDetermination.py | 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.dkc_returns.archetypes.SpindlePositionInterpolant import SpindlePositionInterpolant
@dataclasses.dataclass()
class UnknownStruct74(BaseProperty):
look_at_position: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'C\xa6\xde\xd6') # 0x43a6ded6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_position.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
look_at_position=SpindlePositionInterpolant.from_json(data['look_at_position']),
)
def to_json(self) -> dict:
return {
'look_at_position': self.look_at_position.to_json(),
}
def _decode_look_at_position(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x43a6ded6: ('look_at_position', _decode_look_at_position),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct74.py | 0.624408 | 0.290078 | UnknownStruct74.py | 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.dkc_returns as enums
@dataclasses.dataclass()
class BeatUpHandlerStruct(BaseProperty):
item: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.Banana)
num_awarded: int = dataclasses.field(default=1)
chance: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xb3\xe3\xe1\xe3') # 0xb3e3e1e3
data.write(b'\x00\x04') # size
self.item.to_stream(data)
data.write(b'\x8f\xa6|\x9e') # 0x8fa67c9e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_awarded))
data.write(b'z{3\x0e') # 0x7a7b330e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chance))
@classmethod
def from_json(cls, data: dict):
return cls(
item=enums.PlayerItem.from_json(data['item']),
num_awarded=data['num_awarded'],
chance=data['chance'],
)
def to_json(self) -> dict:
return {
'item': self.item.to_json(),
'num_awarded': self.num_awarded,
'chance': self.chance,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb3e3e1e3, 0x8fa67c9e, 0x7a7b330e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BeatUpHandlerStruct]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHlLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return BeatUpHandlerStruct(
enums.PlayerItem(dec[2]),
dec[5],
dec[8],
)
def _decode_item(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_num_awarded(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_chance(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]]] = {
0xb3e3e1e3: ('item', _decode_item),
0x8fa67c9e: ('num_awarded', _decode_num_awarded),
0x7a7b330e: ('chance', _decode_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BeatUpHandlerStruct.py | 0.632389 | 0.296311 | BeatUpHandlerStruct.py | 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.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class TranslationSplines(BaseProperty):
x_translation: Spline = dataclasses.field(default_factory=Spline)
y_translation: Spline = dataclasses.field(default_factory=Spline)
z_translation: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'$\xe9\xa0\x9b') # 0x24e9a09b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_translation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\xbb\x16z') # 0xcbbb167a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_translation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!=\xcb\x18') # 0x213dcb18
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_translation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_translation=Spline.from_json(data['x_translation']),
y_translation=Spline.from_json(data['y_translation']),
z_translation=Spline.from_json(data['z_translation']),
)
def to_json(self) -> dict:
return {
'x_translation': self.x_translation.to_json(),
'y_translation': self.y_translation.to_json(),
'z_translation': self.z_translation.to_json(),
}
def _decode_x_translation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_translation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_translation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x24e9a09b: ('x_translation', _decode_x_translation),
0xcbbb167a: ('y_translation', _decode_y_translation),
0x213dcb18: ('z_translation', _decode_z_translation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TranslationSplines.py | 0.651355 | 0.322793 | TranslationSplines.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.