static void PostMoveCompleted(string data, int matchId)
        {
            var response = JsonSerializer.DeseriaizeFromJSON<MoveResponse>(data);
            bool newGame = false;
            int gameId;
            int oldGameId;
            Match match;
            Player tttdPlayer;
            CentralServerSession session;
            StatusFlag flag = CentralServerCommunicationChannel.ParseStatus(response.StatusFlag);
            using (IGameDataService dataService = new GameDataService())
            {
                match = dataService.GetMatch(matchId, null);
                session = dataService.GetCentralServerSession(null, null, match.CurrentGameId.Value);
                tttdPlayer = dataService.GetPlayer(match.PlayerOneId);
                oldGameId = match.CurrentGameId.Value;

                if (response.NewGameId != null && response.NewGameId > 0 && response.NewGameId != session.CentralServerGameId)
                {
                    int newGameId = TicTacToeHost.Instance.ConfigureGame(matchId);
                    gameId = newGameId;
                    newGame = true;
                    session = dataService.CreateCentralServerSession(newGameId, response.NewGameId);
                }
                else
                {
                    gameId = match.CurrentGameId.Value;
                }
                dataService.Save();
            }

            if (response.YourTurn
                //|| (newGame && response.X == null && response.Y == null)
                )
            {
                using (IGameDataService dataService = new GameDataService())
                {
                    dataService.SetPlayerTurn(gameId, match.PlayerOneId);
                    dataService.Save();
                }
            }
            else if(flag == StatusFlag.ChallengeMove || flag == StatusFlag.ChallengeWin)
            {
                using (IGameDataService dataService = new GameDataService())
                {
                    dataService.EndGame(oldGameId, null);
                    dataService.Save();
                }
            }
            else if (response.X >= 0 && response.Y >= 0)
            {
                if (flag == StatusFlag.AcceptLoss)
                {
                    using (IGameDataService dataService = new GameDataService())
                    {
                        dataService.EndGame(oldGameId, match.PlayerOneId);
                        dataService.Save();
                    }
                }

                if (newGame)
                {
                    using (IGameDataService dataService = new GameDataService())
                    {
                        dataService.SetPlayerTurn(gameId, match.PlayerTwoId);
                        dataService.Save();
                    }
                }

                Move move = new Move() { GameId = gameId, PlayerId = match.PlayerTwoId };
                GameState state = TicTacToeHost.Instance.GetGameState(gameId, match.PlayerTwoId);
                if (state.Mode == PlayMode.DeathMatch)
                {
                    move.OriginX = response.X;
                    move.OriginY = response.Y;
                    for (int x = 0; x < 3; x++)
                    {
                        for (int y = 0; y < 3; y++)
                        {
                            if (state.GameBoard[x][y] == null || state.GameBoard[x][y] == 0)
                            {
                                move.X = x;
                                move.Y = y;
                            }
                        }
                    }
                }
                else
                {
                    move.X = response.X.Value;
                    move.Y = response.Y.Value;
                }

                MoveResult opponentMoveResult = TicTacToeHost.Instance.Move(move, false);
                GameState postMoveState = TicTacToeHost.Instance.GetGameState(gameId, match.PlayerTwoId);
                if (opponentMoveResult != MoveResult.Valid || flag == StatusFlag.WinningMove || postMoveState.YouWon)
                {
                    MoveRequest challengeRequest = new MoveRequest();
                    challengeRequest.GameId = session.CentralServerGameId.Value;
                    challengeRequest.PlayerName = tttdPlayer.PlayerName;
                    challengeRequest.X = 0;
                    challengeRequest.Y = 0;

                    bool challenging = false;
                    if (opponentMoveResult != MoveResult.Valid)
                    {
                        challengeRequest.Flags = CentralServerCommunicationChannel.GetStatus(StatusFlag.ChallengeMove);
                        challenging = true;
                    }
                    else
                    {
                        if (flag == StatusFlag.WinningMove && !postMoveState.YouWon)
                        {
                            challengeRequest.Flags = CentralServerCommunicationChannel.GetStatus(StatusFlag.ChallengeWin);
                            challenging = true;
                        }
                        else
                        {
                            challengeRequest.Flags = CentralServerCommunicationChannel.GetStatus(StatusFlag.AcceptLoss);
                        }
                    }

                    if (challenging)
                    {
                        using (IGameDataService dataService = new GameDataService())
                        {
                            dataService.EndGame(gameId, null);
                            dataService.Save();
                        }
                    }

                    CentralServerCommunicationChannel.Instance.PostMove(challengeRequest, match.CurrentGameId.Value, match.MatchId);
                }
            }
        }
コード例 #2
0
 public MoveResult Move(Move move)
 {
     return this.host.Move(move);
 }
コード例 #3
0
        public MoveResult Move(Move move, bool raiseEvent)
        {
            MoveResult validationResult = this.ValidateMove(move);
            bool canMove = true;
            if (validationResult != MoveResult.Valid)
                canMove = false;

            Logger.Instance.Log("MoveAttempt", string.Format("GameId:{1}|PlayerId:{2}|ValidationResult:{0}", validationResult.ToString(), move.GameId, move.PlayerId), JsonSerializer.SerializeToJSON(move));

            if (!canMove)
                return validationResult;

            Match match;
            GameState currentState = TicTacToeHost.Instance.GetGameState(move.GameId, move.PlayerId);
            using (IGameDataService gameDataService = new GameDataService())
            {
                match = gameDataService.GetMatch(null, move.GameId);
                gameDataService.Move(move.GameId, move.PlayerId, move.OriginX, move.OriginY, move.X, move.Y);
                gameDataService.Save();
            }

            this.UpdateGame(move.GameId);

            if (validationResult == MoveResult.Valid && raiseEvent)
            {
                GameConfiguration config = GameConfigCache.Instance.GetConfig(match.MatchId);
                if (config.GameType == GameType.Network)
                    this.PlayerMove(this, new MoveEventArgs()
                    {
                        MatchId = match.MatchId,
                        PlayerId = move.PlayerId,
                        Mode = currentState.Mode,
                        OriginX = move.OriginX,
                        OriginY = move.OriginY,
                        X = move.X,
                        Y = move.Y
                    });
            }

            return validationResult;
        }
コード例 #4
0
        public MoveResult ValidateMove(Move move)
        {
            GameState state = this.GetGameState(move.GameId, move.PlayerId);
            if (state == null)
                return MoveResult.InvalidGame;
            else if (state.YourTurn == false)
                return MoveResult.NotPlayerTurn;
            else
            {
                if (move.OriginX != null || move.OriginY != null)
                {
                    if ((state.Mode != PlayMode.DeathMatch)
                        || (move.OriginX == null || move.OriginY == null)
                        || (move.OriginX < 0 || move.OriginX > 2)
                        || (move.OriginY < 0 || move.OriginY > 2)
                        || (state.GameBoard[move.OriginX.Value][move.OriginY.Value] != 1))
                    {
                        return MoveResult.InvalidOrigin;
                    }
                }

                if ((move.X < 0 || move.X > 2)
                    || (move.Y < 0 || move.Y > 2)
                    || (state.GameBoard[move.X][move.Y] != null))
                {
                    return MoveResult.InvalidDestination;
                }

                return MoveResult.Valid;
            }

            //If there isn't a rule to catch by now, we just need to fail.
            return MoveResult.Failed;
        }
コード例 #5
0
 public MoveResult Move(Move move)
 {
     return this.Move(move, true);
 }