Ejemplo n.º 1
0
        private void ProcessMessages()
        {
            m_GenericGameMessageSubscriber = BesiegedServer.MessageSubject
                .Where(message => message is GenericGameMessage && message.GameId == GameId)
                .Subscribe(message =>
                {
                    var genericMessage = message as GenericGameMessage;
                    switch (genericMessage.MessageEnum)
                    {
                        case GameMessage.GameMessageEnum.PlayerNotReady:
                            LookupPlayerById(message.ClientId).IsReady.Value = false;
                            break;

                        case GameMessage.GameMessageEnum.Start:
                            m_GameMachine.Fire(Trigger.CreatorPressedStart);
                            break;

                        case GameMessage.GameMessageEnum.PlayerLeft:
                            RemovePlayer(message.ClientId);
                            ConsoleLogger.Push(string.Format("Leave game command received from {0} Client Id {1} in game {2}", LookupPlayerName(message.ClientId), message.ClientId, Name));
                            break;

                        case GameMessage.GameMessageEnum.StartBattlePhase:

                            break;

                        default:
                            break;
                    }
                });

            m_GameMessageSubscriber = BesiegedServer.MessageSubject
                .Where(message => message is GameMessage && !(message is GenericGameMessage) && message.GameId == GameId)
                .Subscribe(message =>
                {
                    if (message is GameChatMessage)
                    {
                        var gameChatMessage = message as GameChatMessage;
                        if (gameChatMessage.Contents.Equals("All your base are belong to us", StringComparison.OrdinalIgnoreCase))
                        {
                            m_WinnerId = message.ClientId;
                            m_GameMachine.Fire(Trigger.Cheatcode);
                        }
                        else
                        {
                            string chatMessage = string.Format("{0}: {1}", LookupPlayerName(message.ClientId), gameChatMessage.Contents);
                            ClientChatMessage clientChat = new ClientChatMessage() { Contents = chatMessage };
                            NotifyAllPlayers(clientChat.ToXml());
                        }
                    }

                    else if (message is JoinGameMessage)
                    {
                        if ((message as JoinGameMessage).Password == Password)
                        {
                            AddPlayer(BesiegedServer.GetConnectedClientById(message.ClientId));
                        }
                        else
                        {
                            ErrorDialogMessage error = new ErrorDialogMessage() { Contents = "Incorrect Password!" };
                            BesiegedServer.GetConnectedClientById(message.ClientId).Callback.SendMessage(error.ToXml());
                        }
                    }

                    else if (message is PlayerReadyMessage)
                    {
                        var player = LookupPlayerById(message.ClientId);
                        player.IsReady.Value = true;
                        player.ArmyType = (message as PlayerReadyMessage).ArmyType;
                    }

                    else if (message is EndMoveTurnMessage)
                    {
                        // we need to validate all of the users moves against the server's gamestate to make sure they are valid
                        EndMoveTurnMessage endMessage = message as EndMoveTurnMessage;

                        GameState tempState = new GameState(GameState);
                        List<UnitMove> InvalidMoves = new List<UnitMove>();
                        endMessage.Moves.ForEach(move =>
                        {
                            if (!ValidateMove(move))
                                InvalidMoves.Add(move);
                            else
                            {
                                BaseUnit selectedUnit =
                                        GameState.Units.FirstOrDefault(
                                            unit =>
                                            unit.X_Position == move.StartCoordinate.XCoordinate &&
                                            unit.Y_Position == move.StartCoordinate.YCoordinate);
                                if (selectedUnit == null) return;
                                selectedUnit.X_Position = move.EndCoordinate.XCoordinate;
                                selectedUnit.Y_Position = move.EndCoordinate.YCoordinate;
                                selectedUnit.MovementLeft = selectedUnit.Movement;
                            }
                        });

                        if (InvalidMoves.Count == 0)
                        {
                            var waitingPlayers = Players.Where(x => x.ClientId != message.ClientId).ToList();
                            waitingPlayers.ForEach(player => player.Callback.SendMessage((new UpdatedUnitPositionMessage() { Moves = endMessage.Moves }).ToXml()));
                            if (pathFinder.IsAnyUnitWithinAttackableRange(message.ClientId))
                            {
                                LookupPlayerById(message.ClientId).Callback.SendMessage((new GenericClientMessage() { MessageEnum = ClientMessage.ClientMessageEnum.StartBattlePhase }).ToXml());
                            }
                            else
                            {
                                m_GameMachine.Fire(Trigger.PlayerTurn);
                            }
                        }
                        else
                        {
                            // we need to notify the client of invalid moves
                            GameState.Units = tempState.Units; // roll back the unit positions and movement
                        }
                    }
                });
        }
Ejemplo n.º 2
0
        public void RemovePlayer(string clientId)
        {
            if (clientId == m_GameCreatorClientId)
            {
                GenericClientMessage disbanded = new GenericClientMessage() { MessageEnum = ClientMessage.ClientMessageEnum.GameDisbanded };
                NotifyAllPlayers(disbanded.ToXml());
                BesiegedServer.DisbandGame(GameId);
            }
            else
            {
                Player player = Players.FirstOrDefault(x => x.ClientId == clientId);
                Players.Remove(player);
                ConsoleLogger.Push(string.Format("{0} with ClientId {1} has left game {2}", player.Name, player.ClientId, Name));

                AggregateMessage aggregate = new AggregateMessage();
                GenericClientMessage remove = new GenericClientMessage() { MessageEnum = ClientMessage.ClientMessageEnum.RemovePlayer, ClientId = player.ClientId };
                ClientChatMessage chatMessage = new ClientChatMessage() { Contents = string.Format("* {0} has left the game *", player.Name) };
                aggregate.MessageList.Add(remove);
                aggregate.MessageList.Add(chatMessage);
                NotifyAllPlayers(aggregate.ToXml());

                ColorPool.Push(player.PlayerColor);
                player.Callback.SendMessage((new GenericClientMessage() { MessageEnum = ClientMessage.ClientMessageEnum.TransitionToMultiplayerMenuState }).ToXml());
                player = null;
                m_GameMachine.Fire(Trigger.PlayerLeft);
            }
        }