using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TheSlimesJourney
{
    public static class Game
    {
        public enum Actions
        {
            Attack,
            Cancel,
            Continue,
            Defend,
            DefenseUpgrade,
            DropItem,
            EatItem,
            EatItemDirect,
            Grow,
            HealthUpgrade,
            Help,
            LeaveItem,
            Mutate,
            Rest,
            Run,
            Status,
            StrengthUpgrade,
            TakeItem,
            UseItem,
            UseItemCombat,
            Wander,
            Quit,
            RealQuit,
            One,
            Two,
            Three,
            Four,
            Five,
            Six,
            Seven,
            Eight,
            Nine,
            Yes,
            No
        }

        public enum GameState
        {
            Combat,
            Dead,
            Dead2,
            DroppingItem,
            EatingItem,
            EventChoice,
            Free,
            Growing,
            Intro,
            Mutating,
            ObtainingItem,
            Returning,
            Quitting,
            UsingItem,
            UsingItemCombat,
            Victory,
            Wandering
        }

        //Internal stuff
        public static bool ambushed = false;
        static List<Actions> availableActions;
        public static List<string> eventChoiceDescriptions;
        public static List<string> eventChoiceResults;
        public static GameState gameState = GameState.Intro;
        public static List<Item> itemsToBeHandled = new List<Item>();
        static List<Mutation> mutationOptions;
        static int originalNumberOfEnemies = 0;
        static Random random = new Random();
        static bool running = true;
        public static string victoryEvent = "";
        static List<Event> wanderEvents;
        static UI ui;

        //Game info
        static bool canUseItems = false;
        static List<Effect> effects = new List<Effect>();
        static List<Character> enemies = new List<Character>();
        public static Dictionary<string, bool> flags = new Dictionary<string, bool>();
        public static Location location;
        public static Character player;
        public static int turn = 0;

        //Stats
        static int healthUpgrade = 1;
        static int inventorySize = 0;
        static int strengthUpgrade = 1;
        static int defenseUpgrade = 1;
        static int mutation = 1;

        //=======================GENERAL==================

        public static void AddAvailableChoices(int amount, bool canCancel)
        {
            availableActions.Add(Actions.One);
            if (amount > 1) availableActions.Add(Actions.Two);
            if (amount > 2) availableActions.Add(Actions.Three);
            if (amount > 3) availableActions.Add(Actions.Four);
            if (amount > 4) availableActions.Add(Actions.Five);
            if (amount > 5) availableActions.Add(Actions.Six);
            if (amount > 6) availableActions.Add(Actions.Seven);
            if (amount > 7) availableActions.Add(Actions.Eight);
            if (amount > 8) availableActions.Add(Actions.Nine);
            if (canCancel) availableActions.Add(Actions.Cancel);
        }

        public static void ChangeLocation(string newLocation)
        {
            location = new Location(newLocation);
            ShuffleDeck();
        }

        static void CreatePlayer()
        {
            player = new Character();
            player.name = "Slime";
            player.health = 10;
            player.maxHealth = 10;
            player.strength = 5;
            player.defense = 0;
        }

        //Returns true if you're dead
        public static bool DeathCheck()
        {
            if (player.health <= 0) return true;
            return false;
        }

        public static void EnterCombat(List<Character> enemies)
        {
            itemsToBeHandled = new List<Item>();
            effects = new List<Effect>();
            Game.enemies = enemies;
            originalNumberOfEnemies = enemies.Count;
            gameState = GameState.Combat;
            string enemiesDescription = "a " + enemies[0].name;
            ui.Print("");
            
            if (ambushed)
            {
                ui.Print("#red#You are ambushed by " + enemiesDescription + "!");
                ui.Pause();
                ambushed = false;
                CombatEnemyTurn();
            }
            else
            {
                ui.Print("#yellow#You encounter " + enemiesDescription + "!");
                ui.Pause();
                StartTurn();
            }
        }

        public static bool GetFlag(string name)
        {
            if (!flags.ContainsKey(name)) return false;
            else return flags[name];
        }

        static void Grow()
        {
            ui.Print("You have " + player.experience + " experience left to spend.");
            ui.Print("");
            ui.Print("#white#(1)#default# Upgrade Health: " + player.maxHealth + " -> " + (player.maxHealth + 5) + " [" + healthUpgrade + " experience]");
            ui.Print("#white#(2)#default# Upgrade Strength: " + player.strength + " -> " + (player.strength + 1) + " [" + strengthUpgrade + " experience]");
            ui.Print("#white#(3)#default# Upgrade Defense: " + player.defense + " -> " + (player.defense + 1) + " [" + defenseUpgrade + " experience]");
            ui.Print("#white#(4)#default# Acquire a new mutation [" + (mutation * 5) + " experience]");
            ui.Print("#white#(0)#default# Cancel");
            gameState = GameState.Growing;
        }

        public static void HandleAction(Actions action)
        {
            switch (action)
            {
                //Free mode
                case Actions.DropItem: DropItem(); break;
                case Actions.EatItem: EatItem(); break;
                case Actions.Grow: Grow(); break;
                case Actions.UseItem: UseItem(false); break;
                case Actions.Rest: Rest(); break;
                case Actions.Wander: Wander(); break;
                case Actions.Quit: gameState = GameState.Quitting; break;
                case Actions.RealQuit: running = false; break;
                //Combat mode
                case Actions.Attack: CombatPlayerAttack(); break;
                case Actions.Defend: CombatPlayerDefend(); break;
                case Actions.UseItemCombat: UseItem(true); break;
                case Actions.Run: CombatRun(); break;
                //Grow
                case Actions.HealthUpgrade: UpgradeHealth(); break;
                case Actions.StrengthUpgrade: UpgradeStrength(); break;
                case Actions.DefenseUpgrade: UpgradeDefense(); break;
                case Actions.Mutate: Mutate(); break;
                //Obtaining items
                case Actions.LeaveItem:
                    ui.Print("You leave the #purple#" + itemsToBeHandled[0].name + "#default#.");
                    ui.Pause();
                    itemsToBeHandled.RemoveAt(0);
                    ObtainItem();
                    break;
                case Actions.TakeItem:
                    ui.Print("You take the #purple#" + itemsToBeHandled[0].name + "#default#.");
                    ui.Pause();
                    player.inventory.Add(itemsToBeHandled[0]);
                    itemsToBeHandled.RemoveAt(0);
                    ObtainItem();
                    break;
                case Actions.EatItemDirect:
                    player.inventory.Add(itemsToBeHandled[0]);
                    EatItem(itemsToBeHandled[0]);
                    itemsToBeHandled.RemoveAt(0);
                    ObtainItem();
                    break;
                //Misc
                case Actions.Cancel:
                case Actions.Continue:
                    switch (gameState)
                    {
                        case GameState.Growing:
                        case GameState.Returning:
                        case GameState.DroppingItem:
                        case GameState.UsingItem:
                        case GameState.EatingItem:
                            gameState = GameState.Free;
                            break;
                        case GameState.UsingItemCombat:
                            gameState = GameState.Combat;
                            break;
                        case GameState.Intro:
                            IntroStory();
                            break;
                    }
                    break;
                case Actions.One: HandleChoice(0); break;
                case Actions.Two: HandleChoice(1); break;
                case Actions.Three: HandleChoice(2); break;
                case Actions.Four: HandleChoice(3); break;
                case Actions.Five: HandleChoice(4); break;
                case Actions.Six: HandleChoice(5); break;
                case Actions.Seven: HandleChoice(6); break;
                case Actions.Eight: HandleChoice(7); break;
                case Actions.Nine: HandleChoice(8); break;
            }

            //State-specific actions
            switch (gameState)
            {
                case GameState.Victory:
                    switch (action)
                    {
                        case Actions.Yes: Return(); break;
                        case Actions.No: running = false; break;
                    }
                    break;
                case GameState.Dead:
                    switch (action)
                    {
                        case Actions.Yes: ui.PrintStatus(); gameState = GameState.Dead2; break;
                        case Actions.No: running = false; break;
                    }
                    break;
                case GameState.Quitting:
                    switch (action)
                    {
                        case Actions.Yes: running = false; break;
                        case Actions.No: gameState = GameState.Free; break;
                    }
                    break;
            }
        }

        public static void HandleChoice(int choice)
        {
            switch (gameState)
            {
                case GameState.Wandering:
                    if (wanderEvents.Count > choice)
                    {
                        //Return other cards
                        for (int i = 0; i < wanderEvents.Count; i++)
                        {
                            if (i != choice)
                            {
                                location.currentDeck.Add(wanderEvents[i]);
                            }
                        }

                        //Execute script
                        ScriptHandler.HandleScript(wanderEvents[choice].script);
                    }
                    break;
                case GameState.Mutating:
                    if (mutationOptions.Count > choice)
                    {
                        //Return other cards
                        for (int i = 0; i < mutationOptions.Count; i++)
                        {
                            if (i != choice)
                            {
                                Mutation.possibleMutations.Add(mutationOptions[i]);
                            }
                        }

                        //Add mutation
                        AddMutation(mutationOptions[choice]);
                        Grow();
                    }
                    break;
                case GameState.DroppingItem:
                    if (player.inventory.Count > choice)
                    {
                        Item item = player.inventory[choice];
                        ui.Print("You drop the #purple#" + item.GetName() + "#default#.");
                        if (item.equipped) ScriptHandler.HandleScript(item.unequipScript, item);
                        player.inventory.Remove(item);

                        if (player.inventory.Count > inventorySize) DropItem();
                        else Return();
                    }
                    break;
                case GameState.EatingItem:
                    if (player.inventory.Count > choice)
                    {
                        EatItem(player.inventory[choice]);
                        Return();
                    }
                    break;
                case GameState.UsingItem:
                    if (player.inventory.Count > choice)
                    {
                        UseItem(player.inventory[choice], false);
                        Return();
                    }
                    break;
                case GameState.UsingItemCombat:
                    if (player.inventory.Count > choice)
                    {
                        UseItem(player.inventory[choice], true);
                        CombatEnemyTurn();
                    }
                    break;
                case GameState.EventChoice:
                    if (eventChoiceResults.Count > choice)
                    {
                        ScriptHandler.HandleScript(new Event(eventChoiceResults[choice]).script);
                    }
                    break;
            }
        }

        public static void IntroStory()
        {
            ui.Clear();
            ui.Print("When you were but a young slime, a cruel adventurer #red#killed#default# both of your parents in front of your eyes.");
            ui.Print("It was no isolated incident. For as long as slimekind can remember, humans have always murdered slimes - for territory, for practice, or even sheerly for sport.");
            ui.Print("To this day, adventurers keep murdering dozens of innocent slimes on a daily basis.");
            ui.Print("But on that day, they crossed the wrong slime. On that day, you vowed to yourself: I will avenge my parents and stop the human massacres.");
            ui.Print("After a long time, you are finally ready to set out on your journey to change the world.");
            Return();
        }

        public static void ObtainItem()
        {
            bool nothingToDo = false;
            if (itemsToBeHandled.Count == 0) nothingToDo = true;
            if (inventorySize == 0 && !player.mutations.ContainsKey("Item Absorption")) nothingToDo = true;

            if (nothingToDo)
            {
                Return();
            }
            else
            {
                ui.Print("What do you wish to do with the #purple#" + itemsToBeHandled[0].name + "#default#?");
                gameState = GameState.ObtainingItem;
            }
        }

        public static void Rest()
        {
            if (player.mutations.ContainsKey("Dwelling"))
            {
                ScriptHandler.HandleScript(new Event("dwelling").script);
            }
            else
            {
                if (location.restDeck == null || location.restDeck.Count == 0)
                {
                    ui.Print("You cannot rest here.");
                    Return();
                }
                else
                {
                    ScriptHandler.HandleScript(location.restDeck[random.Next(location.restDeck.Count)].script);
                }
            }
        }

        public static void Return()
        {
            gameState = GameState.Returning;

            if (itemsToBeHandled.Count > 0 && (canUseItems || player.mutations.ContainsKey("Item Absorption")))
            {
                ObtainItem();
            }
        }

        public static void SetFlag(string key, bool value)
        {
            if (flags.ContainsKey(key)) flags.Remove(key);
            flags.Add(key, value);
        }

        public static void SetUI(UI newUI)
        {
            ui = newUI;
            ScriptHandler.SetUI(newUI);
        }

        //Puts all usable cards from FullDeck in CurrentDeck. (Doesn't actually shuffle.)
        public static void ShuffleDeck()
        {
            location.currentDeck = new List<Event>();
            for (int i = 0; i < location.fullDeck.Count; i++)
            {
                Event theEvent = location.fullDeck[i];
                
                //Check requirements
                bool accepted = true;
                if (theEvent.requirements != null)
                {
                    for (int ii = 0; ii < theEvent.requirements.Length; ii++)
                    {
                        string[] split = theEvent.requirements[ii].Split(new string[] { " " }, StringSplitOptions.None);
                        if (split.Length > 0)
                        {
                            string baseCommand = split[0];
                            string argument = Utils.RBQ(theEvent.requirements[ii]);

                            if (!ScriptHandler.Evaluate(baseCommand, argument, false)) accepted = false;
                        }
                    }
                }
                
                //Add it
                if (accepted) location.currentDeck.Add(theEvent);
            }
        }

        public static void StartGame()
        {
            Mutation.AddMutations();
            CreatePlayer();
            ChangeLocation("infinity_plains");

            ui.DisplayIntro();

            while (running)
            {
                StartTurn();
            }
        }

        public static void StartTurn()
        {
            //Death check
            if (gameState != GameState.Dead && gameState != GameState.Dead2 && DeathCheck())
            {
                ui.GameOver();
                gameState = GameState.Dead;
            }

            //Regenerate
            if (gameState == GameState.Combat)
            {
                if (player.mutations.ContainsKey("Regeneration"))
                {
                    if (player.health < player.maxHealth)
                    {
                        int amountHealed = player.Heal(2);
                        ui.Print("You regenerate, healing " + amountHealed + " HP.");
                    }
                }
            }

            //Check if player has too many items
            if (player.inventory.Count > inventorySize) DropItem();

            //Start of turn script
            if (location.updateScript != null)
            {
                ScriptHandler.HandleScript(location.updateScript);
            }

            //Add actions
            availableActions = new List<Actions>();
            switch (gameState)
            {
                case GameState.Free:
                    ui.Print("#cyan#Location: " + location.name);
                    ui.Print(location.description);

                    if (player.inventory.Count > 0) availableActions.Add(Actions.DropItem);
                    if (player.mutations.ContainsKey("Item Absorption") && player.inventory.Count > 0) availableActions.Add(Actions.EatItem);
                    if (player.experience > 0) availableActions.Add(Actions.Grow);
                    if (canUseItems && player.inventory.Count > 0) availableActions.Add(Actions.UseItem);
                    availableActions.Add(Actions.Rest);
                    availableActions.Add(Actions.Status);
                    availableActions.Add(Actions.Wander);
                    availableActions.Add(Actions.Quit);
                    break;

                case GameState.Combat:
                    ui.Print("");
                    ui.DisplayCondition();
                    ui.DescribeEnemies(enemies);

                    availableActions.Add(Actions.Attack);
                    if (player.mutations.ContainsKey("Defensive Ability")) availableActions.Add(Actions.Defend);
                    if (canUseItems) availableActions.Add(Actions.UseItemCombat);
                    availableActions.Add(Actions.Run);
                    break;

                case GameState.Dead2:
                    availableActions.Add(Actions.RealQuit);
                    break;

                case GameState.Returning:
                case GameState.Intro:
                    availableActions.Add(Actions.Continue);
                    break;

                case GameState.Wandering:
                    availableActions.Add(Actions.One);
                    if (wanderEvents.Count > 1) availableActions.Add(Actions.Two);
                    if (wanderEvents.Count > 2) availableActions.Add(Actions.Three);
                    break;

                case GameState.Growing:
                    availableActions.Add(Actions.HealthUpgrade);
                    availableActions.Add(Actions.StrengthUpgrade);
                    availableActions.Add(Actions.DefenseUpgrade);
                    availableActions.Add(Actions.Mutate);
                    availableActions.Add(Actions.Cancel);
                    break;

                case GameState.Mutating:
                    availableActions.Add(Actions.One);
                    if (mutationOptions.Count > 1) availableActions.Add(Actions.Two);
                    if (mutationOptions.Count > 2) availableActions.Add(Actions.Three);
                    break;

                case GameState.ObtainingItem:
                    availableActions.Add(Actions.LeaveItem);
                    if (player.mutations.ContainsKey("Item Absorption")) availableActions.Add(Actions.EatItemDirect);
                    if (inventorySize > 0) availableActions.Add(Actions.TakeItem);
                    break;

                case GameState.DroppingItem:
                case GameState.EatingItem:
                case GameState.UsingItem:
                case GameState.UsingItemCombat:
                    AddAvailableChoices(player.inventory.Count, player.inventory.Count <= inventorySize);
                    break;
                case GameState.EventChoice:
                    AddAvailableChoices(eventChoiceResults.Count, false);
                    break;

                case GameState.Victory:
                case GameState.Quitting:
                case GameState.Dead:
                    availableActions.Add(Actions.Yes);
                    availableActions.Add(Actions.No);
                    break;
            }

            ui.WaitForInput(availableActions);
        }

        public static void Wander()
        {
            itemsToBeHandled.Clear();
            victoryEvent = "";
            wanderEvents = new List<Event>();
            turn++;
            //Add first event
            if (location.currentDeck.Count == 0)
            {
                ui.Print("You are stuck without options. Blame the developer or whoever messed with the game files, as this is not supposed to happen.");
                ui.Pause();
                ui.Print("");
            }
            else
            {
                Event toAdd = location.currentDeck[random.Next(location.currentDeck.Count)];
                wanderEvents.Add(toAdd);
                location.currentDeck.Remove(toAdd);
                //Add second event, if possible
                if (location.currentDeck.Count > 0)
                {
                    toAdd = location.currentDeck[random.Next(location.currentDeck.Count)];
                    wanderEvents.Add(toAdd);
                    location.currentDeck.Remove(toAdd);
                }
                //Add third event if you have Keen Senses
                if (player.mutations.ContainsKey("Keen Senses"))
                {
                    if (location.currentDeck.Count > 0)
                    {
                        toAdd = location.currentDeck[random.Next(location.currentDeck.Count)];
                        wanderEvents.Add(toAdd);
                        location.currentDeck.Remove(toAdd);
                    }
                }

                gameState = GameState.Wandering;
                ui.DisplayWanderOptions(wanderEvents);
            }
        }

        public static void WinGame()
        {
            SetFlag("wongame", true);
            ui.Print("");
            ui.Print("#white#Congratulations! You have cleared the game in " + turn + " turns!");
            ui.Pause();
            ui.Pause();
            ui.Pause();
            ui.Pause();
            ui.Pause();
            ui.Print("");
            ui.Print("Do you wish to continue playing?");
            gameState = GameState.Victory;
        }

        //=================GROWTH=================
        static void AddMutation(Mutation mutation)
        {
            player.mutations.Add(mutation.name, mutation.description);
            ui.Print("You gain a new mutation: " + mutation.name + "!");
            ui.Pause();

            //Special stuff on acquiring certain mutations
            switch (mutation.name)
            {
                case "Tentacle":
                case "Goo Hand":
                case "Claw":
                    inventorySize++;
                    canUseItems = true;
                    SetFlag("inventory", true);
                    SetFlag("itemuse", true);
                    break;
                case "Body Storage":
                    inventorySize += 3;
                    SetFlag("inventory", true);
                    break;
                case "Wings":
                    player.dodgeChance += 20;
                    break;
                case "Speed":
                    player.dodgeChance += 10;
                    break;
            }
        }

        static void UpgradeHealth()
        {
            if (player.experience >= healthUpgrade)
            {
                player.experience -= healthUpgrade;
                healthUpgrade++;
                player.maxHealth += 5;
                player.health += 5;
                Grow();
            }
            else
            {
                ui.Print("You do not have enough experience to upgrade your health.");
                ui.Pause();
                Grow();
            }
        }

        static void UpgradeStrength()
        {
            if (player.experience >= strengthUpgrade)
            {
                player.experience -= strengthUpgrade;
                strengthUpgrade++;
                player.strength += 1;
                Grow();
            }
            else
            {
                ui.Print("You do not have enough experience to upgrade your strength.");
                ui.Pause();
                Grow();
            }
        }

        static void UpgradeDefense()
        {
            if (player.experience >= defenseUpgrade)
            {
                player.experience -= defenseUpgrade;
                defenseUpgrade++;
                player.defense += 1;
                Grow();
            }
            else
            {
                ui.Print("You do not have enough experience to upgrade your defense.");
                ui.Pause();
                Grow();
            }
        }

        static void Mutate()
        {
            if (player.experience >= mutation * 5)
            {
                mutationOptions = new List<Mutation>();

                if (Mutation.possibleMutations.Count == 0)
                {
                    ui.Print("You are unable to mutate any further in the current location.");
                    ui.Pause();
                    ui.Print("");
                }
                else
                {
                    for (int i = 0; i < 3; i++)
                    {
                        if (Mutation.possibleMutations.Count > 0)
                        {
                            Mutation toAdd = Mutation.possibleMutations[random.Next(Mutation.possibleMutations.Count)];
                            mutationOptions.Add(toAdd);
                            Mutation.possibleMutations.Remove(toAdd);
                        }
                    }

                    player.experience -= mutation * 5;
                    mutation++;

                    gameState = GameState.Mutating;
                    ui.DisplayMutationOptions(mutationOptions);
                }
            }
            else
            {
                ui.Print("You do not have enough experience to gain a mutation.");
                ui.Pause();
                Grow();
            }
        }

        //=================ITEMS============
        static void DropItem()
        {
            bool forced = (player.inventory.Count > inventorySize);

            if (forced)
            {
                string itemPlural = "items";
                if (inventorySize == 1) itemPlural = "item";
                ui.Print("#red#You are carrying too many items. You can only carry " + inventorySize + " i" + itemPlural + ".");
                ui.Print("");
            }
            gameState = GameState.DroppingItem;
            ui.DisplayInventoryOptions(player.inventory, forced);
        }

        static void EatItem()
        {
            gameState = GameState.EatingItem;
            ui.DisplayInventoryOptions(player.inventory, false);
        }

        static void EatItem(Item item)
        {
            player.experience += item.experience;
            ui.Print("You eat the #purple#" + item.GetName() + ".");
            ui.Pause();
            ui.Print("#white#You gain " + item.experience + " experience!");
            ui.Pause();
            if (item.equipped) ScriptHandler.HandleScript(item.unequipScript, item);
            player.inventory.Remove(item);
        }

        static void UseItem(bool inCombat = false)
        {
            if (inCombat) gameState = GameState.UsingItemCombat;
            else gameState = GameState.UsingItem;
            ui.DisplayInventoryOptions(player.inventory, false);
        }

        static void UseItem(Item item, bool inCombat = false)
        {
            if (item != null)
            {
                if (inCombat == false && item.useScript != null)
                {
                    ScriptHandler.HandleScript(item.useScript, item);
                }
                else if (inCombat == true && item.combatUseScript != null)
                {
                    ScriptHandler.HandleScript(item.combatUseScript, item);
                }
                else
                {
                    ui.Print("You do not understand how to use this item.");
                    ui.Pause();
                }
            }

            if (inCombat)
            {
                gameState = GameState.Combat;
            }
            else Return();
        }

        //=================COMBAT====================
        //Returns damage dealt, or -1 if attack is dodged
        public static int CombatAttack(Character attacker, Character defender)
        {
            //Dodge chance
            if (random.NextDouble() * 100 < defender.dodgeChance) return -1;

            //Calculate damage
            int damage = attacker.strength;
            damage -= defender.defense;
            if (damage < 1) damage = 1;

            if (attacker.mutations.ContainsKey("Aggression"))
            {
                damage *= 2;
            }

            //Apply damage
            defender.health -= damage;

            return damage;
        }

        static void CombatEnd()
        {
            for (int i = 0; i < effects.Count; i++)
            {
                Effect effect = effects[i];
                if (effect.triggerAtEndOfCombat)
                {
                    if (CombatHandleEffect(effect)) i--; //Returns true if effect is removed
                }
            }

            Return();
        }

        static void CombatEndTurn()
        {
            for (int i = 0; i < effects.Count; i++)
            {
                Effect effect = effects[i];
                if (effect.triggerAtEndOfTurn)
                {
                    if (CombatHandleEffect(effect)) i--; //Returns true if effect is removed
                }
            }
        }

        public static void CombatEnemyDeathCheck()
        {
            bool stopAndRecheck = false;

            for (int i = 0; i < enemies.Count; i++)
            {
                if (!stopAndRecheck)
                {
                    Character enemy = enemies[i];

                    if (enemy.health <= 0)
                    {
                        ui.Print("Enemy " + enemy.name + " dies!");
                        ui.Pause();
                        
                        //Gain exp
                        int expgain = enemy.experience;
                        if (player.mutations.ContainsKey("Adaptable"))
                        {
                            expgain = Convert.ToInt32(Math.Floor((float)expgain * 1.2f));
                        }
                        player.experience += expgain;
                        ui.Print("#white#You gain " + expgain + " experience!");
                        
                        //Item drops
                        for (int ii = 0; ii < enemy.inventory.Count; ii++) { itemsToBeHandled.Add(enemy.inventory[ii]); }

                        //Remove enemy
                        enemies.Remove(enemy);
                        ui.Pause();
                        stopAndRecheck = true;
                    }
                }
            }

            if (stopAndRecheck) CombatEnemyDeathCheck();
            else if (enemies.Count == 0)
            {
                //----VICTORY-----
                ui.Print("#white#You are victorious!");
                ui.Pause();
                int numItems = itemsToBeHandled.Count;
                if (numItems > 0 && (inventorySize > 0 || player.mutations.ContainsKey("Item Absorption")))
                {
                    string enemyPlural = "The enemy";
                    if (originalNumberOfEnemies > 1) enemyPlural = "The enemies";
                    string itemPlural = "an item";
                    if (numItems == 2) itemPlural = "two items";
                    else if (numItems == 3) itemPlural = "three items";
                    else if (numItems > 3) itemPlural = "several items";

                    string itemList = "";
                    for (int i = 0; i < numItems; i++)
                    {
                        itemList += "#purple#" + itemsToBeHandled[i].name + "#default#";
                        if (i < numItems - 2)
                        {
                            itemList += ", ";
                        }
                        else if (i == numItems - 2)
                        {
                            itemList += " and ";
                        }
                    }

                    ui.Print(enemyPlural + " left behind " + itemPlural + ": " + itemList);
                }

                CombatEnd();

                if (victoryEvent != "")
                {
                    ScriptHandler.HandleScript(new Event(victoryEvent).script);
                }
            }
        }

        public static void CombatEnemyTurn()
        {
            for (int i = 0; i < enemies.Count; i++)
            {
                Character enemy = enemies[i];

                string attack = enemy.attacks[random.Next(enemy.attacks.Count)];
                int damage = 0;
                switch(attack)
                {
                    case "attack":
                        damage = CombatAttack(enemy, player);
                        if (damage > 0)
                        {
                            ui.Print("#red#" + enemy.name + " hits you for " + damage + " damage!");
                        }
                        else if (damage == -1)
                        {
                            ui.Print("#yellow#" + enemy.name + " attacks, but you manage to dodge!");
                        }
                        break;
                    case "leech":
                        damage = CombatAttack(enemy, player);
                        if (damage > 0)
                        {
                            enemy.Heal(damage, true);
                            ui.Print("#red#" + enemy.name + " bites you, draining " + damage + " health!");
                        }
                        else if (damage == -1)
                        {
                            ui.Print("#yellow#" + enemy.name + " tries to bite you, but misses!");
                        }
                        break;
                    case "stare":
                        ui.Print("#red#" + enemy.name + " stares at you in an intimidating manner.");
                        break;
                    case "cry":
                        ui.Print("#red#" + enemy.name + " makes a wailing sound!");
                        break;
                    case "nothing":
                        ui.Print("#yellow#" + enemy.name + " doesn't do anything.");
                        break;
                    case "regenerate":
                        enemy.FullHeal();
                        ui.Print("#red#" + enemy.name + " regenerates!");
                        ui.Pause();
                        break;
                    default:
                        ui.Print("#yellow#" + enemy.name + " tries to do something but fumbles!");
                        break;
                }
                ui.Pause();

                if (damage > 0)
                {
                    if (player.mutations.ContainsKey("Resilience"))
                    {
                        int healed = player.Heal(4);
                        ui.Print("#green#Your body's natural healing powers activate, healing " + healed + " health!");
                    }
                }
            }

            CombatEndTurn();
        }

        //Returns true if effect is removed from effect list
        static bool CombatHandleEffect(Effect effect)
        {
            switch (effect.name)
            {
                case "defending":
                    player.defense -= effect.parameterInt;
                    effects.Remove(effect);
                    return true;
            }

            return false;
        }

        public static void CombatPlayerAttack()
        {
            Character target = enemies[random.Next(enemies.Count)];
            string attackDescription = "attack";

            if (player.mutations.ContainsKey("Vampirism")) attackDescription = "drain";

            int damage = CombatAttack(player, target);
            if (damage > 0)
            {
                ui.Print("#green#You " + attackDescription + " " + target.name + " for " + damage + " damage!");
                ui.Pause();
                if (player.mutations.ContainsKey("Vampirism"))
                {
                    int healed = player.Heal(damage, true);
                    ui.Print("#green#You heal " + healed + " health!");
                    ui.Pause();
                }
            }
            else if (damage == -1)
            {
                ui.Print("#yellow#You try to " + attackDescription + " " + target.name + ", but miss!");
            }
            CombatEnemyDeathCheck();
            if (gameState == GameState.Combat) { CombatEnemyTurn(); } //Only if enemies are still alive
        }

        public static void CombatPlayerDefend()
        {
            ui.Print("#yellow#You defend yourself against incoming attacks!");
            int defenseBonus = player.defense;
            Effect effect = new Effect("defending", defenseBonus);
            effect.triggerAtEndOfTurn = true;
            effect.triggerAtEndOfCombat = true;
            effects.Add(effect);
            player.defense += defenseBonus;
            CombatEnemyTurn();
        }

        public static void CombatRun()
        {
            float runChance = 0.25f;
            if (player.mutations.ContainsKey("Camouflage")) runChance = 0.5f;
            if (random.NextDouble() < runChance)
            {
                ui.Print("#green#You escaped successfully!");
                itemsToBeHandled.Clear(); //No items for cowards
                CombatEnd();
            }
            else
            {
                ui.Print("#yellow#You do not manage to get away!");
                ui.Pause();
                CombatEnemyTurn();
            }
        }
    }
}