180 lines
6.9 KiB
Python
180 lines
6.9 KiB
Python
import configparser
|
|
from . import guid
|
|
|
|
|
|
class Color:
|
|
def __init__(self, r=0, g=0, b=0, a=0):
|
|
self.r = self.float_to_hex(r) if isinstance(r, float) else r
|
|
self.g = self.float_to_hex(g) if isinstance(g, float) else g
|
|
self.b = self.float_to_hex(b) if isinstance(b, float) else b
|
|
self.a = self.float_to_hex(a) if isinstance(a, float) else a
|
|
|
|
@staticmethod
|
|
def float_to_hex(a: float):
|
|
return ((a - 0.0)/(1.0 - 0.0)) * (255 - 0) + 0.0
|
|
|
|
|
|
class Dino:
|
|
def __init__(self, dino_data=None, parent=False):
|
|
self.parent = parent
|
|
if dino_data is None and parent is False:
|
|
self.dino_data = None
|
|
self.dino_data_orig = None
|
|
self.colors = None
|
|
self.stats = None
|
|
self.ancestry = None
|
|
self.guid = guid.Guid()
|
|
elif parent is False and isinstance(dino_data, configparser.ConfigParser):
|
|
self.dino_data_orig = dino_data
|
|
self.dino_data = self._get_dino_data(dino_data['Dino Data'])
|
|
self.colors = self._get_colors(dino_data['Colorization'])
|
|
self.stats = self._get_colors(dino_data['Max Character Status Values'])
|
|
self.ancestry = self._get_ancestry(dino_data['Dino Ancestry'], dino_data)
|
|
self.guid = self.get_guid()
|
|
elif parent is True and isinstance(dino_data, list):
|
|
self.dino_data = {
|
|
'TamedName': dino_data[0],
|
|
'DinoID1': dino_data[1],
|
|
'DinoID2': dino_data[2]
|
|
}
|
|
self.stats = self._zero_stats()
|
|
self.colors = list()
|
|
self.ancestry = dict()
|
|
self.guid = self.get_guid()
|
|
else:
|
|
raise TypeError('Arguments don\'t match any valid configuration.')
|
|
|
|
def get_guid(self) -> guid.Guid:
|
|
return guid.Guid(self.dino_data['DinoID1'], self.dino_data['DinoID2'])
|
|
|
|
@staticmethod
|
|
def _get_colors(colorization) -> [Color]:
|
|
colors = list()
|
|
for color, values in colorization.items():
|
|
value = values.strip('()').split(',')
|
|
c = dict()
|
|
for v in value:
|
|
v = v.split('=')
|
|
c[v[0]] = float(v[1])
|
|
colors.append(Color(**c))
|
|
return colors
|
|
|
|
def _zero_stats(self):
|
|
return self._get_stats({i: '0' for i in range(12)})
|
|
|
|
@staticmethod
|
|
def _get_stats(stat_values) -> dict:
|
|
stats = [stat for stat in stat_values.values()]
|
|
stats_dict = dict()
|
|
stats_dict['Health'] = float(stats[0])
|
|
stats_dict['Stamina'] = float(stats[1])
|
|
stats_dict['Torpidity'] = float(stats[2])
|
|
stats_dict['Oxygen'] = float(stats[3])
|
|
stats_dict['food'] = float(stats[4])
|
|
stats_dict['Water'] = float(stats[5])
|
|
stats_dict['Temperature'] = float(stats[6])
|
|
stats_dict['Weight'] = float(stats[7])
|
|
stats_dict['Melee Damage'] = float(stats[8])
|
|
stats_dict['Movement Speed'] = float(stats[9])
|
|
stats_dict['Fortitude'] = float(stats[10])
|
|
stats_dict['Crafting Skill'] = float(stats[11])
|
|
return stats_dict
|
|
|
|
@staticmethod
|
|
def _get_dino_data(dino_data) -> dict:
|
|
data = [d for d in dino_data.values()]
|
|
data_dict = dict()
|
|
data_dict['DinoID1'] = int(data[0])
|
|
data_dict['DinoID2'] = int(data[1])
|
|
data_dict['DinoClass'] = data[2]
|
|
data_dict['DinoNameTag'] = data[3]
|
|
if data[4] == 'True':
|
|
data_dict['bIsFemale'] = True
|
|
else:
|
|
data_dict['bIsFemale'] = False
|
|
if data[5] == 'True':
|
|
data_dict['bNeutered'] = True
|
|
else:
|
|
data_dict['bNeutered'] = False
|
|
data_dict['TamerString'] = data[6]
|
|
data_dict['TamedName'] = data[7]
|
|
data_dict['ImprinterName'] = data[8]
|
|
data_dict['RandomMutationsMale'] = int(data[9])
|
|
data_dict['RandomMutationsFemale'] = int(data[10])
|
|
data_dict['BabyAge'] = float(data[11])
|
|
data_dict['CharacterLevel'] = int(data[12])
|
|
data_dict['DinoImprintingQuality'] = float(data[13])
|
|
return data_dict
|
|
|
|
@staticmethod
|
|
def _get_ancestry(ancestry_data, data) -> dict:
|
|
ancestry = [a for a in ancestry_data.values()]
|
|
ancestry_dict = dict()
|
|
ancestry_dict['DinoAncestorsCount'] = int(ancestry[0])
|
|
ancestry_dict['DinoAncestorsMale'] = int(ancestry[1])
|
|
|
|
if ancestry_dict['DinoAncestorsCount'] != 0:
|
|
if 'DinoAncestors' in data.sections():
|
|
dino_anc = [a for a in data['DinoAncestors'].values()]
|
|
ancestors = list()
|
|
for dino in dino_anc:
|
|
ancestors.append(dict([field.split('=') for field in dino.split(';')]))
|
|
ancestry_dict['DinoAncestors'] = ancestors
|
|
|
|
if ancestry_dict['DinoAncestorsMale'] != 0:
|
|
if 'DinoAncestorsMale' in data.sections():
|
|
dino_anc = [a for a in data['DinoAncestorsMale'].values()]
|
|
ancestors_male = list()
|
|
for dino in dino_anc:
|
|
ancestors_male.append(dict([field.split('=') for field in dino.split(';')]))
|
|
ancestry_dict['DinoAncestorsMale'] = ancestors_male
|
|
|
|
return ancestry_dict
|
|
|
|
def parents(self) -> (Dino, Dino):
|
|
if 'DinoAncestors' in self.ancestry:
|
|
parents = self.ancestry['DinoAncestors'][-1]
|
|
father = Dino.from_min_req(parents['MaleName'],
|
|
parents['MaleDinoID1'],
|
|
parents['MaleDinoID2'],
|
|
True)
|
|
mother = Dino.from_min_req(parents['FemaleName'],
|
|
parents['FemaleDinoID1'],
|
|
parents['FemaleDinoID2'],
|
|
True)
|
|
return father, mother
|
|
else:
|
|
return Dino.empty(), Dino.empty()
|
|
|
|
@classmethod
|
|
def from_min_req(cls, name, id1, id2, parent=False):
|
|
return Dino([name, id1, id2], parent=parent)
|
|
|
|
@classmethod
|
|
def empty(cls):
|
|
return Dino()
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, Dino):
|
|
if self.guid == other.guid:
|
|
return self.dino_data == other.dino_data and self.stats == other.stats
|
|
return False
|
|
elif isinstance(other, str):
|
|
try:
|
|
o = guid.Guid(other)
|
|
except TypeError:
|
|
return False
|
|
else:
|
|
return self.guid == o
|
|
elif isinstance(other, guid.Guid):
|
|
return self.guid == other
|
|
else:
|
|
return False
|
|
|
|
def __str__(self):
|
|
return f'<Dino name={self.dino_data["TamedName"]}, level={self.dino_data["CharacterLevel"]}, guid={self.guid}>'
|
|
|
|
def __repr__(self):
|
|
return (f'<Dino species={self.dino_data["DinoNameTag"]} name={self.dino_data["TamedName"]}, '
|
|
f'level={self.dino_data["CharacterLevel"]}, guid={self.guid}>')
|