public static void WriteColor(this UnityEngine.Networking.NetworkWriter writer, Color c)
{
writer.Write(c.r);
writer.Write(c.g);
writer.Write(c.b);
writer.Write(c.a);
}
public OutputMessage(NetworkWriter data, int connectionID, int channelID)
{
Data = data;
ConnectionID = connectionID;
Type = MessageType.Reply;
ChannelID = channelID;
}
public override void Serialize(NetworkWriter writer)
{
writer.WritePackedUInt32((uint) this.oldConnectionId);
writer.WritePackedUInt32((uint) this.playerControllerId);
writer.Write(this.netId);
writer.WriteBytesAndSize(this.msgData, this.msgSize);
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
var serialized = base.OnSerialize (writer, initialState);
var time = animator.playbackTime;
writer.Write (time);
return serialized;
}
public override void Serialize(NetworkWriter writer)
{
writer.Write(this.netId);
writer.WriteBytesFull(this.payload);
writer.Write(this.teleport);
writer.WritePackedUInt32((uint) this.time);
}
public void AddOurselves(ClientPlayer player, NetworkWriter nw)
{
player.currentVessel = this;
player.ChunkI = WorldToChunkI((Vector2)player.transform.position);
int rangeT = (PLAYER_CHUNK_RANGE * 2) + 1;
nw.Write((ushort)ClientMessageType.RequestChunk);
nw.Write((ushort)(rangeT * rangeT));
for (int i = 0; i < rangeT; i++) {
for (int j = 0; j < rangeT; j++) {
Vec2i temp = player.ChunkI + new Vec2i(i - PLAYER_CHUNK_RANGE, j - PLAYER_CHUNK_RANGE);
if (!((temp - player.ChunkI) <= PLAYER_CHUNK_RANGE)) {
VesselChunk temp2 = chunks.TryGet(temp.x, temp.y);
nw.Write(temp.x);
nw.Write(temp.y);
if (temp2 != null) {
nw.Write(temp2.version);
} else {
nw.Write((uint)uint.MaxValue);
}
}
}
}
}
public override void Serialize(NetworkWriter writer)
{
writer.Write(proxyId);
writer.Write((short)packet.Compression);
writer.Write(packet.Length);
writer.WriteBytesFull(packet.Data);
}
public override void Serialize(NetworkWriter writer)
{
writer.Write(this.netId);
writer.Write(this.sceneId);
writer.Write(this.position);
writer.WriteBytesFull(this.payload);
}
private void PostInternalMessage(short msgType)
{
NetworkWriter writer = new NetworkWriter();
writer.StartMessage(msgType);
writer.FinishMessage();
this.PostInternalMessage(writer.AsArray(), 0);
}
public byte[] Serialize()
{
byte[] buffer = new byte[
4 // version
+ 4 // zero for block count
+ 4 // south count
+ southSideMap.Count * 4
+ 4 // west count
+ westSideMap.Count * 4
+ 1 // ending sanity check number
+ 1 // extra byte cuz NetworkWriter is buggy:
// https://bitbucket.org/Unity-Technologies/networking/src/78ca8544bbf4e87c310ce2a9a3fc33cdad2f9bb1/Runtime/NetworkBuffer.cs?at=5.3&fileviewer=file-view-default#NetworkBuffer.cs-160
];
var writer = new UnityEngine.Networking.NetworkWriter(buffer);
writer.Write(CurrentVersion);
// Write dummy block count
writer.Write(0);
SerializeSideMap(southSideMap, writer);
SerializeSideMap(westSideMap, writer);
// Sanity check
writer.Write((byte)42);
// Util.Log($"Wrote {blockMap.Count} blocks, {southSideMap.Count} south walls, and {westSideMap.Count} west walls to {buffer.Length} bytes");
return(buffer);
}
public override void Serialize(NetworkWriter writer)
{
base.Serialize(writer);
writer.Write(Polyline.Count);
foreach (var vector3 in Polyline)
writer.Write(vector3);
}
public override void Serialize(NetworkWriter writer)
{
writer.Write(this.netId);
writer.WritePackedUInt32((uint) this.stateHash);
writer.Write(this.normalizedTime);
writer.WriteBytesAndSize(this.parameters, this.parameters.Length);
}
// A "Voos Name" may be a 32-char GUID or just some string, like
// __DEFAULT_BEHAVIOR__
public static void WriteVoosName(this NET.NetworkWriter writer, string name)
{
if (name.IsNullOrEmpty())
{
writer.Write(VN_EMPTY);
return;
}
System.Guid guid;
if (System.Guid.TryParseExact(name, "N", out guid))
{
writer.Write(VN_GUID); // Indicate GUID
byte[] bytes = guid.ToByteArray();
Debug.Assert(bytes.Length == 16);
for (int i = 0; i < 16; i++)
{
writer.Write(bytes[i]);
}
}
else
{
// Some string, maybe null/empty
writer.Write(VN_UTF16);
writer.WriteUtf16(name);
}
}
/// <summary>
/// Server: Serialize the state over network
/// </summary>
/// <param name="writer"></param>
/// <param name="initialState"></param>
/// <returns></returns>
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
writer.Write(serverLastState.state);
writer.Write(serverLastState.position);
writer.Write(serverLastState.rotation);
return true;
}
internal void InvokeHandlerOnClient(short msgType, MessageBase msg, int channelId)
{
NetworkWriter writer = new NetworkWriter();
writer.StartMessage(msgType);
msg.Serialize(writer);
writer.FinishMessage();
this.InvokeBytesOnClient(writer.AsArray(), channelId);
}
public void TestNetworkWriterSize()
{
var writer = new UnityEngine.Networking.NetworkWriter();
writer.Write((byte)42);
byte[] bytes = writer.ToArray();
Assert.AreEqual(1, bytes.Length);
}
public override void Serialize(NetworkWriter writer)
{
writer.Write((ushort) this.peers.Length);
foreach (PeerInfoMessage message in this.peers)
{
message.Serialize(writer);
}
}
public override void Serialize(NetworkWriter writer)
{
writer.WritePackedUInt32((uint) this.connectionId);
writer.Write(this.address);
writer.WritePackedUInt32((uint) this.port);
writer.Write(this.isHost);
writer.Write(this.isYou);
}
public static byte[] Serialize(INetMsg msg)
{
var networkWriter = new NetworkWriter();
uint index = GetMsgIndexFromType( msg.GetType() );
networkWriter.WritePackedUInt32( index );
((MessageBase)msg).Serialize(networkWriter);
return networkWriter.AsArray();
}
public void TestNetworkWriterWorkaround()
{
// Work around is to add 1 more byte to the end to avoid the resize...
byte[] buffer = new byte[2];
var writer = new UnityEngine.Networking.NetworkWriter(buffer);
writer.Write((byte)42);
Assert.AreEqual((byte)42, buffer[0]);
}
public override void Serialize(NetworkWriter writer)
{
writer.WritePackedUInt32((uint) this.oldServerConnectionId);
writer.Write((ushort) this.peers.Length);
for (int i = 0; i < this.peers.Length; i++)
{
this.peers[i].Serialize(writer);
}
}
public override void Serialize(NetworkWriter writer)
{
base.Serialize(writer);
writer.Write(_instructionBase);
writer.Write(_variantReplacements.Length);
foreach (string replacement in _variantReplacements) {
writer.Write(replacement);
}
}
private void Awake()
{
this.m_PrevPosition = this.m_Target.localPosition;
this.m_PrevRotation = this.m_Target.localRotation;
if (base.localPlayerAuthority)
{
this.m_LocalTransformWriter = new NetworkWriter();
}
}
public override void Serialize(NetworkWriter writer)
{
writer.Write(ChannelId);
writer.Write(SenderUserId);
writer.Write(SenderUserName);
writer.Write(Message);
var json = JsonWrapper.SerializeObject(Timestamp);
writer.Write(json);
}
public override void Serialize(NetworkWriter writer)
{
writer.Write((ushort) this.scripts.Length);
for (int i = 0; i < this.scripts.Length; i++)
{
writer.Write(this.scripts[i].name);
writer.Write(this.scripts[i].channel);
}
}
public void TestNetworkWriterBug()
{
byte[] buffer = new byte[1];
var writer = new UnityEngine.Networking.NetworkWriter(buffer);
writer.Write((byte)42);
// You'd expect this to be 42...but actually it's 0 cuz NetworkWriter wrongly resized into a new buffer...
Assert.AreEqual((byte)0, buffer[0]);
}
public byte[] GetVoosInitBytes()
{
var voosBuffer = VOOS_INIT_BYTES_REUSED;
Array.Clear(voosBuffer, 0, voosBuffer.Length);
var writer = new UNET.NetworkWriter(voosBuffer);
voosEngine.SerializePlayerInitPayloadV2(writer);
return(Util.GZip(writer.ToArray()));
}
/// <summary>
/// Send an Update to all Clients of the Status Connection of a Player
/// </summary>
/// <remarks>
/// Order:
/// String UserName
/// bool ConnectedStatus
/// float ServerTime
/// </remarks>
/// <param name="UserName"></param>
/// <param name="connectedStatus"></param>
/// <param name="ServerTime"></param>
public void PlayerStatusUpdate(String UserName, bool connectedStatus, float ServerTime)
{
NetworkWriter data = new NetworkWriter();
data.Write((ushort)Subjects.PlayerStatusUpdate);
data.Write(UserName);
data.Write(connectedStatus);
data.Write(ServerTime);
OutputMessage output = new OutputMessage(data);
GameServer.LLApiServer.addOutPutMessageToQueue(output);
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
bool needToUpdate = false;
if (fbxObj != null)
{
//Call an fbxobj method to write whatever is necessary, return true if "needToUpdate"
writer.Write(fbxObj.gameObject.transform.position);
needToUpdate = true;
}
return needToUpdate;
}
public override void Serialize(NetworkWriter writer)
{
writer.Write(this.netId);
if (this.parameters == null)
{
writer.WriteBytesAndSize(this.parameters, 0);
}
else
{
writer.WriteBytesAndSize(this.parameters, this.parameters.Length);
}
}
private void Awake()
{
this.m_RigidBody3D = base.GetComponent<Rigidbody>();
this.m_RigidBody2D = base.GetComponent<Rigidbody2D>();
this.m_CharacterController = base.GetComponent<CharacterController>();
this.m_PrevPosition = base.transform.position;
this.m_PrevRotation = base.transform.rotation;
this.m_PrevVelocity = 0f;
if (base.localPlayerAuthority)
{
this.m_LocalTransformWriter = new NetworkWriter();
}
}
void SerializeSideMap(SortedDictionary <Cell, SideInfo> map, UnityEngine.Networking.NetworkWriter writer)
{
writer.Write(map.Count);
foreach (var pair in map)
{
writer.Write(pair.Value.b0);
Debug.Assert(pair.Key.x + cellArrayOffsetX < 256);
Debug.Assert(pair.Key.y + cellArrayOffsetY < 256);
Debug.Assert(pair.Key.z + cellArrayOffsetZ < 256);
writer.Write((byte)(pair.Key.x + cellArrayOffsetX));
writer.Write((byte)(pair.Key.y + cellArrayOffsetY));
writer.Write((byte)(pair.Key.z + cellArrayOffsetZ));
}
}
public void TestUtf16Serialize()
{
byte[] buffer = new byte[100];
var writer = new UnityEngine.Networking.NetworkWriter(buffer);
string sample = "japanese いろはに";
writer.WriteUtf16(sample);
var reader = new UnityEngine.Networking.NetworkReader(buffer);
string actual = reader.ReadUtf16();
Assert.AreEqual(sample, actual);
}
public bool SendMessage(int connectionId, NetworkWriter writer, int channel, out NetworkError Error)
{
byte error;
byte[] buffer = writer.ToArray();
NetworkTransport.Send(SocketId, connectionId, channel, buffer, buffer.Length, out error);
Error = (NetworkError)error;
if (Error != NetworkError.Ok)
{
return true;
}
else
{
return false;
}
}
public static void WriteUtf16(this UnityEngine.Networking.NetworkWriter writer, string s)
{
if (s == null)
{
writer.Write((ushort)0);
return;
}
if (s.Length >= 65535)
{
throw new System.Exception("We do not support serializing strings of length beyond 65k chars");
}
writer.Write((ushort)s.Length);
for (int i = 0; i < s.Length; i++)
{
writer.Write((ushort)s[i]);
}
}
static void CommandPIStats(CommandArg[] args)
{
var engine = consoleInstance;
System.Action doBinTest = () =>
{
byte[] buffer = new byte[10 * 1024 * 1024];
var writer = new UnityEngine.Networking.NetworkWriter(buffer);
engine.SerializePlayerInitPayloadV2(writer);
byte[] bytesUsed = writer.ToArray();
byte[] zipped = Util.GZip(bytesUsed);
Util.Log($"{zipped.Length / 1024} kb zipped, {bytesUsed.Length / 1024} kb orig");
};
doBinTest();
Util.Log($"Current stats:");
FindObjectOfType <NetworkingController>().LogInitPlayerPayloadStats();
}
public override void Serialize(NetworkWriter writer)
{
writer.WritePackedUInt32((uint) this.connectionId);
writer.Write(this.address);
writer.WritePackedUInt32((uint) this.port);
writer.Write(this.isHost);
writer.Write(this.isYou);
if (this.playerIds == null)
{
writer.WritePackedUInt32(0);
}
else
{
writer.WritePackedUInt32((uint) this.playerIds.Length);
for (int i = 0; i < this.playerIds.Length; i++)
{
writer.Write(this.playerIds[i].netId);
writer.WritePackedUInt32((uint) this.playerIds[i].playerControllerId);
}
}
}
public override void Serialize(NetworkWriter writer) {
writer.StartMessage(MSGID);
//Send the number of elements
writer.Write(inputsList.Count);//int32
//Add the entire list
foreach(Inputs i in inputsList) {
writer.Write(i.crouch);//bool
writer.Write(i.jump);//bool
writer.Write(i.move);//bool
writer.Write(i.pitch);//float
writer.Write(i.rotate);//bool
writer.Write(i.timeStamp);//long
writer.Write(i.walk);//bool
writer.Write(i.wasd[0]);//bool
writer.Write(i.wasd[1]);//bool
writer.Write(i.wasd[2]);//bool
writer.Write(i.wasd[3]);//bool
writer.Write(i.yaw);//float
}
writer.FinishMessage();
}
public override void Serialize(NetworkWriter writer)
{
base.Serialize(writer);
Type t = _actionSet.GetType();
if (t == typeof(SinglePanelActionSet)) {
writer.Write((byte)0);
} else if (t == typeof(ReplacementPanelActionSet)) {
writer.Write((byte)1);
} else if (t == typeof(CodePanelActionSet)) {
writer.Write((byte)2);
} else {
throw new Exception("Unexpected Action Set Type " + t);
}
_actionSet.Serialize(writer);
writer.Write(_x);
writer.Write(_y);
writer.Write(_prefabIndex);
}
public void WriteSetChunk(NetworkWriter nw)
{
if (updateMessageBytes) {
NetworkWriter temp = new NetworkWriter();
temp.Write(index.x);
temp.Write(index.y);
temp.Write(version);
temp.Write(tileCount);
for (int i = 0; i < VesselChunk.SIZE; i++) {
for (int j = 0; j < VesselChunk.SIZE; j++) {
VesselTile tile = TileAt(i, j);
if (tile != null) {
temp.Write(i);
temp.Write(j);
temp.Write((byte)tile.floor0);
temp.Write((byte)tile.floor1);
temp.Write((byte)tile.wallMask);
temp.Write(tile.wallNode);
}
}
}
messageBytes = temp.ToArray();
updateMessageBytes = false;
}
nw.WriteBytesFull(messageBytes);
}
public static void SerializeRotation2D(NetworkWriter writer, float rot, CompressionSyncMode compression)
{
WriteAngle(writer, rot, compression);
}
public static void SerializeSpin2D(NetworkWriter writer, float angularVelocity, CompressionSyncMode compression)
{
WriteAngle(writer, angularVelocity, compression);
}
public bool SendWriter(NetworkWriter writer)
{
return(SendBytes(writer.AsArraySegment().Array, writer.AsArraySegment().Count));
}
public NetworkConnection()
{
m_Writer = new NetworkWriter();
}
public static void SerializeVelocity2D(NetworkWriter writer, Vector2 velocity, CompressionSyncMode compression)
{
writer.Write(velocity);
}
public override void Serialize(UnityEngine.Networking.NetworkWriter writer)
{
base.Serialize(writer);
writer.Write(_actionInstruction);
}
protected abstract void SerializeItem(NetworkWriter writer, T item);
// use this to implicitly become ready
public static bool AddPlayer(NetworkConnection readyConn, short playerControllerId, MessageBase extraMessage)
{
if (playerControllerId < 0)
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is negative");
}
return(false);
}
if (playerControllerId > PlayerController.MaxPlayersPerClient)
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is too high, max is " + PlayerController.MaxPlayersPerClient);
}
return(false);
}
if (playerControllerId > PlayerController.MaxPlayersPerClient / 2)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is unusually high");
}
}
// fill out local players array
while (playerControllerId >= s_LocalPlayers.Count)
{
s_LocalPlayers.Add(new PlayerController());
}
// ensure valid ready connection
if (readyConn == null)
{
if (!s_IsReady)
{
if (LogFilter.logError)
{
Debug.LogError("Must call AddPlayer() with a connection the first time to become ready.");
}
return(false);
}
}
else
{
s_IsReady = true;
s_ReadyConnection = readyConn;
}
PlayerController existingPlayerController;
if (s_ReadyConnection.GetPlayerController(playerControllerId, out existingPlayerController))
{
if (existingPlayerController.IsValid && existingPlayerController.gameObject != null)
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " already in use.");
}
return(false);
}
}
if (LogFilter.logDebug)
{
Debug.Log("ClientScene::AddPlayer() for ID " + playerControllerId + " called with connection [" + s_ReadyConnection + "]");
}
#if ENABLE_UNET_HOST_MIGRATION
if (!hasMigrationPending())
{
#endif
var msg = new AddPlayerMessage();
msg.playerControllerId = playerControllerId;
if (extraMessage != null)
{
var writer = new NetworkWriter();
extraMessage.Serialize(writer);
msg.msgData = writer.ToArray();
msg.msgSize = writer.Position;
}
s_ReadyConnection.Send(MsgType.AddPlayer, msg);
#if ENABLE_UNET_HOST_MIGRATION
}
else
{
return(SendReconnectMessage(extraMessage));
}
#endif
return(true);
}
public static void SerializeRotation3D(NetworkWriter writer, Quaternion rot, AxisSyncMode mode, CompressionSyncMode compression)
{
switch (mode)
{
case AxisSyncMode.None:
break;
case AxisSyncMode.AxisX:
{
Vector3 eulerAngles12 = rot.eulerAngles;
WriteAngle(writer, eulerAngles12.x, compression);
break;
}
case AxisSyncMode.AxisY:
{
Vector3 eulerAngles11 = rot.eulerAngles;
WriteAngle(writer, eulerAngles11.y, compression);
break;
}
case AxisSyncMode.AxisZ:
{
Vector3 eulerAngles10 = rot.eulerAngles;
WriteAngle(writer, eulerAngles10.z, compression);
break;
}
case AxisSyncMode.AxisXY:
{
Vector3 eulerAngles8 = rot.eulerAngles;
WriteAngle(writer, eulerAngles8.x, compression);
Vector3 eulerAngles9 = rot.eulerAngles;
WriteAngle(writer, eulerAngles9.y, compression);
break;
}
case AxisSyncMode.AxisXZ:
{
Vector3 eulerAngles6 = rot.eulerAngles;
WriteAngle(writer, eulerAngles6.x, compression);
Vector3 eulerAngles7 = rot.eulerAngles;
WriteAngle(writer, eulerAngles7.z, compression);
break;
}
case AxisSyncMode.AxisYZ:
{
Vector3 eulerAngles4 = rot.eulerAngles;
WriteAngle(writer, eulerAngles4.y, compression);
Vector3 eulerAngles5 = rot.eulerAngles;
WriteAngle(writer, eulerAngles5.z, compression);
break;
}
case AxisSyncMode.AxisXYZ:
{
Vector3 eulerAngles = rot.eulerAngles;
WriteAngle(writer, eulerAngles.x, compression);
Vector3 eulerAngles2 = rot.eulerAngles;
WriteAngle(writer, eulerAngles2.y, compression);
Vector3 eulerAngles3 = rot.eulerAngles;
WriteAngle(writer, eulerAngles3.z, compression);
break;
}
}
}
public static void WriteVoosBoolean(this UnityEngine.Networking.NetworkWriter writer, bool val)
{
writer.Write((byte)(val ? 1 : 0));
}
public override void Serialize(NetworkWriter writer)
{
writer.WritePackedUInt32(this.state);
}
public override bool SendWriter(NetworkWriter writer, int channelId)
{
return(this.m_LocalServer.InvokeBytes(this, writer.AsArray(), (int)((short)writer.AsArray().Length), channelId));
}
public static void WriteVoosVector3(this UnityEngine.Networking.NetworkWriter writer, Vector3 v)
{
writer.Write(v.x);
writer.Write(v.y);
writer.Write(v.z);
}
protected override void SerializeItem(NetworkWriter writer, float item)
{
writer.Write(item);
}
public static bool AddPlayer(NetworkConnection readyConn, short playerControllerId, MessageBase extraMessage)
{
bool result;
if (playerControllerId < 0)
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is negative");
}
result = false;
}
else if (playerControllerId > 32)
{
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[]
{
"ClientScene::AddPlayer: playerControllerId of ",
playerControllerId,
" is too high, max is ",
32
}));
}
result = false;
}
else
{
if (playerControllerId > 16)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is unusually high");
}
}
while ((int)playerControllerId >= ClientScene.s_LocalPlayers.Count)
{
ClientScene.s_LocalPlayers.Add(new PlayerController());
}
if (readyConn == null)
{
if (!ClientScene.s_IsReady)
{
if (LogFilter.logError)
{
Debug.LogError("Must call AddPlayer() with a connection the first time to become ready.");
}
return(false);
}
}
else
{
ClientScene.s_IsReady = true;
ClientScene.s_ReadyConnection = readyConn;
}
PlayerController playerController;
if (ClientScene.s_ReadyConnection.GetPlayerController(playerControllerId, out playerController))
{
if (playerController.IsValid && playerController.gameObject != null)
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " already in use.");
}
return(false);
}
}
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[]
{
"ClientScene::AddPlayer() for ID ",
playerControllerId,
" called with connection [",
ClientScene.s_ReadyConnection,
"]"
}));
}
if (!ClientScene.hasMigrationPending())
{
AddPlayerMessage addPlayerMessage = new AddPlayerMessage();
addPlayerMessage.playerControllerId = playerControllerId;
if (extraMessage != null)
{
NetworkWriter networkWriter = new NetworkWriter();
extraMessage.Serialize(networkWriter);
addPlayerMessage.msgData = networkWriter.ToArray();
addPlayerMessage.msgSize = (int)networkWriter.Position;
}
ClientScene.s_ReadyConnection.Send(37, addPlayerMessage);
result = true;
}
else
{
result = ClientScene.SendReconnectMessage(extraMessage);
}
}
return(result);
}
// Serialize the contents of this message into the writer
public virtual void Serialize(NetworkWriter writer)
{
}
public static bool AddPlayer(NetworkConnection readyConn, short playerControllerId, MessageBase extraMessage)
{
PlayerController controller;
if (playerControllerId < 0)
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is negative");
}
return(false);
}
if (playerControllerId > 0x20)
{
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[] { "ClientScene::AddPlayer: playerControllerId of ", playerControllerId, " is too high, max is ", 0x20 }));
}
return(false);
}
if ((playerControllerId > 0x10) && LogFilter.logWarn)
{
Debug.LogWarning("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " is unusually high");
}
while (playerControllerId >= s_LocalPlayers.Count)
{
s_LocalPlayers.Add(new PlayerController());
}
if (readyConn == null)
{
if (!s_IsReady)
{
if (LogFilter.logError)
{
Debug.LogError("Must call AddPlayer() with a connection the first time to become ready.");
}
return(false);
}
}
else
{
s_IsReady = true;
s_ReadyConnection = readyConn;
}
if ((s_ReadyConnection.GetPlayerController(playerControllerId, out controller) && controller.IsValid) && (controller.gameObject != null))
{
if (LogFilter.logError)
{
Debug.LogError("ClientScene::AddPlayer: playerControllerId of " + playerControllerId + " already in use.");
}
return(false);
}
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "ClientScene::AddPlayer() for ID ", playerControllerId, " called with connection [", s_ReadyConnection, "]" }));
}
AddPlayerMessage msg = new AddPlayerMessage {
playerControllerId = playerControllerId
};
if (extraMessage != null)
{
NetworkWriter writer = new NetworkWriter();
extraMessage.Serialize(writer);
msg.msgData = writer.ToArray();
msg.msgSize = writer.Position;
}
s_ReadyConnection.Send(0x25, msg);
return(true);
}
public override void Serialize(UnityEngine.Networking.NetworkWriter writer)
{
writer.Write(slotId);
writer.Write(loadedState);
}
public virtual void Serialize(UnityEngine.Networking.NetworkWriter writer)
{
writer.Write(_setId);
writer.Write(_currentVariantIndex);
writer.Write(_panelLabel);
}
