public void Deserialize(NetDataReader reader)
{
error = (Error)reader.GetByte();
sceneName = reader.GetString();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
sceneName = reader.GetString();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
connectKey = reader.GetString();
}
public void OnNetworkReceive(NetPeer _netPeer, NetDataReader _netDataReader)
{
try
{
if (_netDataReader.Data == null)
{
return;
}
NetworkTags networkTag = (NetworkTags)_netDataReader.GetInt();
if (networkTag == NetworkTags.NT_S_Receiv_Player_Position)
{
float x = _netDataReader.GetFloat();
float y = _netDataReader.GetFloat();
float z = _netDataReader.GetFloat();
Console.WriteLine($"netPeer.ConnectId --> {_netPeer.ConnectId} Got pos packet : {x} | {y} | {z} ");
_dictionary_Server_Players_Pose[_netPeer.ConnectId].X = x;
_dictionary_Server_Players_Pose[_netPeer.ConnectId].Y = y;
_dictionary_Server_Players_Pose[_netPeer.ConnectId].Z = z;
_dictionary_Server_Players_Pose[_netPeer.ConnectId].Moved = true;
}
}
catch (Exception ex)
{
Console.WriteLine($"OnNetworkReceive Error: {ex.Message}");
}
}
public void Deserialize(NetDataReader reader)
{
_packetVersion = reader.GetByte();
SampleRate = reader.GetInt();
Channels = reader.GetByte();
Codec = Encoding.UTF8.GetString(reader.GetBytesWithLength());
}
private async Task HandleJoinProjectSuccess(NetPeer peer, NetDataReader reader)
{
var projectId = Guid.ParseExact(reader.GetString(), "N");
var joinResult = (JoinResult)reader.GetInt();
if (joinResult == JoinResult.ClientRequiresUpdate)
{
var downloadUrl = $"{_uoStudioApiBaseUrl}api/file/{projectId:N}";
var tempFileName = Path.GetTempFileName();
var httpClientProgressWrapper = new HttpClientProgressWrapper(_httpClient, downloadUrl, tempFileName, projectId);
httpClientProgressWrapper.ProgressChanged += HttpClientProgressChanged;
httpClientProgressWrapper.ProgressCompleted += HttpClientProgressWrapperOnProgressCompleted;
await httpClientProgressWrapper.StartDownload().ConfigureAwait(false);
/*
* if (response.IsSuccessStatusCode)
* {
*
* }
* else
* {
* var joinProjectFailed = JoinProjectFailed;
* joinProjectFailed?.Invoke("");
* }
*/
}
else
{
var projectPath = Path.Combine(_projectsPath, projectId.ToString("N"));
Directory.CreateDirectory(projectPath);
var joinProjectSuccessful = JoinProjectSuccessful;
joinProjectSuccessful?.Invoke(projectPath);
}
}
protected override void OnHandleMessage(NetDataReader reader)
{
int unitCount = reader.GetInt();
for (int i = 0; i < unitCount; i++)
{
UnitData unitData = MessageSerializerService.DeserializeObjectOfType <UnitData>(reader.GetString());
UnitController newUnit = ((GameObject)Instantiate(Resources.Load("Objects/Player"),
new Vector3(unitData.PositionData.X, unitData.PositionData.Y, unitData.PositionData.Z),
Quaternion.identity)).GetComponent <UnitController>();
NetObject netObject = newUnit.gameObject.GetComponent <NetObject>();
netObject.Id = unitData.UnitId;
newUnit.Health = unitData.Health;
newUnit.MoveSpeed = unitData.MoveSpeed;
newUnit.MinDamage = unitData.MinDamage;
newUnit.MaxDamage = unitData.MaxDamage;
newUnit.AttackRadius = unitData.AttackRadius;
ClientNetEventListener.Instance.NetObjects.Add(unitData.UnitId, netObject);
BattleManager.Instance.EnemyUnits.Add(i, newUnit);
}
BattleManager.Instance.StartSession();
}
public void Deserialize(NetDataReader reader)
{
id = reader.GetInt();
name = reader.GetString(50);
ready = reader.GetBool();
active = reader.GetBool();
}
public void Deserialize(NetDataReader reader)
{
type = (BuffType)reader.GetByte();
dataId = reader.GetInt();
level = reader.GetShort();
buffRemainsDuration = reader.GetFloat();
}
public void Deserialize(NetDataReader reader)
{
message = (UITextKeys)reader.GetPackedUShort();
sceneName = reader.GetString();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
}
public override void DeserializeData(NetDataReader reader)
{
peerInfo = new CentralServerPeerInfo();
peerInfo.Deserialize(reader);
time = reader.GetInt();
hash = reader.GetString();
}
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;
}
}
public void Deserialize(NetDataReader reader)
{
instanceID = reader.GetInt();
UNIQUE_ID = reader.GetString();
position = reader.GetVector3();
eulerAngles = reader.GetVector3();
}
public void OnNetworkReceive(NetPeer peer, NetDataReader reader)
{
if (reader.RawData == null)
{
return;
}
Debug.Log("Client: " + reader.RawData.Length);
if (reader.RawData.Length >= 4)
{
NetworkTags netTag = (NetworkTags)reader.GetInt();
if (netTag == NetworkTags.PlayerPositionsArray)
{
int lengthArray = (reader.RawData.Length - 4) / (sizeof(long) + sizeof(float) * 3);
Debug.Log("Positions array data num: " + lengthArray);
for (int i = 0; i < lengthArray; i++)
{
long playerId = reader.GetLong();
if (!netDictionary.ContainsKey(playerId))
{
netDictionary.Add(playerId, new NetPlayer());
}
netDictionary[playerId].X = reader.GetFloat();
netDictionary[playerId].Y = reader.GetFloat();
netDictionary[playerId].Z = reader.GetFloat();
}
}
}
}
private void ReadFields(NetDataReader reader, int length, int frame, bool discardOutOfOrderPackets)
{
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, startPosition + length, arbiter, frame, discardOutOfOrderPackets, false);
}
else
{
world.statefulObjects[id].ReadStateFields(reader, startPosition + length, arbiter, frame, discardOutOfOrderPackets, true);
}
}
}
public static void LoadServerData()
{
string path = GameConfig.gameSaveFolder + DSPGame.LoadFile + FILE_EXTENSION;
PlayerManager playerManager = MultiplayerHostSession.Instance.PlayerManager;
if (!File.Exists(path) || playerManager == null)
{
return;
}
byte[] source = File.ReadAllBytes(path);
NetDataReader netDataReader = new NetDataReader(source);
int playerNum = netDataReader.GetInt();
using (playerManager.GetSavedPlayerData(out var savedPlayerData))
{
for (int i = 0; i < playerNum; i++)
{
string hash = netDataReader.GetString();
PlayerData playerData = netDataReader.Get <PlayerData>();
if (!savedPlayerData.ContainsKey(hash))
{
savedPlayerData.Add(hash, playerData);
}
}
}
}
public override void OnMessage(NetPeer peer, NetDataReader reader)
{
var count = reader.GetInt();
for (int i = 0; i < count; i++)
{
var npcid = reader.GetLong();
var npcType = (NpcType)reader.GetUShort();
var position = reader.GetVector3();
var rotation = reader.GetQuaternion();
NPCView npcView = null;
switch (npcType)
{
case NpcType.Player:
npcView = npcMgr.CreateNpc <TankView>();
break;
case NpcType.Monster:
npcView = npcMgr.CreateNpc <AnimalView>();
break;
}
if (npcView != null)
{
npcView.Initialize(npcid);
npcView.InitInterpolateFields(position, rotation);
}
Debugger.LogWarning("OnResNpcs--->>>" + npcid + " " + npcType + " " + position);
}
}
protected void ParseProtoBytes(NetDataReader reader, ref string name, ref byte[] bytes)
{
var protoName = reader.GetString();
var count = reader.GetInt();
reader.GetBytes(bytes, count);
}
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, WorldManager.Inst.textureFormat, false);
buffer = new byte[w * h * Utils.SomeTextureFormatsToBytes(WorldManager.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)
{
Error = reader.GetString();
Success = reader.GetByte();
ArmyId = reader.GetInt();
Destination = reader.Get <Coord>();
}
public void Deserialize(NetDataReader reader)
{
var count = reader.GetInt();
Clear();
for (var i = 0; i < count; ++i)
{
var dealingItem = new DealingCharacterItem();
dealingItem.nonEquipIndex = reader.GetInt();
dealingItem.dataId = reader.GetInt();
dealingItem.level = reader.GetShort();
dealingItem.amount = reader.GetShort();
dealingItem.durability = reader.GetFloat();
Add(dealingItem);
}
}
public void Deserialize(NetDataReader reader)
{
pid = reader.GetUInt();
username = reader.GetString();
level = reader.GetString();
position = reader.GetVector2();
animationState = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
int numQuadrants = reader.GetInt();
byte[] bytes = new byte[ByteLength(numQuadrants)];
reader.GetBytes(bytes, bytes.Length);
this.QuadrantList = ByteArrayToQuadrantList(bytes, numQuadrants);
}
public override void OnRead(NetDataReader reader)
{
MatchStarted = reader.GetBool();
GoldenGoal = reader.GetBool();
ElapsedMatchTime = reader.GetFloat();
MatchLength = reader.GetInt();
MaxPlayers = reader.GetInt();
ServerName = reader.GetString();
Teams[TEAM_TYPE.TEAM_1].Color = reader.GetColor();
Teams[TEAM_TYPE.TEAM_1].Name = reader.GetString();
Teams[TEAM_TYPE.TEAM_1].Score = reader.GetInt();
Teams[TEAM_TYPE.TEAM_2].Color = reader.GetColor();
Teams[TEAM_TYPE.TEAM_2].Name = reader.GetString();
Teams[TEAM_TYPE.TEAM_2].Score = reader.GetInt();
}
public void Deserialize(NetDataReader reader)
{
BattleId = Guid.Parse(reader.GetString());
CurrentArmyId = reader.GetInt();
CurrentUnitId = reader.GetInt();
var armiesLength = reader.GetUShort();
Armies = new ArmyParams[armiesLength];
for (int i = 0; i < armiesLength; i++)
{
Armies[i] = reader.Get <ArmyParams>();
}
GameId = reader.GetInt();
GameString = reader.GetString();
}
void OnNetworkReceivedHandler(byte networkDataType, NetDataReader reader, int clientId)
{
if (networkDataType == NetworkDataType.NetworkInstantiate)
{
int objectId = reader.GetInt();
string prefabName = reader.GetString();
float posX = reader.GetFloat();
float posY = reader.GetFloat();
float posZ = reader.GetFloat();
float rotX = reader.GetFloat();
float rotY = reader.GetFloat();
float rotZ = reader.GetFloat();
float rotW = reader.GetFloat();
NetworkInstantiate(clientId, objectId, prefabName, posX, posY, posZ, rotX, rotY, rotZ, rotW);
}
if (networkDataType == NetworkDataType.UpdateObjectPose)
{
string groupName = reader.GetString();
int dataNum = reader.GetInt();
if (!_NetworkObjectDictionary.ContainsKey(groupName))
{
return;
}
Vector3 position = Vector3.zero;
Quaternion rotation = Quaternion.identity;
for (int i = 0; i < dataNum; i++)
{
int objectId = reader.GetInt();
position.x = reader.GetFloat();
position.y = reader.GetFloat();
position.z = reader.GetFloat();
rotation.x = reader.GetFloat();
rotation.y = reader.GetFloat();
rotation.z = reader.GetFloat();
rotation.w = reader.GetFloat();
if (_NetworkObjectDictionary[groupName].ContainsKey(objectId))
{
_NetworkObjectDictionary[groupName][objectId].transform.SetPositionAndRotation(position, rotation);
}
}
}
}
public override void DeserializeData(NetDataReader reader)
{
error = (Error)reader.GetByte();
sceneName = reader.GetString();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
connectKey = reader.GetString();
}
public void Execute(NetDataReader reader, int netId)
{
int playerId = reader.GetInt();
OccupationType ocp = (OccupationType)reader.GetByte();
string name = reader.GetString();
GL_User.s_instance.CommandCreateCharacter(netId, playerId, ocp, name);
}
public void Deserialize(NetDataReader reader)
{
hashAssetId = reader.GetInt();
objectId = reader.GetPackedUInt();
connectionId = reader.GetLong();
position = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
rotation = Quaternion.Euler(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
}
public void Deserialize(NetDataReader reader)
{
peerType = (CentralServerPeerType)reader.GetByte();
networkAddress = reader.GetString();
networkPort = reader.GetInt();
connectKey = reader.GetString();
extra = reader.GetString();
}
public void Deserialize(NetDataReader reader)
{
nonEquipIndex = reader.GetInt();
CharacterItem tempCharacterItem = new CharacterItem();
tempCharacterItem.Deserialize(reader);
characterItem = tempCharacterItem;
}
