Ejemplo n.º 1
0
        /// <summary>
        /// Deal the hands to each player for phase 1
        /// </summary>
        /// <param name="Game"></param>
        /// <param name="Context"></param>
        public static void BeginPhase1(GameModel Game, HttpContextBase Context)
        {
            string[]         player_Ids = Game.Player_Ids.SplitAndTrim(',');
            PlayerModel[]    players    = new PlayerModel[player_Ids.Length];
            HashSet <string> scores     = new HashSet <string>();

            scores.Add("Round " + Game.Round);
            for (int i = 0; i < player_Ids.Length; i++)
            {
                players[i] = Context.Application["Player-" + player_Ids[i]] as PlayerModel;
                scores.Add(players[i].Name + ": " + players[i].Score);
            }

            // Then calculate the card actions
            foreach (var player in players)
            {
                // Clear the player
                PlayerMethods.ClearPlayer(player);

                // Add the current scores
                player.Messages = scores;

                player.Card_Ids = GenerateHand(1, Game.Random);
                Context.Application["Player-" + player.Id] = player;
            }

            Game.Phase     = 1;
            Game.DirtCount = 0;
            Game.Active_Card_Ids.Clear();
            Context.Application["Game-" + Game.Id] = Game;
        }
Ejemplo n.º 2
0
        public static void EndGame(GameModel Game, HttpContextBase Context)
        {
            //Remove all the players
            string[] player_Ids = Game.Player_Ids.SplitAndTrim(',');
            foreach (string id in player_Ids)
            {
                var player = Context.Application["Player-" + id] as PlayerModel;
                PlayerMethods.ClearPlayer(player);
                Context.Application["Player-" + id] = player;
            }

            //Remove the game
            Context.Application["Game-" + Game.Id] = null;
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Take the actions that have been performed in phase 1 and apply them to the pending scores and defense states of each player
        /// </summary>
        /// <param name="Game"></param>
        /// <param name="Context"></param>
        public static int BeginPhase2(GameModel Game, HttpContextBase Context)
        {
            Game.Active_Card_Ids.Clear();

            string[] player_Ids = Game.Player_Ids.SplitAndTrim(',');
            Dictionary <string, int> PendingAttacks = new Dictionary <string, int>();

            PlayerModel[] players   = new PlayerModel[player_Ids.Length];
            int           dirtCount = 0;

            // First build up the array of card effects
            for (int i = 0; i < player_Ids.Length; i++)
            {
                players[i] = Context.Application["Player-" + player_Ids[i]] as PlayerModel;
                PendingAttacks.Add(player_Ids[i], 0);
            }

            // Then calculate the card actions
            foreach (var player in players)
            {
                //var player = players.FirstOrDefault(a => a.Id == id);
                if (player.SelectedCard != null)
                {
                    // Find the action the player has made this round
                    var card = Constants.Cards.GetCard(player.SelectedCard);
                    // Apply the self actions
                    player.Dirt = card.Dirty ? card.Name : null;
                    dirtCount  += player.Dirty ? 1 : 0;

                    player.PendingDefense += card.Defense;
                    player.PendingScore   += card.Score;

                    if (card.Target == Constants.List_CardTargets.Other)
                    {
                        // Store the pending action against its target
                        PendingAttacks[player.SelectedTarget] += card.Attack;
                    }
                    else if (card.Target == Constants.List_CardTargets.Global)
                    {
                        // Store the pending action against its targets
                        foreach (var key in player_Ids.Where(a => a != player.Id))
                        {
                            PendingAttacks[key] += card.Attack;
                        }
                    }
                    if (card.Effect_Id > 0)
                    {
                        Game.Active_Card_Ids.Add(card.Effect_Id);

                        switch (card.Effect_Id)
                        {
                        case 8:
                            players.First(a => a.Id == player.SelectedTarget).Active_Card_Ids.Add(8);
                            break;

                        case 9:
                            PendingAttacks[player.Id] += card.Attack;
                            break;
                        }
                    }
                }

                // Clear the player
                PlayerMethods.ClearPlayer(player, false);
            }

            // Finally, apply them and generate the card messages
            foreach (var player in players)
            {
                //Clear any old messages
                player.Messages.Clear();

                // Create the new hand for the player
                player.Card_Ids = GenerateHand(2, Game.Random);

                PendingAttacks[player.Id] -= player.PendingDefense;

                if (!player.Dirty && Game.Active_Card_Ids.Contains(6))
                {
                    PendingAttacks[player.Id] += 100;
                }
                if (player.Dirty && Game.Active_Card_Ids.Contains(7))
                {
                    PendingAttacks[player.Id] += 300;
                }
                if (PendingAttacks[player.Id] > 0)
                {
                    player.PendingScore -= PendingAttacks[player.Id];
                }

                player.PendingDefense = 0;

                if (dirtCount > 0)
                {
                    player.Messages.Add(dirtCount + " players have been found to be acting illegally.");
                }
                Context.Application["Player-" + player.Id] = player;
            }
            Game.Phase     = 2;
            Game.DirtCount = dirtCount;
            Context.Application["Game-" + Game.Id] = Game;

            return(dirtCount);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Takes the actions people performed in phase and applies it to their players for investigation
        /// </summary>
        /// <param name="Game"></param>
        /// <param name="Context"></param>
        public static void BeginPhase3(GameModel Game, HttpContextBase Context)
        {
            string[] player_Ids = Game.Player_Ids.SplitAndTrim(',');
            List <InvestigationModel> PendingInvestigations = new List <InvestigationModel>();

            PlayerModel[] players = new PlayerModel[player_Ids.Length];

            // First build up the array of card effects
            for (int i = 0; i < player_Ids.Length; i++)
            {
                players[i] = Context.Application["Player-" + player_Ids[i]] as PlayerModel;
            }

            // Then calculate the card actions
            foreach (var player in players)
            {
                if (player.SelectedCard != null)
                {
                    // Find the action the player has made this round
                    var card = Constants.Cards.GetCard(player.SelectedCard);

                    // Apply the self actions
                    player.DefenseType += card.SubType;

                    if (card.Type == "Investigation")
                    {
                        if (card.Target == Constants.List_CardTargets.Other)
                        {
                            // Store the pending action against its target
                            PendingInvestigations.Add(new InvestigationModel {
                                Game_Id = Game.Id, Instigator_Id = player.Id, Target_Id = player.SelectedTarget, Type = card.SubType
                            });
                        }
                        else if (card.Target == Constants.List_CardTargets.Global)
                        {
                            // Store the pending action against its targets
                            foreach (var target in players.Where(a => a.Id != player.Id))
                            {
                                PendingInvestigations.Add(new InvestigationModel {
                                    Game_Id = Game.Id, Instigator_Id = player.Id, Target_Id = target.Id, Type = card.SubType
                                });
                            }
                        }
                    }
                    else if (card.Type == "Twist")
                    {
                        if (card.Effect_Id > 0)
                        {
                            Game.Active_Card_Ids.Add(card.Effect_Id);
                            switch (card.Effect_Id)
                            {
                            case 13:     // Baiting card
                                player.Baiting = true;
                                break;
                            }
                        }
                    }
                }

                //Clear any old messages
                player.Messages.Clear();

                // Clear the hand for the player
                player.Card_Ids = new int[0];
            }

            // Finally, apply them and generate the card messages
            int    index          = new Random().Next(0, player_Ids.Length);
            string vote_master_id = player_Ids[index];

            foreach (var player in players)
            {
                foreach (var investigation in PendingInvestigations.Where(a => a.Instigator_Id == player.Id))
                {
                    var    target = players.FirstOrDefault(a => a.Id == investigation.Target_Id);
                    string result = "";
                    if (target.DefenseType == investigation.Type || Game.Active_Card_Ids.Contains(1))
                    {
                        switch (investigation.Type)
                        {
                        case "Dirt":
                            result = target.Name + " is clean";
                            break;

                        default:  result = "The investigation returned nothing of note";
                            break;
                        }
                    }
                    else
                    {
                        switch (investigation.Type)
                        {
                        case "Dirt":
                            result = target.Name + (target.Dirty ? " has dirt on them" : " is clean");
                            break;

                        case "Score":
                            result = target.Name + " is looking to " + (target.PendingScore >= 0 ? "gain " : "lose ") + target.PendingScore + " points of popularity";
                            break;

                        case "Target":
                            string attackedPlayer = "an unknown player";
                            if (String.IsNullOrEmpty(target.SelectedTarget))
                            {
                                switch (Constants.Cards.GetCard(player.SelectedCard).Target)
                                {
                                case "Global": attackedPlayer = "everyone"; break;

                                case "Self": attackedPlayer = "themself"; break;

                                case "Other": attackedPlayer = "another player"; break;
                                }
                            }
                            else
                            {
                                attackedPlayer = players.First(a => a.Id == target.SelectedTarget).Name;
                            }
                            result = target.Name + " targeted " + attackedPlayer + " this round";
                            break;

                        case "History":
                            result = target.Name + " has made " + target.HistoricDirt + " illegal actions in this game";
                            break;
                        }
                    }
                    player.Messages.Add(result);
                }

                if (vote_master_id == player.Id)
                {
                    player.Voting = true;
                }
                else
                {
                    player.Messages.Add("Another player is controlling the vote, discuss as a group and figure out who to accuse of foul play");
                }

                // Clear the player
                PlayerMethods.ClearPlayer(player, false);

                Context.Application["Player-" + player.Id] = player;
            }
            Game.Phase = 3;
            Context.Application["Game-" + Game.Id] = Game;
        }