MonoGame.Samples/RolePlayingGame/Core/Session/Party.cs

//-----------------------------------------------------------------------------
// Party.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using RolePlaying.Data;

namespace RolePlaying
{
    /// <summary>
    /// The group of players, under control of the user.
    /// </summary>
    public class Party
    {


        /// <summary>
        /// The ordered list of players in the party.
        /// </summary>
        /// <remarks>The first entry is the leader.</remarks>
        private List<Player> players = new List<Player>();

        /// <summary>
        /// The ordered list of players in the party.
        /// </summary>
        /// <remarks>The first entry is the leader.</remarks>
        [ContentSerializerIgnore]
        public List<Player> Players
        {
            get { return players; }
            set { players = value; }
        }



        /// <summary>
        /// Add a new player to the party.
        /// </summary>
        /// <param name="player">The new player.</param>
        /// <remarks>Instead of using the lists directly, this fixes all data.</remarks>
        public void JoinParty(Player player)
        {
            // check the parameter
            if (player == null)
            {
                throw new ArgumentNullException("player");
            }
            if (players.Contains(player))
            {
                throw new ArgumentException("The player was already in the party.");
            }

            // add the new player to the list
            players.Add(player);

            // add the initial gold
            partyGold += player.Gold;
            // only as NPCs are players allowed to have their own gold
            player.Gold = 0;

            // add the player's inventory items
            foreach (ContentEntry<Gear> contentEntry in player.Inventory)
            {
                AddToInventory(contentEntry.Content, contentEntry.Count);
            }
            // only as NPCs are players allowed to have their own non-equipped gear
            player.Inventory.Clear();
        }


        /// <summary>
        /// Gives the experience amount specified to all party members.
        /// </summary>
        public void GiveExperience(int experience)
        {
            // check the parameters
            if (experience < 0)
            {
                throw new ArgumentOutOfRangeException("experience");
            }
            else if (experience == 0)
            {
                return;
            }

            List<Player> leveledUpPlayers = null;
            foreach (Player player in players)
            {
                int oldLevel = player.CharacterLevel;
                player.Experience += experience;
                if (player.CharacterLevel > oldLevel)
                {
                    if (leveledUpPlayers == null)
                    {
                        leveledUpPlayers = new List<Player>();
                    }
                    leveledUpPlayers.Add(player);
                }
            }

            if ((leveledUpPlayers != null) && (leveledUpPlayers.Count > 0))
            {
                Session.ScreenManager.AddScreen(new LevelUpScreen(leveledUpPlayers));
            }
        }






        /// <summary>
        /// The items held by the party.
        /// </summary>
        private List<ContentEntry<Gear>> inventory = new List<ContentEntry<Gear>>();

        /// <summary>
        /// The items held by the party.
        /// </summary>
        [ContentSerializerIgnore]
        public ReadOnlyCollection<ContentEntry<Gear>> Inventory
        {
            get { return inventory.AsReadOnly(); }
        }


        /// <summary>
        /// Add the given gear, in the given quantity, to the party's inventory.
        /// </summary>
        public void AddToInventory(Gear gear, int count)
        {
            // check the parameters
            if ((gear == null) || (count <= 0))
            {
                return;
            }

            // search for an existing entry
            ContentEntry<Gear> existingEntry = inventory.Find(
                delegate (ContentEntry<Gear> entry)
                {
                    return (entry.Content == gear);
                });
            // increment the existing entry, if any
            if (existingEntry != null)
            {
                existingEntry.Count += count;
                return;
            }

            // no existing entry - create a new entry
            ContentEntry<Gear> newEntry = new ContentEntry<Gear>();
            newEntry.Content = gear;
            newEntry.Count = count;
            newEntry.ContentName = gear.AssetName;
            if (newEntry.ContentName.StartsWith(@"Gear\"))
            {
                newEntry.ContentName = newEntry.ContentName.Substring(5);
            }
            inventory.Add(newEntry);
        }


        /// <summary>
        /// Remove the given quantity of the given gear from the party's inventory.
        /// </summary>
        /// <returns>True if the quantity specified could be removed.</returns>
        public bool RemoveFromInventory(Gear gear, int count)
        {
            // check the parameters
            if (gear == null)
            {
                throw new ArgumentNullException("gear");
            }
            if (count <= 0)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            // search for an existing entry
            ContentEntry<Gear> existingEntry = inventory.Find(
                delegate (ContentEntry<Gear> entry)
                {
                    return (entry.Content == gear);
                });
            // no existing entry, so this is moot
            if (existingEntry == null)
            {
                return false;
            }

            // decrement the existing entry
            existingEntry.Count -= count;
            bool fullRemoval = (existingEntry.Count >= 0);

            // if the entry is empty, then remove it
            if (existingEntry.Count <= 0)
            {
                inventory.Remove(existingEntry);
            }

            return fullRemoval;
        }


        /// <summary>
        /// The gold held by the party.
        /// </summary>
        private int partyGold;

        /// <summary>
        /// The gold held by the party.
        /// </summary>
        [ContentSerializer(Optional = true)]
        public int PartyGold
        {
            get { return partyGold; }
            set { partyGold = value; }
        }






        /// <summary>
        /// The name and kill-count of monsters killed in the active quest.
        /// </summary>
        /// <remarks>
        /// Used to determine if the requirements for the active quest have been met.
        /// </remarks>
        private Dictionary<string, int> monsterKills = new Dictionary<string, int>();

        /// <summary>
        /// The name and kill-count of monsters killed in the active quest.
        /// </summary>
        /// <remarks>
        /// Used to determine if the requirements for the active quest have been met.
        /// </remarks>
        public Dictionary<string, int> MonsterKills
        {
            get { return monsterKills; }
        }


        /// <summary>
        /// Add a new monster-kill to the party's records.
        /// </summary>
        public void AddMonsterKill(Monster monster)
        {
            if (monsterKills.ContainsKey(monster.AssetName))
            {
                monsterKills[monster.AssetName]++;
            }
            else
            {
                monsterKills.Add(monster.AssetName, 1);
            }
        }






        /// <summary>
        /// Creates a new Party object from the game-start description.
        /// </summary>
        public Party(GameStartDescription gameStartDescription,
            ContentManager contentManager)
        {
            // check the parameters
            if (gameStartDescription == null)
            {
                throw new ArgumentNullException("gameStartDescription");
            }
            if (contentManager == null)
            {
                throw new ArgumentNullException("contentManager");
            }

            // load the players
            foreach (string contentName in gameStartDescription.PlayerContentNames)
            {
                // load the player and add it to the party
                /* TODO var player = contentManager.Load<Player>(
                    Path.Combine(@"Characters\Players", contentName)).Clone()
                    as Player;*/

                var player = Player.Load(Path.Combine(@"Characters\Players", contentName), contentManager);

                JoinParty(player);
            }
        }


        /// <summary>
        /// Create a new Party object from serialized party data.
        /// </summary>
        public Party(PartySaveData partyData, ContentManager contentManager)
        {
            // check the parameters
            if (partyData == null)
            {
                throw new ArgumentNullException("partyData");
            }
            if (contentManager == null)
            {
                throw new ArgumentNullException("contentManager");
            }

            // load the players
            foreach (PlayerSaveData playerData in partyData.players)
            {
                /*Player player = 
                    contentManager.Load<Player>(playerData.assetName).Clone() as Player;*/

                var player = Player.Load(playerData.assetName, contentManager);

                player.CharacterLevel = playerData.characterLevel;
                player.Experience = playerData.experience;
                player.EquippedEquipment.Clear();
                foreach (string equipmentAssetName in playerData.equipmentAssetNames)
                {
                    // TODO var equipment = contentManager.Load<Equipment>(equipmentAssetName);

                    var equipment = Equipment.Load(equipmentAssetName);

                    player.Equip(equipment);
                }
                player.StatisticsModifiers = playerData.statisticsModifiers;

                JoinParty(player);
            }

            // load the party inventory
            inventory.Clear();
            inventory.AddRange(partyData.inventory);
            foreach (ContentEntry<Gear> entry in inventory)
            {
                entry.Content = contentManager.Load<Gear>(
                    Path.Combine(@"Gear", entry.ContentName));
            }

            // set the party gold
            partyGold = partyData.partyGold;

            // load the monster kills
            for (int i = 0; i < partyData.monsterKillNames.Count; i++)
            {
                monsterKills.Add(partyData.monsterKillNames[i],
                    partyData.monsterKillCounts[i]);
            }
        }
    }
}