void update_Elapsed(object sender, ElapsedEventArgs e)
{
if (_client.ServerConnection == null)
{
return;
}
if (ControllablePlayer.ControllablePlayerInstance != null && ControllablePlayer.ControllablePlayerInstance.UniqueID != 0)
{
if (Vector2.Distance(_lastSentPosition, ControllablePlayer.ControllablePlayerInstance.Position) > 0.002f)
{
Packets.MovePacket movePacket = Packets.CreateMovementPacket(ControllablePlayer.ControllablePlayerInstance);
NetOutgoingMessage outMsg = _client.CreateMessage();
Packets.WritePacket(ref outMsg, ref movePacket);
SendPacket(outMsg, _client.ServerConnection, NetDeliveryMethod.UnreliableSequenced);
_lastSentPosition = ControllablePlayer.ControllablePlayerInstance.Position;
}
}
}
public void Update()
{
NetIncomingMessage msg;
while ((msg = _client.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
{
//Read Packet Header (Byte) and Convert It To PacketTypes Enum
byte PacketHeader = msg.ReadByte();
Packets.Types PacketType = (Packets.Types)Enum.ToObject(typeof(Packets.Types), PacketHeader);
//Switch Read Functionality Based on Packet Header
switch (PacketType)
{
case Packets.Types.MOVE:
{
//Read Packet
Packets.MovePacket movePacket = new Packets.MovePacket();
Packets.ReadPacket(ref msg, ref movePacket);
//Update Local Simulation
InvokePlayerMove(new NetworkManager.PlayerMoveEventArgs(movePacket.uid, movePacket.posX, movePacket.posY, movePacket.facingDirection));
break;
}
case Packets.Types.ATTACK:
{
// Read packet.
Packets.AttackPacket attackPacket = new Packets.AttackPacket();
Packets.ReadPacket(ref msg, ref attackPacket);
// Update local simulation.
InvokePlayerAttack(new PlayerAttackEventArgs(attackPacket.uid, attackPacket.posX, attackPacket.posY, attackPacket.facingDirection));
break;
}
case Packets.Types.LOGIN_RESPONCE:
{
//Read Packet
Packets.LoginResponcePacket loginPacket = new Packets.LoginResponcePacket();
Packets.ReadPacket(ref msg, ref loginPacket);
// Invoke Event Handler
InvokeOnPlayerConnected(new PlayerConnectedEventArgs()
{
playerPacket = loginPacket.playerPacket
});
break;
}
case Packets.Types.WORLDSTATE:
{
//Read Packet
Packets.WorldPacket worldPacket = new Packets.WorldPacket();
worldPacket.playerPackets = new List <Packets.PlayerPacket>();
Packets.ReadPacket(ref msg, ref worldPacket);
//Clear Engine Players
Player.ClearAllPlayersExcept(ControllablePlayer.ControllablePlayerInstance);
//Read Players
foreach (Packets.PlayerPacket p in worldPacket.playerPackets)
{
//Get Player Object From Packet
//Update Last Sync DesiredPosition If Login Packet Of Local Player
if (p.uid == _client.UniqueIdentifier)
{
InvokeOnLocalPlayerConnected(new PlayerConnectedEventArgs()
{
playerPacket = p
});
}
else
{
InvokeOnPlayerConnected(new PlayerConnectedEventArgs()
{
playerPacket = p
});
}
}
break;
}
case Packets.Types.DISCONNECT:
{
//Read Packet
Packets.DisconnectPacket disconnectPacket = new Packets.DisconnectPacket();
Packets.ReadPacket(ref msg, ref disconnectPacket);
// Invoke Event Handler
InvokeOnPlayerDisconnected(new PlayerDisconnectedEventArgs(disconnectPacket.uid));
break;
}
}
/*
*
* //Process Specific Handling Of Packet Types
* switch (Packet.GetPacketType())
* {
* case PacketTypes.MOVE:
* {
* // ------------------ Read Move Packet -----------------------//
*
* //Cast Packet to Login Type
* MovePacket movePacket = (MovePacket)Packet;
*
* InvokePlayerMove(new PlayerMoveEventArgs()
* {
* uniqueID = movePacket.uniqueID,
* posX = movePacket.posX,
* posY = movePacket.posY
* });
*
* break;
* }
* case PacketTypes.WORLDSTATE:
* {
* /*
* // ------------------ Read World Packet -----------------------//
*
* //Cast Packet to World Type
* WorldPacket packet = (WorldPacket)Packet;
*
* //Load All Players
* for (int i = 1; i <= packet.playerCount; i++)
* {
* Player player = new Player();
*
* msg.ReadAllFields(player);
* msg.ReadAllProperties(player);
*
* //Update Last Sync DesiredPosition If Login Packet Of Local Player
* bool _local = (player.UniqueIdentifier == _client.UniqueIdentifier);
* if (_local)
* {
* _lastUpdateX = player.DesiredPosition.X;
* _lastUpdateY = player.DesiredPosition.Y;
* }
*
* // Invoke Event Handler
* InvokeOnPlayerConnected(new PlayerConnectedEventArgs()
* {
* player = player,
* local = _local
* });
* }
* break;
* }
*/
}
break;
case NetIncomingMessageType.StatusChanged:
{
int a = 0;
break;
}
}
_client.Recycle(msg);
}
}
private void ProcessMessages()
{
NetIncomingMessage msg;
while ((msg = _server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
#region Data
case NetIncomingMessageType.Data:
{
//Read Packet Header (Byte) and Convert It To PacketTypes Enum
byte PacketHeader = msg.ReadByte();
Packets.Types PacketType = (Packets.Types)Enum.ToObject(typeof(Packets.Types), PacketHeader);
//Switch Read Functionality Based on Packet Header
switch (PacketType)
{
case Packets.Types.MOVE:
{
//Read Move Packet
Packets.MovePacket movePacket = new Packets.MovePacket();
Packets.ReadPacket(ref msg, ref movePacket);
//Update Local Simulation
InvokePlayerMove(new PlayerMoveEventArgs(movePacket.uid, movePacket.posX, movePacket.posY, movePacket.facingDirection));
//Foward Move Packet
NetOutgoingMessage outMsg = _server.CreateMessage();
Packets.WritePacket(ref outMsg, ref movePacket);
SendPacketExcept(outMsg, msg.SenderConnection, NetDeliveryMethod.UnreliableSequenced, 1);
break;
}
case Packets.Types.ATTACK:
{
// Read attack packet.
Packets.AttackPacket attackPacket = new Packets.AttackPacket();
Packets.ReadPacket(ref msg, ref attackPacket);
// Update local simulation.
InvokePlayerAttack(new PlayerAttackEventArgs(attackPacket.uid, attackPacket.posX, attackPacket.posY, attackPacket.facingDirection));
// Forward Attack packet.
NetOutgoingMessage outMsg = _server.CreateMessage();
Packets.WritePacket(ref outMsg, attackPacket);
SendPacketExcept(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableUnordered);
break;
}
}
break;
}
#endregion Data
// If incoming message is Request for connection approval
// This is the very first packet/message that is sent from client
// Here you can do new player initialisation stuff
case NetIncomingMessageType.ConnectionApproval:
{
//Read Packet Header (Byte) and Convert It To PacketTypes Enum
byte PacketHeader = msg.ReadByte();
Packets.Types PacketType =
(Packets.Types)Enum.ToObject(typeof(Packets.Types), PacketHeader);
//Switch Read Functionality Based on Packet Header
if (PacketType == Packets.Types.LOGIN_REQUEST)
{
Packets.PlayerPacket packet;
//LoginRequestPacket
{
//Create Packet
Packets.LoginRequestPacket loginPacket = new Packets.LoginRequestPacket();
//Read Packet Data From Message
Packets.ReadPacket(ref msg, ref loginPacket);
// Approve clients connection ( Its sort of agreement. "You can be my client and i will host you" )
msg.SenderConnection.Approve();
//Create new Player Instance
packet = new Packets.PlayerPacket(loginPacket.name, msg.SenderConnection.RemoteUniqueIdentifier, 50, 50, Player.FacingDirections.N);
// Invoke Event Handler
InvokeOnPlayerConnected(new PlayerConnectedEventArgs()
{
playerPacket = packet
});
}
//LoginResponcePacket
{
Packets.LoginResponcePacket loginResponcePacket = new Packets.LoginResponcePacket(0, packet);
NetOutgoingMessage outMsg = _server.CreateMessage();
Packets.WritePacket(ref outMsg, ref loginResponcePacket);
_loginResponceQueue.Add(new MessageQueue()
{
connection = msg.SenderConnection,
msg = outMsg,
target = MessageTarget.GLOBAL_EXCEPT
});
}
//World Packet
{
Packets.WorldPacket worldPacket = new Packets.WorldPacket(0);
foreach (var player in Player.AllPlayers)
{
worldPacket.playerCount++;
worldPacket.playerPackets.Add(Packets.CreatePlayerPacket(player));
}
NetOutgoingMessage outMsg = _server.CreateMessage();
Packets.WritePacket(ref outMsg, ref worldPacket);
_loginResponceQueue.Add(new MessageQueue()
{
connection = msg.SenderConnection,
msg = outMsg,
target = MessageTarget.DIRECT
});
}
} //if request pecket
}
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.DiscoveryRequest:
case NetIncomingMessageType.DiscoveryResponse:
case NetIncomingMessageType.Error:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.NatIntroductionSuccess:
case NetIncomingMessageType.Receipt:
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
switch (status)
{
case NetConnectionStatus.Connected:
{
//Inform Clients of Connection Event
NetOutgoingMessage outMsg = _server.CreateMessage();
Packets.ConnectPacket connectPacket = new Packets.ConnectPacket();
connectPacket.uid = msg.SenderConnection.RemoteUniqueIdentifier;
//Write Packet
Packets.WritePacket(ref outMsg, ref connectPacket);
SendPacketExcept(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
}
case NetConnectionStatus.Disconnected:
{
//Inform Clients of Disconnection Event
NetOutgoingMessage outMsg = _server.CreateMessage();
Packets.DisconnectPacket disconnectPacket = new Packets.DisconnectPacket();
disconnectPacket.uid = msg.SenderConnection.RemoteUniqueIdentifier;
//Write Packet
Packets.WritePacket(ref outMsg, ref disconnectPacket);
SendPacketExcept(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered);
//Invoke Disconnected Event Handler
InvokeOnPlayerDisconnected(new PlayerDisconnectedEventArgs(msg.SenderConnection.RemoteUniqueIdentifier));
break;
}
case NetConnectionStatus.Disconnecting:
{
break;
}
case NetConnectionStatus.InitiatedConnect:
{
break;
}
case NetConnectionStatus.None:
{
break;
}
case NetConnectionStatus.RespondedConnect:
{
break;
}
}
break;
}
case NetIncomingMessageType.UnconnectedData:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
default:
{
//Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
}
_server.Recycle(msg);
}
}