feat: add some basic classes

src/classes/Dependency.py

@@ -0,0 +1,47 @@
+#
+
+from itertools import chain
+
+_dependencies = {}
+_dependent_vars = set()
+
+def addDependency(dep1: str, dep2: str):
+ global _dependencies, _dependent_vars
+ if dep1 in _dependencies.keys():
+ if not dep2 in _dependencies[dep1]:
+ _dependencies[dep1].append(dep2)
+ #print(f"Appending DEP: {dep1} -> {dep2}")
+ else:
+ _dependencies[dep1] = [dep2]
+ #print(f"Adding DEP: {dep1} -> {dep2}")
+ _dependent_vars = set(chain.from_iterable(_dependencies.values()))
+ #print("DV: \n", _dependent_vars)
+
+def getDependentVars():
+ return _dependent_vars
+
+def getDependencies():
+ return _dependencies
+
+class Dependency:
+ def _reset_dependent_vars(self, name: str):
+ #print(f"DEP\n{_dependencies}")
+ for var in _dependencies[name]:
+ #print(f"Resetting: {var} (due to {name})")
+ try:
+ super().__delattr__(f"{var}")
+ except:
+ #print(f"FAIL")
+ pass
+ if var in _dependencies:
+ self._reset_dependent_vars(var)
+
+ def __setattr__(self, name: str, value):
+ global _dependencies, _dependent_vars
+ if name in _dependent_vars:
+ raise AttributeError("Cannot set this value.")
+ if name in _dependencies:
+ self._reset_dependent_vars(name)
+ name = f"_{name}"
+ #print(f"Setting {name} to {value}")
+ super().__setattr__(name, value)

src/classes/ModDB.py

@@ -0,0 +1,68 @@
+#
+
+from Modifiers import Modifier
+
+class ModifierDatabase:
+ def __init__(self, owner = None):
+ self.owner = owner
+ self.clear()
+
+ def addEntry(self, entry: Modifier):
+ name = entry.name
+ type = entry.type
+ if name not in self.db.keys():
+ self.db[name] = dict()
+ if type not in self.db[name].keys():
+ self.db[name][type] = [entry]
+ else:
+ if not entry in self.db[name][type]:
+ self.db[name][type].append(entry)
+
+ def getBase(self, name: str):
+ retVal = 0
+ if name in self.db.keys() and "BASE" in self.db[name].keys():
+ for entry in self.db[name]["BASE"]:
+ retVal += entry.getValue(self.owner)
+ return retVal
+ return 0
+
+ def getFlat(self, name: str):
+ retVal = 0
+ if name in self.db.keys() and "FLAT" in self.db[name].keys():
+ for entry in self.db[name]["FLAT"]:
+ retVal += entry.getValue(self.owner)
+ return retVal
+ return 0
+
+ def getInc(self, name: str):
+ retVal = 0
+ if name in self.db.keys() and "INC" in self.db[name].keys():
+ for entry in self.db[name]["INC"]:
+ retVal += entry.getValue(self.owner)
+ return retVal
+ return retVal
+
+ def getMore(self, name: str):
+ retVal = 0
+ if name in self.db.keys() and "MORE" in self.db[name].keys():
+ for entry in self.db[name]["MORE"]:
+ retVal += entry.getValue(self.owner)
+ return retVal
+ return retVal
+
+ def clear(self):
+ self.db = dict()
+
+def test():
+ db = ModifierDatabase()
+ mod1 = Modifier("Health", "BASE", 12, "", tags = { "type": "Multiplier", "var": "Level" })
+ mod2 = Modifier("Health", "BASE", 13, "")
+ db.addEntry(mod1)
+ db.addEntry(mod2)
+ import pprint
+ pprint.pprint(db.db)
+
+ print("BASE: " + str(db.getBase("Health")))
+
+if __name__ == "__main__":
+ test()

src/classes/Modifiers.py

@@ -0,0 +1,44 @@
+#
+
+from Dependency import addDependency, _dependencies
+from math import floor
+
+class Modifier:
+ def __init__(self, name: str, type: str, value, source: str, conditionals: set = set(), tags: dict = {}):
+ self.name = name
+ self.type = type
+ self.value = value
+ self.source = source
+ self.conditionals = conditionals
+ self.tags = tags
+ self.process()
+
+ def process(self):
+ if 'type' in self.tags.keys() and self.tags['type'] == "Multiplier":
+ addDependency(self.tags['var'].lower(), f"{self.type.lower()}_{self.name.lower()}")
+ addDependency(f"{self.type.lower()}_{self.name.lower()}", f"max_{self.name.lower()}")
+ #print(self)
+
+ def getValue(self, caller = None):
+ if caller:
+ #print(f"getting var: {self.name}:{self.type}")
+ if 'type' in self.tags.keys() and self.tags['type'] == "Multiplier":
+ var = f"{self.tags['var'].lower()}"
+ l = caller.__getattribute__(var)
+ #print(f"{var}: {l}")
+ return floor(self.value * l)
+ return self.value
+ return self.value
+
+ def __repr__(self):
+ ret = f"{self.name}:{self.type}\n"
+ ret += f"Value: {self.value}\n"
+ ret += f"{self.tags} -- {self.source}"
+ return ret
+
+def test():
+ m = Modifier("Health", "BASE", 12, "", tags = { "type": "Multiplier", "var": "Level" })
+ print(m)
+
+if __name__ == "__main__":
+ test()

src/classes/Player.py

@@ -0,0 +1,114 @@
+#
+
+from functools import cached_property
+from math import floor
+
+from Dependency import Dependency, getDependencies
+from ModDB import ModifierDatabase
+from Modifiers import Modifier
+
+class Player(Dependency):
+ def __init__(self, level, strength):
+ self.modDB = ModifierDatabase(self)
+ self._level = level
+
+ self.addMod(Modifier("Health", "BASE", 12, "Base Per Level", tags = { "type": "Multiplier", "var": "Level" }))
+ self.addMod(Modifier("Health", "BASE", 0.5, "Base Per Strength", tags = { "type": "Multiplier", "var": "Max_Strength"}))
+ self.addMod(Modifier("Strength", "BASE", strength, "Starting"))
+
+ def addMod(self, mod: Modifier):
+ self.modDB.addEntry(mod)
+ attr = f"{mod.type.lower()}_{mod.name.lower()}"
+ try:
+ self.__delattr__(f"{attr}")
+ except:
+ #print("FAIL")
+ pass
+ if attr in getDependencies():
+ self._reset_dependent_vars(attr)
+
+ @cached_property
+ def base_health(self):
+ #ret = 38 + self.level * 12 + floor(self.max_strength / 2) + self.flat_health
+ ret = 38 + self.modDB.getBase("Health") + self.flat_health
+ print(f"BASE Health calculated: {ret}")
+ return ret
+
+ @cached_property
+ def max_health(self):
+ ret = floor(self.base_health * (1 + self.inc_health / 100) * (1 + self.more_health / 100))
+ print(f"Total Health calculated: {ret}")
+ return ret
+
+ @cached_property
+ def base_strength(self):
+ ret = self.modDB.getBase("Strength")
+ print(f"BASE Strength calculated: {ret}")
+ return ret
+
+ @cached_property
+ def max_strength(self):
+ ret = floor((self.base_strength + self.flat_strength) * (1 + self.inc_strength / 100) * (1 + self.more_strength / 100))
+ print(f"Total Strength calculated: {ret}")
+ return ret
+
+ @property
+ def level(self):
+ return self._level
+
+ @cached_property
+ def flat_health(self):
+ ret = self.modDB.getFlat("Health")
+ print(f"FLAT Health calculated: {ret}")
+ return ret
+
+ @cached_property
+ def more_health(self):
+ ret = self.modDB.getMore("Health")
+ print(f"MORE Health calculated: {ret}")
+ return ret
+
+ @cached_property
+ def inc_health(self):
+ ret = self.modDB.getInc("Health")
+ print(f"INC Health calculated: {ret}")
+ return ret
+
+ @cached_property
+ def flat_strength(self):
+ ret = self.modDB.getFlat("Strength")
+ print(f"FLAT Strength calculated: {ret}")
+ return ret
+
+ @cached_property
+ def more_strength(self):
+ ret = self.modDB.getMore("Strength")
+ print(f"MORE Strength calculated: {ret}")
+ return ret
+
+ @cached_property
+ def inc_strength(self):
+ ret = self.modDB.getInc("Strength")
+ print(f"INC Strength calculated: {ret}")
+ return ret
+
+def test():
+ player = Player(1, 20)
+ #print(f"{player.base_health}\n")
+ print(f"{player.max_health}\n")
+
+ player.level = 5
+ print(f"{player.max_health}\n")
+
+ player.addMod(Modifier("Health", "MORE", 100, ""))
+ print(f"{player.max_health}\n")
+
+ player.addMod(Modifier("Strength", "FLAT", 100, ""))
+ player.addMod(Modifier("Strength", "INC", 30, ""))
+ player.addMod(Modifier("Strength", "MORE", 15, ""))
+ player.addMod(Modifier("Health", "FLAT", 500, ""))
+ #print(f"{player.max_strength}\n")
+ print(f"{player.max_health}\n")
+
+if __name__ == "__main__":
+ test()