character.py

from Dice import Dice
import math


class Character:
    """
    Class defines each PC or NPC, including generation and level up
    """

    def __init__(self, name=None, char_class=None, race=None, verbose=False):
        """
        Creates basic char, including race, name and basic stats
        If inputs are empty, char will be generated by prompt

        :param name: char name
        :param char_class: his class
        :param race: his race
        :param verbose: whether prompt should explain steps
        """
        self.MIND = 0
        self.STR = 0
        self.DEX = 0
        self.level = 1
        self.physical = 1
        self.subterfuge = 1
        self.knowledge = 1
        self.communication = 1
        self.attack_bonus = 0
        self.damage_bonus = 0
        self.wallet = 0
        self.name = name
        if self.name is None:
            self.name_prompt()

        self.race = race
        if self.race is None:
            self.race_prompt(verbose)
        self.race_calc()

        self.char_class = char_class
        if self.char_class is None:
            self.class_prompt(verbose)
        self.class_calc()
        self.assign_attributes(verbose)

    def name_prompt(self):
        """
        Gets char name

        :return: sets name
        """
        self.name = str(input("What is your characters name?"))

    def race_prompt(self, verbose):
        """
        User prompt for race choice

        :param verbose: whether or not to explain each choice
        :return: race
        """
        while True:
            if verbose:
                print("\nRaces: \n \u2022 Humans, +1  to  all  skill  rolls\n \u2022 Elves, +2 MIND"
                      "\n \u2022 Dwarves, +2 STR \n \u2022 Halflings, +2 DEX")
            try:
                resp = int(input("Are they a Human[0], Elf[1], Dwarf[2] or Halfling[3]?"))
                if 4 > resp > -1:
                    self.race = resp
                    break
            except ValueError:
                continue

    def class_prompt(self, verbose):
        """
        User prompt for class choice

        :param verbose: whether or not to explain each choice
        :return: class
        """
        while True:
            if verbose:
                print("\nClasses: \n \u2022"
                      " Fighters, "
                      "may wear any kind of armor and use shields, +3 bonus to Physical,"
                      " +1 to all attack and damage rolls"
                      "\n \u2022 "
                      "Rogues, "
                      "may use light armor, +3 bonus to Subterfuge, after successful sneak may add Subterfuge to damage"
                      "\n \u2022 "
                      "Magi, "
                      "may not wear armor, +3 bonus to Knowledge, may cast Magi spells "
                      "\n \u2022"
                      " Clerics, "
                      "may use light or medium armor, +3 bonus to Communication,"
                      " can turn undead with Magic Attacks and cast Divine spells")
            try:
                resp = int(input("Are they a Fighter[0], Rogue[1], Magi[2] or Cleric[3]?"))
                if 4 > resp > -1:
                    self.char_class = resp
                    break
            except ValueError:
                continue

    def race_calc(self):
        """
        Calculates effect of race choice on stats

        :return: Attribute changes made to class
        """
        if self.race == 0:
            self.physical += 1
            self.subterfuge += 1
            self.knowledge += 1
            self.communication += 1
        elif self.race == 1:
            self.MIND += 2
            self.race = 1
        elif self.race == 2:
            self.STR += 2
            self.race = 2
        elif self.race == 3:
            self.DEX += 2
            self.race = 3

    def class_calc(self):
        """
        Calculates effect of class choice on stats

        :return: adjusts stats based on class
        """
        if self.char_class == 0:
            self.wallet += 150
            self.physical += 3
            self.attack_bonus += 1
            self.damage_bonus += 1
        elif self.char_class == 1:
            self.wallet += 125
            self.subterfuge += 3
        elif self.char_class == 2:
            self.wallet += 75
            self.knowledge += 3
        elif self.char_class == 3:
            self.wallet += 125
            self.communication += 3

    def assign_attributes(self, verbose):
        """
        Assigns attributes at generation, based on player choice

        :return: nothing
        """
        if verbose:
            print("\nAttributes  represent  the  overall  physical  and  mental  qualities  of  an  individual."
                  " They  define  the  raw  potential  an  individual  has  regardless  of  actual  skill.")
            print("To define these Attributes, the computer will roll 4D6, dropping the lowest roll, and you"
                  " will choose which score to assign to 3 Attributes:\n \u2022 Strength(STR)"
                  "\n \u2022 Dexterity(DEX)\n \u2022 Mind(MIND)")

        outs = Dice(4, 6, 0).calculate_rolls()
        outs.remove(min(outs))

        self.STR = int(input(f"Assign STR {outs[0]}, {outs[1]} or {outs[2]}"))
        outs.remove(self.STR)
        self.DEX = int(input(f"Assign DEX {outs[0]} or {outs[1]}"))
        outs.remove(self.DEX)
        print(f"Assigning {outs[0]} to MIND")
        self.MIND = outs[0]

    def level_up(self, choice=0, verbose=False):
        """
        Levels character up, including recalculating stats dependant on the core stats
        Accounts for both 3rd level extra attribute point, and fighter 5th level bonus

        :return: New stats
        """
        if verbose:
            print("Congratulations! You have leveled up! Your skills and attack rolls have been increased by 1.")
        self.level += 1
        self.subterfuge += 1
        self.knowledge += 1
        self.communication += 1
        self.physical += 1
        self.attack_bonus += 1

        if self.level % 3 == 0:
            if verbose:
                choice = self.make_choice()

            if choice == 0:
                self.STR += 1
            elif choice == 1:
                self.DEX += 1
            elif choice == 2:
                self.MIND += 1

        if self.char_class == 0 and self.level % 5 == 0:
            if verbose:
                print("Congratulations Fighter, this level you get an extra bonus to damage and attack rolls!")
            self.attack_bonus += 1
            self.damage_bonus += 1

    @staticmethod
    def make_choice():
        """
        Gives prompt to make choice

        :return: attribute code
        """
        print("As this is a level divisible by 3,"
              " you may choose whether to allocate an extra point to STR, DEX or MIND")
        while True:
            choice = input("Allocate to STR[A], DEX[B] or MIND[C]?").lower()
            if choice == 'a':
                return 0
            elif choice == "b":
                return 1
            elif choice == "c":
                return 2
            else:
                continue

    def hp(self):
        """
        Calculate HP

        :return: the hp value
        """
        return self.STR + 6

    def ac(self):
        """
        Calculate AC from class, not including equipment

        :return: The AC value
        """
        return self.DEX + 10

    def melee(self):
        """
        Calculate ranged attack bonus

        :return: the ranged sub attribute
        """
        return self.STR + self.level

    def ranged(self):
        """
        Calculate ranged attack bonus

        :return: the ranged sub attribute
        """
        return self.DEX + self.level

    def magic(self):
        """
        Calculate ranged attack bonus

        :return: the ranged sub attribute
        """
        return self.MIND + self.level

    @staticmethod
    def calculate_attribute_bonus(attribute):
        """
        Calculates attribute bonus value

        :param attribute: STR/DEX/MIND value
        :return: The value of the bonus
        """
        return math.floor((attribute - 10) / 2)

    def saving_throw(self, attribute):
        """
        Calculate a saving throw

        :return: the value of the saving throw
        """
        return Dice(1, 20).calculate() + self.calculate_attribute_bonus(attribute) + (0.5 * self.level)

    def skill_roll(self, skill, attribute):
        """
        Calculate skill roll result

        :param skill: the skill in question
        :param attribute: the attribute
        :return: the result of the skill roll
        """
        return Dice(1, 20).calculate() + skill + self.calculate_attribute_bonus(attribute)

    def initiative(self):
        """
        returns initiative value

        :return: initiative
        """
        return Dice(1, 20).calculate() + self.DEX