Function _initialise has a Cognitive Complexity of 73 (exceeds 5 allowed). Consider refactoring.

Open

    def _initialise(self, **settings):
        """
        Preface.
        Character creation in DnD_battler is rather painful. Here due to missing it is even more complex.
        Also, creature, character and monster are used interchangably here unfortunately, which will be fixed one day.

• Read up
  Read up

Function _fill_from_preset has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.

Open

    def _fill_from_preset(self, name:str):
        """
        Legacy... It might stop working due to code changes.
        :param name: the name of creature.
        :return: the stored creature.

• Read up
  Read up

Function _sanitise_settings_for_abilities has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.

Open

    def _sanitise_settings_for_abilities(self, settings) -> dict:
        settings = {k.lower(): v for k, v in settings.items()}
        # ---------- set blanks ----------------------------------------------------------------------------------------
        blank_abilities = {ab: None for ab in self.ability_names}
        # ability_bonuses

• Read up
  Read up

Function clean_settings has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def clean_settings(self, dirtydex: dict) -> dict:
        """
        Sanify the settings

        :return: a cleaned dictionary

• Read up
  Read up

Function apply_settings has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    def apply_settings(self, **settings):
        settings = {k.lower(): v for k, v in settings.items()}
        # -------------- assign fluff values ---------------------------------------------------------------------------
        for key in ('name', 'base', 'type', 'alignment'):
            if key in settings:

• Read up
  Read up

Function describe has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def describe(self, html_formatting:bool=False) -> str:
        badgify = lambda i: f'<span class="badge">{i}</span>'
        if html_formatting:
            # it is bootstrap 3 in Jupyter notebook, but with jupyter themes it looks weird.
            # class="list-group" and class="list-group-item"

• Read up
  Read up

Function predict has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def predict(self, html_formatting: bool = False) -> str:
        def safediv(a, b, default=0):
            try:
                return a / b
            except:

• Read up
  Read up

Function act has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def act(self):
        if not self.arena.find('alive enemy'):
            raise Victory()
        # BONUS ACTION
        # heal  -healing word, a bonus action.

• Read up
  Read up

Function __init__ has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def __init__(self):
        self.name = 'unnamed'
        self.base = 'none'    # human bandit
        self.type = 'unknown' # aberation, humanoid
        self.size = Size('medium')

Function from_notation has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def from_notation(cls, notation: str, **kargs) -> Dice:
        """
        2d6+2 to Dice

        :param notation: 2d6+2

• Read up
  Read up

Function __init__ has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def __init__(self, wildcard, **kwargs):
        """
        Creature object creation. A lot of paramaters make a creature so a lot of assumptions are made (see __init__`).

        :param wildcard: the name of the creature.

• Read up
  Read up

Function _initialise has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def _initialise(self, **settings):
        """
        Preface.
        Character creation in DnD_battler is rather painful. Here due to missing it is even more complex.
        Also, creature, character and monster are used interchangably here unfortunately, which will be fixed one day.

Function parse_attacks has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def parse_attacks(self,
                      attacks: Optional[List[Union[dict, Action, AttackRoll]]] = None,
                      **others) -> Action:
        """
        A multiattack is a curious case where a creature can do multiple attacks as a single action.

• Read up
  Read up

Function remove has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def remove(self, moriturus):
        """
        Removes a creature and resets and rechecks
        :param moriturus: The creature name to be dropped
        :return: self

• Read up
  Read up

Function base_roll has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def base_roll(self, advantage:Optional[int]=None, avg=None, success_on_crit=True):
        """
        returns the roll without the bonuses.
        RAW in 5e, a crit on an ability roll is not a given success,

• Read up
  Read up

Function set_ac has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def set_ac(self,

Function __init__ has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def __init__(self,

Function parse_attack has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def parse_attack(self, attack: Union[None, Action, dict, list]) -> Action:
        if attack is None:  # nothing to be done.
            return None
        elif isinstance(attack, Action):
            return attack  # already an action.

• Read up
  Read up

Function generate_character_sheet has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def generate_character_sheet(self) -> str:
        """
        An markdown character sheet.
        
        :return: a string

• Read up
  Read up

Function set_ability_die has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def set_ability_die(self, ability_name: str, score: Optional[int] = None, bonus: Optional[int] = None):
        ability_die = self[ability_name]
        # print(ability_name, ability_die.score, score, ability_die.bonus, bonus)
        assert isinstance(ability_die, AbilityDie), f'The die for {ability_name} is not a die, but {type(ability_die)}'
        assert ability_name in self.ability_names, f'{ability_name} is not in {self.ability_names}'

• Read up
  Read up