import random
import time
import pickle
import math

FIND_PERCENTAGE = 100
SKILL_PERCENT = 80

class HuntResponse:
    ERROR = -1
    FAILURE = 0
    SUCCESS = 1

    def __init__(self, result, message, monster):
        self.result = result
        self.message = message
        self.monster = monster

exp_to_level = [0, 500, 1250, 2250, 3500, 5000, 6750, 8750, 10950, 13350, 15950, 18750, 21750, 24950, 28350, 31950, 35750, 39750, 43950, 48350, 52950, 57750, 62750, 67850, 73050, 78350, 83750, 89250, 94850, 100550, 106350, 112250, 118250, 124350, 130550, 136850, 143250, 149750, 156350, 163050, 169850, 176750, 183750, 190850, 198050, 205350, 212750, 220250, 227850, 235550, 243350]

exp_table = {
    15: 600, 
    14: 600,
    13: 600,
    12: 600,
    11: 600,
    10: 600,
    9: 600,
    8: 600,
    7: 550,
    6: 450,
    5: 350,
    4: 300,
    3: 240,
    2: 220,
    1: 210,
    0: 200,
    -1: 180,
    -2: 160,
    -3: 150,
    -4: 140,
    -5: 130,
    -6: 120,
    -7: 110,
    -8: 100,
    -9: 80,
    -10: 60,
    -11: 40,
    -12: 40,
    -13: 40,
    -14: 40,
    -15: 20,
}
class Jobs:
    BLM = 1
    BLU = 2
    BRD = 3
    BST = 4
    COR = 5
    DNC = 6
    DRG = 7
    DRK = 8
    GEO = 9
    MNK = 10
    NIN = 11
    PLD = 12
    PUP = 13
    RDM = 14
    RNG = 15
    RUN = 16
    SAM = 17
    SCH = 18
    SMN = 19
    THF = 20
    WAR = 21
    WHM = 22

    def get_job_name(self, job):
        members = [attr for attr in dir(Jobs()) if not callable(attr) and not attr.startswith("__") and not attr.startswith("get_job_name")]
        return members[job-1]

evasion_by_job = {
    Jobs.BLM: {'base_eva': 4, 'eva_per_level': 2.48},
    Jobs.BLU: {'base_eva': 5, 'eva_per_level': 2.78},
    Jobs.BRD: {'base_eva': 4, 'eva_per_level': 2.66},
    Jobs.BST: {'base_eva': 5, 'eva_per_level': 2.78},
    Jobs.COR: {'base_eva': 4, 'eva_per_level': 2.66},
    Jobs.DNC: {'base_eva': 5, 'eva_per_level': 2.88},
    Jobs.DRG: {'base_eva': 5, 'eva_per_level': 2.88},
    Jobs.DRK: {'base_eva': 5, 'eva_per_level': 2.78},
    Jobs.GEO: {'base_eva': 4, 'eva_per_level': 2.66},
    Jobs.MNK: {'base_eva': 5, 'eva_per_level': 2.88},
    Jobs.NIN: {'base_eva': 6, 'eva_per_level': 3},
    Jobs.PLD: {'base_eva': 5, 'eva_per_level': 2.78},
    Jobs.PUP: {'base_eva': 5, 'eva_per_level': 2.88},
    Jobs.RDM: {'base_eva': 4, 'eva_per_level': 2.66},
    Jobs.RNG: {'base_eva': 4, 'eva_per_level': 2.48},
    Jobs.RUN: {'base_eva': 5, 'eva_per_level': 2.88},
    Jobs.SAM: {'base_eva': 5, 'eva_per_level': 2.88},
    Jobs.SCH: {'base_eva': 4, 'eva_per_level': 2.48},
    Jobs.SMN: {'base_eva': 4, 'eva_per_level': 2.48},
    Jobs.THF: {'base_eva': 6, 'eva_per_level': 3},
    Jobs.WAR: {'base_eva': 5, 'eva_per_level': 2.78},
    Jobs.WHM: {'base_eva': 4, 'eva_per_level': 2.48},
}

TemperamentPosture = {
    4: {"name": "Very Agressive", "message": "Show no mercy!", "value": 4},
    3: {"name": "Somewhat Agressive", "message": "Give em' a little more bite!", "value": 3},
    2: {"name": "Somewhat Defensive", "message": "Back off a bit!", "value": 2},
    1: {"name": "Very Defensive", "message": "Guard! Block! Parry! Hold!", "value": 1}
}

TemperamentAttitude = {
    4: {"name": "Very Wild", "message": "Don't think, kill!", "value": 4},
    3: {"name": "Somewhat Wild", "message": "Less thinking, more striking!", "value": 3},
    2: {"name": "Somewhat Tame", "message": "Watch your opponent, then attack!", "value": 2},
    1: {"name": "Very Tame", "message": "Think, and think again!", "value": 1}
}

PhysicalDamageTypes = {
    'blunt': ['Hand-to-Hand', 'Club', 'Staff', 'Harlequin Frame', 'Stormwaker Frame', 'Sharpshot Frame'],
    'slashing': ['Axe', 'Great Axe', 'Great Sword', 'Sword', 'Scythe', 'Katana', 'Great Katana', 'Valoredge Frame'],
    'piercing': ['Dagger', 'Polearm', 'Archery', 'Marksmanship', 'Shuriken', 'Boomerang']
}

FeralSkills = {
    'Airy Shield': {'fp_cost': 0, 'type': 'Enhancing', 'sub_type': 'arrow shield', 'shadows': 'ignore', 'range': None, 'aoe': False, 'spell': 'arrow shield'},
    'Binding Wave': {'type': 'Enfeebling', 'shadows': 'ignore', 'range': 15, 'aoe': True, 'spell': 'bind'},
    'Dire Straight': {'type': 'Physical', 'shadows': 'wipe', 'range': None, 'aoe': False},
    'Dismemberment': {'type': 'Piercing', 'shadows': 'absorb', 'range': None, 'aoe': False}, # causes the monster to lose a body part
    'Earthshatter': {'type': 'Piercing', 'shadows': 'wipe', 'range': None, 'aoe': True},
    'Eyes On Me': {'type': 'Magical', 'sub_type': 'Dark', 'mp_cost': 112, 'shadows': 'absorb', 'range': 13, 'aoe': False},
    'Hypnosis': {'type': 'Enfeebling', 'sub_type': 'sleep', 'shadows': 'ignore', 'range': 'gaze', 'aoe': True},
    'Magic Barrier': {'type': 'Magical', 'sub_type': 'Dark', 'mp_cost': 29, 'shadows': 'absorb', 'range': None, 'aoe': True},
    'Sinker Drill': {'type': 'Physical', 'sub_type': 'Piercing', 'shadows': 'absorb', 'range': None, 'aoe': False},
}
Families = {
    'acrolith': {
        'base_fp': 50,
        'fp_per_level': 0.1,
        'max_fp': 55,
        'available_main_job': [Jobs.WAR, Jobs.DRG, Jobs.DRK, Jobs.PLD],
        'available_support_job': [Jobs.WAR, Jobs.DRG, Jobs.DRK, Jobs.PLD],
        'innate_feral_skills': ['Sinker Drill', 'Dire Straight', 'Dismemberment', 'Earthshatter'],
        'type': 'Arcana',
        'strong_vs': ['Dark'],
        'charmable': False,
        'aspir': False,
        'drain': False,
        'base_vit': 10,
        'vit_per_level': 0.9334,
        'base_str': 9,
        'str_per_level': 0.8934,
        'base_agi': 7,
        'agi_per_level': 0.76,
        'base_dex': 10,
        'dex_per_level': 0.76,
        'temperament_attitude': {
            'initial_value': 4,
            'actions': {
                4: {'use_tp_chance': 100, 'ws': ['Sinker Drill'], 'side_attack_chance': 0, 'range_chance': 0},
                3: {'use_tp_chance': 75, 'ws': ['Eyes On Me'], 'side_attack_chance': 70, 'range_chance': 10},
                2: {'use_tp_chance': 50, 'ws': ['Binding Wave', 'Hypnosis'], 'side_attack_chance': 25, 'range_chance': 70},
                1: {'use_tp_chance': 70, 'ws': ['Binding Wave', 'Hypnosis', 'Magic Barrier', 'Airy Shield'], 'side_attack_chance': 25, 'range_chance': 70}
            }
        },
        'temperament_posture': {
            'initial_value': 4,
            'actions': {
                4: {'use_tp_chance': 100, 'ws': ['Eyes On Me'], 'side_attack_chance': 0, 'range_chance': 0},
                3: {'use_tp_chance': 75, 'ws': ['Eyes On Me'], 'side_attack_chance': 70, 'range_chance': 10},
                2: {'use_tp_chance': 50, 'ws': ['Binding Wave', 'Hypnosis'], 'side_attack_chance': 25, 'range_chance': 70},
                1: {'use_tp_chance': 70, 'ws': ['Magic Barrier', 'Airy Shield'], 'side_attack_chance': 25, 'range_chance': 100}
            }
        }
    },
    'ahriman': {
        'base_fp': 65,
        'fp_per_level': 0.3,
        'max_fp': 80,
        'available_main_job': [Jobs.BLM, Jobs.RDM, Jobs.WAR],
        'available_support_job': [Jobs.BLM, Jobs.RDM, Jobs.WAR],
        'innate_feral_skills': ['Binding Wave', 'Magic Barrier', 'Hypnosis', 'Eyes On Me', 'Airy Shield'],
        'type': 'Demon',
        'traits': ['magic defence bonus +25%'],
        'charmable': False,
        'aspir': True,
        'drain': True,
        'base_vit': 8,
        'vit_per_level': 0.8,
        'base_str': 8,
        'str_per_level': 0.8534,
        'base_agi': 9,
        'agi_per_level': 0.88,
        'base_dex': 10,
        'dex_per_level': 0.714,
        'temperament_attitude': {
            'initial_value': 4,
            'actions': {
                4: {'use_tp_chance': 100, 'ws': ['Eyes On Me'], 'side_attack_chance': 0, 'range_chance': 0},
                3: {'use_tp_chance': 75, 'ws': ['Eyes On Me'], 'side_attack_chance': 70, 'range_chance': 10},
                2: {'use_tp_chance': 50, 'ws': ['Binding Wave', 'Hypnosis'], 'side_attack_chance': 25, 'range_chance': 70},
                1: {'use_tp_chance': 70, 'ws': ['Binding Wave', 'Hypnosis', 'Magic Barrier', 'Airy Shield'], 'side_attack_chance': 25, 'range_chance': 70}
            }
        },
        'temperament_posture': {
            'initial_value': 4,
            'actions': {
                4: {'use_tp_chance': 100, 'ws': ['Eyes On Me'], 'side_attack_chance': 0, 'range_chance': 0},
                3: {'use_tp_chance': 75, 'ws': ['Eyes On Me'], 'side_attack_chance': 70, 'range_chance': 10},
                2: {'use_tp_chance': 50, 'ws': ['Binding Wave', 'Hypnosis'], 'side_attack_chance': 25, 'range_chance': 70},
                1: {'use_tp_chance': 70, 'ws': ['Magic Barrier', 'Airy Shield'], 'side_attack_chance': 25, 'range_chance': 100}
            }
        }
    }
}

Monsters = {
    'Mechanical Menace': {
        'initial_level': 9,
        'family': 'acrolith',
        'zone': 'Abyssea - Uleguerand',
        'hp': 20,
        'weapon_base_damage': 14
    },
    'Floating Eye': {
        'initial_level': 10,
        'family': 'ahriman',
        'zone': 'Ranguemont Pass',
        'hp': 15,
        'weapon_base_damage': 15
    }
}


class Pankration:
    def __init__(self):
        pass

    def start_battle(self, monster1, monster2, battle_type):
        battle = Arena(monster1, monster2, battle_type)
        battle.start()
        return battle

    def list_zones(self):
        zone_list = []
        for monster in Monsters.itervalues():
            if monster['zone'] not in zone_list:
                zone_list.append(monster['zone'])
        return zone_list

    def get_monsters(self, zone):
        monster_list = []
        for monster_name, monster in Monsters.iteritems():
            if monster['zone'] == zone:
                monster_list.append(monster_name)
        return monster_list

    def hunt_monster(self, zone):
        if random.randint(1, 100) < FIND_PERCENTAGE:
            monster_name = random.choice(self.get_monsters(zone))
            monster_data = Monsters[monster_name]
            hp = monster_data['hp']
            weapon_base_damage = monster_data['weapon_base_damage']
            print("Monster: {} Data: {}".format(monster_name, monster_data))
            family_name = monster_data['family']
            family = Families[family_name]
            level = monster_data['initial_level']
            main_job = random.choice(family['available_main_job'])
            support_job = random.choice(family['available_support_job'])
            while support_job == main_job:
                support_job = random.choice(family['available_support_job'])
            feral_skills = []
            skills = random.sample(family['innate_feral_skills'], 3)
            if random.randint(1, 100) < SKILL_PERCENT:
                feral_skills.append(skills[0])
                if random.randint(1, 100) < SKILL_PERCENT:
                    feral_skills.append(skills[1])
                    if random.randint(1, 100) < SKILL_PERCENT:
                        feral_skills.append(skills[2])
            dicipline_level = 1

            monster = Monster(monster_name, family_name, family, hp, level, weapon_base_damage, main_job, support_job, feral_skills,
                              [], dicipline_level)
            return HuntResponse(HuntResponse.SUCCESS, "You captured a *{}*!".format(monster_name),
                                monster)
        else:
            return HuntResponse(HuntResponse.FAILURE, "You were unable to capture a monster's soul.",
                                None)

    def get_action():
        return ""


class Monster:
    def __init__(self, monster_type, family_name, family, base_hp, level, weapon_base_damage, main_job, support_job, innate_feral_skills,
                 equipped_feral_skills, dicipline_level):
        self.monster_type = monster_type
        self.family_name = family_name
        self.family = family
        self.base_hp = base_hp
        self.level = level
        self.main_job = main_job
        self.support_job = support_job
        self.innate_feral_skills = innate_feral_skills
        self.equipped_feral_skills = equipped_feral_skills
        self.discipline_level = dicipline_level
        self.temperament_posture = family['temperament_posture']['initial_value']
        self.temperament_attitude = family['temperament_attitude']['initial_value']
        self.pre_fight_command = {"temperament_posture": None, "temperament_attitude": None}
        self.exp = exp_to_level[level] + 1
        # TODO: Setup something more interesting for each monster. 
        self.weapon_base_damage = weapon_base_damage
        self.ammo_damage = 0
        self.base_vit = family['base_vit']
        self.vit_per_level = family['vit_per_level']
        self.base_str = family['base_str']
        self.str_per_level = family['str_per_level']
        self.base_agi = family['base_agi']
        self.agi_per_level = family['agi_per_level']
        self.base_dex = family['base_dex']
        self.dex_per_level = family['dex_per_level']
        self.hp = self.get_hp()
        self.wins = 0
        self.losses = 0

    def __str__(self):
        try:
            return "**{}**\n*Stats:*\nFamily: {}\nLevel: {}\nMain Job: {}\nSupport Job: {}\nInnate Feral Skills: {}\nEquipped Feral Skills: {}\nFeral Points: {}\n\nWins: {}\nLosses: {}".format(self.monster_type, self.family_name, self.level, Jobs().get_job_name(self.main_job), Jobs().get_job_name(self.support_job), ', '.join(self.innate_feral_skills), ', '.join(self.equipped_feral_skills), self.get_fp(), self.wins, self.losses)
        except AttributeError:
            return "Old Format monster, unable to display."
        #return "Family: {}\nLevel: {}\nMain Job: {}\nSupport Job: {}\nInnate Feral Skills: {}\nEquipped Feral Skills: {}\nDicipline Level: {}\nTemperament...".format(self.family, self.level, self.main_job, self.support_job, self.innate_feral_skills, self.equipped_feral_skills, self.discipline_level)

    def get_soul_plate_description(self):
        try:
            return "*Family:*\n**{}**\nJob Trait: {}\nFeral Points: {}".format(self.family_name, Jobs().get_job_name(self.main_job), self.get_fp())
        except AttributeError:
            return "Old Format monster, unable to display."
        #return "Family: {}\nLevel: {}\nMain Job: {}\nSupport Job: {}\nInnate Feral Skills: {}\nEquipped Feral Skills: {}\nDicipline Level: {}\nTemperament...".format(self.family, self.level, self.main_job, self.support_job, self.innate_feral_skills, self.equipped_feral_skills, self.discipline_level)

    def get_reflector_description(self):
        try:
            return "**{}**\n*Stats:*\nFamily: {}\nLevel: {}\nMain Job: {}\nSupport Job: {}\nInnate Feral Skills: {}\nEquipped Feral Skills: {}\nFeral Points: {}\n\nWins: {}\nLosses: {}".format(self.monster_type, self.family_name, self.level, Jobs().get_job_name(self.main_job), Jobs().get_job_name(self.support_job), ', '.join(self.innate_feral_skills), ', '.join(self.equipped_feral_skills), self.get_fp(), self.wins, self.losses)
        except AttributeError:
            return "Old Format monster, unable to display."
        #return "Family: {}\nLevel: {}\nMain Job: {}\nSupport Job: {}\nInnate Feral Skills: {}\nEquipped Feral Skills: {}\nDicipline Level: {}\nTemperament...".format(self.family, self.level, self.main_job, self.support_job, self.innate_feral_skills, self.equipped_feral_skills, self.discipline_level)

    def get_hp(self):
        #this is a bit dumb but it's close enough.
        return int((self.level * 20) + self.base_hp)

    def get_fp(self):
        return int(self.level / self.family['fp_per_level'] + self.family['base_fp'])

    def add_xp(self, exp_to_add):
        self.exp += exp_to_add
        for i in range(self.level, 51):
            if self.exp > exp_to_level[i]:
                if i > self.level:
                    # We leveled up!
                    self.level = i
                    #print("Start level: {} New Level: {}".format(self.level, i))
            else:
                break

    def get_current_posture(self):
        return TemperamentPosture(self.temperament_posture)

    def get_current_attitude(self):
        return TemperamentAttitude(self.temperament_attitude)

    def get_dicipline_level(self):
        if self.dicipline_level < 2:
            return "Defiant"
        elif self.dicipline_level < 5:
            return "Disrespectful"
        elif self.dicipline_level < 7:
            return "Disobedient"
        else:
            return "Obedient"

    def get_combat_skill(self):
        # This is a very very complicated relationship betwen job and weapon type and how often it is used.
        # We are going to generalize it since it's a pain in the ass and just take the average A+ rating and get the cap for the current level
        return int(round(max(5, self.level * 2.88)))


    def get_dexterity(self):
        return int(round(max(self.base_dex, self.level * self.dex_per_level)))

    def get_accuracy(self):
        # We ignore magic / ranged / melee here and give everyone a good acc. This could be improved by doing a lookup for each type and based on the
        # type of monster (magic, range, or melee) then adjust the combat skill according to what type of attack is being performed.
        return int(math.floor(3*self.get_dexterity()/4) + self.get_combat_skill())

    def get_evasion(self):
        job_eva = evasion_by_job[self.main_job]
        base_eva = int(round(max(job_eva['base_eva'], self.level * job_eva['eva_per_level'])))

        return base_eva + int(self.get_agility() / 2)

    def get_vitality(self):
        return int(round(max(self.base_vit, self.level * self.vit_per_level)))

    def get_strength(self):
        return int(round(max(self.base_str, self.level * self.str_per_level)))

    def get_agility(self):
        return int(round(max(self.base_agi, self.level * self.agi_per_level)))

    def get_base_defense(self):
        return (math.floor(self.get_vitality()/2) + 8 + self.level)

    def get_hp_percent(self):
        print(self.hp)
        return max(0, int(round((self.hp/self.get_hp())*100)))

    def get_hit_rate(self, enemy_eva, level_difference):
        rate = 75 + math.floor(((self.get_accuracy() - enemy_eva)/2)) - (2*level_difference)
        if rate < 20:
            rate = 20
        elif rate > 95:
            rate = 95
        return rate

    # Calculate the base damage against the provided defense
    # attack_type can be 'ranged' or 'melee'
    def get_physical_base_damage(self, defense, attack_type, level_difference, enemy_vit):
        #print("Defense: {} Type: {} Level diff: {}".format(defense, attack_type, level_difference))
        # Calculate the attack/defense ratio
        bd = float(self.weapon_base_damage)
        if attack_type == 'ranged':
            bd += self.ammo_damage

        if defense == 0:
            ratio = 99
        else:
            ratio = bd / float(defense)
        if attack_type == 'ranged':
            cap = 3.0
        else:
            cap = 2.25
        if ratio > cap:
            ratio = cap
        # Get the level correction ratio
        if attack_type == 'ranged':
            cRatio = ratio - 0.025 * level_difference
        else:
            cRatio = ratio - 0.050 * level_difference
        if cRatio < 0:
            cRatio = 0
        if attack_type == 'ranged':
            if cRatio > 3.0:
                cRatio = 3.0
        else:
            if cRatio > 2.25:
                cRatio = 2.25
        # Calculate the pDif max as the max of our RNG
        if cRatio <= 0.5:
            pDif_max = 1+(10/9)*(cRatio-0.5)
        elif 0.5 <= cRatio <= float(3/4):
            pDif_max = 1
        elif float(3/4) <= cRatio <= cap:
            pDif_max = 1+(10/9)*(cRatio-float(3/4))

        # Calculate the pDif max as the max of our RNG
        if cRatio <= 0.5:
            pDif_min = 1/6
        elif 0.5 <= cRatio <= 1.25:
            pDif_min = 1+(10/9)*(cRatio-1.25)
        elif 1.25 <= cRatio <= 1.5:
            pDif_min = 1
        elif 1.5 <= cRatio <= cap:
            pDif_min = 1+(10/9)*(cRatio-1.5)

        # Some fuckery since python doesn't let you do a rand between decimals
        pDif_rand = float(random.randint(int(pDif_min*100000), int(pDif_max*100000))) / 100000.0
        
        fstr = ((self.get_strength() - enemy_vit)+4) / 4
        print("Str: {} Vit: {} fstr: {}".format(self.get_strength(), enemy_vit, fstr))
        bd = bd + fstr
        final_damage = (bd * (pDif_rand * cRatio))
        return final_damage

    def attack(self, monster):
        phy_damage = self.get_physical_base_damage(monster.get_base_defense(), 'melee', monster.level - self.level, monster.get_vitality())
        return (phy_damage, 'hits')

    def is_a_hit(self, monster):
        hit_rate = self.get_hit_rate(monster.get_evasion(),  monster.level - self.level)
        return random.randint(1, 100) < hit_rate

    def apply_damage(self, damage):
        self.hp -= damage
        # Check life and return 'awesome', 'fucked up', 'dead' or something

    # This should ONLY be executed at the start of battle.
    def set_strategy(self, temperament_posture, temperament_attitude):        
        distance_from_nature = abs(self.temperament_posture - temperament_posture)
        distance_from_nature += abs(self.temperament_attitude - temperament_attitude)

        if distance_from_nature == 0:
            chance_of_listening = self.discipline_level
        else:
            chance_of_listening = float(float(self.discipline_level) / (float(distance_from_nature)/10))

        chance_of_listening = abs(float((float(chance_of_listening)-1)/(20-1)))

        if random.randint(1, 100) > chance_of_listening * 100:
            print("DO ACTION:")
            # adjust dicipline_level
            # move temperament
        else:
            #continue action
            #if severe request then reduce dicipline_level
            pass

class Action:
    def __init__(self, monster):
        self.monster = monster

class AttackAction(Action):
    def __init__(self, attacker, target, damage, message):
        self.attacker = attacker
        self.target = target
        self.damage = damage
        self.message = message

class MissAction(Action):
    def __init__(self, attacker, target, message):
        self.attacker = attacker
        self.target = target
        self.message = message

class DefeatAction(Action):
    def __init__(self, attacker, target, message, xp):
        self.attacker = attacker
        self.target = target
        self.message = message
        self.xp = xp


class Arena:

    def __init__(self, monster1, monster2, battle_type):
        self.monster1 = monster1
        self.monster2 = monster2
        self.battle_type = battle_type

    def heal_monsters(self):
        pass

    def start(self):
        self.heal_monsters()
        self.m1_init = self.monster1.get_agility() + random.randint(1, 20)
        self.m2_init = self.monster2.get_agility() + random.randint(1, 20)

    def step(self):
        actions = []
        if self.m1_init > self.m2_init:
            primary = self.monster1
            secondary = self.monster2
        else:
            primary = self.monster2
            secondary = self.monster1

        if primary.is_a_hit(secondary):
            result1 = primary.attack(secondary)
            secondary.apply_damage(result1[0])
            actions.append(AttackAction(primary, secondary, result1[0], result1[1]))
            if secondary.hp <= 0:
                level_difference = secondary.level - primary.level
                if level_difference in exp_table:
                    xp = exp_table[level_difference]
                elif level_difference > 15:
                    xp = exp_table[15]
                else:
                    xp = 0
                actions.append(DefeatAction(primary, secondary, 'was defeated', xp))
                return actions
        else:
            actions.append(MissAction(primary, secondary, 'missed'))

        if secondary.is_a_hit(primary):
            result2 = secondary.attack(primary)
            primary.apply_damage(result2[0])
            actions.append(AttackAction(secondary, primary, result2[0], result2[1]))
            if primary.hp <= 0:
                xp = 200 + (20 * (primary.level - secondary.level))
                actions.append(DefeatAction(secondary, primary, 'was defeated', xp))
                return actions
        else:
            actions.append(MissAction(secondary, primary, 'missed'))
        return actions


if __name__ == "__main__":
    #print Families

    p = Pankration()
    print("Zones: \n\n{}".format('\n'.join(p.list_zones())))
    hunt_zone = p.list_zones()[0]
    print("Hunting for monster in zone: {}\n".format(hunt_zone))
    hunt_response = p.hunt_monster(hunt_zone)
    print("hunt_response")
    print(str(hunt_response.result))
    time.sleep(0.5)
    if hunt_response.result == HuntResponse.SUCCESS:
        print(hunt_response.message)
        monster = hunt_response.monster
        # print("The Soul Plate Shows: \n\n{}".format(monster))
        # print(monster.set_strategy(4, 3))
        # print(monster.set_strategy(1, 1))
        # print(monster.set_strategy(1, 2))
        #monster.add_xp(22900)
        # phy_damage = monster.get_physical_base_damage(100, 'melee', -15)
        # print("Phys Attack: {}".format(phy_damage))
        # print(monster.get_base_defense())
        # monster.add_xp(22900)
        # print(monster.get_base_defense())
        # monster.add_xp(222900)
        # print(monster.get_base_defense())
    else:
        print(hunt_response.message)


    hunt_zone = p.list_zones()[1]
    hunt_response = p.hunt_monster(hunt_zone)
    if hunt_response.result == HuntResponse.SUCCESS:
        monster2 = hunt_response.monster
        #monster2.add_xp(16900)
        phy_damage = monster2.attack(monster)
        print("Phys Attack: {}".format(phy_damage))


    print("Acc: {}".format(monster.get_accuracy()))
    print("Eva: {}".format(monster.get_evasion()))

    print("Acc: {}".format(monster2.get_accuracy()))
    print("Eva: {}".format(monster2.get_evasion()))

    battle_arena = p.start_battle(monster, monster2, "derp")
    fighting = True
    while fighting:
        actions = battle_arena.step()
        time.sleep(2)
        for action in actions:
            if isinstance(action, MissAction):
                print("{} {} {}.".format(action.attacker.monster_type, action.message, action.target.monster_type))
            if isinstance(action, AttackAction):
                print("{} {} {} for {}.".format(action.attacker.monster_type, action.message, action.target.monster_type, action.damage))
            if isinstance(action, DefeatAction):
                print("{} {}. {} gains {} xp.".format(action.target.monster_type, action.message, action.attacker.monster_type, action.xp))
                fighting = False
                break
        print("\n{} {}%    -    {}  {}%\n".format(monster.monster_type, monster.get_hp_percent(), monster2.monster_type, monster2.get_hp_percent()))