root/lang/csharp/DominionEngine/DominionEngine.CardInfo/Unit/Worth.cs @ 37574

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

namespace DominionEngine.CardInfo
{
    /// <summary>
    /// 価値
    /// </summary>
    public class Worth: IEquatable<Worth>
    {
        #region ビルダ

        /// <summary>
        /// 無価値
        /// </summary>
        public static readonly Worth None = new Worth(new Dictionary<Type, int>());

        /// <summary>
        /// 新たな価値
        /// </summary>
        /// <typeparam name="T">価値の種類</typeparam>
        /// <param name="value">個数</param>
        /// <returns></returns>
        public static Worth Create<T>(int value)
            where T : Unit
        {
            Dictionary<Type, int> items = new Dictionary<Type, int>();
            items.Add(typeof(T), value);
            return new Worth(items);
        }

        /// <summary>
        /// コイン
        /// </summary>
        /// <param name="value">個数</param>
        /// <returns>価値</returns>
        public static Worth Coin(int value) { return Create<CoinUnit>(value); }

        #endregion

        #region フィールドとコンストラクタ

        /// <summary>
        /// 価値ごとの個数
        /// </summary>
        internal Dictionary<Type, int> items;

        /// <summary>
        /// 価値を作成
        /// </summary>
        internal Worth(Dictionary<Type, int> items) {
            this.items = items;

            hashCode = 0;
            foreach (var item in items)
            {
                hashCode += item.Key.GetHashCode() * item.Value;
            }
        }

        #endregion

        /// <summary>
        /// コストが支払えるかどうか
        /// </summary>
        /// <param name="cost">対象のコスト</param>
        /// <returns></returns>
        public bool IsAfford(Worth cost)
        {
            foreach (var item in cost.items)
            {
                if (this[item.Key] < item.Value) return false;
            }

            return true;
        }

        /// <summary>
        /// ToString
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return String.Format("{0}C", CoinValue);
        }

        /// <summary>
        /// 指定したカードのコストより現在の価値だけ大きい新しい価値
        /// </summary>
        /// <param name="card"></param>
        /// <returns></returns>
        public Worth MoreThan(ICardInfo card)
        {
            return card.Cost + this;
        }

        #region 単位ごと価値

        /// <summary>
        /// 単位ごとの価値
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        internal int this[Type key]
        {
            get { return items.ContainsKey(key) ? items[key] : 0; }
        }

        /// <summary>
        /// 単位ごとの価値
        /// </summary>
        /// <typeparam name="T">価値の単位</typeparam>
        /// <returns></returns>
        public int Value<T>()
            where T : Unit
        {
            return this[typeof(T)];
        }

        /// <summary>
        /// コイン価値
        /// </summary>
        /// <returns></returns>
        public int CoinValue { get { return Value<CoinUnit>(); } }

        #endregion

        #region 算術演算子

        public static Worth operator +(Worth cost1, Worth cost2)
        {
            Dictionary<Type, int> items = new Dictionary<Type, int>(cost1.items);

            foreach (var item in cost2.items)
            {
                if (!items.ContainsKey(item.Key)) items[item.Key] = 0;
                items[item.Key] += item.Value;
            }
            return new Worth(items);
        }

        public static Worth operator -(Worth cost1, Worth cost2)
        {
            Dictionary<Type, int> items = new Dictionary<Type, int>(cost1.items);

            foreach (var item in cost2.items)
            {
                if (!items.ContainsKey(item.Key)) items[item.Key] = 0;
                items[item.Key] -= item.Value;
            }
            return new Worth(items);
        }

        #endregion

        #region 等価比較

        public override bool Equals(object obj)
        {
            if (obj is Worth) return Equals((Worth)obj);
            return false;
        }

        public bool Equals(Worth other)
        {
            return hashCode == other.hashCode;
        }

        public static bool operator ==(Worth x, Worth y)
        {
            // 同一のオブジェクトなら常に等価
            if (System.Object.ReferenceEquals(x, y)) return true;
            // それ以外なら内容を比較
            return x.Equals(y);
        }

        public static bool operator !=(Worth a, Worth b)
        {
            return !(a == b);
        }

        internal int hashCode;

        public override int GetHashCode()
        {
            return hashCode;
        }

        #endregion

        #region 価値の単位

        /// <summary>
        /// 価値の単位
        /// </summary>
        public interface Unit { };

        /// <summary>
        /// コイン
        /// </summary>
        public class CoinUnit : Unit { }

        #endregion

        /// <summary>
        /// デフォルトの比較クラス
        /// </summary>
        public class DefaultComparer : Comparer<Worth>
        {
            public override int Compare(Worth x, Worth y)
            {
                // コインが低い順
                if (x.CoinValue != y.CoinValue) return x.CoinValue.CompareTo(y.CoinValue);

                return 0;
            }
        }
    }

    public static class WorthExtension
    {
        public static Worth Coin(this Int32 value)
        {
            return Worth.Coin(value);
        }
    }
}