public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(width);
writer.WriteInt(height);
writer.WriteFloat(playerForce);
writer.WriteFloat(bulletVelocity);
}
protected override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteFloat(Position.x);
writer.WriteFloat(Position.y);
writer.WriteFloat(Position.z);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte(fillType ? (byte)1 : (byte)0);
writer.WriteFloat(centerX);
writer.WriteFloat(centerY);
writer.WriteFloat(radius);
writer.WriteInt((int)shape);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(this.horizMove);
writer.WriteFloat(this.vertMove);
writer.WriteFloat(this.targetPitch);
writer.WriteFloat(this.targetYaw);
writer.WriteByte(this.jump);
writer.WriteByte(this.interact);
writer.WriteByte(this.sprint);
}
public static void WriteVector3ListToStream(List <Vector3> vector3s, ref DataStreamWriter writer)
{
writer.WriteInt(vector3s.Count);
foreach (Vector3 vector3 in vector3s)
{
writer.WriteFloat(vector3.x);
writer.WriteFloat(vector3.y);
writer.WriteFloat(vector3.z);
}
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(checkTick);
writer.WriteInt(renderTick);
writer.WriteInt((int)(moveYaw * 10));
writer.WriteInt((int)(moveMagnitude * 100));
writer.WriteUInt((uint)buttons.flags);
writer.WriteFloat(lookYaw);
writer.WriteFloat(lookPitch);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(shoot);
writer.WriteInt(shootID);
writer.WriteInt(check);
writer.WriteInt(autoMove);
writer.WriteInt(autoSpawn);
writer.WriteInt(revive);
writer.WriteInt(ballscheck);
writer.WriteInt(vertical);
writer.WriteFloat(zMov);
writer.WriteFloat(xMov);
writer.WriteFloat(yRot);
writer.WriteFloat(xRot);
writer.WriteFloat(currentCameraRotationX);
}
public void DenyGameAction(GameAction gameAction, GameAction.IParameters parameters, int actorNumber,
float triggerTime)
{
if (State == ServerState.Debug)
{
return;
}
if (State != ServerState.Started)
{
throw new InvalidOperationException($"Cannot deny {gameAction}: Server not running");
}
var streamWriter = new DataStreamWriter(MaxBytesPerMessage, Allocator.Temp);
streamWriter.WriteInt(Commands.GameAction);
streamWriter.WriteInt(GameActionManager.Instance.GetID(gameAction));
streamWriter.WriteInt(actorNumber);
streamWriter.WriteFloat(triggerTime);
streamWriter.WriteBool(false); // invalid
gameAction.SerializeParameters(ref streamWriter, parameters);
for (var i = 0; i < _connections.Length; i++)
{
if (_connections[i].InternalId == actorNumber)
{
DataStreamWriter writer = _serverDriver.BeginSend(_reliablePipeline, _connections[i]);
writer.WriteBytes(streamWriter.AsNativeArray());
_serverDriver.EndSend(writer);
}
}
}
public void SendRPC(NetBehaviour netBehaviour, string methodName, object[] args)
{
if (State == ServerState.Debug)
{
return;
}
if (State != ServerState.Started)
{
throw new InvalidOperationException($"Cannot send rpc {methodName}: Server not running");
}
var streamWriter = new DataStreamWriter(MaxBytesPerMessage, Allocator.Temp);
{
streamWriter.WriteInt(Commands.NetObjectRPC);
streamWriter.WriteFloat(Time);
streamWriter.WriteInt(netBehaviour.NetObject.ID);
streamWriter.WriteUShort(netBehaviour.NetBehaviourID);
NetObjectManager.Instance.SerializeRPC(ref streamWriter, netBehaviour, methodName, args);
for (var i = 0; i < _connections.Length; i++)
{
DataStreamWriter writer = _serverDriver.BeginSend(_reliablePipeline, _connections[i]);
writer.WriteBytes(streamWriter.AsNativeArray());
_serverDriver.EndSend(writer);
}
}
}
private byte[] SerializeParams()
{
var writer = new DataStreamWriter(1000, Allocator.Temp);
for (var i = 0; i < _animator.parameterCount; i++)
{
switch (_animatorControllerParameters[i].type)
{
case AnimatorControllerParameterType.Float:
writer.WriteFloat(_animator.GetFloat(_animatorControllerParameters[i].nameHash));
break;
case AnimatorControllerParameterType.Int:
writer.WriteInt(_animator.GetInteger(_animatorControllerParameters[i].nameHash));
break;
case AnimatorControllerParameterType.Bool:
case AnimatorControllerParameterType.Trigger:
writer.WriteBool(_animator.GetBool(_animatorControllerParameters[i].nameHash));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(writer.AsNativeArray().ToArray());
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(pilotSettings.Length);
for (int i = 0; i < pilotSettings.Length; i++)
{
writer.WriteFloat(pilotSettings[i]);
}
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(buildX);
writer.WriteFloat(buildZ);
writer.WriteFloat(destinationX);
writer.WriteFloat(destinationZ);
writer.WriteFloat(selectionX1);
writer.WriteFloat(selectionZ1);
writer.WriteFloat(selectionX2);
writer.WriteFloat(selectionZ2);
}
public static void Serialize(PilotSettings serverVariables, ref DataStreamWriter writer)
{
var varibles = typeof(PilotSettings).GetFields();
for (int i = 0; i < varibles.Length; i++)
{
if (varibles[i].FieldType == typeof(float))
{
writer.WriteFloat((float)typeof(PilotSettings).GetField(varibles[i].Name).GetValue(serverVariables));
}
}
var speedVaribles = typeof(PilotSettings.Speeds).GetFields();
for (int i = 0; i < speedVaribles.Length; i++)
{
if (speedVaribles[i].FieldType == typeof(float))
{
writer.WriteFloat((float)typeof(PilotSettings.Speeds).GetField(speedVaribles[i].Name).GetValue(serverVariables.speeds));
}
}
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(positon.x);
writer.WriteFloat(positon.y);
writer.WriteFloat(positon.z);
writer.WriteFloat(rotation.value.x);
writer.WriteFloat(rotation.value.y);
writer.WriteFloat(rotation.value.z);
writer.WriteFloat(rotation.value.w);
}
protected override void Serialize(ref DataStreamWriter writer, byte dirtyMask)
{
if (IsDirtyAt(dirtyMask, 0))
{
writer.WriteInt(_paramBytes.Length);
writer.WriteBytes(new NativeArray <byte>(_paramBytes, Allocator.Temp));
}
if (IsDirtyAt(dirtyMask, 1))
{
writer.WriteInt(_currentStateHash);
writer.WriteFloat(_currentEnterTime);
}
}
public virtual void SerializePosition(ref DataStreamWriter writer)
{
// Position
writer.WriteFloat(Entity.Position.x);
writer.WriteFloat(Entity.Position.y);
writer.WriteFloat(Entity.Position.z);
// Rotation
writer.WriteFloat(Entity.Rotation.x);
writer.WriteFloat(Entity.Rotation.y);
writer.WriteFloat(Entity.Rotation.z);
writer.WriteFloat(Entity.Rotation.w);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(type);
writer.WriteUInt(tick);
if ((type & 0b1) != 0)
{
writer.WriteFloat(location.x);
writer.WriteFloat(location.y);
}
if ((type & 0b10) != 0)
{
writer.WriteFloat(orientation.x);
writer.WriteFloat(orientation.y);
}
if ((type & 0b100) != 0)
{
writer.WriteInt(ghostId);
}
if ((type & 0b1000) != 0)
{
writer.WriteFloat(angle);
}
if ((type & 0b10000) != 0)
{
//pass (rotate left)
}
if ((type & 0b100000) != 0)
{
//pass (rotate right)
}
if ((type & 0b10000000) != 0)
{
writer.WriteInt(ghostId_released);
}
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(origin.x);
writer.WriteFloat(origin.y);
writer.WriteFloat(origin.z);
writer.WriteFloat(direction.x);
writer.WriteFloat(direction.y);
writer.WriteFloat(direction.z);
writer.WriteUInt(lastFire);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(ox);
writer.WriteFloat(oy);
writer.WriteFloat(oz);
writer.WriteFloat(vx);
writer.WriteFloat(vy);
writer.WriteFloat(vz);
writer.WriteInt(playerId);
}
protected override void Serialize(ref DataStreamWriter writer, byte dirtyMask)
{
var mask = (DirtyMask)dirtyMask;
if (dirtyMask != 0)
{
writer.WriteFloat(_lastUpdateTime);
}
if (mask.HasFlag(DirtyMask.Position))
{
writer.WriteVector3(_latestPosition);
}
if (mask.HasFlag(DirtyMask.Rotation))
{
writer.WriteQuaternion(_latestRotation);
}
}
public void SendPing()
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
Debug.LogWarning($"Cannot send messages in client state {State}");
return;
}
DataStreamWriter writer = _clientDriver.BeginSend(_unreliablePipeline, _clientToServerConnection);
writer.WriteInt(Commands.Ping);
writer.WriteFloat(Time.time);
_clientDriver.EndSend(writer);
DataSent?.Invoke(writer.Length);
}
public void SendRPC(NetAsset netAsset, string methodName, object[] args)
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
throw new InvalidOperationException($"Cannot send rpc {methodName}: not connected");
}
DataStreamWriter streamWriter = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
streamWriter.WriteInt(Commands.NetAssetRPC);
streamWriter.WriteFloat(Server.Time);
streamWriter.WriteInt(netAsset.NetID);
netAsset.SerializeRPC(ref streamWriter, methodName, args);
_clientDriver.EndSend(streamWriter);
DataSent?.Invoke(streamWriter.Length);
}
public void SendGameAction(GameAction gameAction, GameAction.IParameters parameters)
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
throw new InvalidOperationException($"Cannot send game action {gameAction}: not connected");
}
DataStreamWriter streamWriter = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
streamWriter.WriteInt(Commands.GameAction);
streamWriter.WriteInt(GameActionManager.Instance.GetID(gameAction));
streamWriter.WriteInt(ActorNumber);
streamWriter.WriteFloat(Server.Time);
gameAction.SerializeParameters(ref streamWriter, parameters);
_clientDriver.EndSend(streamWriter);
DataSent?.Invoke(streamWriter.Length);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(intValue);
writer.WriteShort(shortValue);
writer.WriteFloat(floatValue);
}
public static void WriteScoreUpdate(ServerBehaviour sender, ref DataStreamWriter writer)
{
writer.WriteFloat(sender.latestDamageData.m_damage);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(this.Size);
writer.WriteInt(this.ChunkResolution);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(angleH);
writer.WriteFloat(angleV);
writer.WriteFloat(speed);
}
private static void WritePlayerTakesDamage(ServerBehaviour sender, ref DataStreamWriter writer)
{
writer.WriteInt(sender.latestDamageData.m_receiver.ID);
writer.WriteInt(sender.latestDamageData.m_dealer.ID);
writer.WriteFloat(sender.latestDamageData.m_damage);
}
public static void WriteVector2(ref DataStreamWriter writer, Vector2 input)
{
writer.WriteFloat(input.x);
writer.WriteFloat(input.y);
}
private void ReadDataEvent(NetworkConnection connection, DataStreamReader streamReader)
{
try
{
int senderActorNumber = connection.InternalId;
int command = streamReader.ReadInt();
switch (command)
{
case Commands.AcknowledgeActorNumber:
{
if (_acceptAllPlayers)
{
AcceptPlayer(senderActorNumber);
}
break;
}
case Commands.PlayerData:
{
string playerData = streamReader.ReadManagedString();
PlayerDataReceived?.Invoke(senderActorNumber, playerData);
break;
}
case Commands.Ping:
_lastPingTimes[connection] = Time;
float sendLocalTime = streamReader.ReadFloat();
DataStreamWriter writer = _serverDriver.BeginSend(_unreliablePipeline, connection);
writer.WriteInt(Commands.Ping);
writer.WriteFloat(sendLocalTime);
writer.WriteFloat(Time);
writer.WriteFloat(UnityEngine.Time.deltaTime);
_serverDriver.EndSend(writer);
break;
case Commands.RequestSpawnMessage:
{
var connections = new NativeList <NetworkConnection>(1, Allocator.Temp)
{
connection
};
SendSpawnMessage(NetObjectManager.Instance.NetObjects, connections);
connections.Dispose();
break;
}
case Commands.UpdateNetObjects:
{
int objectsInMessage = streamReader.ReadInt();
for (var obj = 0; obj < objectsInMessage; obj++)
{
int netObjID = streamReader.ReadInt();
int size = streamReader.ReadInt();
NetObject netObject = NetObjectManager.Instance.Exists(netObjID)
? NetObjectManager.Instance.Get(netObjID)
: null;
// ignore illegal updates and those from local host client
if (netObject == null ||
netObject.OwnerActorNumber != senderActorNumber || // cheater?
Client.IsHost && Client.Instance.ActorNumber == senderActorNumber)
{
streamReader.DiscardBytes(size);
}
else
{
int bytesRead = streamReader.GetBytesRead();
try
{
netObject.Deserialize(ref streamReader, b => b.ClientAuthoritative);
}
catch (Exception e)
{
Debug.LogException(e);
int remainingBytes = size + bytesRead - streamReader.GetBytesRead();
streamReader.DiscardBytes(remainingBytes);
}
}
}
break;
}
case Commands.GameAction:
{
int gameActionID = streamReader.ReadInt();
int actorNumber = streamReader.ReadInt();
float triggerTime = streamReader.ReadFloat();
try
{
GameAction gameAction = GameActionManager.Instance.Get(gameActionID);
GameAction.IParameters parameters =
gameAction.DeserializeParameters(ref streamReader);
gameAction.ReceiveOnServer(parameters, actorNumber, senderActorNumber,
triggerTime);
break;
}
catch (Exception e)
{
Debug.LogException(e);
break;
}
}
case Commands.NetAssetRPC:
{
float sentServerTime = streamReader.ReadFloat();
int netAssetID = streamReader.ReadInt();
NetAsset netAsset = NetAssetManager.Instance.Get(netAssetID);
NetAsset.RPC rpc = netAsset.DeserializeRPC(ref streamReader);
var messageInfo = new MessageInfo
{
SentServerTime = sentServerTime, SenderActorNumber = senderActorNumber
};
rpc.Invoke(messageInfo);
break;
}
case Commands.NetObjectRPC:
{
float sentServerTime = streamReader.ReadFloat();
int netObjectID = streamReader.ReadInt();
if (!NetObjectManager.Instance.Exists(netObjectID))
{
Debug.LogWarning("Ignoring received RPC, because NetObject was not found.");
break;
}
NetObject netObject = NetObjectManager.Instance.Get(netObjectID);
ushort netBehaviourID = streamReader.ReadUShort();
NetBehaviour netBehaviour = netObject.Get(netBehaviourID);
NetObjectManager.RPC rpc =
NetObjectManager.Instance.DeserializeRPC(ref streamReader, netBehaviour);
var messageInfo = new MessageInfo
{
SentServerTime = sentServerTime, SenderActorNumber = senderActorNumber
};
rpc.Invoke(messageInfo);
break;
}
default:
Debug.LogException(new NetException($"Unknown command {command}"));
break;
}
}
catch (Exception e)
{
Debug.LogException(new NetException("Failed to handle data event", e));
}
}