First uncategorized solution for The Warlords by _Chico_ - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.
First solution in Uncategorized category for The Warlords by _Chico_
# ----------------------

# NOTE: Descriptors are at the class level, so all instances of a class use the same descriptor instance!

class RangedInt(object):
    """Descriptor:  Integer with max and/or min limit cutoff.
        Allows for changing min/max values in object's instance, as a range between [min] and [max]

        Setting min/max in class def will lock min/max value for the attribute.
        Value of None for max/min means no limit imposed, then just an int.

        if not locked, may set/change range by setting in instance,
            instance attributes '_max' or '_min'
            eg. inst.x_max = 100, will then set max for inst.x to 100

        Inverse ranges are possible, where _max is lower than _min, but _min will be returned.
    """
    def __init__(self, label, value_min=None, value_max=None):
        self.label = str(label)
        self.label_min = ''.join((self.label, '_min'))
        self.label_max = ''.join((self.label, '_max'))
        self.value_min = None if value_min is None else int(value_min)
        self.value_max = None if value_max is None else int(value_max)
        if not (self.value_min is None or self.value_max is None) and self.value_max < self.value_min:
            raise ValueError("value_max must be greater than value_min")

    def _get_min(self, inst):
        return self.value_min if self.value_min is not None else inst.__dict__.get(self.label_min, None)

    def _get_max(self, inst):
        return self.value_max if self.value_max is not None else inst.__dict__.get(self.label_max, None)

    def _get_default(self, inst):
        # TODO: Still unsure what default to use.
        _min, _max = self._get_min(inst), self._get_max(inst)
        if not (_max is None or _min is None) and _max < _min: _max = _min
        return int(_max) if _max is not None else (int(_min) if _min is not None else 0)

    def __get__(self, inst, owner):
        """Get the attribute value"""
        return inst.__dict__.get(self.label, self._get_default(inst))

    def __set__(self, inst, value):
        """Set the attribute value"""
        if self.value_min is not None:
            inst.__dict__[self.label_min] = self.value_min
        if self.value_max is not None:
            inst.__dict__[self.label_max] = self.value_max

        # make sure _min/_max attributes exist on instance
        if inst.__dict__.get(self.label_min, None) is None:
            inst.__dict__[self.label_min] = None
        if inst.__dict__.get(self.label_max, None) is None:
            inst.__dict__[self.label_max] = None

        _min, _max = self._get_min(inst), self._get_max(inst)

        if not (_max is None or _min is None) and _max < _min:
            _max = _min

        if _max is not None and value > _max:
            inst.__dict__[self.label] = int(_max)
        elif _min is not None and value < _min:
            inst.__dict__[self.label] = int(_min)
        else:
            inst.__dict__[self.label] = int(value)


# ----------------------

class Warrior(object):
    """A Warrior Combat Unit"""
    warrior_count = 0

    health = RangedInt('health')  # no minimum, 0 and below is not alive ;)
    attack = RangedInt('attack', value_min=0)

    def __init__(self, health=50, attack=5, **kwargs):
        self.health_max = int(health)
        self.health = self.health_max
        self.attack_max = int(attack)
        self.attack = self.attack_max
        self.attrs = ['health', 'attack']

        Warrior.warrior_count += 1
        self.serial = self.warrior_count

        self.weapons = []

        self.init_kw = kwargs
        for k, v in kwargs.items():
            if k.startswith('_') or k in ['serial', 'attrs', 'init_kw', 'weapons']: continue
            setattr(self, k, v)

    def __repr__(self):
        attrs_str = ['{}:{}/{}'.format(a, getattr(self,a), getattr(self,'{}_max'.format(a))) for a in self.attrs]
        return "{}({})".format(self.__class__.__name__, ', '.join(attrs_str))

    def __str__(self):
        return "Warrior({}h,{}a)".format(self.health, self.attack)

    @property
    def is_alive(self):
        return self.health > 0

    def take_hit(self, attack):
        """Returns damage inflicted"""
        health_was = self.health
        self.health -= int(attack)
        return health_was - self.health

    def rejuvinate(self, amt):
        if self.is_alive:
            health_was = self.health
            self.health += amt  # max/min limited by descriptor
            return self.health - health_was
        return False

    def resurrect(self):
        self.health = self.health_max
        self.attack = self.attack_max

    def _uncurse_max(self, attr):
        """Uncurse _max limit, by setting to _min"""
        attr_min, attr_max = ''.join(attr, '_min'), ''.join(attr, '_max')
        _min, _max = getattr(self, attr_min, 0), getattr(self, attr_max, None)
        if not (_min is None or _max is None) and _max < _min:
            setattr(self, attr_max, _min)

    def equip_weapon(self, weapon):
        """Equip a Weapon:  Will bless(+ve) or curse(-ve).
            NOTE: cursed weapon will affect _max, and will need blessed weapon to undo
                - TODO: is this expected logic
        """
        if isinstance(weapon, Weapon):
            self.weapons.append(weapon)
            # picking up a cursed weapon with neg health may kill you, dead!
            for attr in self.attrs:
                attr_max = ''.join((attr, '_max'))
                #self._uncurse_max(attr)
                self.__dict__[attr] += getattr(weapon, attr, 0)
                self.__dict__[attr_max] += getattr(weapon, attr, 0)
            return weapon
        return False


class Knight(Warrior):

    def __init__(self, health=50, attack=7, **kwargs):
        super(Knight, self).__init__(health, attack, **kwargs)

    def __str__(self):
        return "Knight({}h,{}a)".format(self.health, self.attack)


class Defender(Warrior):

    defense = RangedInt('defense', value_min=0)

    def __init__(self, health=60, attack=3, defense=2, **kwargs):
        super(Defender, self).__init__(health, attack, **kwargs)
        self.defense_max = int(defense)
        self.defense = self.defense_max
        self.attrs.append('defense')

    def __str__(self):
        return "Defender({}h,{}a,{}d)".format(self.health, self.attack, self.defense)

    def take_hit(self, attack, with_defense=True):
        """Take a hit, with or without defense"""
        eff_attack = int(attack) - self.defense if with_defense else int(attack)
        if eff_attack > 0:
            return super(Defender, self).take_hit(eff_attack)
        return 0


class Vampire(Warrior):

    vampirism = RangedInt('vampirism', value_min=0)

    def __init__(self, health=40, attack=4, vampirism=50, **kwargs):
        super(Vampire, self).__init__(health, attack, **kwargs)
        self.vampirism_max = int(vampirism)  # as percent
        self.vampirism = self.vampirism_max
        self.attrs.append('vampirism')

    def __str__(self):
        return "Vampire({}h,{}a,{}%v)".format(self.health, self.attack, self.vampirism)

    def attack_heal(self, attack_damage):
        rejuv = int(attack_damage * (self.vampirism / 100.0))
        if rejuv > 0:
            return super(Vampire, self).rejuvinate(rejuv)
        return 0


class Lancer(Warrior):

    lancability = RangedInt('lancability', value_min=0)

    def __init__(self, health=50, attack=6, lancability=50, **kwargs):
        super(Lancer, self).__init__(health, attack, **kwargs)
        self.lancability_max = int(lancability) # as percent
        self.lancability = self.lancability_max
        self.attrs.append('lancability')

    def __str__(self):
        return "Lancer({}h,{}a,{}%L)".format(self.health, self.attack, self.lancability)

    def lancing_attack(self, unit_damage):
        return int(unit_damage * (self.lancability / 100.0))


class Healer(Warrior):

    heal_power = RangedInt('heal_power', value_min=0)  # how much health may be healed

    def __init__(self, health=60, attack=0, heal_power=2, **kwargs):
        super(Healer, self).__init__(health, attack, **kwargs)
        self.heal_power_max = int(heal_power)
        self.heal_power = self.heal_power_max
        self.attrs.append('heal_power')

    def __str__(self):
        return "Healer({}h,{}a,{}j)".format(self.health, self.attack, self.heal_power)

    def heal(self, other):
        if self.is_alive and isinstance(other, Warrior):
            return other.rejuvinate(self.heal_power)
        return False

# ----------------------

class StrawMan(Warrior):
    """Just takes a beating, first and last man in an army as a Null return"""
    def __init__(self, health=0, attack=0, **kwargs):
        super(StrawMan, self).__init__(health, attack, **kwargs)

    def __str__(self):
        return "StrawMan({}h,{}a)".format(self.health, self.attack)

    def equip_weapon(self, weapon):
        # Can't hold or use a weapon ;). Please no torches.
        return False

# ----------------------

class Warlord(Warrior):  # could be subclass of Defender instead?
    """A Warlord"""
    defense = RangedInt('defense', value_min=0)

    def __init__(self, health=100, attack=4, defense=2, **kwargs):
        super(Warlord, self).__init__(health, attack, **kwargs)
        self.defense_max = int(defense)
        self.defense = self.defense_max
        self.attrs.append('defense')

    def __str__(self):
        return "Warlord({}h,{}a,{}d)".format(self.health, self.attack, self.defense)

    def take_hit(self, attack, with_defense=True):
        """Take a hit, with or without defense"""
        eff_attack = int(attack) - self.defense if with_defense else int(attack)
        if eff_attack > 0:
            return super(Warlord, self).take_hit(eff_attack)
        return 0

# ----------------------

class Army(object):
    """An army of units"""
    army_count = 0

    def __init__(self, army_name=""):
        Army.army_count += 1
        self.army_name = army_name if army_name else "army#{}".format(self.army_count)
        self.head_pos = 0
        self.array = []  # a list of units/Warriors with [0] the vanguard
        self.strawman = StrawMan()  # not part of ranks/array, returned instead of None
        self._warlord = StrawMan()

        self.attack_priority = {
                    'Lancer': 1, 'Vampire': 2, 'Knight': 3,
                    'Defender': 4, 'Warrior': 5,
                    'Healer': 8, 'Warlord': 9,
                    }

    def __repr__(self):
        return "Army(name:'{}', array:{}".format(self.army_name, self.array)

    def __str__(self):
        return "Army: '{}' - Units({}): {}".format(self.army_name, len(self.array), self.array)

    def add_units(self, unit, count=1, **kwargs):
        assert issubclass(unit, Warrior)
        assert count > 0
        if unit.__name__ == Warlord.__name__:  # or issubclass(unit, Warlord)?
            # ignore count > 1
            if isinstance(self._warlord, StrawMan):
                self._warlord = unit(**kwargs)
                self.array.append(self._warlord)
        else:
            for i in range(count):
                self.array.append(unit(**kwargs))

    @property
    def units(self):
        return self.array

    @property
    def is_alive(self):
        if len(self.array) > 0:
            return any(x.is_alive for x in self.array)
        return False

    @property
    def alive_units(self):
        return (u for u in self.array if u.is_alive)

    @property
    def head_unit(self):
        for pos, unit in enumerate(self.array):
            if unit.is_alive:
                self.head_pos = pos
                return unit
        return self.strawman  # instead of None

    def unit_next(self, depth=1):
        """Unit next inline in array after head unit (may not be alive)"""
        #self.head_unit  # let caller advance position if head_unit is dead
        idx = self.head_pos + depth
        return self.array[idx] if idx < len(self.array) else self.strawman  # instead of None

    def resurrect(self):
        for unit in self.array:
            unit.resurrect()

    @property
    def has_warlord(self):
        return isinstance(self._warlord, Warlord)

    def move_units(self):
        """Resort Unit order in array.
            Sort Rules:
             Lancers first in front, All Healers always in pos 2+, Warlord in the back.
        """
        if self.has_warlord:  # and self._warlord.is_alive ## TODO does alive matter??
            # Category [Bracket] Groups:
            # front = 1 # One unit, Lancer first
            # healers = 2 # be healed
            # reserves = 3,4 # go to front, has attack > 0
            # rabble = 5,6 # fodder, no attack
            # gentry = 7 # Warlords and dignitaries
            # pire = 9 # Bring out your dead!
            healers, reserve_lancers, reserves, rabble, gentry, pire = 2, 3, 4, 5, 7, 9
            self._front_pick = None

            def unit_bracket_eff(unit):
                if not unit.is_alive:
                    bkt = pire
                elif isinstance(unit, Healer):
                    bkt = healers
                elif isinstance(unit, Lancer):
                    bkt = reserve_lancers
                elif isinstance(unit, Warlord):
                    bkt = gentry
                elif unit.attack > 0:
                    bkt = reserves
                else:
                    bkt = rabble
                # lower is better - to match attack_priority
                eff = int(self.attack_priority.get(unit.__class__.__name__, 11) * 100)
                eff += int(100 - ((unit.health + (unit.attack * 10)) * unit.is_alive) / 100.0)
                return (unit, bkt, eff)

            sorted_regiment = [unit_bracket_eff(unit) for unit in self.array]
            sorted_regiment = sorted(sorted_regiment, key=lambda u: u[2])  # effectiveness
            sorted_regiment = sorted(sorted_regiment, key=lambda u: u[1])  # rank

            # Fill front position
            # Move units based on effectiveness or not, or just rank ? FIXME??
            # When only left with healers and warlord, healers go first ;), front_pick is None
            for unit, bkt, eff in sorted_regiment:  # pick next candidate
                if bkt > healers and bkt < gentry \
                        and (self._front_pick is None
                            or bkt < self._front_pick[1]
                            or (bkt == self._front_pick[1] and eff < self._front_pick[2])
                            ):
                    self._front_pick = (unit, bkt, eff)

            new_regiment = [u for u, *_ in sorted_regiment]
            if self._front_pick is not None:
                new_regiment.remove(self._front_pick[0])
                new_regiment.insert(0, self._front_pick[0])
            assert len(self.array) == len(new_regiment)
            self.array = new_regiment
            return True
        return False


# ----------------------
# Weapons
# ----------------------

class Weapon(object):
    """A Weapon"""
    weapon_count = 0

    def __init__(self, health=0, attack=0, defense=0, vampirism=0, heal_power=0, name="", **kwargs):
        self.health = int(health)
        self.attack = int(attack)
        self.defense = int(defense)
        self.vampirism = int(vampirism)  # in percent
        self.heal_power = int(heal_power)  # amount of health imputed
        self.attrs = ['health', 'attack', 'defense', 'vampirism', 'heal_power']

        Weapon.weapon_count += 1
        self.serial = self.weapon_count
        self.name = name if name else "weapon#{}".format(self.serial)

        self.init_kw = kwargs
        for k, v in kwargs.items():
            if k.startswith('_') or k in ['serial', 'attrs', 'init_kw']: continue
            setattr(self, k, v)

    def __repr__(self):
        attrs_str = ['{}:{}'.format(a, getattr(self,a)) for a in self.attrs]
        return "Weapon({}: name:'{}', {})".format(self.__class__.__name__, self.name, ', '.join(attrs_str))

    def __str__(self):
        return "Weapon({}:'{}':{}h,{}a,{}d,{}v,{}j)".format(
                self.__class__.__name__,
                self.name,
                self.health, self.attack,
                self.defense, self.vampirism, self.heal_power)


class Sword(Weapon):
    def __init__(self, health=5, attack=2, defense=0, vampirism=0, heal_power=0, **kwargs):
        super(Sword, self).__init__(health, attack, defense, vampirism, heal_power, **kwargs)


class Shield(Weapon):
    def __init__(self, health=20, attack=-1, defense=2, vampirism=0, heal_power=0, **kwargs):
        super(Shield, self).__init__(health, attack, defense, vampirism, heal_power, **kwargs)


class GreatAxe(Weapon):
    def __init__(self, health=-15, attack=5, defense=-2, vampirism=10, heal_power=0, **kwargs):
        super(GreatAxe, self).__init__(health, attack, defense, vampirism, heal_power, **kwargs)


class Katana(Weapon):
    def __init__(self, health=-20, attack=6, defense=-5, vampirism=50, heal_power=0, **kwargs):
        super(Katana, self).__init__(health, attack, defense, vampirism, heal_power, **kwargs)


class MagicWand(Weapon):
    def __init__(self, health=30, attack=3, defense=0, vampirism=0, heal_power=3, **kwargs):
        super(MagicWand, self).__init__(health, attack, defense, vampirism, heal_power, **kwargs)

# ----------------------

class Battle(object):
    """Battle between combatants: Armies and units"""
    def __init__(self):
        self.field = {}

    def _unit_attack_round(self, attacker, defender):
        # Unit Attack
        damage = defender.take_hit(attacker.attack)
        # Unit effects
        if isinstance(attacker, Vampire):
            attacker.attack_heal(damage)
        return damage

    def unit_combat(self, unit_a, unit_b, max_rounds=0):
        """Mortal Combat between two Units
        """
        if max_rounds < 1: max_rounds = (unit_a.health + unit_b.health) * 2

        for i in range(max_rounds):

            if unit_a.is_alive and unit_b.is_alive: # fight is on
                if i % 2 == 0:
                    self._unit_attack_round(unit_a, unit_b)
                else:
                    self._unit_attack_round(unit_b, unit_a)
            else:
                return unit_a.is_alive

        # Max rounds and still no winner?
        return None

    def _army_combat_effects(self, attacker, defender, attacking_army, defending_army, attack_damage):
        # Army effects to/from other units
        if isinstance(attacker, Lancer):
            lanced_unit = defending_army.unit_next()
            lanced_unit.take_hit(attacker.lancing_attack(attack_damage))
            if not lanced_unit.is_alive:
                defending_army.move_units()

        attacking_unit_next = attacking_army.unit_next()
        if isinstance(attacking_unit_next, Healer):
            attacking_unit_next.heal(attacker)

    def army_unit_combat(self, army_a, army_b, max_rounds=0):
        """Mortal Combat between Units in an Army
        """
        unit_a = army_a.head_unit
        unit_b = army_b.head_unit

        if max_rounds < 1: max_rounds = (unit_a.health + unit_b.health) * 2

        for i in range(max_rounds):

            if unit_a.is_alive and unit_b.is_alive: # fight is on

                if i % 2 == 0:
                    unit_damage = self._unit_attack_round(unit_a, unit_b)
                    self._army_combat_effects(unit_a, unit_b, army_a, army_b, unit_damage)
                else:
                    unit_damage = self._unit_attack_round(unit_b, unit_a)
                    self._army_combat_effects(unit_b, unit_a, army_b, army_a, unit_damage)
            else:
                return unit_a.is_alive

        # Max rounds and still no winner?
        return None

    def battle(self, army_a, army_b, max_volleys=0, as_straight_fight=False):
        """Army Battle
            Returns True|False|None for winner of army_a|army_b, or neither after max_rounds
        """
        if max_volleys < 1:
            max_volleys = (len(army_a.array) + len(army_b.array)) * 2

        # Warlords:
        if not as_straight_fight:
            army_a.move_units()
            army_b.move_units()

        for i in range(max_volleys):

            if army_a.is_alive and army_b.is_alive:  # To Battle!

                if as_straight_fight:
                    # rank and file (1v1) combat
                    fights = zip(army_a.alive_units, army_b.alive_units)
                    combat_result = [self.unit_combat(*fight) for fight in fights]

                    # Warlords:
                    # if any(combat_result):     # army_a unit(s) have win
                    #     army_b.move_units()
                    # if not all(combat_result):  # army_b unit(s) have win
                    #     army_a.move_units()

                else:
                    # single file combat
                    combat_result = self.army_unit_combat(army_a, army_b)
                    if combat_result is None:
                        return None

                    # Warlords:
                    if combat_result:   # army_a unit won
                        army_b.move_units()
                    else:               # army_b unit won
                        army_a.move_units()

            elif army_a.is_alive and not army_b.is_alive:
                return True
            elif not army_a.is_alive and army_b.is_alive:
                return False
            else:
                raise ValueError("Both Armies Perished, Possible?!")

        return None

    def fight(self, combatant_a, combatant_b, max_rounds=0):
        """Fight between combatants"""
        if isinstance(combatant_a, Army):
            return self.battle(combatant_a, combatant_b, max_volleys=max_rounds)
        return self.unit_combat(combatant_a, combatant_b, max_rounds=max_rounds)

    def straight_fight(self, army_a, army_b, max_volleys=0):
        """Return True|False|None for winner of army_a|army_b, or neither after max_rounds

            Army_a fights Army_b as ranks with combat between each file of alive units, per volley
            a[0] fights b[0], a[1] fights b[1], ...
        """
        return self.battle(army_a, army_b, max_volleys=max_volleys, as_straight_fight=True)

# ----------------------

def fight(unit_a, unit_b, max_rounds=0):
    return Battle().fight(unit_a, unit_b, max_rounds=max_rounds)

# Testing individual prowess
def all_1v1():
    warriors = [Warrior, Knight, Defender, Vampire, Lancer, Healer, Warlord]
    fights = [(w(), u()) for w in warriors for u in warriors]
    results = [fight(*clash) for clash in fights]
    return [ "{} v {} => {}".format(w[0],w[1], r) for w, r in zip(fights, results)]

# ----------------------

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing

    ogre = Warrior()
    lancelot = Knight()
    richard = Defender()
    eric = Vampire()
    freelancer = Lancer()
    priest = Healer()

    sword = Sword()
    shield = Shield()
    axe = GreatAxe()
    katana = Katana()
    wand = MagicWand()
    super_weapon = Weapon(50, 10, 5, 150, 8)

    ogre.equip_weapon(sword)
    ogre.equip_weapon(shield)
    ogre.equip_weapon(super_weapon)
    lancelot.equip_weapon(super_weapon)
    richard.equip_weapon(shield)
    eric.equip_weapon(super_weapon)
    freelancer.equip_weapon(axe)
    freelancer.equip_weapon(katana)
    priest.equip_weapon(wand)
    priest.equip_weapon(shield)

    ogre.health == 125
    lancelot.attack == 17
    richard.defense == 4
    eric.vampirism == 200
    freelancer.health == 15
    priest.heal_power == 5

    fight(ogre, eric) == False
    fight(priest, richard) == False
    fight(lancelot, freelancer) == True

    my_army = Army()
    my_army.add_units(Knight, 1)
    my_army.add_units(Lancer, 1)

    enemy_army = Army()
    enemy_army.add_units(Vampire, 1)
    enemy_army.add_units(Healer, 1)

    my_army.units[0].equip_weapon(axe)
    my_army.units[1].equip_weapon(super_weapon)

    enemy_army.units[0].equip_weapon(katana)
    enemy_army.units[1].equip_weapon(wand)

    battle = Battle()

    battle.fight(my_army, enemy_army) == True

    ronald = Warlord()
    heimdall = Knight()

    fight(heimdall, ronald) == False

    my_army = Army()
    my_army.add_units(Warlord, 1)
    my_army.add_units(Warrior, 2)
    my_army.add_units(Lancer, 2)
    my_army.add_units(Healer, 2)

    enemy_army = Army()
    enemy_army.add_units(Warlord, 3)
    enemy_army.add_units(Vampire, 1)
    enemy_army.add_units(Healer, 2)
    enemy_army.add_units(Knight, 2)

    my_army.move_units()
    enemy_army.move_units()

    type(my_army.units[0]) == Lancer
    type(my_army.units[1]) == Healer
    type(my_army.units[-1]) == Warlord

    type(enemy_army.units[0]) == Vampire
    type(enemy_army.units[-1]) == Warlord
    type(enemy_army.units[-2]) == Knight

    #6, not 8, because only 1 Warlord per army could be
    len(enemy_army.units) == 6

    battle = Battle()
    battle.fight(my_army, enemy_army) == True

    #print("Coding complete? Let's try tests!")
May 17, 2021
Incinerator
0 %
CheckiO ClassRoom Don’t waste any time! Create your first class right now for free and help your students to learn programming more effectively.