template improved, using multiple .py files now

main.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python3
+from adventurers import *
 import random
 
 armor= { 'None' : 9, 'Leather' : 7, 'Leather, Shield' : 6, 'Chain' : 5, 'Chain, Shield' : 4, 'Plate' : 3, 'Plate, Shield' : 2 }
@@ -19,140 +20,6 @@ weapons = [
     { 'name' : 'war hammer',   'damage-dice' : 6,  'traits' : [ 'melee', 'blunt' ] }
 ]
 
-# Player Character Classes
-class Adventurer:
-    def __init__(self, level=1, attributes={}) -> None:
-        # using a get() method to pull an attribute else use a default value, https://python-academy.org/en/handbook/get
-        self.player_class = None
-        self.level = level
-        self.strength     = attributes.get('strength', roll_dice(3,6))
-        self.intelligence = attributes.get('intelligence', roll_dice(3,6))
-        self.wisdom       = attributes.get('wisdom', roll_dice(3,6))
-        self.dexterity    = attributes.get('dexterity', roll_dice(3,6))
-        self.constitution = attributes.get('constitution', roll_dice(3,6))
-        self.charisma     = attributes.get('charisma', roll_dice(3,6))
-        self.hp = 1
-        self.torches = roll_dice(1,6)
-        self.rations =  roll_dice(1,6)
-        self.equipment = [ 'backpack', 'tinderbox', 'waterskin' ]
-        # all armor, individual classes may have overrides
-        self.possible_armor = list(armor.keys())
-        # all weapons, individual classes may have overrides
-        self.possible_weapons = weapons
-        self.possible_melee_weapons = list(filter(lambda d: 'melee' in d['traits'], weapons))
-        self.possible_missile_weapons = list(filter(lambda d: 'missile' in d['traits'], weapons))
-        # each character should get 1 melee and 1 random (missle or melee)
-        self.weapons = [ random.choice(self.possible_melee_weapons), random.choice(self.possible_weapons) ]
-        self.armor = random.choice(self.possible_armor)
-
-    def __str__(self):
-        return f"{self.player_class}"
-
-    def character_sheet(self):
-        sheet = []
-        sheet.append('{0: <26}'.format(f"| {self.player_class.title()} - Level {self.level}"))
-        for key, val in self.get_attributes().items():
-            key_string = "| " + '{0:12}'.format(f"{key}").capitalize() + f" {val}"
-            sheet += ['{0: <26}'.format(key_string)]
-        sheet.append('| ----------------------- ')
-        sheet.append('{0: <26}'.format(f"| HP: {self.hp}  AC: {self.ac}"))
-        sheet.append('{0: <26}'.format(f"| Torches: {self.torches}"))
-        sheet.append('{0: <26}'.format(f"| Rations: {self.rations}"))
-        sheet.append('{0: <26}'.format(f"| Armor: {self.armor}"))
-        sheet.append('{0: <26}'.format(f"| Weapons:")) 
-        sheet.append('{0: <26}'.format(f"|   {self.weapons[0]['name'].title()}"))
-        sheet.append('{0: <26}'.format(f"|   {self.weapons[1]['name'].title()}"))
-        return sheet
-
-    def get_attributes(self):
-        attribute_list = ['strength', 'intelligence', 'wisdom', 'dexterity', 'constitution', 'charisma']
-        return {k: self.__dict__[k] for k in attribute_list}
-
-    def get_best_prime_attribute(self):
-        attribute_list = [ 'strength', 'intelligence', 'wisdom', 'dexterity' ]
-        prime_attributes =  {k: self.__dict__[k] for k in attribute_list}
-        # return highest, found this at https://stackoverflow.com/a/280156
-        return max(prime_attributes, key=prime_attributes.get) 
-
-    def roll_equipment(self):
-        print("testing!")
-
-        
-class Fighter(Adventurer):
-    prime_requisite = "strength"
-    requirements = None
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "fighter"
-        self.hp = roll_dice(self.level, 8)
-        self.ac = armor[self.armor]
-
-class MagicUser(Adventurer):
-    prime_requisite = "intelligence"
-    requirements = None
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "magic user"
-        self.hp = roll_dice(self.level, 4)
-        self.armor = "None"
-        self.ac = armor[self.armor]
-        self.weapons = [ list(filter(lambda d: 'silver dagger' in d['name'],weapons))[0], { "name" : "" } ]
-
-
-class Cleric(Adventurer):
-    prime_requisite = "wisdom"
-    requirements = None
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "cleric"
-        self.hp = roll_dice(self.level, 6)
-        self.armor = random.choice(list(armor.keys()))
-        self.ac = armor[self.armor]
-        # clerics can only wield blunt weapons
-        self.possible_melee_weapons = list(filter(lambda d: 'blunt' in d['traits'] and 'melee' in d['traits'], weapons))
-        self.possible_weapons = list(filter(lambda d: 'blunt' in d['traits'], weapons))
-        self.weapons = [ random.choice(self.possible_melee_weapons), random.choice(self.possible_weapons) ]
-
-class Thief(Adventurer):
-    prime_requisite = "dexterity"
-    requirements = None
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "thief"
-        self.hp = roll_dice(self.level, 4)
-        self.armor = random.choice(list(armor.keys()))
-        self.ac = armor[self.armor]
-
-class Dwarf(Adventurer):
-    prime_requisite = "strength"
-    requirements = {'constitution' : 9 }
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "dwarf"
-        self.hp = roll_dice(self.level, 8)
-        self.armor = random.choice(list(armor.keys()))
-        self.ac = armor[self.armor]
-
-class Elf(Adventurer):
-    prime_requisite = "intellgence"
-    requirements = {'intelligence' : 9 }
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "elf"
-        self.hp = roll_dice(self.level, 6)
-        self.armor = random.choice(list(armor.keys()))
-        self.ac = armor[self.armor]
-
-class Halfling(Adventurer):
-    prime_requisite = "dexterity"
-    requirements = {'constitution' : 9, 'dexterity' : 9 }
-    def __init__(self, level, attributes={}) -> None:
-        Adventurer.__init__(self, level, attributes)
-        self.player_class = "halfling"
-        self.hp = roll_dice(self.level, 6)
-        self.armor = random.choice(list(armor.keys()))
-        self.ac = armor[self.armor]
-
 # Player Class Selector
 class ClassSelector():
     def __init__(self, player: Adventurer) -> None:
@@ -210,11 +77,16 @@ class PartyGenerator():
                     self.adventurer_types.append(new_player.player_class)
 
     def get_character_sheets(self):
+        sheet_string = ""
+        character_sheets = []
+        for c in self.adventurers:
+            character_sheets.append(c.character_sheet())
         for i in range(15):
             for j in range(len(self.adventurers)):
                 adv = self.adventurers[j]
-                print(adv.character_sheet()[i],end='')
-            print('|\n',end='')
+                sheet_string += adv.character_sheet()[i]
+            sheet_string += '|\n'
+        return character_sheets
 
     def __str__(self):
         return f"{self.adventurers}"
@@ -223,9 +95,17 @@ class PartyGenerator():
 def roll_dice(count, sides):
     return sum(random.randint(1,sides) for _ in range(count))
 
-def main():
+def returnSheets(foo):
     new_party = PartyGenerator()
     new_party.gen_party()
-    new_party.get_character_sheets()
+    return new_party.get_character_sheets()
 
-main()
+def main():
+    character_sheets = returnSheets('foo')
+    for c in character_sheets:
+        for l in c:
+            print(f"{l}|")
+        print()
+
+if __name__ == "__main__":
+    main()