Python Monsters - WIP

class Monster:
    """parent class for all Monsters"""
    def __init__(self, name, weight, health = 30):
        """initialies an Animal instance"""
        self.__name = name
        self.__weight = weight
        self.__health = health

    #Standard Damage Taking, Health - Damage
    def takeDamage(self, damage):
        if (damage < self.__health):
            healthRemaining = self.__health - damage
            print("%s Has Taken Damage! Health Remaining: %d"  %(self.__name,healthRemaining))
            self.__health = healthRemaining


        else:
            print("Critical Blow! %s is defeated!"%(self.__name))
            self.__health = 0

    #Returns whether a monster is Alive or Not
    def isAlive(self):
        return self.__health > 0

    #Returns the health of a monster
    def getHealth(self):
        return self.__health

    @property
    def weight(self):
        return self.__weight

    @property
    def name(self):
        return self.__name

    #Allows a Monster to recover Health
    def recoverHealth(self, recovery):
        newHealth = self.__health + recovery
        self.__health = newHealth
        print(" %s Recovered Health! New Health: %d" %(self.__name, self.__health))



#ArmoredMonster, a subclass of Monster
class ArmoredMonster(Monster):
    def __init__(self, name, weight, health, armor = 30):
        super().__init__(name, weight, health)
        self.__armor = armor

    #Returns an armored monsters Armor
    def getArmor(self):
        return self.__armor

    #Armored Monster Taking Damage. ArmoredMonsters take damage to Armor first, then their health.
    def takeDamage(self, damage):
        if(damage <= self.__armor ):
            remainingArmor = self.__armor - damage
            print("%s Has Taken Damage! Armor Remaining: %d" %(self._Monster__name,remainingArmor))
            self.__armor = remainingArmor

        elif(damage < self._Monster__health+self.__armor):
            remainingArmor = self.__armor - damage
            self.__armor = remainingArmor
            remainingHealth = remainingArmor + self._Monster__health
            print("%s Has Taken Damage! Health Remaining: %d" %(self._Monster__name,remainingHealth))
            self._Monster__health = remainingHealth
            self.__armor = 0

        else:
            self.__armor = 0
            self._Monster__health = 0
            print("Critical Blow! %s is defeated!" %(self._Monster__name))


    #Allows an Armored Monster to repair its armor
    def repairArmor(self, repair):
        newArmor = self.__armor + repair
        self.__armor = newArmor
        print("%s Repaired Their Armor! New Armor: %d" %(self._Monster__name, self.__armor))

#ShieldedMonster, a subclass of Monster
class ShieldedMonster(Monster):
    def __init__(self, name, weight, health, shield = 50, resistance = "arc"):
        super().__init__(name, weight, health)
        self.__shield = shield
        self.__resistance = resistance

    #Returns a shielded Monsters Shield value
    def getShield(self):
        return self.__shield

    #Returns the Resistance of a Shielded Monsters Shield
    def getResistance(self):
        return self.__resistance


    #Since Shielded Monsters must take damage to their shield first, we must determine if the elements match first, then use that to determine damage
    def takeDamage(self, damage, element = "none"):
        if(element.lower() == self.__resistance.lower()):
            shieldDamage = (damage * 2)
        else:
            shieldDamage = (damage * 0.5)


        if(shieldDamage <= self.__shield ):
            remainingShield = self.__shield - shieldDamage
            print("%s Has Taken Damage! Shield Remaining: %d" %(self._Monster__name,remainingShield))
            self.__shield = remainingShield

        elif(shieldDamage < self._Monster__health + self.__shield):
            remainingShield = self.__shield - shieldDamage
            self.__shield = remainingShield
            remainingHealth = remainingShield + self._Monster__health
            print("%s Has Taken Damage! Health Remaining: %d" %(self._Monster__name,remainingHealth))
            self._Monster__health = remainingHealth
            self.__armor = 0

        else:
            self.__shield = 0
            self._Monster__health = 0
            print("Critical Blow! %s is defeated!" %(self._Monster__name))

#A Cabal, A classification of Monster
class Cabal(Monster):
    def __init__(self,name,weight, health):
        super().__init__(name, weight, health)


    #Returns the Title of a Cabal based on their Weight classification.
    def getTitle(self):
        if(self._Monster__weight > 1000):
            self.__title = "Emperor"
        elif(self._Monster__weight > 900):
            self.__title = "Dominus"
        elif(self._Monster__weight > 800):
            self.__title = "Colossus"
        elif(self._Monster__weight > 700):
            self.__title = "Centurion"
        elif(self._Monster__weight > 600):
            self.__title = "Gladiator"
        elif(self._Monster__weight > 500):
            self.__title = "Incendior"
        elif(self._Monster__weight > 400):
            self.__title = "Phalanx"
        elif(self._Monster__weight > 300):
            self.__title = "Legionary"
        elif(self._Monster__weight > 200):
            self.__title = "Psion"
        elif(self._Monster__weight > 100):
            self.__title = "War Beast"
        else:
            self.__title = "Unworthy"


        return self.__title


#A Fallen, a Classification of Shielded Monster
class Fallen(ShieldedMonster):
    def __init__(self, name, weight, health, shield = 50, resistance = "arc"):
        super().__init__(name, weight, health, shield, resistance)


    #Assigns the Title of the Fallen based on their Shield Capacity
        if(self._ShieldedMonster__shield > 700):
            self.__title= "Kell"
        elif(self._ShieldedMonster__shield > 600):
            self.__title = "Archon"
        elif(self._ShieldedMonster__shield > 500):
            self.__title = "Servitor"
        elif(self._ShieldedMonster__shield > 400):
            self.__title = "Captain"
        elif(self._ShieldedMonster__shield > 300):
            self.__title = "Vandal"
        elif(self._ShieldedMonster__shield > 200):
            self.__title = "Dreg"
        elif(self._ShieldedMonster__shield > 100):
            self.__title = "Shank"
        else:
            self.__title = "Hatchling"

#Returns the title of a Fallen
    def getTitle(self):
        return self.__title


#A Hive, a Classification of Armored Monster
class Hive(ArmoredMonster):
    def __init__(self, name, weight, health, armor = 30):
        super().__init__(name, weight, health, armor)

        if(self._ArmoredMonster__armor > 600):
            self.__title = "Blood of Oryx"
        elif(self._ArmoredMonster__armor > 500):
            self.__title = "Captain"
        elif(self._ArmoredMonster__armor > 400):
            self.__title = "Knight"
        elif(self._ArmoredMonster__armor > 300):
            self.__title = "Adherent"
        elif(self._ArmoredMonster__armor > 200):
            self.__title = "Acolyte"
        elif(self._ArmoredMonster__armor > 100):
            self.__title = "Thrall"
        else:
            self.__title = "Larva"

    #Returns the Title of the Hive
    def getTitle(self):
        return self.__title