public void NetworkSerialize(NetworkSerializer serializer)
{
if (serializer.IsReading)
{
float[] statValuesArray = null;
serializer.Serialize(ref statValuesArray);
StatValues = new List <float>(statValuesArray);
}
else
{
float[] statValuesArray = StatValues?.ToArray() ?? new float[0];
serializer.Serialize(ref statValuesArray);
}
}
public void UpdateInfo(Action _callback)
{
if (Network.peerType == NetworkPeerType.Disconnected)
{
if (_callback != null)
{
_callback();
}
return;
}
m_UpdateInfoCallbacks += _callback;
if (m_IsUpdatingInfo)
{
return;
}
m_IsUpdatingInfo = true;
var _playerInfoSerial = NetworkSerializer.Serialize(mine);
networkView.RPC("PlayerManager_RequestUpdateInfo", RPCMode.Others, Network.player, _playerInfoSerial);
if (Network.isServer)
{
PlayerManager_ResponseUpdateInfo();
}
}
public void NetworkSerialize(NetworkSerializer serializer)
{
int paramCount = serializer.IsReading ? 0 : Parameters.Count;
serializer.Serialize(ref paramCount);
var paramArray = serializer.IsReading ? new KeyValuePair <int, (AnimatorControllerParameterType Type, object Boxed)> [paramCount] : Parameters.ToArray();
/// <summary>
/// Serializes the number of packets lost.
/// </summary>
/// <returns>The serialization of the network.</returns>
public byte[] Serialize()
{
var l = new List <byte>(NetworkSerializer.Serialize((uint)Lost));
l.RemoveAt(0);
return(l.ToArray());
}
private void ReadyManager_PollReadyInfoRequest(NetworkPlayer _player)
{
var _readyInfo = new List <string>(m_ReadyInfo);
networkView.RPC("ReadyManager_PollReadyInfoResponse", _player,
NetworkSerializer.Serialize(_readyInfo));
}
public void NetworkSerialize(NetworkSerializer serializer)
{
serializer.Serialize(ref Index);
serializer.Serialize(ref EnemyId);
serializer.Serialize(ref GeneratePointX);
serializer.Serialize(ref GeneratePointY);
serializer.Serialize(ref AppearPointX);
serializer.Serialize(ref AppearPointY);
serializer.Serialize(ref DisappearPointX);
serializer.Serialize(ref DisappearPointY);
}
public void RequestStartGame(GameTransition _transition)
{
if (!Network.isServer)
{
Debug.Log("Only server can start the game!");
return;
}
networkView.RPC("TransitionManager_RequestStartGame", RPCMode.All, NetworkSerializer.Serialize(_transition));
}
public void RequestStartScene(SceneTransition _transition)
{
if (!Network.isServer)
{
Debug.Log("Only server is allowed to transfer to scene " + _transition.scene);
return;
}
networkView.RPC("TransitionManager_RequestStartScene", RPCMode.All, NetworkSerializer.Serialize(_transition));
}
public override byte[] Serialize()
{
base.Serialize();
using var ms = new MemoryStream();
ms.Write(NetworkSerializer.Serialize(SSRC));
foreach (var block in RR_Block_list)
{
ms.Write(block.Serialize());
}
return(ms.ToArray());
}
public override byte[] Serialize()
{
base.Serialize();
using var writer = new MemoryStream();
writer.Write(NetworkSerializer.Serialize(SRC));
foreach (var i in items)
{
writer.Write(i.Serialize());
}
return(writer.ToArray());
}
void ListenInfoChanged(PlayerInfo _playerInfo)
{
if (Network.peerType == NetworkPeerType.Disconnected)
{
InformPlayerInfoChangedLocal(_playerInfo);
}
else
{
var _playerInfoSerial = NetworkSerializer.Serialize(_playerInfo);
networkView.RPC("PlayerManager_InformPlayerInfoChanged", RPCMode.All, _playerInfoSerial);
}
}
public override byte[] Serialize()
{
using var ms = new MemoryStream();
byte[] b = new byte[2];
b[0] |= 2 << 6;
b[0] |= (byte)(this.Padding ? 1 : 0);
b[0] |= Count;
b[1] = (byte)Type;
ms.Write(b);
ms.Write(NetworkSerializer.Serialize(Length));
//ms.Write(NetworkSerializer.Serialize(SSRC));
return(ms.ToArray());
}
void PlayerManager_RequestRefreshPlayerInfo(NetworkPlayer _player)
{
foreach (var _playerInfo in players)
{
if (_playerInfo.Key == _player.guid)
{
continue;
}
var _playerInfoStr = NetworkSerializer.Serialize(_playerInfo.Value);
networkView.RPC("PlayerManager_ResponseRefreshPlayerInfo", _player, _playerInfoStr);
}
networkView.RPC("PlayerManager_ResponseRefreshPlayerInfoDone", _player);
}
public override byte[] Serialize()
{
byte[] b = new byte[4 * SRC.Length];
using (BinaryWriter bw = new BinaryWriter(new MemoryStream(b)))
{
foreach (uint i in SRC)
{
bw.Write(NetworkSerializer.Serialize(i));
}
}
return(b);
}
public byte[] Serialize()
{
var b = new byte[24];
using var writer = new BinaryWriter(new MemoryStream(b));
writer.Write(NetworkSerializer.Serialize(SSRC));
writer.Write(this.Fraction);
writer.Write(this.mLost.Serialize());
writer.Write(NetworkSerializer.Serialize(LastSequence));
writer.Write(NetworkSerializer.Serialize(Jitter));
writer.Write(NetworkSerializer.Serialize(LastSource));
writer.Write(NetworkSerializer.Serialize(DelayLastSource));
return(b);
}
public void NetworkSerialize(NetworkSerializer serializer)
{
serializer.Serialize(ref ClientId);
serializer.Serialize(ref PlayerName);
serializer.Serialize(ref PlayerNum);
serializer.Serialize(ref SeatState);
serializer.Serialize(ref SeatIdx);
serializer.Serialize(ref LastChangeTime);
}
public void Propagate()
{
if (!Network.isServer)
{
Debug.LogWarning("Only server can propagate results!");
return;
}
if (!IsLatest())
{
FillIn();
}
game.networkView.RPC("GameResult_Propagate", RPCMode.All, gameID, NetworkSerializer.Serialize(results));
}
public override byte[] Serialize()
{
using (var ms = new MemoryStream())
{
ms.Write(NetworkSerializer.Serialize(SSRC));
ms.Write(NetworkSerializer.Serialize(NTP_Timestamp));
ms.Write(NetworkSerializer.Serialize(NTP_Fraction));
ms.Write(NetworkSerializer.Serialize(RTP_Timestamp));
ms.Write(NetworkSerializer.Serialize(Packets_Sent));
ms.Write(NetworkSerializer.Serialize(Octets_Sent));
foreach (var v in RR_Block)
{
ms.Write(v.Serialize());
}
return(ms.ToArray());
}
}
public void NetworkSerialize(NetworkSerializer serializer)
{
PackFlags flags = PackFlags.None;
if (!serializer.IsReading)
{
flags = GetPackFlags();
}
serializer.Serialize(ref ActionTypeEnum);
serializer.Serialize(ref flags);
if (serializer.IsReading)
{
ShouldQueue = (flags & PackFlags.ShouldQueue) != 0;
CancelMovement = (flags & PackFlags.CancelMovement) != 0;
ShouldClose = (flags & PackFlags.ShouldClose) != 0;
}
if ((flags & PackFlags.HasPosition) != 0)
{
serializer.Serialize(ref Position);
}
if ((flags & PackFlags.HasDirection) != 0)
{
serializer.Serialize(ref Direction);
}
if ((flags & PackFlags.HasTargetIds) != 0)
{
serializer.Serialize(ref TargetIds);
}
if ((flags & PackFlags.HasAmount) != 0)
{
serializer.Serialize(ref Amount);
}
}
public void NetworkSerialize(NetworkSerializer serializer) => serializer.Serialize(ref Value);
void PlayerManager_RequestRefreshPlayerInfo(NetworkPlayer _player)
{
var _playerInfosStr = NetworkSerializer.Serialize(players);
networkView.RPC("PlayerManager_ResponseRefreshPlayerInfo", _player, _playerInfosStr);
}
public void NetworkSerialize(NetworkSerializer serializer)
{
serializer.Serialize(ref ChuzaCoins);
serializer.Serialize(ref DoggaCoins);
}
public string Serialize()
{
return(NetworkSerializer.Serialize(this)
+ Serializer.serialize(velocity));
}
