public static void LoadServerData()
{
string path = GameConfig.gameSaveFolder + DSPGame.LoadFile + FILE_EXTENSION;
IPlayerManager playerManager = Multiplayer.Session.Network.PlayerManager;
if (!File.Exists(path) || playerManager == null)
{
return;
}
byte[] source = File.ReadAllBytes(path);
NetDataReader netDataReader = new NetDataReader(source);
ushort revision = 0;
try
{
string revString = netDataReader.GetString();
if (revString != "REV")
{
throw new System.Exception();
}
revision = netDataReader.GetUShort();
Log.Info($"Loading server data, revision {revision}");
if (revision != REVISION)
{
// Supported revision: 4~6
if (revision < 4 || revision > REVISION)
{
throw new System.Exception();
}
}
}
catch (System.Exception)
{
Log.Warn("Skipping server data from unsupported Nebula version...");
return;
}
int playerNum = netDataReader.GetInt();
using (playerManager.GetSavedPlayerData(out Dictionary <string, IPlayerData> savedPlayerData))
{
for (int i = 0; i < playerNum; i++)
{
string hash = netDataReader.GetString();
PlayerData playerData = null;
if (revision == REVISION)
{
playerData = netDataReader.Get <PlayerData>();
}
else if (revision == 4)
{
playerData = new PlayerData();
playerData.Deserialize_4(netDataReader);
}
else if (revision == 5)
{
playerData = new PlayerData();
playerData.Deserialize_5(netDataReader);
}
if (!savedPlayerData.ContainsKey(hash) && playerData != null)
{
savedPlayerData.Add(hash, playerData);
}
else if (playerData == null)
{
Log.Warn($"could not load player data from unsupported save file revision {revision}");
}
}
}
}
private NetConnectRequestPacket(long connectionTime, byte connectionNumber, byte[] targetAddress, NetDataReader data)
{
ConnectionTime = connectionTime;
ConnectionNumber = connectionNumber;
TargetAddress = targetAddress;
Data = data;
}
public static TransformValue GetTransformValue2D(this NetDataReader reader)
{
return(new TransformValue {
Position = reader.GetVector2(), Rotation = reader.GetVector2(), Scale = reader.GetVector2()
});
}
public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
{
}
private NetConnectRequestPacket(long connectionId, byte connectionNumber, NetDataReader data)
{
ConnectionTime = connectionId;
ConnectionNumber = connectionNumber;
Data = data;
}
public void Deserialize(NetDataReader reader)
{
PlayerId = reader.GetLong();
Position = reader.GetVector2();
}
public void Deserialize(NetDataReader reader)
{
NotificationCount = reader.GetInt();
}
public void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
{
Console.WriteLine("[Server] ReceiveUnconnected: {0}", reader.GetString(100));
}
public static DateTime GetDateTime(this NetDataReader reader)
{
return(DateTime.Parse(reader.GetString()));
}
public void Instantiate_CLIENT(string type, bool isOwner, uint netID, byte[] netState, byte[] data, byte[] paramsData)
{
NetDataReader reader = null;
try {
if (!spawnables.TryGetValue(type, out Type t))
{
throw new Exception("No Spawnable of Type " + type + " found in dictionary.");
}
List <object> instantiateParameters = new List <object>();
reader = NetworkPool.GetReader(paramsData);
while (!reader.EndOfData)
{
instantiateParameters.Add(NetData.Read(NetData.PacketBytes[reader.GetByte()], reader));
}
NetworkPool.ReturnReader(reader);
// TODO: Temporary fix to prevent error where JSON deserializes floats to doubles.
for (int i = 0; i < instantiateParameters.Count; i++)
{
if (instantiateParameters[i] is double)
{
instantiateParameters[i] = Convert.ToSingle(instantiateParameters[i]);
}
}
object obj = instantiateParameters != null
? Activator.CreateInstance(t, instantiateParameters.ToArray())
: Activator.CreateInstance(t);
INetLogic logic = null;
if (obj is INetLogicProxy proxy)
{
logic = proxy.NetLogic;
}
else if (obj is INetLogic netLogic)
{
logic = netLogic;
}
if (logic == null)
{
throw new Exception("NetLogic not found.");
}
reader = NetworkPool.GetReader(netState);
SetupNetLogic(logic, netID, isOwner, reader);
NetworkPool.ReturnReader(reader);
SpawnedNetObjects.TryAdd(logic.ID, new SpawnedNetObject(logic, logic.ID, type));
if (logic is INetInstantiatable instantiatable)
{
reader = NetworkPool.GetReader(data);
instantiatable.OnNetworkInstantiatedClient(type, isOwner, reader);
NetworkPool.ReturnReader(reader);
}
} catch (Exception) {
NetworkPool.ReturnReader(reader);
throw;
}
}
public override void ReadPayload(NetDataReader message)
{
base.ReadPayload(message);
SystemId = message.GetString(100);
}
public void Deserialize(NetDataReader reader)
{
Position = reader.GetVector3();
Rotation = reader.GetQuaternion();
}
public override void Pass(NetDataReader reader)
{
reader.GetBool();
}
public override void Read(NetDataReader reader)
{
Value = reader.GetBool();
}
private NetConnectAcceptPacket(long connectionId, byte connectionNumber, bool isReusedPeer, NetDataReader data)
{
ConnectionId = connectionId;
ConnectionNumber = connectionNumber;
IsReusedPeer = isReusedPeer;
Data = data;
}
public static NO_SkillParam GetSkillParam(this NetDataReader reader)
{
return(new NO_SkillParam(reader.GetInt(), reader.GetVector2(), reader.GetVector2()));
}
public void Deserialize(NetDataReader reader)
{
Id = reader.GetByte();
Position = reader.GetVector2();
Rotation = reader.GetFloat();
}
public void Deserialize(NetDataReader reader)
{
UserId = reader.GetString();
ChangeAmount = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
MailId = reader.GetString();
UserId = reader.GetString();
}
private void DataReceived(byte[] reusableBuffer, int count, IPEndPoint remoteEndPoint)
{
#if STATS_ENABLED
Statistics.PacketsReceived++;
Statistics.BytesReceived += (uint)count;
#endif
//Try read packet
NetPacket packet = NetPacketPool.GetPacket(count, false);
if (!packet.FromBytes(reusableBuffer, 0, count))
{
NetPacketPool.Recycle(packet);
NetUtils.DebugWriteError("[NM] DataReceived: bad!");
return;
}
//Check unconnected
switch (packet.Property)
{
case PacketProperty.DiscoveryRequest:
if (DiscoveryEnabled)
{
var netEvent = CreateEvent(NetEventType.DiscoveryRequest);
netEvent.RemoteEndPoint = remoteEndPoint;
netEvent.DataReader.SetSource(packet.RawData, NetConstants.HeaderSize, count);
EnqueueEvent(netEvent);
}
return;
case PacketProperty.DiscoveryResponse:
{
var netEvent = CreateEvent(NetEventType.DiscoveryResponse);
netEvent.RemoteEndPoint = remoteEndPoint;
netEvent.DataReader.SetSource(packet.RawData, NetConstants.HeaderSize, count);
EnqueueEvent(netEvent);
}
return;
case PacketProperty.UnconnectedMessage:
if (UnconnectedMessagesEnabled)
{
var netEvent = CreateEvent(NetEventType.ReceiveUnconnected);
netEvent.RemoteEndPoint = remoteEndPoint;
netEvent.DataReader.SetSource(packet.RawData, NetConstants.HeaderSize, count);
EnqueueEvent(netEvent);
}
return;
case PacketProperty.NatIntroduction:
case PacketProperty.NatIntroductionRequest:
case PacketProperty.NatPunchMessage:
{
if (NatPunchEnabled)
{
NatPunchModule.ProcessMessage(remoteEndPoint, packet);
}
return;
}
}
//Check normal packets
NetPeer netPeer;
bool isPeerConnecting;
lock (connectingPeers)
{
isPeerConnecting = connectingPeers.Contains(remoteEndPoint);
peers.TryGetValue(remoteEndPoint, out netPeer);
}
if (netPeer != null)
{
if (netPeer.ConnectionState == ConnectionState.Disconnected)
{
return;
}
NetEvent netEvent;
switch (packet.Property)
{
case PacketProperty.Disconnect:
if (netPeer.ConnectionState == ConnectionState.InProgress ||
netPeer.ConnectionState == ConnectionState.Connected)
{
if (BitConverter.ToInt64(packet.RawData, 1) != netPeer.ConnectId)
{
//Old or incorrect disconnect
NetPacketPool.Recycle(packet);
return;
}
netEvent = CreateEvent(NetEventType.Disconnect);
netEvent.Peer = netPeer;
netEvent.DataReader.SetSource(packet.RawData, 9, packet.Size);
netEvent.DisconnectReason = DisconnectReason.RemoteConnectionClose;
EnqueueEvent(netEvent);
netPeer.ProcessPacket(packet);
SendRaw(new[] { (byte)PacketProperty.ShutdownOk }, 0, 1, remoteEndPoint);
}
return;
case PacketProperty.ConnectAccept:
if (netPeer.ProcessConnectAccept(packet))
{
var connectEvent = CreateEvent(NetEventType.Connect);
connectEvent.Peer = netPeer;
EnqueueEvent(connectEvent);
}
return;
case PacketProperty.ConnectRequest:
long newId = BitConverter.ToInt64(packet.RawData, NetConstants.RequestConnectIdIndex);
NetUtils.DebugWrite("ConnectRequest LastId: {0}, NewId: {1}, EP: {2}", netPeer.ConnectId, newId, remoteEndPoint);
//Remove old peer and connect new
if (newId > netPeer.ConnectId)
{
netEvent = CreateEvent(NetEventType.Disconnect);
netEvent.Peer = netPeer;
netEvent.DataReader.SetSource(packet.RawData, 9, packet.Size);
netEvent.DisconnectReason = DisconnectReason.RemoteConnectionClose;
peers.RemovePeer(netPeer);
break;
//To reconnect peer
}
else
{
//Just answer accept
netPeer.ProcessPacket(packet);
return;
}
default:
netPeer.ProcessPacket(packet);
return;
}
}
//Unacked shutdown
if (packet.Property == PacketProperty.Disconnect)
{
SendRaw(new[] { (byte)PacketProperty.ShutdownOk }, 0, 1, remoteEndPoint);
return;
}
if (packet.Property == PacketProperty.ConnectRequest && packet.Size >= 12)
{
NetUtils.DebugWrite("[NM] Received ConnectionRequest");
if (isPeerConnecting)
{
NetUtils.DebugWrite("[NM] Peer already connecting");
return;
}
if (GetPeersCount(ConnectionState.Connected | ConnectionState.InProgress) < maxConnections)
{
int protoId = BitConverter.ToInt32(packet.RawData, 1);
if (protoId != NetConstants.ProtocolId)
{
NetUtils.DebugWrite(ConsoleColor.Cyan,
"[NM] Peer connect reject. Invalid protocol ID: " + protoId);
return;
}
//Getting new id for peer
long connectionId = BitConverter.ToInt64(packet.RawData, 5);
// Read data and create request
var reader = new NetDataReader(null, 0, 0);
if (packet.Size > 12)
{
reader.SetSource(packet.RawData, 13, packet.Size);
}
NetUtils.DebugWrite("[NM] Creating request event: " + connectionId);
lock (connectingPeers)
{
connectingPeers.Add(remoteEndPoint);
}
var netEvent = CreateEvent(NetEventType.ConnectionRequest);
netEvent.ConnectionRequest =
new ConnectionRequest(connectionId, remoteEndPoint, reader, OnConnectionSolved);
EnqueueEvent(netEvent);
}
}
}
public void Deserialize(NetDataReader reader)
{
AttackerArmyId = reader.GetInt();
DefenderArmyId = reader.GetInt();
}
public void CustomPackageTest()
{
var writer = new NetDataWriter();
_packetProcessor.Write(writer, _samplePacket);
var reader = new NetDataReader(writer);
SamplePacket readPackage = null;
_packetProcessor.SubscribeReusable <SamplePacket>(
packet =>
{
readPackage = packet;
});
_packetProcessor.ReadAllPackets(reader);
Assert.NotNull(readPackage);
Assert.IsTrue(AreSame(_samplePacket.EmptyString, readPackage.EmptyString));
Assert.AreEqual(_samplePacket.SomeFloat, readPackage.SomeFloat);
Assert.AreEqual(_samplePacket.SomeIntArray, readPackage.SomeIntArray);
Assert.IsTrue(AreSame(_samplePacket.SomeString, readPackage.SomeString));
Assert.AreEqual(_samplePacket.SomeVector2, readPackage.SomeVector2);
Assert.AreEqual(_samplePacket.SomeVectors, readPackage.SomeVectors);
Assert.AreEqual(_samplePacket.SomeEnum, readPackage.SomeEnum);
Assert.AreEqual(_samplePacket.TestObj.Value, readPackage.TestObj.Value);
Assert.AreEqual(_samplePacket.TestArray, readPackage.TestArray);
Assert.AreEqual(_samplePacket.SomeByteArray, readPackage.SomeByteArray);
Assert.AreEqual(_samplePacket.SampleClassArray, readPackage.SampleClassArray);
Assert.AreEqual(0, readPackage.IgnoreMe); // expect 0 because it should be ignored
CollectionAssert.AreEqual(_samplePacket.SampleClassList, readPackage.SampleClassList);
CollectionAssert.AreEqual(_samplePacket.VectorList, readPackage.VectorList);
//remove test
_samplePacket.SampleClassList.RemoveAt(0);
_samplePacket.SampleClassArray = new [] { new SampleClass {
Value = 1
} };
_samplePacket.VectorList.RemoveAt(0);
writer.Reset();
_packetProcessor.Write(writer, _samplePacket);
reader.SetSource(writer);
_packetProcessor.ReadAllPackets(reader);
Assert.AreEqual(_samplePacket.SampleClassArray, readPackage.SampleClassArray);
CollectionAssert.AreEqual(_samplePacket.SampleClassList, readPackage.SampleClassList);
//add test
_samplePacket.SampleClassList.Add(new SampleClass {
Value = 152
});
_samplePacket.SampleClassList.Add(new SampleClass {
Value = 154
});
_samplePacket.SampleClassArray = new[] { new SampleClass {
Value = 1
}, new SampleClass {
Value = 2
}, new SampleClass {
Value = 3
} };
_samplePacket.VectorList.Add(new SomeVector2(500, 600));
writer.Reset();
_packetProcessor.Write(writer, _samplePacket);
reader.SetSource(writer);
_packetProcessor.ReadAllPackets(reader);
Assert.AreEqual(_samplePacket.SampleClassArray, readPackage.SampleClassArray);
CollectionAssert.AreEqual(_samplePacket.SampleClassList, readPackage.SampleClassList);
}
public void Deserialize(NetDataReader reader)
{
logData.Deserialize(reader);
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
}
public void Deserialize(NetDataReader reader)
{
PartyId = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
Value = reader.GetInt();
}
public static Vector2 GetVector2(this NetDataReader reader)
{
return(new Vector2(reader.GetFloat(), reader.GetFloat()));
}
public virtual void OnNetworkReceiveUnconnected(NetEndPoint remoteEndPoint, NetDataReader reader, UnconnectedMessageType messageType)
{
}
public void Deserialize(NetDataReader reader)
{
Error = (UITextKeys)reader.GetByte();
StorageCharacterItems = reader.GetList <CharacterItem>();
}
public override void Deserialize(NetDataReader reader)
{
Value = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
}
