root/lang/csharp/DominionEngine/DominionEngine.Core/Game.cs @ 37703

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using DominionEngine.CardInfo;
using System.Threading;

namespace DominionEngine
{
    /// <summary>
    /// ゲーム
    /// </summary>
    public class Game
    {
        #region ランダマイザ

        internal Random Random = new Random();
        public int RandomSeed { set { Random = new Random(value); } }

        #endregion

        #region メタ情報

        /// <summary>
        /// 非同期かどうか
        /// </summary>
        public bool IsAsync { get { return async != null; } }
        internal Thread async;

        /// <summary>
        /// ゲームが進行中かどうか
        /// </summary>
        public bool IsPlaying { get; internal set; }

        /// <summary>
        /// ゲームの終了条件を満たしたかどうか
        /// </summary>
        public bool IsEndOfGame
        {
            get
            {
                // Provinceが空なら終了
                if (provinceSupplyPile.Count == 0) return true;

                // 3人までなら3山。4人以上なら4山切れたら終了
                int emptySupplies = supplyPiles.Count(supply => supply.Count == 0);
                return (emptySupplies >= (Players.Count <= 4 ? 3 : 4));
            }
        }

        #endregion

        #region 情報

        /// <summary>
        /// 現在のターン数
        /// </summary>
        public int Turn { get; internal set; }

        /// <summary>
        /// 現在のフェイズ
        /// </summary>
        public Phase Phase { get{return phase;}
            internal set
            {
                phase = value;
                PhaseChanged(this, EventArgs.Empty);
            }
        }
        internal Phase phase;

        /// <summary>
        /// 購入フェイズに一度でも購入を行ったか
        /// </summary>
        public bool IsBuyed { get; internal set; }

        /// <summary>
        /// 残アクション回数
        /// </summary>
        public int RemainAction { get; internal set; }

        /// <summary>
        /// 残購入回数
        /// </summary>
        public int RemainBuy { get; internal set; }

        /// <summary>
        /// 利用可能な価値
        /// </summary>
        public Worth SpendableWorth { get; set; }

        #endregion

        #region プレイヤー

        /// <summary>
        /// プレイヤー
        /// </summary>
        public IList<PlayerInfo> Players { get; internal set; }

        /// <summary>
        /// 現在のターンプレイヤー位置
        /// </summary>
        internal int turnPlayerPosition;

        /// <summary>
        /// 現在のターンプレイヤー
        /// </summary>
        public PlayerInfo TurnPlayer { get { return Players[turnPlayerPosition]; } }

        /// <summary>
        /// プレイヤーを初期化する
        /// </summary>
        /// <param name="playerCount">プレイヤー人数</param>
        internal void InitializePlayers(int playerCount)
        {
            // プレイヤー人数は2～6人。それ以外なら例外発生
            if (playerCount < 2 || playerCount > 6) throw new ArgumentOutOfRangeException("playerCount", playerCount, "playerCount between 2 and 6");

            // プレイヤーのリストを作成
            PlayerInfo[] players = new PlayerInfo[playerCount];
            Players = new ReadOnlyCollection<PlayerInfo>(players);

            for (int i = 0; i < playerCount; i++)
            {
                players[i] = new PlayerInfo(this, i);
            }
        }

        #endregion

        #region 場

        #region トラッシュ

        /// <summary>
        /// トラッシュパイル
        /// </summary>
        public ICardList TrashPile { get; internal set; }
        internal CardList trashPile = new CardList();

        /// <summary>
        /// トラッシュパイルを初期化する
        /// </summary>
        internal void InitializeTrashPile()
        {
            TrashPile = trashPile.AsReadOnly();
        }

        #endregion

        #region サプライ

        /// <summary>
        /// サプライパイルのリスト
        /// </summary>
        public IList<IUnitaryCardList> SupplyPiles { get; internal set; }
        internal List<IUnitaryCardList> readOnlySupplyPiles = new List<IUnitaryCardList>();

        /// <summary>
        /// サプライパイルのリスト
        /// </summary>
        internal IList<IUnitaryCardList> supplyPiles = new SupplyCollection();

        /// <summary>
        /// 終了条件取得用Provinceサプライパイル
        /// </summary>
        internal IUnitaryCardList provinceSupplyPile;

        /// <summary>
        /// サプライパイルを初期化する
        /// </summary>
        internal void InitializeSupplyPiles()
        {
            supplyPiles.Clear();
            readOnlySupplyPiles.Clear();
            SupplyPiles = readOnlySupplyPiles.AsReadOnly();

            SetSupply<Copper>();
            SetSupply<Silver>();
            SetSupply<Gold>();
            SetSupply<Estate>();
            SetSupply<Duchy>();
            SetSupply<Province>();
            SetSupply<Curse>();

            provinceSupplyPile = supplyPiles.First(supply => supply.CardInfo is Province);
        }

        /// <summary>
        /// 使用するサプライを追加する
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void SetSupply<T>()
            where T : ICardInfo, new()
        {
            UnitaryCardList add = new UnitaryCardList<T>(Players.Count);
            supplyPiles.Add(add);
            readOnlySupplyPiles.Add(add.AsReadOnly());
        }

        /// <summary>
        /// 使用するサプライを除去する
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void UnsetSupply<T>()
            where T : ICardInfo, new()
        {
            supplyPiles.Remove(supplyPiles.FirstOrDefault(cardList => cardList.CardInfo is T));
            readOnlySupplyPiles.Remove(readOnlySupplyPiles.FirstOrDefault(cardList => cardList.CardInfo is T));
        }

        #endregion

        #endregion

        #region CardInfo側イベント

        /// <summary>
        /// カードリスト取得
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void AnyPlayer_CardListGetting(object sender, AnyPlayer.CardListGettingEventArgs e)
        {
            ICardList cardList = GetCardList(e.Position);
            List<CardInfo.Card> result = new List<CardInfo.Card>();

            foreach (var card in cardList)
            {
                result.Add(new CardInfo.Card(card.CardInfo, e.Position));
            }

            e.Result = result;
        }

        /// <summary>
        /// ドロー
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void AnyPlayer_Drawing(object sender, AnyPlayer.DrawingEventArgs e)
        {
            Players[e.Player].Draw(e.Quantity);
        }

        /// <summary>
        /// カード選択
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void AnyPlayer_Choosing(object sender, AnyPlayer.ChoosingEventArgs e)
        {
            CardChoosingEventArgs args = new CardChoosingEventArgs(e.Player, e.MinQuantity, e.MaxQuantity, e.Filter);

            switch (e.From.Position)
            {
                        case CardPosition.PositionEnum.Deck:
                case CardPosition.PositionEnum.Discard:
                case CardPosition.PositionEnum.Hand:
                case CardPosition.PositionEnum.PlayArea:
                    HandChoosing(this, args);
                    break;
                case CardPosition.PositionEnum.Supply:
                    SupplyChoosing(this, args);
                    break;
                default:
                    break;
            }


            IList<ICardInfo> result = args.Result;
            if (result == null) result = new ICardInfo[0];

            if ((!e.Force && result.Count < e.MinQuantity) || (result.Count > e.MaxQuantity))
            {
                // 選びなおし
            }

            e.Result = new List<CardInfo.Card>();
            foreach (ICardInfo cardInfo in result)
            {
                e.Result.Add(new CardInfo.Card(cardInfo, e.From));
            }
        }

        /// <summary>
        /// カードを移動させる
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void Card_Moving(object sender, DominionEngine.CardInfo.Card.MovingEventArgs e)
        {
            ICardList fromCardList = GetCardList(e.From.Position);
            DominionEngine.Card card = fromCardList.First(findCard => findCard.CardInfo == e.From.CardInfo);

            ICardList toCardList = GetCardList(e.ToPosition);

            toCardList.Add(card);
            fromCardList.Remove(card);
        }

        /// <summary>
        /// +X Actions
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void TurnPlayer_ActionChanged(object sender, ValueChangedEventArgs e)
        {
            RemainAction += e.Value;
        }

        /// <summary>
        /// +X Buy
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void TurnPlayer_BuyChanged(object sender, ValueChangedEventArgs e)
        {
            RemainBuy += e.Value;
        }

        /// <summary>
        /// +(X)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        internal void TurnPlayer_CoinChanged(object sender, ValueChangedEventArgs e)
        {
            SpendableWorth += Worth.Coin(e.Value);
        }

        #endregion

        /// <summary>
        /// 指定した位置のカード一覧を取得する
        /// </summary>
        /// <param name="position"></param>
        /// <returns></returns>
        internal ICardList GetCardList(CardPosition position)
        {
            switch (position.Position)
            {
                case CardPosition.PositionEnum.Deck:
                    return Players[position.Player].deck;

                case CardPosition.PositionEnum.Discard:
                    return Players[position.Player].discardPile;

                case CardPosition.PositionEnum.Hand:
                    return Players[position.Player].hand;

                case CardPosition.PositionEnum.PlayArea:
                    return Players[position.Player].playArea;

                case CardPosition.PositionEnum.Supply:
                    return (SupplyCollection)supplyPiles;

                case CardPosition.PositionEnum.Trash:
                    return trashPile;

                default:
                    return null;
            }
        }

        #region イベント

        /// <summary>
        /// ターンが変更された
        /// </summary>
        public event EventHandler<EventArgs> TurnChanged = (sender, e) => { };

        /// <summary>
        /// フェイズが変更された
        /// </summary>
        public event EventHandler<EventArgs> PhaseChanged = (sender, e) => { };

        /// <summary>
        /// アクションフェイズ
        /// </summary>
        public event EventHandler<EventArgs> ActionPhase = (sender, e) => { };

        /// <summary>
        /// 購入フェイズ
        /// </summary>
        public event EventHandler<EventArgs> BuyPhase = (sender, e) => { };

        /// <summary>
        /// 手札からカードを選択
        /// </summary>
        public event EventHandler<CardChoosingEventArgs> HandChoosing = (sender, e) => { };

        /// <summary>
        /// サプライからカードを選択
        /// </summary>
        public event EventHandler<CardChoosingEventArgs> SupplyChoosing = (sender, e) => { };

        /// <summary>
        /// カード選択イベント引数
        /// </summary>
        public class CardChoosingEventArgs : EventArgs
        {
            /// <summary>
            /// プレイヤー
            /// </summary>
            public int Player { get; private set; }

            /// <summary>
            /// 最小枚数
            /// </summary>
            public int MinQuantity { get; private set; }

            /// <summary>
            /// 最大枚数
            /// </summary>
            public int MaxQuantity { get; private set; }

            /// <summary>
            /// フィルタ
            /// </summary>
            public Func<ICardInfo, bool> Filter { get; private set; }

            /// <summary>
            /// 結果
            /// </summary>
            public IList<ICardInfo> Result { get; set; }

            /// <summary>
            /// 最小枚数に満たないが限界まで選択した
            /// </summary>
            public bool Force { get; set; }

            /// <summary>
            /// コンストラクタ
            /// </summary>
            /// <param name="minQuantity">最小枚数</param>
            /// <param name="maxQuantity">最大枚数</param>
            /// <param name="filter">フィルタ</param>
            public CardChoosingEventArgs(int player, int minQuantity, int maxQuantity, Func<ICardInfo, bool> filter)
            {
                Player = player;
                MinQuantity = minQuantity;
                MaxQuantity = maxQuantity;
                Filter = filter;
                Force = false;
            }
        }

        #endregion

        /// <summary>
        /// 新しいゲームを作成する
        /// </summary>
        /// <param name="playerCount">プレイヤー人数</param>
        public Game(int playerCount)
        {
            InitializePlayers(playerCount);
            InitializeTrashPile();
            InitializeSupplyPiles();

            CardInfo.AnyPlayer.ClearEvent();
            CardInfo.AnyPlayer.CardListGetting += AnyPlayer_CardListGetting;
            CardInfo.AnyPlayer.Drawing += AnyPlayer_Drawing;
            CardInfo.AnyPlayer.Choosing += AnyPlayer_Choosing;
            CardInfo.Card.Moving += Card_Moving;


            CardInfo.TurnPlayer.ClearEvent();
            CardInfo.TurnPlayer.ActionChanged += TurnPlayer_ActionChanged;
            CardInfo.TurnPlayer.BuyChanged += TurnPlayer_BuyChanged;
            CardInfo.TurnPlayer.CoinChanged += TurnPlayer_CoinChanged;
        }

        /// <summary>
        /// カードをプレイする
        /// </summary>
        /// <param name="card"></param>
        public void Play(Card card)
        {
            switch (Phase)
            {
                case Phase.Action:
                    if (!(card.CardInfo is IAction)) return;

                    TurnPlayer.hand.Remove(card);
                    TurnPlayer.playArea.Add(card);
                    RemainAction -= 1;
                    ((IAction)card.CardInfo).Action();
                    break;

                case Phase.Buy:
                    if (IsBuyed) return;
                    if (!(card.CardInfo is ITreasure)) return;

                    TurnPlayer.hand.Remove(card);
                    TurnPlayer.playArea.Add(card);
                    SpendableWorth += ((ITreasure)card.CardInfo).GenerateWorth;
                    break;

                default:
                    return;
            }
        }

        /// <summary>
        /// 購入
        /// </summary>
        public Card Buy(ICardInfo cardInfo)
        {
            if (Phase != Phase.Buy) return null;
            IsBuyed = true;
            if (RemainBuy <= 0) return null;

            ICardList supply = supplyPiles.First(cardList => cardList.CardInfo == cardInfo);
            Card card = supply.First();
            TurnPlayer.Gain(card);
            supply.Remove(card);

            SpendableWorth -= cardInfo.Cost;
            RemainBuy -= 1;

            return card;
        }

        /// <summary>
        /// 購入
        /// </summary>
        public Card Buy<T>()
            where T : ICardInfo, new()
        {
            return Buy(CardInfo<T>.Instance);
        }

        #region プレイング処理

        #region ゲーム

        /// <summary>
        /// ゲームを開始する
        /// </summary>
        public void Start()
        {
            IsPlaying = true;

            turnPlayerPosition = 0;
            foreach (var item in EachTurns())
            {
                if (!IsPlaying) break;
                ExecuteTurn();
            }

            async = null;
            IsPlaying = false;
        }

        /// <summary>
        /// 非同期でゲームを開始する
        /// </summary>
        public void StartAsync()
        {
            async = new Thread(Start);
            async.Start();
        }

        /// <summary>
        /// ゲームを中断する
        /// </summary>
        public void Abort()
        {
            if (async != null)
            {
                async.Abort();
                async = null;
            }
            IsPlaying = false;
        }

        /// <summary>
        /// ゲームが終了するまでターンを進行する
        /// </summary>
        /// <returns></returns>
        internal IEnumerable<int> EachTurns()
        {
            Turn = -1;
            while (!IsEndOfGame)
            {
                yield return ++Turn;
            }
        }

        #endregion

        #region ターン

        /// <summary>
        /// ターンを進行する
        /// </summary>
        internal void ExecuteTurn()
        {
            InitializeTurn();
            TurnChanged(this, EventArgs.Empty);

            ExecuteActionPhase();
            ExecuteBuyPhase();
            ExecuteCleanUpPhase();

            turnPlayerPosition = (turnPlayerPosition + 1) % Players.Count;
            Global.TurnPlayer = turnPlayerPosition;
        }

        /// <summary>
        /// ターンのデータを初期化
        /// </summary>
        internal void InitializeTurn()
        {
            RemainAction = 1;
            RemainBuy = 1;
            SpendableWorth = Worth.None;
        }

        #endregion

        #region フェイズ

        /// <summary>
        /// アクションフェイズ
        /// </summary>
        internal void ExecuteActionPhase()
        {
            Phase = Phase.Action;

            ActionPhase(this, EventArgs.Empty);
            WaitPhaseFinished();
        }

        /// <summary>
        /// 購入フェイズ
        /// </summary>
        internal void ExecuteBuyPhase()
        {
            Phase = Phase.Buy;
            IsBuyed = false;

            BuyPhase(this, EventArgs.Empty);
            WaitPhaseFinished();
        }

        /// <summary>
        /// クリーンアップフェイズ
        /// </summary>
        internal void ExecuteCleanUpPhase()
        {
            Phase = Phase.CleanUp;

            TurnPlayer.CleanUp();
        }

        /// <summary>
        /// フェイズを終了する
        /// </summary>
        internal void FinishPhase()
        {
            phaseWaiting = false;
        }

        /// <summary>
        /// フェイズ終了まで待つ
        /// </summary>
        internal void WaitPhaseFinished()
        {
            if (!IsAsync) return;

            phaseWaiting = true;
            while (phaseWaiting) Thread.Sleep(0);
        }

        internal bool phaseWaiting = false;

        #endregion
        
        #endregion
    }

    /// <summary>
    /// フェイズ
    /// </summary>
    public enum Phase
    {
        /// <summary>
        /// アクション
        /// </summary>
        Action,

        /// <summary>
        /// 購入
        /// </summary>
        Buy,

        /// <summary>
        /// クリーンアップ
        /// </summary>
        CleanUp,
    }
}