C#

Itemfactory.cs   

   using System.Collections.Generic;
   using System.IO;
   using System.Linq;
   using System.Xml;
   using Engine.Actions;
   using Engine.Models;
   using Engine.Shared;
   using SOSCSRPG.Core;

   namespace Engine.Factories
  {
    public static class ItemFactory
    {
        private const string GAME_DATA_FILENAME = 
        ".\\GameData\\GameItems.xml";

        private static readonly List<GameItem> _standardGameItems = new 
        List<GameItem> 
        ();

        static ItemFactory()
        {
            if(File.Exists(GAME_DATA_FILENAME))
            {
                XmlDocument data = new XmlDocument();
                data.LoadXml(File.ReadAllText(GAME_DATA_FILENAME));

                LoadItemsFromNodes(data.SelectNodes("/GameItems/Weapons/Weapon"));
                
LoadItemsFromNodes(data.SelectNodes("/GameItems/HealingItems/HealingItem"));
                
LoadItemsFromNodes(data.SelectNodes("/GameItems/MiscellaneousItems/MiscellaneousItem"));
            }
            else
            {
                throw new FileNotFoundException($"Missing data file: 
                {GAME_DATA_FILENAME}");
            }
        }

        public static GameItem CreateGameItem(int itemTypeID)
        {
            return _standardGameItems.FirstOrDefault(item => 
            item.ItemTypeID == 
            itemTypeID)?.Clone();
        }

        private static void LoadItemsFromNodes(XmlNodeList nodes)
        {
            if(nodes == null)
            {
                return;
            }

            foreach(XmlNode node in nodes)
            {
                GameItem.ItemCategory itemCategory = 
                DetermineItemCategory(node.Name);
                
                GameItem gameItem =
                    new GameItem(itemCategory,
                                 node.AttributeAsInt("ID"),
                                 node.AttributeAsString("Name"),
                                 node.AttributeAsInt("Price"),
                                 itemCategory == 
                                 GameItem.ItemCategory.Weapon);

                if(itemCategory == GameItem.ItemCategory.Weapon)
                {
                    gameItem.Action =
                        new AttackWithWeapon(gameItem, 
                        node.AttributeAsString("DamageDice"));
                }
                else if(itemCategory == 
                GameItem.ItemCategory.Consumable)
                {
                    gameItem.Action =
                        new Heal(gameItem,
                                 
                        node.AttributeAsInt("HitPointsToHeal"));
                }

                _standardGameItems.Add(gameItem);
            }
        }

        private static GameItem.ItemCategory 
        DetermineItemCategory(string itemType)
        {
            switch(itemType)
            {
                case "Weapon":
                    return GameItem.ItemCategory.Weapon;
                case "HealingItem":
                    return GameItem.ItemCategory.Consumable;
                default:
                    return GameItem.ItemCategory.Miscellaneous;
            }
        }
    }
}


MonsterFactory.cs

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Xml;
    using Engine.Models;
    using Engine.Services;
    using Engine.Shared;
    using SOSCSRPG.Core;

    namespace Engine.Factories
    {
        public static class MonsterFactory
        {
            private const string GAME_DATA_FILENAME = 
            ".\\GameData\\Monsters.xml";

            private static readonly GameDetails s_gameDetails;
            private static readonly List<Monster> s_baseMonsters = new 
            List<Monster>();

            static MonsterFactory()
            {
                if(File.Exists(GAME_DATA_FILENAME))
                {
                    s_gameDetails = 
                    GameDetailsService.ReadGameDetails();
                
                    XmlDocument data = new XmlDocument();
                    data.LoadXml(File.ReadAllText(GAME_DATA_FILENAME));

                    string rootImagePath =
                    data.SelectSingleNode("/Monsters")
                   .AttributeAsString("RootImagePath");

                    LoadMonstersFromNodes(data.SelectNodes("/Monsters/Monster"), 
                    rootImagePath);
                    }
                    else
                    {
                        throw new FileNotFoundException($"Missing data 
                        file: 
                        {GAME_DATA_FILENAME}");
                    }
                }

                public static Monster GetMonsterFromLocation(Location 
                location)
               {
                    if (!location.MonstersHere.Any())
                    {
                        return null;
                    }

                    // Total the percentages of all monsters at this 
                       location.
                    int totalChances = location.MonstersHere.Sum(m => 
                    m.ChanceOfEncountering);

                   // Select a random number between 1 and the total 
                      (in case the total 
                  chances is not 100).
                  int randomNumber = 
                  DiceService.Instance.Roll(totalChances, 1).Value;

                 // Loop through the monster list, 
                 // adding the monster's percentage chance of appearing 
                    to the 
                    runningTotal 
                    variable.
               // When the random number is lower than the 
                 runningTotal,
              // that is the monster to return.
             int runningTotal = 0;

            foreach (MonsterEncounter monsterEncounter in 
            location.MonstersHere)
            {
                runningTotal += monsterEncounter.ChanceOfEncountering;

                if (randomNumber <= runningTotal)
                {
                    return GetMonster(monsterEncounter.MonsterID);
                }
            }

            // If there was a problem, return the last monster in the 
               list.
            return GetMonster(location.MonstersHere.Last().MonsterID);
        }

        private static void LoadMonstersFromNodes(XmlNodeList nodes, 
        string 
        rootImagePath)
        {
            if(nodes == null)
            {
                return;
            }

            foreach(XmlNode node in nodes)
            {
                var attributes = s_gameDetails.PlayerAttributes;

                attributes.First(a => a.Key.Equals("DEX")).BaseValue =
                    Convert.ToInt32(node.SelectSingleNode("./Dexterity").InnerText);
                attributes.First(a => 
                a.Key.Equals("DEX")).ModifiedValue =
                    Convert.ToInt32(node.SelectSingleNode("./Dexterity").InnerText);
                
                Monster monster =
                    new Monster(node.AttributeAsInt("ID"),
                                node.AttributeAsString("Name"),
                                $".{rootImagePath} 
                                {node.AttributeAsString("ImageName")}",
                                
                               node.AttributeAsInt("MaximumHitPoints"),
                                attributes,
                                ItemFactory.CreateGameItem(node.AttributeAsInt("WeaponID")),
                                node.AttributeAsInt("RewardXP"),
                                node.AttributeAsInt("Gold"));

                XmlNodeList lootItemNodes = 
                node.SelectNodes("./LootItems/LootItem");
                
                if(lootItemNodes != null)
                {
                    foreach(XmlNode lootItemNode in lootItemNodes)
                    {
                        monster.AddItemToLootTable(lootItemNode.AttributeAsInt("ID"),
                                                   
                        lootItemNode.AttributeAsInt("Percentage"));
                    }
                }

                s_baseMonsters.Add(monster);
            }
        }

        private static Monster GetMonster(int id)
        {
            Monster newMonster = s_baseMonsters.FirstOrDefault(m => 
            m.ID == 
            id).Clone();

            foreach (ItemPercentage itemPercentage in 
            newMonster.LootTable)
            {
                // Populate the new monster's inventory, using the loot 
                   table
                if (DiceService.Instance.Roll(100).Value <= 
                    itemPercentage.Percentage)
                {
                    newMonster.AddItemToInventory(ItemFactory.CreateGameItem(itemPercentage.ID));
                }
            }

            return newMonster;
        }
    }
}

QuestFactory.cs


    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Xml;
    using Engine.Models;
    using Engine.Shared;

    namespace Engine.Factories
    {
        internal static class QuestFactory
        {
            private const string GAME_DATA_FILENAME = 
            ".\\GameData\\Quests.xml";

            private static readonly List<Quest> _quests = new 
            List<Quest>();

        static QuestFactory()
        {
            if(File.Exists(GAME_DATA_FILENAME))
            {
                XmlDocument data = new XmlDocument();
                data.LoadXml(File.ReadAllText(GAME_DATA_FILENAME));

                LoadQuestsFromNodes(data.SelectNodes("/Quests/Quest"));
            }
            else
            {
                throw new FileNotFoundException($"Missing data file: 
                {GAME_DATA_FILENAME}");
            }
        }

        private static void LoadQuestsFromNodes(XmlNodeList nodes)
        {
            foreach(XmlNode node in nodes)
            {
                // Declare the items need to complete the quest, and 
                   its reward items
                List<ItemQuantity> itemsToComplete = new 
                List<ItemQuantity>();
                List<ItemQuantity> rewardItems = new List<ItemQuantity> 
                ();

                foreach(XmlNode childNode in 
                node.SelectNodes("./ItemsToComplete/Item"))
                {
                    GameItem item = ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID"));

                    itemsToComplete.Add(new ItemQuantity(item, 
                    childNode.AttributeAsInt("Quantity")));
                }

                foreach(XmlNode childNode in 
                node.SelectNodes("./RewardItems/Item"))
                {
                    GameItem item = ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID"));

                    rewardItems.Add(new ItemQuantity(item, 
                    childNode.AttributeAsInt("Quantity")));
                }

                _quests.Add(new Quest(node.AttributeAsInt("ID"),
                                      
                node.SelectSingleNode("./Name")?.InnerText ?? "",
                                      
                node.SelectSingleNode("./Description")?.InnerText 
                                      ?? "",
                                      itemsToComplete,
                                      
                         node.AttributeAsInt("RewardExperiencePoints"),
                                      
                         node.AttributeAsInt("RewardGold"),
                                      rewardItems));
            }
        }

        internal static Quest GetQuestByID(int id)
        {
            return _quests.FirstOrDefault(quest => quest.ID == id);
        }
    }
}


RecipeFactory.cs

    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Xml;
    using Engine.Models;
    using Engine.Shared;

    namespace Engine.Factories
   {
    public static class RecipeFactory
    {
        private const string GAME_DATA_FILENAME = 
        ".\\GameData\\Recipes.xml";

        private static readonly List<Recipe> _recipes = new 
        List<Recipe>();

        static RecipeFactory()
        {
            if(File.Exists(GAME_DATA_FILENAME))
            {
                XmlDocument data = new XmlDocument();
                data.LoadXml(File.ReadAllText(GAME_DATA_FILENAME));

                LoadRecipesFromNodes(data.SelectNodes("/Recipes/Recipe"));
            }
            else
            {
                throw new FileNotFoundException($"Missing data file: 
                {GAME_DATA_FILENAME}");
            }
        }

        private static void LoadRecipesFromNodes(XmlNodeList nodes)
        {
            foreach(XmlNode node in nodes)
            {
                var ingredients = new List<ItemQuantity>();

                foreach(XmlNode childNode in 
                node.SelectNodes("./Ingredients/Item"))
                {
                    GameItem item = ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID"));

                    ingredients.Add(new ItemQuantity(item, 
                    childNode.AttributeAsInt("Quantity")));
                }

                var outputItems = new List<ItemQuantity>();

                foreach (XmlNode childNode in 
                node.SelectNodes("./OutputItems/Item"))
                {
                    GameItem item = ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID"));

                    outputItems.Add(new ItemQuantity(item, 
                    childNode.AttributeAsInt("Quantity")));
                }

                Recipe recipe =
                    new Recipe(node.AttributeAsInt("ID"),
                        node.SelectSingleNode("./Name")?.InnerText ?? 
                        "",
                        ingredients, outputItems);

                _recipes.Add(recipe);
            }
        }

        public static Recipe RecipeByID(int id)
        {
            return _recipes.FirstOrDefault(x => x.ID == id);
        }
    }
}


Traderfactory.cs


    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Xml;
    using Engine.Models;
    using Engine.Shared;

    namespace Engine.Factories
    {
        public static class TraderFactory
        {
            private const string GAME_DATA_FILENAME = 
            ".\\GameData\\Traders.xml";

            private static readonly List<Trader> _traders = new 
            List<Trader>();

            static TraderFactory()
        {
            if(File.Exists(GAME_DATA_FILENAME))
            {
                XmlDocument data = new XmlDocument();
                data.LoadXml(File.ReadAllText(GAME_DATA_FILENAME));

                LoadTradersFromNodes(data.SelectNodes("/Traders/Trader"));
            }
            else
            {
                throw new FileNotFoundException($"Missing data file: 
                {GAME_DATA_FILENAME}");
            }
        }

        private static void LoadTradersFromNodes(XmlNodeList nodes)
        {
            foreach(XmlNode node in nodes)
            {
                Trader trader =
                    new Trader(node.AttributeAsInt("ID"),
                               
                    node.SelectSingleNode("./Name")?.InnerText ?? "");

                foreach(XmlNode childNode in 
                node.SelectNodes("./InventoryItems/Item"))
                {
                    int quantity = 
                    childNode.AttributeAsInt("Quantity");

                    // Create a new GameItem object for each item we 
                       add.
                    // This is to allow for unique items, like swords 
                       with 
                       enchantments.
                    for(int i = 0; i < quantity; i++)
                    {
                        trader.AddItemToInventory(ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID")));
                    }
                }

                _traders.Add(trader);
            }
        }

        public static Trader GetTraderByID(int id)
        {
            return _traders.FirstOrDefault(t => t.ID == id);
        }
    }
}


WorldFactory.cs


    using System.IO;
    using System.Xml;
    using Engine.Models;
    using Engine.Shared;

    namespace Engine.Factories
    {
        internal static class WorldFactory
        {
            private const string GAME_DATA_FILENAME = 
            ".\\GameData\\Locations.xml";

            internal static World CreateWorld()
            {
                World world = new World();

                if(File.Exists(GAME_DATA_FILENAME))
                {
                    XmlDocument data = new XmlDocument();
                    data.LoadXml(File.ReadAllText(GAME_DATA_FILENAME));

                    string rootImagePath =
                    data.SelectSingleNode("/Locations")
                   .AttributeAsString("RootImagePath");

                LoadLocationsFromNodes(world, 
                rootImagePath, 
                data.SelectNodes("/Locations/Location"));
            }
            else
            {
                throw new FileNotFoundException($"Missing data file: 
                {GAME_DATA_FILENAME}");
            }

            return world;
        }

        private static void LoadLocationsFromNodes(World world, string 
        rootImagePath, 
        XmlNodeList nodes)
        {
            if(nodes == null)
            {
                return;
            }

            foreach(XmlNode node in nodes)
            {
                Location location =
                    new Location(node.AttributeAsInt("X"),
                                 node.AttributeAsInt("Y"),
                                 node.AttributeAsString("Name"),
                                 node.SelectSingleNode("./Description")?.InnerText ?? 
                                 "",
                                 $".{rootImagePath} 
                                 
                              {node.AttributeAsString("ImageName")}");

                AddMonsters(location, 
                node.SelectNodes("./Monsters/Monster"));
                AddQuests(location, 
                node.SelectNodes("./Quests/Quest"));
                AddTrader(location, node.SelectSingleNode("./Trader"));

                world.AddLocation(location);
            }
        }

        private static void AddMonsters(Location location, XmlNodeList 
        monsters)
        {
            if(monsters == null)
            {
                return;
            }

            foreach(XmlNode monsterNode in monsters)
            {
                location.AddMonster(monsterNode.AttributeAsInt("ID"),
                monsterNode.AttributeAsInt("Percent"));
            }
        }

        private static void AddQuests(Location location, XmlNodeList 
        quests)
        {
            if(quests == null)
            {
                return;
            }

            foreach(XmlNode questNode in quests)
            {
                location.QuestsAvailableHere
                        
               .Add(QuestFactory.GetQuestByID(questNode.AttributeAsInt("ID")));
            }
        }

        private static void AddTrader(Location location, XmlNode 
        traderHere)
        {
            if(traderHere == null)
            {
                return;
            }

            location.TraderHere =
            TraderFactory.GetTraderByID(traderHere.AttributeAsInt("ID"));
        }
    }
}


SpellFactory.cs


    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Engine.Models;

    namespace Engine.Factories
    {
        public static class SpellFactory
        {
            private static readonly List<spells> _standardSpell = new 
            List<Spells> 
            ();

            static SpellFactory()
        {
            _standardSpell.Add(new Spell(8000, "Fireball", 5));
            _standardSpell.Add(new Spell(8001, "Lightning", 5));
            _standardSpell.Add(new Spell(8002, "Frost Bolt", 5));
        }

        public static Spell CreateSpell(int SpellID)
        {
            standardSpell = _standardSpell.FirstOrDefault(spell =>
            spell.SpellID == SpellID);

            if (standardSpell != null)
            {
                return standardSpell.Clone();
            }
            return null;
        }
    }
}