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 %
You ClassRoom Demo is Ready With the new tool CheckiO ClassRoom, you will be able to analyze your students' progress, have your own leaderboard, change missions order on the map, and so on.