public void SendGameParamUpdate(GameParamUpdate update)
 {
     if (inSession) {
         NetworkPacket packet = new NetworkPacket();
         packet.Write((byte)MessageType.GameParamUpdateID);
         packet.Write(update);
         peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed | SendFlags.NoLoopback);
     }
 }
 public void SendGameParamUpdate(GameParamUpdate update)
 {
     if (inSession)
     {
         NetworkPacket packet = new NetworkPacket();
         packet.Write((byte)MessageType.GameParamUpdateID);
         packet.Write(update);
         peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed | SendFlags.NoLoopback);
     }
 }
Beispiel #3
0
        public void SendGameParamUpdate()
        {
            if ((null == netPeer) || (otherPlayers.Count < 1))
            {
                return;
            }
            GameParamUpdate update = new GameParamUpdate();

            update.Gravity   = gravity;
            update.GameSpeed = gameSpeed;
            if (bounceBack)
            {
                update.BounceBack = 1;
            }
            else
            {
                update.BounceBack = 0;
            }

            if (inverseGravity)
            {
                update.InverseGravity = 1;
            }
            else
            {
                update.InverseGravity = 0;
            }

            if (blackHole)
            {
                update.BlackHole = 1;
            }
            else
            {
                update.BlackHole = 0;
            }

            update.WindowSize = windowBounds.Size;

            netPeer.SendGameParamUpdate(update);
        }
Beispiel #4
0
        public void DataReceived(object sender, ReceiveEventArgs rea)
        {
            int senderID = rea.Message.SenderID;

            //Ignore messages received before we are initialized
            if ((gameState == GameStates.Loading) ||
                (gameState == GameStates.Config))
            {
                rea.Message.ReceiveData.Dispose();
                return;
            }

            byte        mType       = (byte)rea.Message.ReceiveData.Read(typeof(byte));
            MessageType messageType = (MessageType)mType;

            switch (messageType)
            {
            case MessageType.PlayerUpdateID: {
                PlayerUpdate update = (PlayerUpdate)rea.
                                      Message.ReceiveData.Read(typeof(PlayerUpdate));
                ShotUpdate shotUpdate = new ShotUpdate();
                shotUpdate.ShotPosition = new Vector2[Constants.NumShots];
                shotUpdate.ShotAge      = new int[Constants.NumShots];

                for (int i = 0; i < Constants.NumShots; i++)
                {
                    shotUpdate.ShotPosition[i] =
                        (Vector2)rea.Message.ReceiveData.Read(typeof(Vector2));
                    shotUpdate.ShotAge[i] =
                        (int)rea.Message.ReceiveData.Read(typeof(int));
                }

                rea.Message.ReceiveData.Dispose();



                lock (otherPlayers) {
                    object playerObject = otherPlayers[senderID];
                    if (null == playerObject)
                    {
                        return;
                    }
                    RemotePlayer player = (RemotePlayer)playerObject;

                    Shot[] shotArray = new Shot[Constants.NumShots];
                    for (int i = 0; i < Constants.NumShots; i++)
                    {
                        shotArray[i]          = new Shot();
                        shotArray[i].Position = shotUpdate.ShotPosition[i];
                        shotArray[i].Age      = shotUpdate.ShotAge[i];
                    }
                    player.Ship.ShotHandler.SetShotArray(shotArray);

                    player.Ship.Position   = update.ShipPosition;
                    player.Ship.Outline    = update.Outline;
                    player.Ship.Velocity   = update.ShipVelocity;
                    player.Ship.State      = update.State;
                    player.Ship.WaitCount  = update.WaitCount;
                    player.Ship.DeathCount = update.DeathCount;
                    player.Ship.FlameIndex = update.FlameIndex;
                    player.Ship.Sounds     = (Sounds)update.Sounds;
                    player.Ship.Score      = update.Score;

                    player.UpdateTime = DateTime.Now;
                    player.Active     = true;

                    otherPlayers[senderID] = player;
                }

                break;
            }

            case MessageType.GameParamUpdateID: {
                GameParamUpdate update = (GameParamUpdate)rea.Message.
                                         ReceiveData.Read(typeof(GameParamUpdate));
                rea.Message.ReceiveData.Dispose();
                gravity   = update.Gravity;
                gameSpeed = update.GameSpeed;

                if (update.BounceBack != 0)
                {
                    bounceBack = true;
                }
                else
                {
                    bounceBack = false;
                }

                if (update.InverseGravity != 0)
                {
                    inverseGravity = true;
                }
                else
                {
                    inverseGravity = false;
                }

                if (update.BlackHole != 0)
                {
                    blackHole = true;
                }
                else
                {
                    blackHole = false;
                }
                Size      newWindowSize = update.WindowSize;
                Rectangle newBounds     = new
                                          Rectangle(this.windowBounds.Location, newWindowSize);
                //Initialize(newBounds);
                break;
            }

            case MessageType.Add1ToScore: {
                rea.Message.ReceiveData.Dispose();
                ship.Score += 1;
                break;
            }

            case MessageType.Add2ToScore: {
                rea.Message.ReceiveData.Dispose();
                ship.Score += 2;
                break;
            }

            case MessageType.GamePaused: {
                rea.Message.ReceiveData.Dispose();
                gameState = GameStates.Paused;
                break;
            }

            case MessageType.GameRunning: {
                rea.Message.ReceiveData.Dispose();
                if (gameState == GameStates.Paused)
                {
                    gameState = GameStates.Running;
                }
                break;
            }
            }
        }
        public void SendGameParamUpdate()
        {
            if ((null == netPeer) || (otherPlayers.Count < 1))
                return;
            GameParamUpdate update = new GameParamUpdate();
            update.Gravity = gravity;
            update.GameSpeed = gameSpeed;
            if (bounceBack)
                update.BounceBack = 1;
            else
                update.BounceBack = 0;

            if (inverseGravity)
                update.InverseGravity = 1;
            else
                update.InverseGravity = 0;

            if (blackHole)
                update.BlackHole = 1;
            else
                update.BlackHole = 0;

            update.WindowSize = windowBounds.Size;

            netPeer.SendGameParamUpdate(update);
        }