void HandlePlayerSaveState(PlayerSaveStatePacket pss)
{
// send all entities in area to player eventually.
// notify all other players that this player is here.
PlayerState ps = new PlayerState();
ps.connectionId = nextConnectionId;
ps.accountId = pss.state.accountId;
ps.characterId = pss.state.characterId;
ps.entityId = GetNewUserId();
playerIds.Add(ps);
ServerConnectionHeader gatewayHeader = (ServerConnectionHeader)IntrepidSerialize.TakeFromPool(PacketType.ServerConnectionHeader);
gatewayHeader.connectionId = ps.connectionId;
EntityPacket entityNotification = (EntityPacket)IntrepidSerialize.TakeFromPool(PacketType.Entity);
entityNotification.entityId = ps.entityId;
deserializedPackets.Add(gatewayHeader);
deserializedPackets.Add(entityNotification);
/* socket.Send(gatewayHeader);
* socket.Send(entityNotification);*/
}
void HandleServerHopping(ServerPingHopperPacket packet)
{
ServerConnectionHeader gatewayHeader = (ServerConnectionHeader)IntrepidSerialize.TakeFromPool(PacketType.ServerConnectionHeader);
gatewayHeader.connectionId = nextConnectionId;
socket.Send(gatewayHeader);
ServerPingHopperPacket hopper = packet as ServerPingHopperPacket;
string name = Assembly.GetCallingAssembly().GetName().Name;
hopper.Stamp(name + " received");
Send(packet);
}
void HandlePlayerPackets(BasePacket packet)
{
if (packet.PacketType == PacketType.ServerConnectionHeader)
{
ServerConnectionHeader sch = packet as ServerConnectionHeader;
if (sch != null)
{
nextConnectionId = sch.connectionId;
return;
}
}
if (packet.PacketType == PacketType.PlayerSaveState)
{
HandlePlayerSaveState(packet as PlayerSaveStatePacket);
return;
}
if (packet.PacketType == PacketType.WorldEntity)
{
WorldEntityPacket wep = packet as WorldEntityPacket;
if (wep != null)
{
foreach (var playerId in playerIds)
{
if (playerId.entityId == wep.entityId)
{
playerId.Set(wep.position.Get(), wep.rotation.Get());
//SendAllEntityPositions();
}
}
return;
}
}
if (packet.PacketType == PacketType.RenderSettings)
{
RenderSettings rs = packet as RenderSettings;
if (rs != null)
{
foreach (var playerId in playerIds)
{
if (playerId.entityId == nextConnectionId)
{
playerId.settings = rs;
}
}
return;
}
}
}
void SendAccumulatorToPlayer(int connectionId, byte[] bytes)
{
Utils.DatablobAccumulator acc = new Utils.DatablobAccumulator();
List <DataBlob> blobs = acc.PrepToSendRawData(bytes, bytes.Length);
var Timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
Console.WriteLine(Timestamp);
foreach (var blob in blobs)
{
ServerConnectionHeader gatewayHeader = (ServerConnectionHeader)IntrepidSerialize.TakeFromPool(PacketType.ServerConnectionHeader);
gatewayHeader.connectionId = connectionId;
deserializedPackets.Add(gatewayHeader);
deserializedPackets.Add(blob);
}
}
void ForwardAllOutgoingPackets()
{
lock (containersLock)
{
foreach (var packetPair in containers.outgoingPackets)
{
if (packetPair.connectionId != InvalidConnectionId)
{
ServerConnectionHeader gatewayHeader = (ServerConnectionHeader)IntrepidSerialize.TakeFromPool(PacketType.ServerConnectionHeader);
gatewayHeader.connectionId = packetPair.connectionId;
gatewaySocket.Send(gatewayHeader);
}
gatewaySocket.Send(packetPair.packet);
}
containers.outgoingPackets.Clear();
}
}
public override void Send(BasePacket packet)
{
ServerConnectionHeader sch = packet as ServerConnectionHeader;
if (sch != null)
{
nextConnectionId = sch.connectionId;
}
/* if (packet.PacketType == PacketType.DataBlob)
* {
* if(accumulator.Add(packet as DataBlob) == true)
* {
* byte[] bytes = accumulator.ConvertDatablobsIntoRawData();
* validateReceivedBuffer(bytes);
* accumulator.Clear();
* }
* return;
* }*/
if (packet.PacketType == PacketType.RequestPacket)
{
// Set camera position on renderer and rotation
// call to Michaelangelo
// requestedRenderFrame
PlayerState ps = GetPlayerState(nextConnectionId);
if (ps != null)
{
ps.requestedRenderFrame = true;
}
}
HandlePlayerPackets(packet);
IntrepidSerialize.ReturnToPool(packet);
}
public override void HandlePackets(Queue <BasePacket> listOfPackets)
{
server.numPacketsReceived += listOfPackets.Count;
foreach (var packet in listOfPackets)
{
// normal processing
ServerConnectionHeader sch = packet as ServerConnectionHeader;// should be converted to a wrapper
if (sch != null)
{
server.NextConnectionId = sch.connectionId;
continue;
}
PlayerSaveStatePacket pss = packet as PlayerSaveStatePacket;
if (pss != null)
{
server.LogInPlayer(server.NextConnectionId, pss.state);
// send all entities in area to player eventually.
// notify all other players that this player is here.
continue;
}
//--------------------------------------------
KeepAlive ka = packet as KeepAlive;
if (ka != null)
{
KeepAliveResponse kar = (KeepAliveResponse)IntrepidSerialize.TakeFromPool(PacketType.KeepAliveResponse);
//gatewaySocket.Send(kar);
server.AddOutgoingPacket(kar, ServerNetworking.InvalidConnectionId);
continue;
}
if (server.connectedClients.ContainsKey(server.NextConnectionId))
{
server.connectedClients[server.NextConnectionId].AddIncomingPacket(packet);
}
}
}
void SendAllEntityPositions()
{
foreach (var playerId in playerIds)
{
if (playerId.connectionId != 0)
{
foreach (var destPlayerId in playerIds) // n^2
{
//if (playerId.connectionId != destPlayerId.connectionId)
{
ServerConnectionHeader gatewayHeader = (ServerConnectionHeader)IntrepidSerialize.TakeFromPool(PacketType.ServerConnectionHeader);
gatewayHeader.connectionId = destPlayerId.connectionId;
WorldEntityPacket entityNotification = (WorldEntityPacket)IntrepidSerialize.TakeFromPool(PacketType.WorldEntity);
entityNotification.entityId = playerId.entityId;
entityNotification.position.Set(playerId.position);
entityNotification.rotation.Set(playerId.rotation);
socket.Send(gatewayHeader);
socket.Send(entityNotification);
}
}
}
}
}
private void Sock_OnPacketsReceived(IPacketSend arg1, Queue <BasePacket> listOfPackets)
{
// all of these boolean checks should be replaced by a Strategy
if (isBoundToGateway == true)
{
foreach (var packet in listOfPackets)
{
numPacketsReceived++;
// normal processing
KeepAlive ka = packet as KeepAlive;
if (ka != null)
{
KeepAliveResponse kar = (KeepAliveResponse)IntrepidSerialize.TakeFromPool(PacketType.KeepAliveResponse);
socket.Send(kar);
continue;
}
WorldEntityPacket wep = packet as WorldEntityPacket;
if (wep != null)
{
foreach (var playerId in playerIds)
{
if (playerId.entityId == wep.entityId)
{
playerId.position = wep.position.Get();
playerId.rotation = wep.rotation.Get();
SendAllEntityPositions();
}
}
continue;
}
ServerConnectionHeader sch = packet as ServerConnectionHeader;
if (sch != null)
{
nextConnectionId = sch.connectionId;
continue;
}
PlayerSaveStatePacket pss = packet as PlayerSaveStatePacket;
if (pss != null)
{
HandlePlayerSaveState(pss);
continue;
}
if (packet is ServerPingHopperPacket)
{
HandleServerHopping(packet as ServerPingHopperPacket);
continue;
}
}
}
else
{
foreach (var packet in listOfPackets)
{
numPacketsReceived++;
if (packet is ServerIdPacket)
{
ServerIdPacket id = packet as ServerIdPacket;
if (id != null && id.Type == ServerIdPacket.ServerType.Gateway)
{
isBoundToGateway = true;
break;
}
}
}
}
}
