예제 #1
0
 public GameDataPacket(IPEndPoint destination, GameData gameData)
     : base(PacketType.GAMEDATA, destination)
 {
     AddContent(gameData.GetByteArray());
     FinalizeData();
     return;
 }
 /// <summary>
 /// Perform a transion between states.
 /// </summary>
 /// <param name="transEvent">An event that is occuring when a packet arrives.</param>
 /// <param name="packet">The packet received over the network.</param>
 public void DoTransition(GameServerTransition transEvent, GameData packet)
 {
     Tuple<GameServerState, TransitionAction> transition = null;
     try
     {
         transition = TransitionTable[new Tuple<GameServerState,GameServerTransition>(CurrentState,transEvent)];
         transition.Item2(packet);
         CurrentState = transition.Item1;
     }
     catch (Exception error)
     {
         Debug.WriteLine("You managed to break the GameServerStateMachine. Congratulations, asshole: {0}", new Object[] {error.Message});
         Debug.WriteLine("Violating Transition: {0} - {1} - {2}",new Object[] {CurrentState,transEvent,packet});
         throw error;
     }
     return;
 }
예제 #3
0
        /// <summary>
        /// Handles a Game Start Request
        /// </summary>
        /// <param name="gameData">The game data related to character locking.</param>
        protected override void OnGameStart(GameData gameData)
        {
            // Set player as ready
            Game.GetPlayer(gameData.PlayerID).PlayerReady = true;

            for (int i = 0; i < Game.players.Length; ++i)
            {
                Player player = Game.GetPlayer(i);
                if (player != null && !player.PlayerReady)
                {
                    return;
                }
            }

            // If everyone has sent the start game request:
            Game.Network.BroadCastGameData(new GameData(GameData.GameDataType.GameStart));
            Game.StartGame();
            return;
        }
예제 #4
0
        /// <summary>
        /// A Player has joined, set them up in the system.
        /// </summary>
        /// <param name="gameData">The game data related to the character joining the session.</param>
        protected override void OnPlayerConnect(GameData gameData)
        {
            GameData response;
            Player player = Game.ConnectionIDToPlayer(gameData.ConnectionInfo);
            switch ((GameData.ConnectionDetails)gameData.EventDetail)
            {
                case GameData.ConnectionDetails.IdReqest:
                    if (player == null) // If this is a new player, assign them a new ID, otherwise just resend the old id
                    {
                        player = new Player(gameData.ConnectionInfo, Game);
                    }
                    response = new GameData(GameData.GameDataType.Connect, player.PlayerID, (int)GameData.ConnectionDetails.IdReqest);

                    //TODO: Ask Ben Cassel, why is this broadcast?
                    Game.Network.BroadCastGameData(response);

                    for (int i = 0; i < Game.players.Length; ++i)
                    {
                        if (Game.players[i] != null)
                        {
                            response = new GameData(GameData.GameDataType.Connect, Game.players[i].PlayerID, (int)GameData.ConnectionDetails.Connected);
                            Game.Network.BroadCastGameData(response);
                        }
                    }

                    break;
                case GameData.ConnectionDetails.Disconnected:
                case GameData.ConnectionDetails.Dropped:
                    if (player != null) // This is a known player based on their connection, so we can drop them
                    {
                        Game.UnregisterPlayer(player);

                        response = new GameData(GameData.GameDataType.Connect,player.PlayerID,(int)GameData.ConnectionDetails.Disconnected);
                        Game.Network.BroadCastGameData(response);

                    }
                    break;
                default:
                    throw new ArgumentException();
            }
            return;
        }
예제 #5
0
 /// <summary>
 /// Update hanlder from the network layer. This is only invoked until control passes back to the game server.
 /// </summary>
 /// <param name="gameData">Game data being used to update the state of the game.</param>
 public void UpdateLobbyState(GameData gameData)
 {
     switch (gameData.Type)
     {
         case GameData.GameDataType.Connect:
             OnPlayerConnect(gameData);
             break;
         case GameData.GameDataType.SelectCharacter:
             OnPlayerSelectCharacter(gameData);
             break;
         case GameData.GameDataType.LockCharacter:
             OnPlayerLockCharacter(gameData);
             break;
         case GameData.GameDataType.GameStart:
             OnGameStart(gameData);
             break;
         default:
             throw new ArgumentException();
     }
     return;
 }
예제 #6
0
 /// <summary>
 /// Run logic for when a player locks or unlocks a character.
 /// </summary>
 /// <param name="gameData">The game data related to the player's actions.</param>
 protected abstract void OnPlayerLockCharacter(GameData gameData);
예제 #7
0
 /// <summary>
 /// Run logic for a player connecting to or disconnecting from the game.
 /// </summary>
 /// <param name="gameData">The game data related to the player's actions.</param>
 protected abstract void OnPlayerConnect(GameData gameData);
예제 #8
0
 /// <summary>
 /// Handles a Game Start Request
 /// </summary>
 /// <param name="gameData">The game data related to character locking.</param>
 protected abstract void OnGameStart(GameData gameData);
예제 #9
0
 /// <summary>
 /// Send a unit of game data to a particular client.
 /// </summary>
 /// <param name="gameData">The unit of game data to send.</param>
 /// <param name="connectionID">The ID of the client to send the game data to.</param>
 public void SendGameData(GameData gameData, ConnectionID connectionID)
 {
     networkWorker.SendPacket(new GameDataPacket(connectionID.IPEndPoint, gameData));
     return;
 }
예제 #10
0
        /// <summary>
        /// After choosing the level and number of players, start the game.
        /// </summary>
        /// <param name="levelID">The ID of the level to initialize.</param>
        /// <param name="myPlayerID">The ID of the player character.</param>
        public void SetupGameState(int levelID, int myPlayerID)
        {
            Level level = new Level(GameState.root, LevelPack.levels[levelID]);

            SpawnPointEntity sp = level.spawnPoints[myPlayerID];
            TestMan tm = new TestMan(sp, true);
            players[myPlayerID].EntityID = tm.id;
            LocalPlayer.EntityID = players[myPlayerID].EntityID;    //hack?

            EntityData entityData = new EntityData(EntityData.EntityType.TestMan, tm.id, tm.transform);
            GameData gameData = new GameData(GameData.GameDataType.NewEntity, myPlayerID, 0, null, entityData);
            Network.SendGameData(gameData);
            return;
        }
예제 #11
0
        /// <summary>
        /// Update an entity based on a transform.
        /// </summary>
        /// <param name="entity">The entity to update.</param>
        public virtual void OnTransformChange(Entity entity)
        {
            // Generate a transform change packet, put it on stack
            TransformData transformData = new TransformData(entity.id, entity.transform);

            // TODO: This likely doesn't work. This neeeds to be fixed (the player ID and event detail might need changing, or we may simply need a new constructor).
            GameData gameData = new GameData(GameData.GameDataType.Movement, LocalPlayer.PlayerID, 0, transformData);

            lock (gameStatesToSend)
            {
                gameStatesToSend.Add(gameData);
            }
            return;
        }
예제 #12
0
 /// <summary>
 /// A player has changed their character selection.
 /// </summary>
 /// <param name="gameData">The game data related to character selection.</param>
 protected override void OnPlayerSelectCharacter(GameData gameData)
 {
     Player player = Game.ConnectionIDToPlayer(gameData.ConnectionInfo);
     player.CharacterSelection = gameData.EventDetail;
     Game.Network.BroadCastGameData(new GameData(GameData.GameDataType.SelectCharacter, player.PlayerID, gameData.EventDetail));
     return;
 }
예제 #13
0
 /// <summary>
 /// Hanldes the character lock request
 /// </summary>
 /// <param name="gameData">The game data related to character locking.</param>
 protected override void OnPlayerLockCharacter(GameData gameData)
 {
     Player player = Game.ConnectionIDToPlayer(gameData.ConnectionInfo);
     player.CharacterLocked = true;
     Game.Network.BroadCastGameData(new GameData(GameData.GameDataType.LockCharacter, player.PlayerID));
     return;
 }
예제 #14
0
 /// <summary>
 /// Handles reception of game data updates from the client.
 /// </summary>
 /// <param name="packet">A packet that contains game data information.</param>
 protected override void OnGameData(NetworkPacket packet)
 {
     GameData gameData = new GameData(packet.DataArray);
     gameData.ConnectionInfo = connections[packet.Destination];
     gameDataUpdater(gameData);
     return;
 }
예제 #15
0
 /// <summary>
 /// Run logic for a player choosing between different characters.
 /// </summary>
 /// <param name="gameData">The game data related to the player's actions.</param>
 protected abstract void OnPlayerSelectCharacter(GameData gameData);
예제 #16
0
        /// <summary>
        /// Send out state change information
        /// </summary>
        /// <param name="entity">The entity to update.</param>
        public virtual void OnEntityStateChange(Entity entity)
        {
            EntityStateData stateData;
            // Invoke class-specific constructors, to avoid sending extra information
            if (entity is MobileEntity)
            {
                stateData = new EntityStateData((MobileEntity)entity);
            }
            else
            {
                stateData = new EntityStateData(entity);
            }

            GameData gameData = new GameData(GameData.GameDataType.EntityStateChange, LocalPlayer.PlayerID, 0);
            gameData.EventDetail = entity.id;
            gameData.EntityStateData = stateData;

            lock (gameStatesToSend)
            {
                gameStatesToSend.Add(gameData);
            }
            return;
        }
예제 #17
0
 /// <summary>
 /// Handles a Game Start Request
 /// </summary>
 /// <param name="gameData">The game data related to character locking.</param>
 protected override void OnGameStart(GameData gameData)
 {
     Game.SetupGameState(0, Game.LocalPlayer.PlayerID);
     Game.StartGame();
     newGameUpdater.Invoke(Game);
     return;
 }
예제 #18
0
 /// <summary>
 /// Add incoming data to the game states.
 /// </summary>
 /// <param name="gameData">Received game data that should inform us about changing state, requests, etc.</param>
 protected virtual void AddGameState(GameData gameData)
 {
     lock (gameStatesToCommit)
     {
         gameStatesToCommit.Add(gameData);
     }
     return;
 }
예제 #19
0
 /// <summary>
 /// A Player has joined, set them up in the system.
 /// </summary>
 /// <param name="gameData">The game data related to the character joining the session.</param>
 protected override void OnPlayerConnect(GameData gameData)
 {
     // TODO: Add responses to some of these events if necessary
     switch ((GameData.ConnectionDetails)gameData.EventDetail)
     {
         case GameData.ConnectionDetails.IdReqest:
             if (Game.LocalPlayer == null)
             {
                 Game.LocalPlayer = new Player(null, Game, gameData.PlayerID);
                 Entity.next_id = gameData.PlayerID * (int.MaxValue / GameBase.MAX_PLAYERS);
             }
             break;
         case GameData.ConnectionDetails.Connected: // Register a new player on a client
             new Player(null, Game, gameData.PlayerID);
             break;
         case GameData.ConnectionDetails.Disconnected: // Drop a connected player from the client
         case GameData.ConnectionDetails.Dropped:
                 Game.UnregisterPlayer(Game.GetPlayer(gameData.PlayerID));
             break;
         default:
             throw new ArgumentException();
     }
     return;
 }
예제 #20
0
 /// <summary>
 /// Update the state over the game based on incoming game data.
 /// </summary>
 /// <param name="gameData">The received game data.</param>
 protected override void AddGameState(GameData gameData)
 {
     lock (gameStatesToCommit)
     {
         for (int i = 0; i < players.Length; i++) // Forward the received information to other machines (but not the one received from)
         {
             Player player = GetPlayer(i);
             if (i == gameData.PlayerID || player == null)
             {
                 continue;
             }
             Network.SendGameData(gameData, PlayerToConnectionID(players[i]));
             gameStatesToCommit.Add(gameData);
         }
     }
     return;
 }
예제 #21
0
 /// <summary>
 /// A player has changed their character selection.
 /// </summary>
 /// <param name="gameData">The game data related to character selection.</param>
 protected override void OnPlayerSelectCharacter(GameData gameData)
 {
     throw new NotImplementedException();
 }
예제 #22
0
 /// <summary>
 /// Send a unit of game data to the server.
 /// </summary>
 /// <param name="gameData">The game data to send to the server.</param>
 public void SendGameData(GameData gameData)
 {
     networkWorker.SendPacket(new GameDataPacket(serverEndPoint, gameData));
     return;
 }
예제 #23
0
 /// <summary>
 /// Broadcast a unit of game data to all users.
 /// </summary>
 /// <param name="gameData">The unit of game data to broadcast.</param>
 public void BroadCastGameData(GameData gameData)
 {
     foreach (ConnectionID connection in connections.Values)
     {
         SendGameData(gameData, connection);
     }
     return;
 }