/// <summary>
        /// Deal card.
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="data">Data received from client.</param>
        public static void DealCard(PirateHost host, PirateMessage data)
        {
            Contract.Requires(host != null && data != null && data.Head == PirateMessageHead.Xcrd);
            var player = PirateMessage.GetPlayerName(data);
            if(player == null) {
                return;
            }

            var pclient = host.PlayerFromString(player);
            if(pclient == null) {
                return;
            }

            var card = Card.FromString(data.Body);
            if(card == null) {
                return;
            }

            pclient.GetCard(card);

            Console.WriteLine("Host: Sending card " + card.ToShortString() + " to " + pclient);

            var msg = new PirateMessage(PirateMessageHead.Xcrd, card.ToString());
            host.SendMessage(pclient, msg);

            if(host.Game.Round.CardsDealt == host.Game.Round.TotalCards) {
                RequestBets(host);
            }
        }
Beispiel #2
0
        private static void Host()
        {
            Console.WriteLine("Creating host");
            var host = new PirateHost(4939) { DebugMode = true };
            host.Start();
            Console.WriteLine("Host started");
            Console.Title = "Host";
            while (host.Started) {
                var cmd = Console.ReadLine();
                switch(cmd) {
                    case "start":
                    case "s":
                        if (!host.Game.Started) {
                            if (host.Game.Players.Count >= 2) {
                                host.StartGame();
                                host.Game.GameFinished += GameFinished;
                            } else {
                                Console.WriteLine("Not enough players to start the game!");
                            }
                        }else {
                            Console.WriteLine("Game already started!");
                        }
                        break;

                    case "exit":
                    case "e":
                        host.Stop();
                        break;
                }
            }
        }
 public void InitConnection(
     PirateHost host,
     PirateClient pclient,
     PirateMessage data
 )
 {
     PirateHostCommands.InitConnection(host, pclient, data);
     // TODO: add assertions to method PirateHostCommandsTest.InitConnection(PirateHost, PirateClient, PirateMessage)
 }
 public void ErrorMessage(
     PirateHost host,
     PirateClient pclient,
     PirateError error
 )
 {
     PirateHostCommands.ErrorMessage(host, pclient, error);
     // TODO: add assertions to method PirateHostCommandsTest.ErrorMessage(PirateHost, PirateClient, PirateError)
 }
        public void PlayGame()
        {
            PirateHost host = new PirateHost(4939);
            host.Start();
            host.Broadcaster.Interval = 1.1;
            Assert.That(host.Broadcaster.Interval < 1.11 && host.Broadcaster.Interval > 1.09);

            PirateClient player1 = new PirateClient("Player1", "127.0.0.1", 4939);
            player1.SetGame(new Game());
            player1.BetRequested += OnBetRequest;
            player1.CardRequested += OnCardRequest;
            player1.Disconnected += OnDisconnect;
            player1.InitConnection();
            while(!host.ContainsPlayer(player1.Name)) {}

            Assert.That(PirateScanner.CheckIp(PirateScanner.GetIp("127.0.0.1"), 4939, 1000));

            PirateClient player2 = new PirateClient("Player2", "127.0.0.1", 4939);
            player2.SetGame(new Game());
            player2.BetRequested += OnBetRequest;
            player2.CardRequested += OnCardRequest;
            player2.Disconnected += OnDisconnect;
            player2.InitConnection();
            while(!host.ContainsPlayer(player2.Name)) {}
            Assert.That(host.ContainsPlayer(player1.Name));

            var ps = new PirateScanner();
            var gameinfos = ps.ScanForGames(4939, 2000);
            Assert.That(gameinfos.Count > 0);
            var gameinfo = gameinfos[0];

            PirateClient player3 = new PirateClient("Player3", gameinfo.Ip, 4939);
            player3.SetGame(new Game());
            player3.BetRequested += OnBetRequest;
            player3.CardRequested += OnCardRequest;
            player3.Disconnected += OnDisconnect;
            player3.InitConnection();
            while(!host.ContainsPlayer(player3.Name)) {}
            Assert.That(player1.Name == host.PlayerFromSocket(host.GetPlayers().First().Socket).Name);

            while(host.Game.Players.Count != 3) {}

            host.StartGame();

            while(!host.Game.Finished) {
                Assert.That(host.Game.Started);
            }

            Assert.That(host.Game.Finished);

            host.Stop();

            while(player1.Socket.Connected || player2.Socket.Connected || player3.Socket.Connected) {}
        }
        /// <summary>
        /// Begin round.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void BeginRound(PirateHost host)
        {
            Contract.Requires(host != null && host.Game.Round.BetsDone);

            var bets = new HashSet<string>();
            foreach(var player in host.GetPlayers()) {
                bets.Add(PirateMessage.ConstructPlayerBet(player));
            }
            bets.Add(PirateMessage.ConstructRoundNumber(host.Game.CurrentRound));

            var msg = new PirateMessage(PirateMessageHead.Bgrn, PirateMessage.ConstructBody(bets));

            foreach(var player in host.GetPlayers()) {
                host.SendMessage(player, msg);
            }
            lock (host.Game.Round) {
                host.Game.Round.Begin();
            }
        }
Beispiel #7
0
 /// <summary>
 /// Helper method for taking action upon a button press
 /// </summary>
 /// <param name="b">The button that has been pressed</param>
 private void ButtonAction(Button b)
 {
     Contract.Requires(b != null);
     Contract.Ensures(
         game.State == GameState.StartUp
         ||
         (PirateHost.IsValidGameName(serverName.Text)
              ? (game.Host != null && game.Client != null && game.PlayingGame != null
                 && game.State == GameState.InGame)
              : game.State == GameState.CreateGame));
     var str = b.Name;
     switch(str) {
         case "creategame":
             if(serverName.Text == "" || !PirateHost.IsValidGameName(serverName.Text)) {
                 return;
             }
             var players = numberOfPlayers.ParseInput();
             var sName = serverName.Text;
             var host = new PirateHost(4939);
             host.Start(sName, players);
             var client = new PirateClient(game.PlayerName, host.Ip, 4939);
             PirateClientCommands.SendPlayerInfo(client);
             var playingGame = new Game();
             game.GameName = sName;
             game.MaxPlayers = players;
             game.Host = host;
             game.Client = client;
             client.SetGame(playingGame);
             game.PlayingGame = playingGame;
             game.State = GameState.InGame;
             break;
         case "cancelcg":
             game.State = GameState.StartUp;
             break;
     }
 }
        /// <summary>
        /// Set player info.
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="pclient">The client.</param>
        /// <param name="data">The data received from client.</param>
        public static void SetPlayerInfo(PirateHost host, PirateClient pclient, PirateMessage data)
        {
            Contract.Requires(host != null && pclient != null && data != null && data.Head == PirateMessageHead.Pnfo);
            var player = PirateMessage.GetPlayerName(data);
            if (player == null) return;

            if (!host.ContainsPlayer(player)) {
                if(host.Game.Contains(pclient)) host.Game.RemovePlayer(pclient);
                host.SetPlayerName(pclient, player);
                host.Game.ClearPlayers();
                host.Game.AddPlayers(host.GetPlayers());
                pclient.SetGame(host.Game);
                SendPlayerInfo(host);
            }else {
                var msg = new PirateMessage(PirateMessageHead.Erro, PirateError.NameAlreadyTaken.ToString());
                host.SendMessage(pclient, msg);
            }
        }
        /// <summary>
        /// Round finished.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void RoundFinished(PirateHost host)
        {
            Contract.Requires(host != null);

            var body =
                PirateMessage.ConstructBody(
                    PirateMessage.ContstructPlayerScores(host.Game.GetRoundScoreTotal(host.Game.CurrentRound)));
            var msg = new PirateMessage(PirateMessageHead.Frnd, body);

            foreach (var player in host.GetPlayers()) {
                host.SendMessage(player, msg);
            }
        }
        /// <summary>
        /// Request bets from players.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void RequestBets(PirateHost host)
        {
            Contract.Requires(host != null);

            var msg = new PirateMessage(PirateMessageHead.Breq, "");
            foreach(var pclient in host.GetPlayers()) {
                host.SendMessage(pclient, msg);
            }
        }
Beispiel #11
0
 public static string ConstructHostInfo(PirateHost host)
 {
     Contract.Requires(host != null);
     Contract.Ensures(Contract.Result<string>() != null);
     return ConstructBody(
         ConstructHostIp(host),
         ConstructGameName(host),
         ConstructPlayersInGame(host.PlayerCount),
         ConstructMaxPlayersInGame(host.MaxPlayers));
 }
Beispiel #12
0
 public static string ConstructGameName(PirateHost host)
 {
     Contract.Requires(host != null);
     Contract.Ensures(Contract.Result<string>() != null);
     return "game_name: " + host.GameName;
 }
 public string ConstructHostIp(PirateHost host)
 {
     string result = PirateMessage.ConstructHostIp(host);
     return result;
     // TODO: add assertions to method PirateMessageTest.ConstructHostIp(PirateHost)
 }
 public void PlayCard(PirateHost host, PirateMessage data)
 {
     PirateHostCommands.PlayCard(host, data);
     // TODO: add assertions to method PirateHostCommandsTest.PlayCard(PirateHost, PirateMessage)
 }
 public void NewRound(PirateHost host)
 {
     PirateHostCommands.NewRound(host);
     // TODO: add assertions to method PirateHostCommandsTest.NewRound(PirateHost)
 }
        /// <summary>
        /// Play card from player.
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="data">Data received from client.</param>
        public static void PlayCard(PirateHost host, PirateMessage data)
        {
            Contract.Requires(host != null && data != null && data.Head == PirateMessageHead.Pcrd);
            var playerName = PirateMessage.GetPlayerName(data);
            var player = host.PlayerFromString(playerName);
            var card = Card.FromString(data.Body);

            if(!player.CardPlayable(card, host.Game.Round.BoardCards.FirstCard)) {
                ErrorMessage(host, player, PirateError.CardNotPlayable);
                var returnCard = new PirateMessage(PirateMessageHead.Xcrd, card.ToString());
                host.SendMessage(player, returnCard);
                RequestCard(host, player);
                return;
            }

            Console.WriteLine(player.Name + " plays " + card.ToShortString());

            var msg = new PirateMessage(
                PirateMessageHead.Pcrd, PirateMessage.ConstructBody(player.ToString(), card.ToString()));

            foreach(var pclient in host.GetPlayers()) {
                host.SendMessage(pclient, msg);
            }

            player.PlayCard(card);
            //host.Game.Round.PlayCard(player, card);
            if(!host.Game.Round.Finished) {
                RequestCard(host, host.PlayerFromIndex(host.Game.Round.CurrentPlayer));
            }else {
                host.Game.NewRound();
            }
        }
        /// <summary>
        /// Receive bet from player.
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="player">The client.</param>
        /// <param name="msg">The data received from the client.</param>
        public static void ReceiveBet(PirateHost host, PirateClient player, PirateMessage msg)
        {
            Contract.Requires(host != null && player != null && msg != null && msg.Head == PirateMessageHead.Pbet && host.Game.Round.AwaitingBets);

            lock (host.Game.Round) {
                var bet = 0;
                if (int.TryParse(msg.Body, out bet)) {
                    player.SetBet(bet);
                } else {
                    ErrorMessage(host, player, PirateError.InvalidBet);
                }

                if (host.Game.Round.BetsDone) {
                    BeginRound(host);
                }
            }
        }
Beispiel #18
0
 public static string ConstructHostIp(PirateHost host)
 {
     Contract.Requires(host != null);
     Contract.Ensures(Contract.Result<string>() != null);
     return "host_ip: " + host.Ip;
 }
 /// <summary>
 /// Request card from player.
 /// </summary>
 /// <param name="host">The host.</param>
 /// <param name="pclient">The player.</param>
 public static void RequestCard(PirateHost host, PirateClient pclient)
 {
     Contract.Requires(host != null && pclient != null);
     Console.WriteLine("Sending card request to " + pclient.Name);
     var msg = new PirateMessage(PirateMessageHead.Creq, "");
     host.SendMessage(pclient, msg);
 }
        /// <summary>
        /// Game finished.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void GameFinished(PirateHost host)
        {
            Contract.Requires(host != null);

            var body =
                PirateMessage.ConstructBody(
                    PirateMessage.ContstructPlayerScores(host.Game.GetTotalScores()));
            body = PirateMessage.AppendBody(body, PirateMessage.ConstructWinner(host.Game.Leader));
            var msg = new PirateMessage(PirateMessageHead.Gfin, body);

            foreach (var player in host.GetPlayers()) {
                host.SendMessage(player, msg);
            }
        }
        /// <summary>
        /// Send player info.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void SendPlayerInfo(PirateHost host)
        {
            Contract.Requires(host != null);

            var msg = new PirateMessage(PirateMessageHead.Pigm, PirateMessage.ConstructBody(host.GetPlayers().Select(player => player.ToString()).ToArray()));

            if (host.PlayerCount > 0) {
                if(host.DebugMode) Console.WriteLine("Host: Players in game:");
                foreach (var player in host.GetPlayers()) {
                    if(host.DebugMode) Console.WriteLine("\t" + player.Name);
                    host.SendMessage(player, msg);
                }
            }
        }
 /// <summary>
 /// Get player info.
 /// </summary>
 /// <param name="host">The host.</param>
 /// <param name="pclient">The client.</param>
 public static void GetPlayerInfo(PirateHost host, PirateClient pclient)
 {
     Contract.Requires(host != null && pclient != null);
     var msg = new PirateMessage(PirateMessageHead.Pnfo, "");
     host.SendMessage(pclient, msg);
 }
        /// <summary>
        /// Start game.
        /// </summary>
        /// <param name="host">The game.</param>
        public static void StartGame(PirateHost host)
        {
            Contract.Requires(host != null && host.PlayerCount >= 2);
            host.StopAccepting();

            var dealerIndex = CollectionFnc.PickRandom(0, host.Game.Players.Count - 1);
            Console.WriteLine("Starting player is: " + host.Game.Players[dealerIndex].Name);

            var msg = new PirateMessage(PirateMessageHead.Gstr, PirateMessage.ConstructStartingPlayer(host.Game.Players[dealerIndex]));
            foreach(var pclient in host.GetPlayers()) {
                host.SendMessage(pclient, msg);
            }

            host.Game.Start(true, dealerIndex);
        }
 /// <summary>
 /// Reply to a connection initialization.
 /// </summary>
 /// <param name="host">The host.</param>
 /// <param name="pclient">The client.</param>
 /// <param name="data">The data received from the client.</param>
 public static void InitConnection(PirateHost host, PirateClient pclient, PirateMessage data)
 {
     Contract.Requires(host != null && pclient != null && data != null && data.Head == PirateMessageHead.Init);
     var msg = new PirateMessage(PirateMessageHead.Init, WelcomePhrase);
     host.SendMessage(pclient, msg);
 }
 /// <summary>
 /// Client verification.
 /// </summary>
 /// <param name="host">The host.</param>
 /// <param name="pclient">The client.</param>
 /// <param name="data">The data received from the client.</param>
 public static void VerifyConnection(PirateHost host, PirateClient pclient, PirateMessage data)
 {
     Contract.Requires(host != null && pclient != null && data != null && data.Head == PirateMessageHead.Verf);
     if(data.Body == WelcomePhrase) {
         GetPlayerInfo(host, pclient);
     }
 }
 /// <summary>
 /// Reply to a knock.
 /// </summary>
 /// <param name="host">The host.</param>
 /// <param name="pclient">The client.</param>
 public static void KnockKnock(PirateHost host, PirateClient pclient)
 {
     Contract.Requires(host != null && pclient != null);
     var msg = new PirateMessage(PirateMessageHead.Knck, "");
     host.SendMessage(pclient, msg);
 }
 /// <summary>
 /// Send error message.
 /// </summary>
 /// <param name="host">The host.</param>
 /// <param name="pclient">The client.</param>
 /// <param name="error">The error.</param>
 public static void ErrorMessage(PirateHost host, PirateClient pclient, PirateError error)
 {
     Contract.Requires(host != null && pclient != null && error != PirateError.Unknown);
     var msg = new PirateMessage(PirateMessageHead.Erro, error.ToString());
     host.SendMessage(pclient, msg);
 }
        /// <summary>
        /// New pile.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void NewPile(PirateHost host)
        {
            Contract.Requires(host != null);

            var body = PirateMessage.ConstructBody(PirateMessage.ConstructPlayerTricks(host.Game.Round));
            body = PirateMessage.AppendBody(body, PirateMessage.ConstructWinner(host.Game.Round.LastTrick.Winner));
            var msg = new PirateMessage(PirateMessageHead.Trdn, body);

            foreach(var player in host.GetPlayers()) {
                host.SendMessage(player, msg);
            }
        }
 public PirateHost Constructor(int port)
 {
     PirateHost target = new PirateHost(port);
     return target;
     // TODO: add assertions to method PirateHostTest.Constructor(Int32)
 }
        /// <summary>
        /// New round.
        /// </summary>
        /// <param name="host">The host.</param>
        public static void NewRound(PirateHost host)
        {
            Contract.Requires(host != null);

            var body =
                PirateMessage.ConstructBody(
                    PirateMessage.ConstructDealer(host.Game.Players[host.Game.Round.Dealer].Name),
                    PirateMessage.ConstructRoundNumber(host.Game.CurrentRound));
            var msg = new PirateMessage(PirateMessageHead.Nrnd, body);
            foreach (var pclient in host.GetPlayers()) {
                host.SendMessage(pclient, msg);
            }
            Console.WriteLine("Starting new round: " + host.Game.CurrentRound);
        }