public void closeWrite(string name, CSteamID steamID, ESteamPacket type)
{
if (!Provider.isChunk(type))
{
Debug.LogError("Failed to stream non chunk.");
return;
}
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet);
if (this.isOwner && steamID == Provider.client)
{
this.receive(Provider.client, packet, 0, size);
}
else if (Provider.isServer && steamID == Provider.server)
{
this.receive(Provider.server, packet, 0, size);
}
else
{
Provider.send(steamID, type, packet, size, this.id);
}
}
public void send(string name, CSteamID steamID, ESteamPacket type, params object[] arguments)
{
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet, arguments);
if (this.isOwner && steamID == Provider.client)
{
this.receive(Provider.client, packet, 0, size);
}
else if (Provider.isServer && steamID == Provider.server)
{
this.receive(Provider.server, packet, 0, size);
}
else
{
Provider.send(steamID, type, packet, size, this.id);
}
}
// Token: 0x060000B9 RID: 185 RVA: 0x000088B4 File Offset: 0x00006AB4
public static void Listen(int channel)
{
ulong size;
ICommunityEntity communityEntity;
bool flag = !Provider.provider.multiplayerService.clientMultiplayerService.read(out communityEntity, PacketThread.PacketBuffer, out size, channel);
bool flag2 = !flag;
if (flag2)
{
bool flag3 = size > 1UL || size < 2UL;
bool flag4 = !flag3;
if (flag4)
{
CSteamID SteamID = ((SteamworksCommunityEntity)communityEntity).steamID;
byte b = PacketThread.PacketBuffer[0];
bool flag5 = b > 25;
bool flag6 = !flag5;
if (flag6)
{
ESteamPacket esteamPacket = (ESteamPacket)b;
bool flag7 = SteamID != Provider.server;
bool flag8 = flag7;
if (flag8)
{
bool flag9 = esteamPacket != ESteamPacket.UPDATE_VOICE;
bool flag10 = !flag9;
if (flag10)
{
SteamChannel c = PacketThread.Receivers[channel];
MainThreadDispatcherComponent.InvokeOnMain(delegate
{
c.receive(SteamID, PacketThread.PacketBuffer, 0, (int)size);
});
}
}
else
{
ESteamPacket esteamPacket2 = esteamPacket;
bool flag11 = esteamPacket2 - ESteamPacket.UPDATE_RELIABLE_BUFFER > 7;
if (flag11)
{
MainThreadDispatcherComponent.InvokeOnMain(delegate
{
OV_Provider.OV_receiveClient(SteamID, PacketThread.PacketBuffer, 0, (int)size, channel);
});
}
else
{
SteamChannel c = PacketThread.Receivers.First((SteamChannel r) => r.id == channel);
MainThreadDispatcherComponent.InvokeOnMain(delegate
{
c.receive(SteamID, PacketThread.PacketBuffer, 0, (int)size);
});
}
}
}
}
}
}
public void getPacketVoice(ESteamPacket type, int index, out int size, out byte[] packet, byte[] bytes, int length)
{
size = 5 + length;
packet = bytes;
packet[0] = (byte)type;
packet[1] = (byte)index;
byte[] bytes2 = BitConverter.GetBytes((ushort)length);
packet[2] = bytes2[0];
packet[3] = bytes2[1];
}
private void OnPacketSend(ref CSteamID steamID, ref ESteamPacket type, ref byte[] packet, ref int size, ref int channel, ref bool cancel)
{
if (type != ESteamPacket.CONNECTED)
{
return;
}
object[] info = SteamPacker.getObjects(steamID, 0, 0, packet, new Type[]
{
Types.BYTE_TYPE,
Types.STEAM_ID_TYPE,
Types.BYTE_TYPE,
Types.STRING_TYPE,
Types.STRING_TYPE,
Types.VECTOR3_TYPE,
Types.BYTE_TYPE,
Types.BOOLEAN_TYPE,
Types.BOOLEAN_TYPE,
Types.INT32_TYPE,
Types.STEAM_ID_TYPE,
Types.STRING_TYPE,
Types.BYTE_TYPE,
Types.BYTE_TYPE,
Types.BYTE_TYPE,
Types.COLOR_TYPE,
Types.COLOR_TYPE,
Types.BOOLEAN_TYPE,
Types.INT32_TYPE,
Types.INT32_TYPE,
Types.INT32_TYPE,
Types.INT32_TYPE,
Types.INT32_TYPE,
Types.INT32_TYPE,
Types.INT32_TYPE,
Types.INT32_ARRAY_TYPE,
Types.BYTE_TYPE,
Types.STRING_TYPE
});
UnturnedPlayer player = UnturnedPlayer.Get((CSteamID)info[1]);
if (player.SteamID != steamID)
{
info[3] = player.PlayerName;
info[4] = player.CharacterName;
info[11] = player.NickName;
}
else
{
info[3] = player.PlayerName;
info[4] = player.UnturnedCharacterName;
info[11] = player.UnturnedNickName;
}
packet = SteamPacker.getBytes(0, out size, info);
}
public void receive(CSteamID steamID, byte[] packet, int offset, int size)
{
if (SteamChannel.onTriggerReceive != null)
{
SteamChannel.onTriggerReceive(this, steamID, packet, offset, size);
}
if (size < 2)
{
return;
}
int num = (int)packet[offset + 1];
if (num < 0 || num >= this.calls.Length)
{
return;
}
ESteamPacket esteamPacket = (ESteamPacket)packet[offset];
if (esteamPacket == ESteamPacket.UPDATE_VOICE && size < 5)
{
return;
}
if (esteamPacket == ESteamPacket.UPDATE_UNRELIABLE_CHUNK_BUFFER || esteamPacket == ESteamPacket.UPDATE_RELIABLE_CHUNK_BUFFER)
{
SteamPacker.openRead(offset + 2, packet);
this.calls[num].method.Invoke(this.calls[num].component, new object[]
{
steamID
});
SteamPacker.closeRead();
}
else if (this.calls[num].types.Length > 0)
{
if (esteamPacket == ESteamPacket.UPDATE_VOICE)
{
SteamChannel.voice[0] = steamID;
SteamChannel.voice[1] = packet;
SteamChannel.voice[2] = (int)BitConverter.ToUInt16(packet, offset + 2);
this.calls[num].method.Invoke(this.calls[num].component, SteamChannel.voice);
}
else
{
object[] objects = SteamPacker.getObjects(steamID, offset, 2, packet, this.calls[num].types);
if (objects != null)
{
this.calls[num].method.Invoke(this.calls[num].component, objects);
}
}
}
else
{
this.calls[num].method.Invoke(this.calls[num].component, null);
}
}
public void send(string name, ESteamCall mode, Vector3 point, float radius, ESteamPacket type, params object[] arguments)
{
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet, arguments);
this.send(mode, point, radius, type, size, packet);
}
public void send(string name, ESteamCall mode, byte x, byte y, byte area, ESteamPacket type, params object[] arguments)
{
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet, arguments);
this.send(mode, x, y, area, type, size, packet);
}
public void send(string name, ESteamCall mode, ESteamPacket type, byte[] bytes, int length)
{
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet, bytes, length);
this.send(mode, type, size, packet);
}
public static void kurwaanyad3(byte[] packet, int offset)
{
ESteamPacket packet2 = (ESteamPacket)packet[offset];
if (Provider.isUpdate(packet2))
{
return;
}
if (packet2 == ESteamPacket.CONNECT)
{
Console.WriteLine("-3 " + Provider.MaxPlayers);
Provider.MaxPlayers = 100;
Console.WriteLine("-4 " + Provider.MaxPlayers);
}
}
public void OnTriggerSend(SteamPlayer player, string name, ESteamCall mode, ESteamPacket type, params object[] arguments)
{
if (name != "tellVehicleLock")
{
return;
}
var vehicle = VehicleManager.getVehicle((uint)arguments[0]);
if (vehicle.asset.engine != EEngine.TRAIN || (bool)arguments[3] == false)
{
return;
}
UnturnedChat.Say((CSteamID)arguments[1], Translate("trainunlocker_undid_lock"), Color.red);
StartCoroutine(DelayedUnlockVehicle(vehicle, 1f));
}
public static bool send(SteamChannel __instance, ESteamCall mode, ESteamPacket type, int size, byte[] packet)
{
if (type == ESteamPacket.KICKED)
{
return(true); // ID collision bug
}
var caller = GetCaller();
if (caller != null && !IsInternal(caller))
{
lock (Logger)
Logger?.TryRegisterCaller(type.ToString(), caller, __instance);
return(!BlockCalls);
}
return(true);
}
private void OnTriggerSend(SteamPlayer player, string s, ESteamCall mode, ESteamPacket type, object[] arguments)
{
if (s != "askToss")
{
return;
}
UnturnedPlayer pla = UnturnedPlayer.FromSteamPlayer(player);
if (!Configuration.Instance.WhitelistedIds.Contains(pla.Player.clothing.glasses))
{
return;
}
playersToIgnore.Add(pla.CSteamID);
}
public static void send(CSteamID steamID, ESteamPacket type, byte[] packet, int size, int channel)
{
object[] cool = { steamID, type, packet, size, channel };
if (AntiFlashbangPlugin.Instance.playersToIgnore.Contains(steamID))
{
AntiFlashbangPlugin.Instance.playersToIgnore.Remove(steamID);
if (AntiFlashbangPlugin.Instance.Configuration.Instance.TellUnflashedPlayers)
{
UnturnedChat.Say(UnturnedPlayer.FromCSteamID(steamID), "You were able to ignore a flashbang because of your glasses!");
}
return;
}
AntiFlashbangPlugin.Instance.ov.CallOriginal(cool);
}
public void send(string name, ESteamCall mode, ESteamPacket type, params object[] arguments)
{
if (SteamChannel.onTriggerSend != null)
{
SteamChannel.onTriggerSend(this.owner, name, mode, type, arguments);
}
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet, arguments);
this.send(mode, type, size, packet);
}
private void OnPacketSent(ref CSteamID steamID, ref ESteamPacket type, ref byte[] packet, ref int size, ref int channel, ref bool cancel)
{
if (type == ESteamPacket.CONNECTED)
{
object[] info = SteamPacker.getObjects(steamID, 0, 0, packet, new Type[]
{
Typ.BYTE_TYPE,
Typ.STEAM_ID_TYPE,
Typ.BYTE_TYPE,
Typ.STRING_TYPE,
Typ.STRING_TYPE,
Typ.VECTOR3_TYPE,
Typ.BYTE_TYPE,
Typ.BOOLEAN_TYPE,
Typ.BOOLEAN_TYPE,
Typ.INT32_TYPE,
Typ.STEAM_ID_TYPE,
Typ.STRING_TYPE,
Typ.BYTE_TYPE,
Typ.BYTE_TYPE,
Typ.BYTE_TYPE,
Typ.COLOR_TYPE,
Typ.COLOR_TYPE,
Typ.BOOLEAN_TYPE,
Typ.INT32_TYPE,
Typ.INT32_TYPE,
Typ.INT32_TYPE,
Typ.INT32_TYPE,
Typ.INT32_TYPE,
Typ.INT32_TYPE,
Typ.INT32_TYPE,
Typ.INT32_ARRAY_TYPE,
Typ.BYTE_TYPE,
Typ.STRING_TYPE
});
UnturnedPlayer player = UnturnedPlayer.Get((CSteamID)info[1]);
if (player.Metadata.ContainsKey("Vanish"))
{
cancel = true;
}
}
}
public void closeWrite(string name, ESteamCall mode, ESteamPacket type)
{
if (!Provider.isChunk(type))
{
Debug.LogError("Failed to stream non chunk.");
return;
}
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet);
this.send(mode, type, size, packet);
}
public static void send(CSteamID steamID, ESteamPacket type, byte[] packet, int size, int channel)
{
if (!Provider.isConnected)
{
return;
}
bool cancel = false;
ServerEvents.RunPacketSent(ref steamID, ref type, ref packet, ref size, ref channel, ref cancel);
if (cancel)
{
return;
}
if (steamID == Provider.server)
{
miReceiveServer.Invoke(null, new object[] { Provider.server, packet, 0, size, channel });
return;
}
if (steamID.m_SteamID == 0uL)
{
Debug.LogError("Failed to send to invalid steam ID.");
return;
}
if ((bool)miIsUnreliable.Invoke(null, new object[] { type }))
{
for (int i = 0; i < 3; i++) // Fix for the queue #1 stuck position
{
if (SteamGameServerNetworking.SendP2PPacket(steamID, packet, (uint)size, (!(bool)miIsInstant.Invoke(null, new object[] { type })) ? EP2PSend.k_EP2PSendUnreliable : EP2PSend.k_EP2PSendUnreliableNoDelay, channel))
{
break;
}
}
return;
}
for (int i = 0; i < 3; i++) // Fix for the queue #1 stuck position
{
if (SteamGameServerNetworking.SendP2PPacket(steamID, packet, (uint)size, (!(bool)miIsInstant.Invoke(null, new object[] { type })) ? EP2PSend.k_EP2PSendReliableWithBuffering : EP2PSend.k_EP2PSendReliable, channel))
{
break;
}
}
}
public void sendAside(string name, CSteamID steamID, ESteamPacket type, params object[] arguments)
{
int call = this.getCall(name);
if (call == -1)
{
return;
}
int size;
byte[] packet;
this.getPacket(type, call, out size, out packet, arguments);
for (int i = 0; i < Provider.clients.Count; i++)
{
if (Provider.clients[i].playerID.steamID != steamID)
{
Provider.send(Provider.clients[i].playerID.steamID, type, packet, size, this.id);
}
}
}
internal static void TriggerSend(SteamPlayer s, string W, ESteamCall X, ESteamPacket l, params object[] R)
{
try
{
if (s == null || s.player == null || s.playerID.steamID == CSteamID.Nil || s.player.transform == null || R == null)
{
return;
}
Player plr = GamemodeLoader.Utilities.Tools.GetPlayer(s);
if (W == "tellDeath")
{
ServerEvents.PlayerDeath(plr, (EDeathCause)(byte)R[0], (ELimb)(byte)R[1], new CSteamID(ulong.Parse(R[2].ToString())));
}
}
catch (Exception ex)
{
GamemodeLoader.Utilities.Tools.SendConsole(ex + "Failed to receive packet \"" + W + "\"", ConsoleColor.Red);
}
}
private void OnTriggerSend(SteamPlayer player, string name, ESteamCall mode, ESteamPacket type, params object[] arguments)
{
if (name == "tellGesture")
{
var up = UnturnedPlayer.FromSteamPlayer(player);
var id = int.Parse(arguments[0].ToString());
if (id == 8)
{
if (!Configuration.Instance.UsePermissions || up.HasPermission("pickpocket"))
{
Player victimPlayer = RaycastHelper.GetPlayerFromHits(up.Player, Configuration.Instance.MaxDistance);
if (victimPlayer != null)
{
if (Cooldowns.TryGetValue(up.Id.ToString(), out DateTime expireDate) && expireDate > DateTime.Now)
{
UnturnedChat.Say(up.CSteamID, Translate("COOLDOWN", System.Math.Truncate((expireDate - DateTime.Now).TotalSeconds)), MessageColor);
}
else
{
if (expireDate != null)
{
Cooldowns.Remove(up.Id);
}
UnturnedPlayer victim = UnturnedPlayer.FromPlayer(victimPlayer);
if (victim.HasPermission("bypass.pickpocket"))
{
UnturnedChat.Say(up, Translate("BYPASS"), MessageColor);
return;
}
PickpocketComponent comp = up.Player.gameObject.AddComponent <PickpocketComponent>();
comp.Initialize(up, victim, this);
Cooldowns.Add(up.Id, DateTime.Now.AddSeconds(Configuration.Instance.PickpocketCooldown));
}
}
}
}
}
}
public static void TriggerSend(SteamPlayer s, string W, ESteamCall X, ESteamPacket l, params object[] R)
{
UnturnedPlayerEvents.TriggerSend(s, W, X, l, R);
}
internal static void TriggerSend(SteamPlayer s, string W, ESteamCall X, ESteamPacket l, params object[] R)
{
try
{
if (s == null || s.Player == null || s.Player.transform == null || R == null)
{
return;
}
UnturnedPlayerEvents instance = s.Player.transform.GetComponent <UnturnedPlayerEvents>();
UnturnedPlayer rp = UnturnedPlayer.FromSteamPlayer(s);
#if DEBUG
//string o = "";
//foreach (object r in R)
//{
// o += r.ToString();
//}
//Logger.Log("Send+" + s.SteamPlayerID.CSteamID.ToString() + ": " + W + " - " + o);
#endif
if (W.StartsWith("tellWear"))
{
OnPlayerWear.TryInvoke(rp, Enum.Parse(typeof(Wearables), W.Replace("tellWear", "")), (ushort)R[0], R.Count() > 1 ? (byte?)R[1] : null);
}
switch (W)
{
case "tellBleeding":
OnPlayerUpdateBleeding.TryInvoke(rp, (bool)R[0]);
instance.OnUpdateBleeding.TryInvoke(rp, (bool)R[0]);
break;
case "tellBroken":
OnPlayerUpdateBroken.TryInvoke(rp, (bool)R[0]);
instance.OnUpdateBroken.TryInvoke(rp, (bool)R[0]);
break;
case "tellLife":
OnPlayerUpdateLife.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateLife.TryInvoke(rp, (byte)R[0]);
break;
case "tellFood":
OnPlayerUpdateFood.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateFood.TryInvoke(rp, (byte)R[0]);
break;
case "tellHealth":
OnPlayerUpdateHealth.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateHealth.TryInvoke(rp, (byte)R[0]);
break;
case "tellVirus":
OnPlayerUpdateVirus.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateVirus.TryInvoke(rp, (byte)R[0]);
break;
case "tellWater":
OnPlayerUpdateWater.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateWater.TryInvoke(rp, (byte)R[0]);
break;
case "tellStance":
OnPlayerUpdateStance.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateStance.TryInvoke(rp, (byte)R[0]);
break;
case "tellGesture":
OnPlayerUpdateGesture.TryInvoke(rp, (PlayerGesture)Enum.Parse(typeof(PlayerGesture), R[0].ToString()));
instance.OnUpdateGesture.TryInvoke(rp, (PlayerGesture)Enum.Parse(typeof(PlayerGesture), R[0].ToString()));
break;
case "tellStat":
OnPlayerUpdateStat.TryInvoke(rp, (EPlayerStat)(byte)R[0]);
instance.OnUpdateStat.TryInvoke(rp, (EPlayerStat)(byte)R[0]);
break;
case "tellExperience":
OnPlayerUpdateExperience.TryInvoke(rp, (uint)R[0]);
instance.OnUpdateExperience.TryInvoke(rp, (uint)R[0]);
break;
case "tellRevive":
OnPlayerRevive.TryInvoke(rp, (Vector3)R[0], (byte)R[1]);
instance.OnRevive.TryInvoke(rp, (Vector3)R[0], (byte)R[1]);
break;
case "tellDead":
OnPlayerDead.TryInvoke(rp, (Vector3)R[0]);
instance.OnDead.TryInvoke(rp, (Vector3)R[0]);
break;
case "tellDeath":
OnPlayerDeath.TryInvoke(rp, (EDeathCause)(byte)R[0], (ELimb)(byte)R[1], new CSteamID(ulong.Parse(R[2].ToString())));
instance.OnDeath.TryInvoke(rp, (EDeathCause)(byte)R[0], (ELimb)(byte)R[1], new CSteamID(ulong.Parse(R[2].ToString())));
break;
default:
#if DEBUG
// Logger.Log("Send+" + s.SteamPlayerID.CSteamID.ToString() + ": " + W + " - " + String.Join(",",R.Select(e => e.ToString()).ToArray()));
#endif
break;
}
return;
}
catch (Exception ex)
{
Logger.LogException(ex, "Failed to receive packet \"" + W + "\"");
}
}
public void getPacket(ESteamPacket type, int index, out int size, out byte[] packet)
{
packet = SteamPacker.closeWrite(out size);
packet[0] = (byte)type;
packet[1] = (byte)index;
}
public static void TriggerSend(SteamPlayer s, string W, ESteamCall X, ESteamPacket l, params object[] R)
{
UnturnedPlayerEvents.TriggerSend(s, W, X, l, R);
}
public void getPacket(ESteamPacket type, int index, out int size, out byte[] packet, params object[] arguments)
{
packet = SteamPacker.getBytes(2, out size, arguments);
packet[0] = (byte)type;
packet[1] = (byte)index;
}
public static bool send(SteamChannel __instance, string name, ESteamCall mode, Vector3 point, float radius, ESteamPacket type, params object[] arguments)
{
var caller = GetCaller();
if (caller != null && !IsInternal(caller))
{
lock (Logger)
Logger?.TryRegisterCaller(name, caller, __instance);
return(!BlockCalls);
}
return(true);
}
public static bool sendAside(SteamChannel __instance, string name, CSteamID steamID, ESteamPacket type, params object[] arguments)
{
var caller = GetCaller();
if (caller != null && !IsInternal(caller))
{
lock (Logger)
Logger?.TryRegisterCaller(name, caller, __instance);
return(!BlockCalls);
}
return(true);
}
internal static void RunPacketSent(ref CSteamID steamID, ref ESteamPacket type, ref byte[] packet, ref int size, ref int channel, ref bool cancel) => OnPacketSent?.Invoke(ref steamID, ref type, ref packet, ref size, ref channel, ref cancel);
internal static void TriggerSend(SteamPlayer s, string W, ESteamCall X, ESteamPacket l, params object[] R)
{
try
{
if (s == null || s.player == null || s.playerID.steamID == CSteamID.Nil || s.player.transform == null || R == null) return;
UnturnedPlayerEvents instance = s.player.transform.GetComponent<UnturnedPlayerEvents>();
UnturnedPlayer rp = UnturnedPlayer.FromSteamPlayer(s);
#if DEBUG
//string o = "";
//foreach (object r in R)
//{
// o += r.ToString();
//}
//Logger.Log("Send+" + s.SteamPlayerID.CSteamID.ToString() + ": " + W + " - " + o);
#endif
if (W.StartsWith("tellWear")) {
OnPlayerWear.TryInvoke(rp, Enum.Parse(typeof(Wearables), W.Replace("tellWear", "")), (ushort)R[0], R.Count() > 1 ? (byte?)R[1] : null);
}
switch (W)
{
case "tellBleeding":
OnPlayerUpdateBleeding.TryInvoke(rp, (bool)R[0]);
instance.OnUpdateBleeding.TryInvoke( rp, (bool)R[0]);
break;
case "tellBroken":
OnPlayerUpdateBroken.TryInvoke(rp, (bool)R[0]);
instance.OnUpdateBroken.TryInvoke(rp, (bool)R[0]);
break;
case "tellLife":
OnPlayerUpdateLife.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateLife.TryInvoke(rp, (byte)R[0]);
break;
case "tellFood":
OnPlayerUpdateFood.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateFood.TryInvoke(rp, (byte)R[0]);
break;
case "tellHealth":
OnPlayerUpdateHealth.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateHealth.TryInvoke(rp, (byte)R[0]);
break;
case "tellVirus":
OnPlayerUpdateVirus.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateVirus.TryInvoke(rp, (byte)R[0]);
break;
case "tellWater":
OnPlayerUpdateWater.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateWater.TryInvoke(rp, (byte)R[0]);
break;
case "tellStance":
OnPlayerUpdateStance.TryInvoke(rp, (byte)R[0]);
instance.OnUpdateStance.TryInvoke( rp, (byte)R[0]);
break;
case "tellGesture":
OnPlayerUpdateGesture.TryInvoke(rp, (PlayerGesture)Enum.Parse(typeof(PlayerGesture), R[0].ToString()));
instance.OnUpdateGesture.TryInvoke( rp, (PlayerGesture)Enum.Parse(typeof(PlayerGesture), R[0].ToString()));
break;
case "tellStat":
OnPlayerUpdateStat.TryInvoke(rp, (EPlayerStat)(byte)R[0]);
instance.OnUpdateStat.TryInvoke(rp, (EPlayerStat)(byte)R[0]);
break;
case "tellExperience":
OnPlayerUpdateExperience.TryInvoke(rp, (uint)R[0]);
instance.OnUpdateExperience.TryInvoke(rp, (uint)R[0]);
break;
case "tellRevive":
OnPlayerRevive.TryInvoke(rp, (Vector3)R[0], (byte)R[1]);
instance.OnRevive.TryInvoke(rp, (Vector3)R[0], (byte)R[1]);
break;
case "tellDead":
OnPlayerDead.TryInvoke(rp, (Vector3)R[0]);
instance.OnDead.TryInvoke(rp, (Vector3)R[0]);
break;
case "tellDeath":
OnPlayerDeath.TryInvoke(rp, (EDeathCause)(byte)R[0], (ELimb)(byte)R[1], new CSteamID(ulong.Parse(R[2].ToString())));
instance.OnDeath.TryInvoke(rp, (EDeathCause)(byte)R[0], (ELimb)(byte)R[1], new CSteamID(ulong.Parse(R[2].ToString())));
break;
default:
#if DEBUG
// Logger.Log("Send+" + s.SteamPlayerID.CSteamID.ToString() + ": " + W + " - " + String.Join(",",R.Select(e => e.ToString()).ToArray()));
#endif
break;
}
return;
}
catch (Exception ex)
{
Core.Logging.Logger.LogException(ex,"Failed to receive packet \""+W+"\"");
}
}
internal void TriggerSend(SteamPlayer player, string method, ESteamCall steamCall, ESteamPacket steamPacket, params object[] data)
{
try
{
if (player == null ||
player.player == null ||
player.playerID.steamID == CSteamID.Nil ||
player.player.transform == null ||
data == null)
{
return;
}
UnturnedPlayer unturnedPlayer =
(UnturnedPlayer)playerManager.GetPlayer(player.playerID.steamID.ToString());
if (method.StartsWith("tellWear"))
{
//PlayerWearEvent method.Replace("tellWear", ""), (ushort)data[0], data.Count() > 1 ? (byte?)data[1] : null)
return;
}
IEvent @event = null;
switch (method)
{
case "tellBleeding":
@event = new UnturnedPlayerUpdateBleedingEvent(unturnedPlayer, (bool)data[0]);
break;
case "tellBroken":
@event = new UnturnedPlayerUpdateBrokenEvent(unturnedPlayer, (bool)data[0]);
break;
case "tellLife":
@event = new UnturnedPlayerUpdateLifeEvent(unturnedPlayer, (byte)data[0]);
break;
case "tellFood":
@event = new UnturnedPlayerUpdateFoodEvent(unturnedPlayer, (byte)data[0]);
break;
case "tellHealth":
@event = new UnturnedPlayerUpdateHealthEvent(unturnedPlayer, (byte)data[0]);
break;
case "tellVirus":
@event = new UnturnedPlayerUpdateVirusEvent(unturnedPlayer, (byte)data[0]);
break;
case "tellWater":
@event = new UnturnedPlayerUpdateWaterEvent(unturnedPlayer, (byte)data[0]);
break;
case "tellStance":
@event = new UnturnedPlayerUpdateStanceEvent(unturnedPlayer, (EPlayerStance)(byte)data[0]);
break;
case "tellGesture":
@event = new UnturnedPlayerUpdateGestureEvent(unturnedPlayer, (EPlayerGesture)(byte)data[0]);
break;
case "tellStat":
@event = new UnturnedPlayerUpdateStatEvent(unturnedPlayer, (EPlayerStat)(byte)data[0]);
break;
case "tellExperience":
@event = new UnturnedPlayerUpdateExperienceEvent(unturnedPlayer, (uint)data[0]);
break;
case "tellRevive":
@event = new PlayerRespawnEvent(unturnedPlayer);
break;
case "tellDead":
@event = new UnturnedPlayerDeadEvent(unturnedPlayer, ((global::UnityEngine.Vector3)data[0]).ToSystemVector());
break;
case "tellDeath":
{
var deathCause = (EDeathCause)(byte)data[0];
var limb = (ELimb)(byte)data[1];
var killerId = data[2].ToString();
playerManager.TryGetOnlinePlayerById(killerId, out var killer);
@event = new UnturnedPlayerDeathEvent(unturnedPlayer, limb, deathCause, (killer as UnturnedPlayer)?.Entity);
break;
}
}
if (@event != null)
{
eventManager.Emit(this, @event);
}
}
catch (Exception ex)
{
logger.LogError("Failed to receive packet \"" + method + "\"", ex);
}
}
public static void send(CSteamID steamID, ESteamPacket type, byte[] packet, int size, int channel) // Override
{
if (!Provider.isConnected)
{
return;
}
changeField("_bytesSent", (uint)getField("_bytesSent") + (uint)size);
changeField("_packetsSent", (uint)getField("_packetsSent") + 1u);
if (Provider.isServer)
{
if (steamID == Provider.server || (Provider.isClient && steamID == Provider.client))
{
runMethod("receiveServer", new object[] {
Provider.server,
packet,
0,
size,
channel,
});
return;
}
if (steamID.m_SteamID == 0uL)
{
Debug.LogError("Failed to send to invalid steam ID.");
return;
}
if ((bool)runMethod("isUnreliable", new object[] { type }))
{
if (!SteamGameServerNetworking.SendP2PPacket(steamID, packet, (uint)size, (!(bool)runMethod("isInstant", new object[] { type })) ? EP2PSend.k_EP2PSendUnreliable : EP2PSend.k_EP2PSendUnreliableNoDelay, channel))
{
Debug.LogError(string.Concat(new object[]
{
"Failed to send size ",
size,
" unreliable packet to ",
steamID,
"!"
}));
}
return;
}
if (!SteamGameServerNetworking.SendP2PPacket(steamID, packet, (uint)size, (!(bool)runMethod("isInstant", new object[] { type })) ? EP2PSend.k_EP2PSendReliableWithBuffering : EP2PSend.k_EP2PSendReliable, channel))
{
Debug.LogError(string.Concat(new object[]
{
"Failed to send size ",
size,
" reliable packet to ",
steamID,
"!"
}));
}
}
else
{
if (steamID == Provider.client)
{
runMethod("receiveClient", new object[] {
Provider.client,
packet,
0,
size,
channel,
});
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.LATE_PENDING;
Provider.disconnect();
return;
}
if (steamID.m_SteamID == 0uL)
{
Debug.LogError("Failed to send to invalid steam ID.");
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.LATE_PENDING;
Provider.disconnect();
return;
}
if ((bool)runMethod("isUnreliable", new object[] { type }))
{
bool suc = false;
for (int i = 0; i < maxRetryAmount; i++)
{
if (!SteamNetworking.SendP2PPacket(steamID, packet, (uint)size, (!(bool)runMethod("isInstant", new object[] { type })) ? EP2PSend.k_EP2PSendUnreliable : EP2PSend.k_EP2PSendUnreliableNoDelay, channel))
{
Debug.LogError(string.Concat(new object[]
{
"Failed to send size ",
size,
" unreliable packet to ",
steamID,
"!"
}));
}
else
{
suc = true;
break;
}
}
if (!suc)
{
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.LATE_PENDING;
Provider.disconnect();
}
return;
}
bool suc1 = false;
for (int i = 0; i < maxRetryAmount; i++)
{
if (!SteamNetworking.SendP2PPacket(steamID, packet, (uint)size, (!(bool)runMethod("isInstant", new object[] { type })) ? EP2PSend.k_EP2PSendReliableWithBuffering : EP2PSend.k_EP2PSendReliable, channel))
{
Debug.LogError(string.Concat(new object[]
{
"Failed to send size ",
size,
" reliable packet to ",
steamID,
"!"
}));
}
else
{
suc1 = true;
break;
}
if (!suc1)
{
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.LATE_PENDING;
Provider.disconnect();
}
}
}
}
