Feat: Base Class Implemenations

docs/code_structure.md

@@ -8,24 +8,24 @@
   -- can return applicable list based on item type
 
 [class] Environment
-    [dict] Environment Configuration
+    [set] Environment Configuration
 
 [class] Build
     [ref] Tree
     [ref] Player
 
 [class] Tree
     [str] version
-    [dict] All Nodes (addressable by Node ID)
-    [dict] Selected Nodes (addressable by Node ID)
+    [set] All Nodes (addressable by Node ID)
+    [set] Allocated Nodes (addressable by Node ID)
 
 [class] Player
     [enum] Class Selection
     [enum] Ascendancy Selection
-    [dict] Stats (e.g. Str/Dex/Int, Hit/Crit, Life/Mana, Block/Spell Block/Evade/Dodge, etc.)
-    [dict] Item Slots
+    [set] Stats (e.g. Str/Dex/Int, Hit/Crit, Life/Mana, Block/Spell Block/Evade/Dodge, etc.)
+    [set] Item Sets
         [per slot ref] Item
-    [optional list] Minions
+    [optional set] Minions
 
 [class] Item
     [dict] Attribute requirements
@@ -43,24 +43,26 @@
 
 [class] Minion
     [ref] Player
-    [dict] Stats
+    [set] Stats
     [ref list] Items
     [ref list] Skills
     [int] Quantity
 
 [class] EnemyModel (e.g. Shaper, Maven)
-    [dict] Stats (e.g. Str/Dex/Int, Hit/Crit, Life/Mana, Block/Spell Block/Evade/Dodge, etc.)
+    [str] Name
+    [set] Stats (e.g. Str/Dex/Int, Hit/Crit, Life/Mana, Block/Spell Block/Evade/Dodge, etc.)
 
 [class] Simulator
     [ref] Environment(s)
     [ref list] Build(s)
     [ref] Enemy Model(s)
 
-[class] Analytics Module
+[module] Analytics Module
     [func] Node Comparison
     [func] Item Comparison
     [func] Gem Comparison
+    [func] Minion Comparison
 
-[list] Saved Builds
+[set] Saved Builds
 
 [dict] UI API imports/exports

src/Build.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+"""
+Build Class
+
+[class] Build
+    [ref] Tree
+    [ref] Player
+"""
+
+import Tree
+import Player
+
+
+class Build:
+    def __init__(self, name: str = "temp") -> None:
+        self.name = name
+        self.tree_ref = Tree.Tree()
+        self.player_ref = Player.Player()
+
+    def __repr__(self) -> str:
+        ret_str = f"[BUILD]: '{self.name}'\n"
+        ret_str += f"{self.tree_ref}"
+        ret_str += f"{self.player_ref}"
+        return ret_str
+
+
+def test() -> None:
+    build = Build()
+    print(build)
+
+
+if __name__ == "__main__":
+    test()

src/Enumerations.py

@@ -0,0 +1,17 @@
+# Enumeration Data for Path of Exile constants
+
+from enum import Enum
+
+
+class PlayerClasses(Enum):
+    SCION = 0
+    MARAUDER = 1
+    RANGER = 2
+    WITCH = 3
+    DUELIST = 4
+    TEMPLAR = 5
+    SHADOW = 6
+
+
+class PlayerAscendancies(Enum):
+    NONE = None

src/Player.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+"""
+Player Class
+
+[class] Player
+     [enum] Class Selection
+     [enum] Ascendancy Selection
+     [set] Stats (e.g. Str/Dex/Int, Hit/Crit, Life/Mana,
+                  Block/Spell Block/Evade/Dodge, etc.)
+     [set] Item Sets
+         [per slot ref] Item
+     [optional set] Minions
+"""
+
+from Enumerations import PlayerClasses, PlayerAscendancies
+
+
+class Player:
+    def __init__(
+        self,
+        player_class: PlayerClasses = PlayerClasses.SCION,
+        ascendancy: PlayerAscendancies = PlayerAscendancies.NONE,
+        level: int = 1,
+    ) -> None:
+        self.player_class = player_class
+        self.ascendancy = ascendancy
+        self.level = level
+        self.stats = set()
+        self.item_sets = set()
+        self.minions = set()
+
+    def __repr__(self) -> str:
+        ret_str = f"Level {self.level} {self.player_class.name}"
+        ret_str += f" {self.ascendancy.value}\n" if self.ascendancy.value else "\n"
+        return ret_str
+
+
+def test() -> None:
+    player = Player()
+    print(player)
+
+
+if __name__ == "__main__":
+    test()

src/Tree.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+"""
+Tree Class
+
+[class] Tree
+    [str] version
+    [set] All Nodes (addressable by Node ID)
+    [set] Allocated Nodes (addressable by Node ID)
+"""
+
+_VERSION_ = "3.17"
+
+
+class Tree:
+    def __init__(self, version: str = _VERSION_) -> None:
+        self.version = version
+        self.tree_nodes = set()
+        self.allocated_nodes = set()
+
+    def __repr__(self) -> str:
+        ret_str = f"[TREE]: version '{self.version}'\n"
+        return ret_str
+
+
+def test() -> None:
+    tree = Tree()
+    print(tree)
+
+
+if __name__ == "__main__":
+    test()