Mickey's refactor.

Author: mickeylyle

README.md

@@ -1,3 +1,8 @@
 # Python-Character-Creator
 Python for a DnD character creator.
 Code is supposed to receive inputs from a user so they may be walked through the creation of a DnD character.
+
+TODO:
+- critical hits
+- critical damage
+- more content

character.py

@@ -0,0 +1,143 @@
+import math
+from random import randint
+from dataclasses import dataclass
+
+from entity import Entity
+from equipment import armors, weapons
+from dice import roll
+
+CHARACTER_ATTRIBUTES = ("Strength", "Dexterity", "Constitution", "Intelligence", "Wisdom", "Charisma")
+
+@dataclass
+class PlayerClass:
+    name: str
+    starting_hp: int
+    hit_die: int
+
+classes = list()
+classes.append(PlayerClass("Fighter", 6, 10))
+
+# Class to represent a base D&D character.
+class Character(Entity):
+    def __init__(self):
+        Entity.__init__(self, input("Name your character: "))
+        self.level = 1
+        self.picker("class", classes)
+        self.reset_attributes()
+        self.pick_attributes(26)
+        self.max_hp = self.player_class.starting_hp + \
+                      self.get_attribute_mod(CHARACTER_ATTRIBUTES[2]) * self.level
+        self.current_hp = self.max_hp
+        print(self.get_attrs_str())
+        self.picker("armor", armors)
+        self.picker("weapon", weapons)
+
+    def get_attribute_mod(self, attribute):
+        return math.floor((self.attributes[attribute] - 10) / 2)
+
+    def get_attribute_mod_cost(self, attribute):
+        a = self.attributes[attribute]
+        if a < 14:
+            return 1
+        elif a == 14:
+            return 2
+        elif a > 14:
+            return "MAX"
+
+    def reset_attributes(self):
+        self.attributes = dict()
+        for a in CHARACTER_ATTRIBUTES:
+            self.attributes[a] = 8
+
+    def pick_attributes(self, points):
+        numbers = range(1, len(CHARACTER_ATTRIBUTES) + 1)
+        error = ""
+
+        while points > 0:
+            print("   Attribute\tValue\tModifier\tCost")
+            for n, a in zip(numbers, CHARACTER_ATTRIBUTES):
+                print(f"{n}: {a}\t{self.attributes[a]}\t{self.get_attribute_mod(a)}\t{self.get_attribute_mod_cost(a)}")
+            print()
+            print(f"Attribute Points: {points}")
+            print(error)
+            choice = int(input("Choose an attribute to increase: "))
+            print()
+            if choice in numbers:
+                choice -= 1
+                a = CHARACTER_ATTRIBUTES[choice]
+                cost = self.get_attribute_mod_cost(a)
+                if cost == "MAX":
+                    error = f"{CHARACTER_ATTRIBUTES[choice]} is at maximum"
+                elif cost <= points:
+                    self.attributes[a] += 1
+                    points -= cost
+                    error = ""
+                else:
+                    error = f"Not enough points to increase {a}"
+            else:
+                error = f"Please pick a number between {min(numbers)} and {max(numbers)}"
+
+    def get_attack_bonus(self):
+        return self.get_attack_attr_bonus() + self.get_proficiency_bonus()
+
+    def get_attack_attr_bonus(self):
+        return max(self.get_attribute_mod["Strength"],
+                   self.get_attribute_mod["Dexterity"]) \
+                   if self.weapon.finesse else self.get_attribute_mod("Strength")
+
+    def get_proficiency_bonus(self):
+        return math.floor(2 + ((self.level - 1) * 0.25))
+
+    def roll_weapon_damage(self):
+        return roll(*self.weapon.damage) + self.get_attack_attr_bonus()
+        
+
+    # Report back character name, species, job, stats, and equipment.
+    def __str__(self):
+        return f"{self.name} is a level {self.level} {self.player_class.name}\n" \
+               f"{self.get_health_str()}\n" \
+               f"Armor: {self.armor.name}  AC: {self.armor.armor_class}  Weapon: {self.weapon.name}" \
+               f"{self.get_attrs_str()}"
+
+    # Display character's stats.
+    def get_attrs_str(self):
+        return ''.join([f"{a}: {self.attributes[a]}\n" for a in CHARACTER_ATTRIBUTES])
+
+    def picker(self, pick_type, pick_list):
+        choices = [g.name for g in pick_list]
+        numbers = range(1, len(pick_list) + 1)
+
+        for i, name in zip(numbers, choices):
+            print(f"{i}: {name}")
+
+        prompt = f"Which {pick_type} would you like? "
+
+        while True:
+            choice = int(input(prompt))
+            if choice in numbers:
+                break
+            else:
+                prompt = f"Please pick a number between {min(numbers)} and {max(numbers)}: "
+
+        if pick_type == "armor":
+            self.armor = armors[choice - 1]
+            print(f"You chose {self.armor.name}.\n")
+        elif pick_type == "weapon":
+            self.weapon = weapons[choice - 1]
+            print(f"You chose {self.weapon.name}.\n")
+        elif pick_type == "class":
+            self.player_class= classes[choice - 1]
+            print(f"You chose {self.player_class.name}.\n")
+
+
+    def attack(self, enemy):
+        attack_roll = roll(1, 20) + self.get_attack_bonus()
+        print(f"{self.name} swings their {self.weapon.name} at the {enemy.name}!")
+        if enemy.armor_class < attack_roll:
+            print(f"{self.name} smacks the {enemy.name} a good one! {attack_roll} vs {enemy.get_ac()} AC")
+            enemy.take_damage(self.roll_weapon_damage())
+        else:
+            print(f"{self.name} wiffs!")
+
+    def get_ac(self):
+        return self.armor.ac + max(self.armor.max_dex_bonus, self.attributes["Dexterity"])

dice.py

@@ -0,0 +1,3 @@
+from random import randint
+
+roll = lambda a, b: sum([randint(1, b) for i in range(a)])

entity.py

@@ -0,0 +1,16 @@
+class Entity:
+    def __init__(self, name):
+        self.name = name
+        self.max_hp = 0
+        self.current_hp = 0
+
+    def get_hp_str(self):
+        return f"{self.name} has {self.current_hp} out of {self.max_hp}"
+
+    def take_damage(self, amount):
+        if self.current_hp <= amount:
+            self.current_hp= 0
+            print(f"{self.name}'s lifeless form crumples to the floor.")
+        else:
+            self.current_hp -= amount
+            print(f"{self.name} takes {amount} damage and has {self.current_hp} hp remaining of {self.max_hp}.")

equipment.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+
+# THIS NEEDS TO BE FIXED
+MAX_INT = 99999
+
+@dataclass
+class Armor:
+    name: str
+    proficiency: str
+    cost_gp: int
+    ac: int
+    max_dex_bonus: int
+    min_str: int
+    stealth_disadvantage: bool
+    weight: int
+
+armors = list()
+armors.append(Armor("Scale Mail", "medium", 50, 14, 2, 0, True, 45))
+armors.append(Armor("Studded Leather", "light", 10, 11, MAX_INT, 0, False, 13))
+
+@dataclass
+class Weapon:
+    name: str
+    martial: bool
+    ranged: bool
+    cost: int
+    damage: (int, int)
+    damage_type: str
+    finesse: bool
+    heavy: bool
+    light: bool
+    loading: bool
+    range_distance: (int, int)
+    reach: bool
+    thrown: bool
+    two_handed: bool
+    versatile: bool
+    versatile_damage: (int, int)
+
+weapons = list()
+weapons.append(Weapon("Club",
+                      False,
+                      False,
+                      1,
+                      (1, 4),
+                      "bludgeoning",
+                      False,
+                      False,
+                      False,
+                      False,
+                      (0, 0),
+                      False,
+                      False,
+                      False,
+                      False,
+                      (0, 0)))

main.py

@@ -1,35 +1,27 @@
-from character_dnd import Character_DnD
-from character_dnd import Monster_DnD
-from random import randint
+#!/usr/bin/env python3
 
-# Getting input on character name.
-character_name = input(
-    "Please type what you would like your character name to be? ")
-# Getting input on character species.
-character_species = input("Please type what you would like your character species to be? Please choose from Human, "
-                          "Elf, or Dwarf. Then hit enter. ")
+from character import Character
+from monster import monsters
 
-while character_species.lower() not in ["human", "elf", "dwarf"]:
-    character_species = input("Whoops, looks like you didn't choose one of the previous species. Please choose from "
-                              "Human, Elf, or Dwarf. Then hit enter. ")
-# Getting input on character job.
-character_job = input("Please type what you would like your character's job to be? Please choose from Fighter, Rogue, "
-                      "or Wizard. Then hit enter. ")
 
-while character_job.lower() not in ["fighter", "rogue", "wizard"]:
-    character_job = input("Whoops, looks like you didn't choose one of the previous jobs. PLease choose from Fighter, "
-                          "Rogue, or Wizard. Then hit enter. ")
-
-my_character = Character_DnD(character_name, character_species, character_job)
-Kobold = Monster_DnD("Kobold", 5, 12, "a dagger", randint(1, 4), "1/8", -1, 4)
-red_dragon = Monster_DnD("the Ancient Red Dragon", 546, 22, "a Bite", randint(2, 10) + 24, 24, 9, 17)
-
-my_character.change_attribute_points()
-my_character.weapon_choice()
-my_character.armor_choice()
-my_character.player_attack(Kobold)
-my_character.player_attack(red_dragon)
-red_dragon.monster_attack(my_character)
-Kobold.monster_attack(my_character)
+# my_character.change_attribute_points()
+# my_character.weapon_choice()
+# my_character.armor_choice()
+# my_character.player_attack(Kobold)
+# my_character.player_attack(red_dragon)
+# red_dragon.monster_attack(my_character)
+# Kobold.monster_attack(my_character)
 # print(my_character.attribute_points)
 # print(my_character)
+
+def fight(p1, p2):
+    while p1.current_hp > 0 and p2.current_hp > 0:
+        p1.attack(p2)
+        if p2.current_hp > 0:
+            p2.attack(p1)
+
+
+if __name__ == "__main__":
+    foo = Character()
+    bar = monsters["Kobold"]
+    fight(foo, bar)

monster.py

@@ -0,0 +1,46 @@
+from entity import Entity
+from dice import roll
+
+class Monster(Entity):
+    def __init__(self,
+                 name,
+                 hit_points,
+                 armor_class,
+                 attack_name,
+                 attack_bonus,
+                 damage_roll,
+                 damage_bonus):
+        Entity.__init__(self, name)
+        self.name = name
+        self.max_hp = hit_points
+        self.current_hp = self.max_hp
+        self.armor_class = armor_class
+        self.attack_name = attack_name
+        self.attack_bonus = attack_bonus
+        self.damage_roll = damage_roll
+        self.damage_bonus = damage_bonus
+
+    def __repr__(self):
+        return (f"\n {self.name} is a challenge rating {self.challenge_rating} monster with {self.hit_points} hit "
+                f"points, {self.armor_class} armor class and that wields {self.weapon}. ")
+
+    def attack(self, enemy):
+        attack_roll = roll(1, 20) + self.attack_bonus
+        print(f"{self.name} swings their {self.attack_name} at the {enemy.name}!")
+        if enemy.get_ac() < attack_roll:
+            print(f"{self.name} smacks {enemy.name} a good one! {attack_roll} vs {enemy.get_ac()} AC")
+            enemy.take_damage(roll(self.damage_roll) + self.damage_bonus)
+        else:
+            print(f"{self.name} wiffs!")
+
+    def get_ac(self):
+        return self.armor_class
+
+monsters = dict()
+monsters["Kobold"] = Monster("Kobold",
+                             5,
+                             12,
+                             "dagger",
+                             0,
+                             (1, 4),
+                             0)