// A "Voos Name" may be a 32-char GUID or just some string, like
// __DEFAULT_BEHAVIOR__
public static string ReadVoosName(this NET.NetworkReader reader)
{
byte header = reader.ReadByte();
if (header == VN_EMPTY)
{
return("");
}
if (header == VN_GUID)
{
// Guid
byte[] bytes = new byte[16];
for (int i = 0; i < 16; i++)
{
bytes[i] = reader.ReadByte();
}
return((new System.Guid(bytes)).ToString("N"));
}
else
{
Debug.Assert(header == VN_UTF16);
return(reader.ReadUtf16());
}
}
Cell ReadCell(UnityEngine.Networking.NetworkReader reader)
{
int x = reader.ReadByte() - cellArrayOffsetX;
int y = reader.ReadByte() - cellArrayOffsetY;
int z = reader.ReadByte() - cellArrayOffsetZ;
Cell c = new Cell(x, y, z);
return(c);
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
var dirty = reader.ReadPackedUInt32();
if (dirty == 0)
{
return;
}
m_Slot = reader.ReadByte();
m_ReadyToBegin = reader.ReadBoolean();
}
internal bool HandleFragment(NetworkReader reader)
{
if (reader.ReadByte() == 0)
{
if (!readingFragment)
{
fragmentBuffer.SeekZero();
readingFragment = true;
}
byte[] array = reader.ReadBytesAndSize();
fragmentBuffer.WriteBytes(array, (ushort)array.Length);
return(false);
}
readingFragment = false;
return(true);
}
void LoadLegacy(UnityEngine.Networking.NetworkReader reader)
{
int count = reader.ReadInt32();
Util.Log($"loading {count} legacy cells");
for (int i = 0; i < count; i++)
{
Cell c = new Cell(reader.ReadInt32(), reader.ReadInt32(), reader.ReadInt32());
LegacyBlockInfo info = new LegacyBlockInfo();
info.SetData(reader.ReadByte());
CellValue block = new CellValue(info.GetBlockType(), info.GetBlockDirection(), BlockStyle.Stone);
SetCell(block, c);
Side westEdge = new Side(c.x, c.y, c.z, CellSide.West);
SetSide(westEdge, info.WestWall(), BlockStyle.Stone);
Side southEdge = new Side(c.x, c.y, c.z, CellSide.South);
SetSide(southEdge, info.SouthWall(), BlockStyle.Stone);
}
}
internal bool HandleFragment(NetworkReader reader)
{
int state = reader.ReadByte();
if (state == 0)
{
if (readingFragment == false)
{
fragmentBuffer.SeekZero();
readingFragment = true;
}
byte[] data = reader.ReadBytesAndSize();
fragmentBuffer.WriteBytes(data, (ushort)data.Length);
return(false);
}
else
{
readingFragment = false;
return(true);
}
}
public void HandleMsg(NetworkReader reader)
{
byte num = reader.ReadByte();
int index = (int)reader.ReadPackedUInt32();
T obj = this.DeserializeItem(reader);
switch (num)
{
case 0:
this.m_Objects.Add(obj);
break;
case 1:
this.m_Objects.Clear();
break;
case 2:
this.m_Objects.Insert(index, obj);
break;
case 3:
this.m_Objects.Remove(obj);
break;
case 4:
this.m_Objects.RemoveAt(index);
break;
case 5:
case 6:
this.m_Objects[index] = obj;
break;
}
if (this.m_Callback == null)
{
return;
}
this.m_Callback((SyncList <T> .Operation)num, index);
}
internal bool HandleFragment(NetworkReader reader)
{
bool result;
if (reader.ReadByte() == 0)
{
if (!this.readingFragment)
{
this.fragmentBuffer.SeekZero();
this.readingFragment = true;
}
byte[] array = reader.ReadBytesAndSize();
this.fragmentBuffer.WriteBytes(array, (ushort)array.Length);
result = false;
}
else
{
this.readingFragment = false;
result = true;
}
return(result);
}
public void HandleMsg(NetworkReader reader)
{
byte op = reader.ReadByte();
int itemIndex = (int)reader.ReadPackedUInt32();
T item = DeserializeItem(reader);
switch ((Operation)op)
{
case Operation.OP_ADD:
m_Objects.Add(item);
break;
case Operation.OP_CLEAR:
m_Objects.Clear();
break;
case Operation.OP_INSERT:
m_Objects.Insert(itemIndex, item);
break;
case Operation.OP_REMOVE:
m_Objects.Remove(item);
break;
case Operation.OP_REMOVEAT:
m_Objects.RemoveAt(itemIndex);
break;
case Operation.OP_SET:
case Operation.OP_DIRTY:
m_Objects[itemIndex] = item;
break;
}
if (m_Callback != null)
{
m_Callback.Invoke((Operation)op, itemIndex);
}
}
public void HandleMsg(NetworkReader reader)
{
byte b = reader.ReadByte();
int num = (int)reader.ReadPackedUInt32();
T val = DeserializeItem(reader);
switch (b)
{
case 0:
m_Objects.Add(val);
break;
case 1:
m_Objects.Clear();
break;
case 2:
m_Objects.Insert(num, val);
break;
case 3:
m_Objects.Remove(val);
break;
case 4:
m_Objects.RemoveAt(num);
break;
case 5:
case 6:
m_Objects[num] = val;
break;
}
if (m_Callback != null)
{
m_Callback((Operation)b, num);
}
}
public void HandleMsg(NetworkReader reader)
{
byte num = reader.ReadByte();
int index = (int)reader.ReadPackedUInt32();
T item = this.DeserializeItem(reader);
switch (((Operation <T>)num))
{
case Operation <T> .OP_ADD:
this.m_Objects.Add(item);
break;
case Operation <T> .OP_CLEAR:
this.m_Objects.Clear();
break;
case Operation <T> .OP_INSERT:
this.m_Objects.Insert(index, item);
break;
case Operation <T> .OP_REMOVE:
this.m_Objects.Remove(item);
break;
case Operation <T> .OP_REMOVEAT:
this.m_Objects.RemoveAt(index);
break;
case Operation <T> .OP_SET:
case Operation <T> .OP_DIRTY:
this.m_Objects[index] = item;
break;
}
if (this.m_Callback != null)
{
this.m_Callback((Operation <T>)num, index);
}
}
public void HandleMsg(NetworkReader reader)
{
byte op = reader.ReadByte();
int num = (int)reader.ReadPackedUInt32();
T t = this.DeserializeItem(reader);
switch (op)
{
case 0:
this.m_Objects.Add(t);
break;
case 1:
this.m_Objects.Clear();
break;
case 2:
this.m_Objects.Insert(num, t);
break;
case 3:
this.m_Objects.Remove(t);
break;
case 4:
this.m_Objects.RemoveAt(num);
break;
case 5:
case 6:
this.m_Objects[num] = t;
break;
}
if (this.m_Callback != null)
{
this.m_Callback((SyncList <T> .Operation)op, num);
}
}
public override void Deserialize(UnityEngine.Networking.NetworkReader reader)
{
slotId = reader.ReadByte();
loadedState = reader.ReadBoolean();
}
public void Deserialize(byte[] cellBytes)
{
Clear();
// Util.Log($"loading terrain data of {cellBytes.Length} bytes");
var reader = new UnityEngine.Networking.NetworkReader(cellBytes);
// Again - kinda awkward to have the deserialize code here.
int version = reader.ReadInt32();
if (version == 0)
{
Util.LogWarning($"Ignoring terrain version 0");
}
else if (version == 1)
{
LoadLegacy(reader);
}
else if (version == TerrainDatabase.CurrentVersion)
{
int blockCount = reader.ReadInt32();
// Util.Log($"reading {blockCount} blocks");
for (int i = 0; i < blockCount; i++)
{
TerrainDatabase.BlockInfo info = new TerrainDatabase.BlockInfo();
info.b0 = reader.ReadByte();
info.b1 = reader.ReadByte();
Cell c = ReadCell(reader);
Debug.Assert(info.GetShape() != BlockShape.Empty);
SetCell(info.ToBlock(), c);
}
System.Action <CellSide> LoadSideMap = (CellSide cellSide) =>
{
int count = reader.ReadInt32();
// Util.Log($"Reading {count} {cellSide} walls");
for (int i = 0; i < count; i++)
{
TerrainDatabase.SideInfo info = new TerrainDatabase.SideInfo();
info.b0 = reader.ReadByte();
Cell c = ReadCell(reader);
Side side = new Side
{
side = cellSide,
x = c.x,
y = c.y,
z = c.z
};
SetSide(side, true, info.GetStyle());
}
};
LoadSideMap.Invoke(CellSide.South);
LoadSideMap.Invoke(CellSide.West);
Debug.Assert(reader.ReadByte() == 42, "End-of-buffer sanity check failed!");
}
else
{
throw new System.Exception($"Given terrain of unknown version: {version}.");
}
}
public static bool ReadVoosBoolean(this UnityEngine.Networking.NetworkReader reader)
{
return(reader.ReadByte() == 1);
}
