public async Task HandleMessage(AuthorizeKnowledgeExchange message, Socket handler)
        {
            if (!ValidateMessage(message))
            {
                return;
            }
            var playerFrom = Players.Where(p => p.Guid == message.playerGuid).Single();
            var playerTo   = Players.Where(p => p.Id == message.withPlayerId).SingleOrDefault();

            await Task.Delay((int)GameMasterClient.Settings.ActionCosts.KnowledgeExchangeDelay);

            if (playerTo == null)
            {
                var permanentReject = new RejectKnowledgeExchange()
                {
                    permanent = true,
                    playerId  = playerFrom.Id
                };
                GameMasterClient.Connection.SendFromClient(handler, XmlMessageConverter.ToXml(permanentReject));
                return;
            }

            if (playerTo.OpenExchangeRequests.Contains(playerFrom.Id))
            {
                var accept = new AcceptExchangeRequest()
                {
                    playerId       = playerTo.Id,
                    senderPlayerId = playerFrom.Id
                };

                playerTo.OpenExchangeRequests.Remove(playerFrom.Id);
                GameMasterClient.Connection.SendFromClient(handler, XmlMessageConverter.ToXml(accept));
                return;
            }

            var response = new KnowledgeExchangeRequest()
            {
                playerId       = playerTo.Id,
                senderPlayerId = playerFrom.Id
            };

            playerFrom.OpenExchangeRequests.Add(playerTo.Id);
            GameMasterClient.Connection.SendFromClient(handler, XmlMessageConverter.ToXml(response));
        }
Example #2
0
            public void HandleMessage(KnowledgeExchangeRequest message)
            {
                var fromPlayer = Player.game.Players.Where(p => p.id == message.senderPlayerId).Single();

                bool accept = false;
                //it is our leader, we have to listen to him or we are the leader
                if (fromPlayer.team == Player.game.Team
                    && (fromPlayer.type == PlayerType.leader || Player.game.Type == PlayerType.leader))
                    accept = true;
                else    //decide if we really want to exchange information
                    accept = true;

                if (accept)
                {
                    //when you accept an information exchange you have to send an AuthorizeKnowledgeExchange to the gm
                    var exchange = new AuthorizeKnowledgeExchange()
                    {
                        gameId = Player.game.GameId,
                        playerGuid = Player.game.Guid,
                        withPlayerId = fromPlayer.id
                    };
                    Player.Send(XmlMessageConverter.ToXml(exchange));
                    //do not play, wait for data answer
                }
                else
                {
                    //otherwise send a RejectKnowledgeExchange directly to the player
                    var reject = new RejectKnowledgeExchange()
                    {
                        playerId = fromPlayer.id,
                        senderPlayerId = Player.game.Id
                    };
                    Player.Send(XmlMessageConverter.ToXml(reject));
                    //after reject we have to play, otherwise we will be stuck (because reject does not generate an answer)
                    Player.ReadyForAction?.Invoke();
                }
            }