TalesOfNovariel/Assets/Scripts/Player/PlayerObject.cs

using System;
using System.Collections.Generic;
using Assets.Scripts.Classes;
using Assets.Scripts.Races;
using Newtonsoft.Json.Linq;

namespace Assets.Scripts.Player
{
    public class PlayerObject
    {
        Random rand = new Random();
        Dictionary<string, PlayerStat> stats;
        string playername;
        BasicRace race;
        BasicClass role;
        BasicSkill[] skills = new BasicSkill[3];
        bool isDodging = false;
        int difficulty;

        public PlayerObject(string playername, BasicRace race, BasicClass role, int difficulty)
        {
            this.playername = playername;
            this.race = race;
            this.role = role;
            this.difficulty = difficulty;
            generateStats(false);
            generateSkills();
            EasterEggHandler.applyEasterEgg(playername);
        }

        public PlayerObject()
        {
            generateStats(true);
        }

        private void generateStats(bool isLoad)
        {
            stats = new Dictionary<string, PlayerStat>
            {
                { "Health", new PlayerStat("Health", 100, "The current health of the player") },
                { "MaxHealth", new PlayerStat("MaxHealth", 100, "The current max health of the player") },
                { "Secondary", new PlayerStat("Secondary", 20, "The current secondary of the player") },
                { "MaxSecondary", new PlayerStat("MaxSecondary", 20, "The current max secondary of the player") },
                { "Strength", new PlayerStat("Strength", 5, "The current strength of the player") },
                { "Dexterity", new PlayerStat("Dexterity", 5, "The current dexterity of the player") },
                { "Intelligence", new PlayerStat("Intelligence", 5, "The current intelligence of the player") },
                { "Experience", new PlayerStat("Experience", 0, "The current experience of the player") },
                { "MaxExperience", new PlayerStat("MaxExperience", 10, "The current max experience of the player") },
                { "SecondaryRegen", new PlayerStat("SecondaryRegen", 5, "The current secondary regen of the player") },
                { "Level", new PlayerStat("Level", 0, "The current level of the player") },
                { "Luck", new PlayerStat("Luck", 20 - (difficulty * 5), "The current luck of the player") },
                { "Killcount", new PlayerStat("Killcount", -1, "The current killcount of the player") },
                { "Points", new PlayerStat("Points", 0, "The current skillpoints of the player") },
                { "TreeCount", new PlayerStat("TreeCount", 0, "The amount of trees the player chopped") },
                { "OreCount", new PlayerStat("OreCount", 0, "The amount of ores the player mined") }
            };

            if (!isLoad)
            {
                race.applyBonus(this);
                role.applyBonus(this);
            }

        }

        private void generateSkills()
        {
            role.GenerateSkills(skills);
        }

        public void loadPlayer(JToken json)
        {
            playername = json["playername"].ToString();

            stats["MaxHealth"].setAmount((int)json["maxHealth"]);
            stats["MaxSecondary"].setAmount((int)json["maxSecondary"]);
            stats["Secondary"].setAmount((int)json["secondary"]);
            stats["Health"].setAmount((int)json["health"]);
            stats["Strength"].setAmount((int)json["strength"]);
            stats["Dexterity"].setAmount((int)json["dexterity"]);
            stats["Intelligence"].setAmount((int)json["intelligence"]);
            stats["Level"].setAmount((int)json["level"]);
            stats["Experience"].setAmount((int)json["experience"]);
            stats["MaxExperience"].setAmount((int)json["maxExperience"]);
            stats["Points"].setAmount((int)json["points"]);
            stats["Luck"].setAmount((int)json["luck"]);
            stats["SecondaryRegen"].setAmount((int)json["secondaryRegen"]);
            stats["Killcount"].setAmount((int)json["killcount"]);
            stats["TreeCount"].setAmount((int)json["treecount"]);
            stats["OreCount"].setAmount((int)json["orecount"]);

            loadRole(json["role"].ToString());
            loadRace(json["race"].ToString());
            isDodging = bool.Parse(json["isDodging"].ToString());
            difficulty = (int)json["difficulty"];
            generateSkills();
        }

        private void loadRole(string name)
        {
            switch (name)
            {
                case "Warrior":
                    role = new WarriorClass();
                    break;
                case "Mage":
                    role = new MageClass();
                    break;
                case "Thief":
                    role = new ThiefClass();
                    break;
            }
        }

        private void loadRace(string name)
        {
            switch (name)
            {
                case "Human":
                    race = new HumanRace();
                    break;
                case "Dwarf":
                    race = new DwarvenRace();
                    break;
                case "Elf":
                    race = new ElvenRace();
                    break;
                case "Giant":
                    race = new GiantRace();
                    break;
                case "Goblin":
                    race = new GoblinRace();
                    break;
                case "Nightelf":
                    race = new NightelfRace();
                break;
            }
        }

        public void changeStats(int strength, int health, int dexterity, int intelligence, int secondary)
        {
            stats["MaxHealth"].changeAmount(health);
            stats["Health"].changeAmount(stats["MaxHealth"].getAmount());
            stats["MaxSecondary"].changeAmount(secondary);
            stats["Secondary"].changeAmount(stats["MaxSecondary"].getAmount());
            stats["Strength"].changeAmount(strength);
            stats["Dexterity"].changeAmount(dexterity);
            stats["Intelligence"].changeAmount(intelligence);
        }

        public void regainSecondary(int equipRegen, int equipStat)
        {
            stats["Secondary"].changeAmount(stats["SecondaryRegen"].getAmount() + equipRegen);
            if (stats["Secondary"].getAmount() >= stats["MaxSecondary"].getAmount() + equipStat)
            {
                stats["Secondary"].setAmount(stats["MaxSecondary"].getAmount() + equipStat);
            }
        }

        public void healPlayer(int regeneration, int equipStat)
        {
            stats["Health"].changeAmount(regeneration);
            if (stats["Health"].getAmount() >= stats["MaxHealth"].getAmount() + equipStat)
            {
                stats["Health"].setAmount(stats["MaxHealth"].getAmount() + equipStat);
            }
        }

        public Dictionary<string, PlayerStat> getStats()
        {
            return stats;
        }

        public void setStats(Dictionary<string, PlayerStat> stats)
        {
            this.stats = stats;
        }

        public PlayerStat getStat(string identifier)
        {
            return stats[identifier];
        }

        public BasicSkill getSkill(int index)
        {
            return skills[index];
        }

        public int calculateDamage(int equipStatStr, int equipStatDex)
        {
            int result;
            int bonus = 0;
            if (isCrit(equipStatDex))
            {
                bonus = (stats["Strength"].getAmount() + equipStatStr) * 2;
            }
            result = stats["Strength"].getAmount() + bonus + 5 + equipStatStr;
            switch (difficulty)
            {
                case 0:
                    result = result * 2;
                    break;
                case 1:
                    //Default difficulty
                    break;
                case 2:
                    result = result / 2;
                    break;
            }
            return result;
        }

        public int castSkill(int index, int equipStatInt, int equipStatStr, int equipStatDex)
        {
            int damage = 0;
            if (skills[index].canPlayerCast(stats["Secondary"].getAmount()))
            {
                if (index == 1)
                {
                    isDodging = true;
                }
                stats["Secondary"].changeAmount(-skills[index].getSecondaryConsumption());
                if (role.classname == "Wizard")
                {
                    damage = skills[index].calculateDamage(stats["Intelligence"].getAmount() + equipStatInt, isCrit(equipStatDex));
                }
                else
                {
                    damage = skills[index].calculateDamage(stats["Strength"].getAmount() + equipStatStr, isCrit(equipStatDex));
                }

                switch (difficulty)
                {
                    case 0:
                        damage = damage * 2;
                        break;
                    case 1:
                        //Default difficulty
                        break;
                    case 2:
                        damage = damage / 2;
                        break;
                }
            }
            return damage;
        }

        public void reduceCooldown(int index)
        {
            for (int i = 0; i < skills.Length; i++)
            {
                if (i != index)
                {
                    skills[i].reduceCooldown();
                }
            }
        }

        public bool isCrit(int equipStat)
        {
            return rand.Next(1, 101) <= stats["Dexterity"].getAmount() + equipStat;
        }

        public bool takeDamage(int amount, int equipStatDex, int equipStatInt)
        {

            if (amount <= 0 || EasterEggHandler.isGodMode(this))
            {
                return isDead();
            }

            if (isDodging)
            {
                isDodging = false;
            }
            else
            {
                int dodgeChance = stats["Dexterity"].getAmount() + equipStatDex + ((stats["Intelligence"].getAmount() + equipStatInt) / 2);
                if (rand.Next(1, 101) > dodgeChance)
                {
                    stats["Health"].changeAmount(-amount);
                }
            }
            return isDead();
        }

        public bool isDead(){
            return stats["Health"].getAmount() <= 0;
        }

        public bool gainExperience(int amount)
        {
            bool result = false;
            stats["Experience"].changeAmount(amount);
            if (stats["Experience"].getAmount() >= stats["MaxExperience"].getAmount())
            {
                stats["Experience"].changeAmount(-stats["MaxExperience"].getAmount());
                stats["MaxExperience"].changeAmount(stats["MaxExperience"].getAmount());
                stats["Level"].changeAmount(1);
                stats["Points"].changeAmount(3);
                stats["Luck"].changeAmount(2);
                result = true;
            }
            return result;
        }

        public bool upgradeStat(string identifier, int amount)
        {
            bool result = false;
            if (stats["Points"].getAmount() > 0)
            {
                result = true;
                stats[identifier].changeAmount(amount);
                stats["Points"].changeAmount(-1);
            }
            return result;
        }

        public string getPlayerName()
        {
            return playername;
        }

        public int getDifficulty()
        {
            return difficulty;
        }

        public BasicRace getRace()
        {
            return race;
        }

        public BasicClass getClass()
        {
            return role;
        }

        public string saveGame()
        {
            string result = "";
            result = result + FileHandler.generateJSON("playername", "\"" + playername + "\"") + ",\r\n";
            result = result + FileHandler.generateJSON("maxHealth", stats["MaxHealth"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("maxSecondary", stats["MaxSecondary"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("secondary", stats["Secondary"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("health", stats["Health"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("strength", stats["Strength"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("dexterity", stats["Dexterity"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("intelligence", stats["Intelligence"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("level", stats["Level"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("experience", stats["Experience"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("maxExperience", stats["MaxExperience"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("race", "\"" + race.racename + "\"") + ",\r\n";
            result = result + FileHandler.generateJSON("role", "\"" + role.classname + "\"") + ",\r\n";
            result = result + FileHandler.generateJSON("points", stats["Points"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("secondaryRegen", stats["SecondaryRegen"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("isDodging", "\"" + isDodging + "\"") + ",\r\n";
            result = result + FileHandler.generateJSON("killcount", stats["Killcount"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("treecount", stats["TreeCount"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("orecount", stats["OreCount"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("luck", stats["Luck"].getAmount()) + ",\r\n";
            result = result + FileHandler.generateJSON("difficulty", difficulty);
            return result;
        }
    }
}