public void Deserialize(NetDataReader reader)
{
_packetVersion = reader.GetByte();
SampleRate = reader.GetInt();
Channels = reader.GetByte();
Codec = Encoding.UTF8.GetString(reader.GetBytesWithLength());
}
public static PartySize GetPartySize(this NetDataReader @this)
{
return(new PartySize
{
CurrentSize = @this.GetByte(),
MaxSize = @this.GetByte()
});
}
public static NO_Shortcut GetShortcut(this NetDataReader reader)
{
ShortcutType type = (ShortcutType)reader.GetByte();
byte placement = reader.GetByte();
long data = reader.GetLong();
return(new NO_Shortcut(type, placement, data));
}
internal override void Deserialize(NetDataReader reader)
{
SelectionIndices = new List <int>(reader.GetByte());
for (int i = 0; i < SelectionIndices.Count; i++)
{
SelectionIndices.Add(reader.GetByte());
}
}
public void Deserialize(NetDataReader reader)
{
GuildId = reader.GetInt();
GuildRole = reader.GetByte();
RoleName = reader.GetString();
CanInvite = reader.GetBool();
CanKick = reader.GetBool();
ShareExpPercentage = reader.GetByte();
}
public void Deserialize(NetDataReader reader)
{
SeqCount = reader.GetByte();
if (SeqCount > 0)
{
StartSeq = reader.GetByte();
Data = reader.GetUInt();
EndSeq = (byte)(StartSeq + SeqCount - 1);
}
}
public TickUpdateData Read(NetDataReader reader)
{
tickId = reader.GetByte();
byte entityUpdateCount = reader.GetByte();
for (int i = 0; i < entityUpdateCount; i++)
{
entityUpdates.Add(new EntityUpdateData().Read(reader));
}
return(this);
}
public void Deserialize(NetDataReader reader)
{
var playerCount = reader.GetByte();
Players = new Dictionary <byte, Timestamped <PlayerTransformsMessage> >(playerCount);
for (var i = 0; i < playerCount; ++i)
{
Players.Add(reader.GetByte(), reader.Get <Timestamped <PlayerTransformsMessage> >());
}
}
internal override void Deserialize(NetDataReader reader)
{
Locked = reader.GetBool();
foreach (var state in this)
{
state.Type = (KeyStateType)reader.GetByte();
state.EnergyLevel = reader.GetByte();
state.StickyPressesRemaining = reader.GetByte();
}
}
internal override void Deserialize(NetDataReader reader)
{
KeysPressedThisFrame = new List <KeyboardKey>(reader.GetByte());
for (int i = 0; i < KeysPressedThisFrame.Count; i++)
{
KeysPressedThisFrame.Add((KeyboardKey)reader.GetByte());
}
Shift = reader.GetBool();
}
public void Deserialize(NetDataReader reader)
{
_packetVersion = reader.GetByte();
PreferredCodec = Encoding.UTF8.GetString(reader.GetBytesWithLength());
byte numCodecs = reader.GetByte();
SupportedCodecs = new string[numCodecs];
for (int i = 0; i < numCodecs; i++)
{
SupportedCodecs[i] = Encoding.UTF8.GetString(reader.GetBytesWithLength());
}
}
public void Deserialize(NetDataReader reader)
{
ID = reader.GetKey32();
Secret = reader.GetJoinSecret();
MaxSize = reader.GetByte();
Level = reader.Get <LevelChangeMessage>();
Players = new PlayerJoinMessage[reader.GetByte()];
for (var i = 0; i < Players.Length; ++i)
{
Players[i] = reader.Get <PlayerJoinMessage>();
}
}
internal override void Deserialize(NetDataReader reader)
{
BracketedText = reader.GetString();
int numCards = reader.GetByte();
if (!initialized)
{
_cards = new List <Card>();
}
drawPile = new List <Card>();
hand = new List <Card>();
discardPile = new List <Card>();
for (int i = 0; i < numCards; i++)
{
Card card;
if (initialized)
{
reader.GetString(); // consume the string, throw away
card = Cards[i];
}
else
{
card = Card.FromName(reader.GetString(), Owner);
_cards.Add(card);
}
card.Deserialize(reader); // get any internal state
switch ((CardStatus)reader.GetByte())
{
case CardStatus.DrawPile:
drawPile.Add(card);
break;
case CardStatus.Hand:
hand.Add(card);
break;
case CardStatus.DiscardPile:
discardPile.Add(card);
break;
default:
throw new ParseException("packet contains byte that is not an expected CardStatus");
}
}
initialized = true;
}
public void ReadPacketStream(NetDataReader stream)
{
ushort repObjId = stream.GetUShort();
while (repObjId != 0)
{
Log.Debug($"Reading ghost with id: {repObjId}");
// first read if there is a status change
if (stream.GetByte() == 1)
{
// read the status change
if (stream.GetByte() == 1)
{
Log.Debug("status changed: ADDED");
// added so read the persistent obj id
byte objRepId = stream.GetByte();
// Create new instance of the object
IPersistentObject obj = PersistentObjectManager.CreatePersistentObject(objRepId);
// unpack stream data
obj.Deserialize(stream);
ReplicatedObjects[repObjId] = new ReplicationRecord
{
Id = repObjId,
Entity = obj as ReplicatableObject
};
}
else
{
Log.Debug("status changed: REMOVED");
// remove the record but also need to destroy game object or queue it to be destroyed..
if (ReplicatedObjects.TryGetValue(repObjId, out ReplicationRecord record))
{
Log.Debug($"Removing record: {record.Id}");
//GameObject.Destroy(record.Entity);
ReplicatedObjects.Remove(repObjId);
}
}
}
else
{
Log.Debug("State update");
// no status change just new state information so unpack into existing replicated obj
ReplicatedObjects[repObjId].Entity.Deserialize(stream);
}
repObjId = stream.GetUShort();
}
}
public void Deserialize(NetDataReader reader)
{
type = (UpdateType)reader.GetByte();
id = reader.GetInt();
switch (type)
{
case UpdateType.Create:
guildName = reader.GetString();
characterId = reader.GetString();
break;
case UpdateType.ChangeLeader:
characterId = reader.GetString();
break;
case UpdateType.SetGuildMessage:
guildMessage = reader.GetString();
break;
case UpdateType.SetGuildRole:
guildRole = reader.GetByte();
roleName = reader.GetString();
canInvite = reader.GetBool();
canKick = reader.GetBool();
shareExpPercentage = reader.GetByte();
break;
case UpdateType.SetGuildMemberRole:
characterId = reader.GetString();
guildRole = reader.GetByte();
break;
case UpdateType.SetSkillLevel:
dataId = reader.GetInt();
level = reader.GetShort();
break;
case UpdateType.SetGold:
gold = reader.GetInt();
break;
case UpdateType.LevelExpSkillPoint:
level = reader.GetShort();
exp = reader.GetInt();
skillPoint = reader.GetShort();
break;
}
}
public override void DeserializeData(NetDataReader reader)
{
error = (Error)reader.GetByte();
sceneName = reader.GetString();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
type = (BuffType)reader.GetByte();
dataId = reader.GetInt();
level = reader.GetShort();
buffRemainsDuration = reader.GetFloat();
}
private void HandleNatIntroduction(NetDataReader dr)
{
// read intro
byte hostByte = dr.GetByte();
NetEndPoint remoteInternal = dr.GetNetEndPoint();
NetEndPoint remoteExternal = dr.GetNetEndPoint();
string token = dr.GetString(MaxTokenLength);
NetUtils.DebugWrite(ConsoleColor.Cyan, "[NAT] introduction received; we are designated " + (hostByte == HostByte ? "host" : "client"));
NetDataWriter writer = new NetDataWriter();
// send internal punch
writer.Put(hostByte);
writer.Put(token);
var packet = _netBase.PacketPool.GetWithData(PacketProperty.NatPunchMessage, writer);
_netBase.SendRawAndRecycle(packet, remoteInternal);
NetUtils.DebugWrite(ConsoleColor.Cyan, "[NAT] internal punch sent to " + remoteInternal);
// send external punch
writer.Reset();
writer.Put(hostByte);
writer.Put(token);
packet = _netBase.PacketPool.GetWithData(PacketProperty.NatPunchMessage, writer);
_netBase.SendRawAndRecycle(packet, remoteExternal);
NetUtils.DebugWrite(ConsoleColor.Cyan, "[NAT] external punch sent to " + remoteExternal);
}
private void HandleRecvData(byte[] buffer, int length, TransportEventData eventData)
{
recvReader.Clear();
recvReader.SetSource(buffer, 0, length);
eventData.type = (ENetworkEvent)recvReader.GetByte();
switch (eventData.type)
{
case ENetworkEvent.ConnectEvent:
// This must received at clients only, then create new kcp here
clientConnId = recvReader.GetUInt();
int remotePort = recvReader.GetInt();
eventData.connectionId = clientConnId;
eventQueue.Enqueue(eventData);
kcpHandles[clientConnId] = CreateKcp(clientConnId, clientSetting);
kcpHandles[clientConnId].remoteEndPoint = new IPEndPoint(eventData.endPoint.Address, remotePort);
break;
case ENetworkEvent.DataEvent:
// Read remaining data
eventData.reader = new NetDataReader(recvReader.GetRemainingBytes());
eventQueue.Enqueue(eventData);
break;
case ENetworkEvent.DisconnectEvent:
// This must received at clients only to force them to stop client
eventQueue.Enqueue(eventData);
break;
}
}
protected virtual void HandleClientCallFunction(LiteNetLibMessageHandler messageHandler)
{
NetDataReader reader = messageHandler.reader;
FunctionReceivers receivers = (FunctionReceivers)reader.GetByte();
long connectionId = -1;
if (receivers == FunctionReceivers.Target)
{
connectionId = (long)reader.GetPackedULong();
}
LiteNetLibElementInfo info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
if (receivers == FunctionReceivers.Server)
{
identity.ProcessNetFunction(info, reader, true);
}
else
{
LiteNetLibFunction netFunction = identity.ProcessNetFunction(info, reader, false);
// Use call with out parameters set because parameters already set while process net function
if (receivers == FunctionReceivers.Target)
{
netFunction.CallWithoutParametersSet(connectionId);
}
else
{
netFunction.CallWithoutParametersSet(DeliveryMethod.ReliableOrdered, receivers);
}
}
}
}
public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
{
if (!imageInitialized)
{
string s = reader.GetString(32);
if (s != string.Empty)
{
print("received: " + s);
int w = 0;
if (int.TryParse(Utils.EatString(ref s), out w))
{
int h;
if (int.TryParse(Utils.EatString(ref s), out h))
{
clientTex = new Texture2D(w, h, StreamingManager.Inst.textureFormat, false);
buffer = new byte[w * h * Utils.SomeTextureFormatsToBytes(StreamingManager.Inst.textureFormat)];//where 16 is fixed render texture bit depth
clientRenderTex.texture = clientTex;
}
}
imageInitialized = true;
}
return;
}
//partially fill buffer at given index
int start = reader.GetInt();
CompressionMode compMode = (CompressionMode)reader.GetByte();
byte[] payload = reader.GetRemainingBytes();
if (compMode != CompressionMode.none)
{
payload = Compressor.UnPack(payload, compMode);
}
System.Array.Copy(payload, 0, buffer, start, payload.Length);
}
public void Deserialize(NetDataReader reader)
{
Id = reader.GetUShort();
Keys = (MovementKeys)reader.GetByte();
Rotation = reader.GetFloat();
ServerTick = reader.GetUShort();
}
public void Deserialize(NetDataReader reader)
{
FromPlayer = reader.GetByte();
CommandId = reader.GetUShort();
Hit = reader.GetVector2();
ServerTick = reader.GetUShort();
}
public void Deserialize(NetDataReader reader)
{
Id = reader.GetByte();
Position = reader.GetVector2();
Rotation = reader.GetFloat();
Tick = reader.GetUShort();
}
public void Deserialize(NetDataReader reader)
{
peerType = (CentralServerPeerType)reader.GetByte();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
extra = reader.GetString();
}
public void Deserialize(NetDataReader reader)
{
PlayerId = reader.GetByte();
Metadata = reader.Get <PlayerMetadata>();
PlayerState = reader.Get <PlayerState>();
NetworkObjectState = reader.Get <NetworkObjectState>();
}
public static Base.Face GetBaseFace(this NetDataReader reader)
{
return(new Base.Face {
direction = (Base.Direction)reader.GetByte(),
cell = reader.GetInt3()
});
}
public void ProcessInitialFields(NetDataReader reader)
{
if (!cachedElements)
{
CacheNetworkMember();
}
for (byte i = 0; i < networkFields.Count; i++)
{
var field = networkFields[i];
var objId = reader.GetUShort();
if (ObjectId != objId)
{
Log.Error(this, $"NetworkObject id don't match! {ObjectId}<->{objId}");
return;
}
var tmpID = reader.GetByte();
if (field.ElementId != tmpID)
{
Log.Error(this, $"server field order is not equal client!");
return;
}
field.Deserialize(reader);
}
}
private void ReadFields(NetDataReader reader, int length, int frame, bool discardOutOfOrderPackets)
{
int startPosition = reader.Position;
// Clear the first byte of the payload. This will be
// a StatefulObject.DataType.Object enum.
if (reader.Position - startPosition < length)
{
reader.GetByte();
}
while (reader.Position - startPosition < length)
{
int id = reader.GetInt();
int guid = reader.GetInt();
if (!world.statefulObjects.ContainsKey(id))
{
IdentifiableObject clone = Object.Instantiate(world.registeredPrefabsMap[guid], Vector3.zero, Quaternion.identity);
world.Add(clone.GetComponent <StatefulObject>(), id);
}
world.statefulObjects[id].ReadStateFields(reader, startPosition + length, arbiter, frame, discardOutOfOrderPackets, false);
}
}
private void ReadFields(NetDataReader reader, int length)
{
if (listenRemote)
{
reader.SkipBytes(length);
return;
}
int startPosition = reader.Position;
// Clear the first byte of the payload. This will be
// a StatefulObject.DataType.Object enum.
if (reader.Position - startPosition < length)
{
reader.GetByte();
}
while (reader.Position - startPosition < length)
{
int id = reader.GetInt();
if (!world.statefulObjects[id].Ownable.HasAuthority(remoteID))
{
world.statefulObjects[id].ReadStateFields(reader, arbiter);
}
else
{
world.statefulObjects[id].ReadStateFields(reader, arbiter, true);
}
}
}
