private static bool ServerKillPlayerPatch(PlayableScps.Scp173 __instance, ReferenceHub target)
{
try
{
var scp = __instance.GetPlayer();
var player = target.GetPlayer();
if (target == __instance.Hub || player.ClassManager.IsAnyScp() || player.ClassManager.CurClass == RoleType.Spectator)
{
return(false);
}
if (!SynapseExtensions.GetHarmPermission(scp, player))
{
return(false);
}
SynapseController.Server.Events.Scp.InvokeScpAttack(scp, player, Api.Enum.ScpAttackType.Scp173_Snap, out var allow);
return(allow);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp173) failed!!\n{e}");
return(true);
}
}
private static bool DistanceChanged(SinkholeEnvironmentalHazard __instance, ReferenceHub player)
{
try
{
var synapseplayer = player.GetPlayer();
if (Vector3.Distance(synapseplayer.Position, __instance.transform.position) <= __instance.DistanceToBeAffected)
{
var allow = true;
if (__instance.SCPImmune && !SynapseExtensions.CanHarmScp(synapseplayer, false) || synapseplayer.GodMode)
{
allow = false;
}
Synapse.Api.Events.EventHandler.Get.Player.InvokeSinkhole(synapseplayer, __instance, ref allow);
if (allow)
{
synapseplayer.GiveEffect(Api.Enum.Effect.SinkHole);
return(false);
}
}
synapseplayer.GiveEffect(Api.Enum.Effect.SinkHole, 0);
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerWalkOnSinkholeEvent failed!!\n{e}");
return(true);
}
}
public void OnDamage(PlayerDamageEventArgs ev)
{
if (ev.Killer.RoleID == 682 && SynapseExtensions.CanHarmScp(ev.Killer, false))
{
if (SCP682.Config.can_kill_on_oneshot)
{
ev.Victim.Kill();
}
ev.Killer.Heal(SCP682.Config.heal_hp_when_eat);
}
}
private static bool BodyInteract(PlayableScps.Scp049 __instance, byte num, GameObject go)
{
if (num != 0)
{
return(true);
}
try
{
if (!__instance._interactRateLimit.CanExecute(true))
{
return(false);
}
if (go == null || __instance.RemainingServerKillCooldown > 0f)
{
return(false);
}
var scp = __instance.GetPlayer();
var player = go.GetPlayer();
if (!SynapseExtensions.GetHarmPermission(scp, player))
{
return(false);
}
if (Vector3.Distance(scp.Position, player.Position) >= PlayableScps.Scp049.AttackDistance * 1.25f)
{
return(false);
}
if (Physics.Linecast(scp.Position, player.Position, InventorySystem.Items.MicroHID.MicroHIDItem.WallMask))
{
return(false);
}
ev.Get.Scp.InvokeScpAttack(scp, player, Api.Enum.ScpAttackType.Scp049_Touch, out var allow);
if (!allow)
{
return(false);
}
player.PlayerStats.DealDamage(new ScpDamageHandler(scp.Hub, 4949f, DeathTranslations.Scp049));
GameCore.Console.AddDebugLog("SCPCTRL", "SCP-049 | Sent 'death time' RPC", MessageImportance.LessImportant, false);
scp.Hub.scpsController.RpcTransmit_Byte(0);
__instance.RemainingServerKillCooldown = PlayableScps.Scp049.KillCooldown;
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp049) failed!!\n{e}");
return(true);
}
}
private static bool OnContain(CharacterClassManager __instance)
{
try
{
if (!NonFacilityCompatibility.currentSceneSettings.enableStandardGamplayItems)
{
return(false);
}
foreach (var player in Server.Get.Players)
{
if (player.Hub.isDedicatedServer || !player.Hub.Ready)
{
continue;
}
if (Vector3.Distance(player.Position, __instance._lureSpj.transform.position) >= 1.97f)
{
continue;
}
if (player.RoleType == RoleType.Spectator || player.Team == Team.SCP)
{
continue;
}
if (player.GodMode || !SynapseExtensions.CanHarmScp(player))
{
continue;
}
var allow = true;
var closeFemur = FemurBrokePeople + 1 >= Server.Get.Configs.synapseConfiguration.RequiredForFemur;
SynapseController.Server.Events.Player.InvokePlayerEnterFemurEvent(player, ref allow, ref closeFemur);
if (!allow)
{
continue;
}
player.PlayerStats.DealDamage(new UniversalDamageHandler(10000, DeathTranslations.UsedAs106Bait));
FemurBrokePeople++;
if (closeFemur)
{
__instance._lureSpj.SetState(__instance._lureSpj.allowContain, true);
}
}
return(false);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerEnterFemur failed!!\n{e}");
return(true);
}
}
private static bool CheckFF(out bool __result, ReferenceHub attacker, ReferenceHub victim, bool ignoreConfig = false)
{
try
{
__result = SynapseExtensions.GetHarmPermission(attacker.GetPlayer(), victim.GetPlayer(), ignoreConfig);
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-API: GetShootPermission failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
__result = true;
return(true);
}
}
private static bool Prefix(CharacterClassManager __instance)
{
try
{
if (!NetworkServer.active)
{
return(false);
}
if (!NonFacilityCompatibility.currentSceneSettings.enableStandardGamplayItems)
{
return(false);
}
foreach (var player in Server.Get.Players)
{
if (!(Vector3.Distance(player.Position, __instance._lureSpj.transform.position) <
1.97f))
{
continue;
}
if (player.RoleType == RoleType.Spectator || player.GodMode || !SynapseExtensions.CanHarmScp(player))
{
continue;
}
var allow = player.Team != Team.SCP;
var closeFemur = FemurBrokePeople + 1 >= Server.Get.Configs.SynapseConfiguration.RequiredForFemur;
SynapseController.Server.Events.Player.InvokePlayerEnterFemurEvent(player, ref allow, ref closeFemur);
if (!allow)
{
continue;
}
player.Hurt(10000, DamageTypes.Lure);
FemurBrokePeople++;
if (closeFemur)
{
__instance._lureSpj.SetState(true);
}
}
return(false);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerEnterFemur failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
private static bool HurtPlayer(Scp049_2PlayerScript __instance, GameObject plyObj)
{
try
{
if (!__instance._iawRateLimit.CanExecute(true) || plyObj == null)
{
return(false);
}
var scp = __instance.GetPlayer();
var player = plyObj?.GetPlayer();
if (player == null)
{
return(false);
}
if (!__instance.iAm049_2 || Vector3.Distance(scp.Position, player.Position) > __instance.distance * 1.5f)
{
return(false);
}
if (!SynapseExtensions.GetHarmPermission(scp, player))
{
return(false);
}
ev.Get.Scp.InvokeScpAttack(scp, player, Api.Enum.ScpAttackType.Scp0492_Scratch, out var allow);
if (!allow)
{
return(false);
}
player.PlayerStats.DealDamage(new ScpDamageHandler(scp.Hub, __instance.damage, DeathTranslations.Zombie));
Hitmarker.SendHitmarker(scp.Connection, 1f);
scp.ClassManager.RpcPlaceBlood(player.Position, 0, player.RoleType == RoleType.Spectator ? 1.3f : 0.5f);
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp049-2) failed!!\n{e}");
return(true);
}
}
private static bool Scp939Attack(PlayableScps.Scp939 __instance, GameObject target, out bool __result)
{
__result = false;
try
{
var scp = __instance.GetPlayer();
if (target.TryGetComponent <BreakableWindow>(out var window))
{
window.Damage(50f, new ScpDamageHandler(scp.Hub, 50f, DeathTranslations.Scp939), Vector3.zero);
__result = true;
}
else
{
var targetplayer = target.GetPlayer();
if (!SynapseExtensions.GetHarmPermission(scp, targetplayer))
{
return(false);
}
ev.Get.Scp.InvokeScpAttack(scp, targetplayer, Api.Enum.ScpAttackType.Scp939_Bite, out var allow);
if (!allow)
{
return(false);
}
targetplayer.PlayerStats.DealDamage(new ScpDamageHandler(scp.Hub, 50f, DeathTranslations.Scp939));
scp.ClassManager.RpcPlaceBlood(targetplayer.Position, 0, 2f);
targetplayer.PlayerEffectsController.EnableEffect <CustomPlayerEffects.Amnesia>(3f, true);
__result = true;
}
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp939) failed!!\n{e}");
return(true);
}
}
private static bool OnDamage(HitboxIdentity __instance, DamageHandlerBase handler)
{
try
{
if (handler is AttackerDamageHandler ahandler)
{
var ply = __instance.TargetHub.GetPlayer();
var attacker = ahandler.Attacker.GetPlayer();
Logger.Get.Debug($"{ply == null} - {attacker == null}");
return(SynapseExtensions.GetHarmPermission(attacker, ply));
}
}
catch (Exception ex)
{
Logger.Get.Error($"Synapse-FF: PlayerDamage failed!!\n{ex}");
}
return(true);
}
private static bool Contain106(PlayerInteract __instance)
{
try
{
var player = __instance.GetPlayer();
if (!SynapseExtensions.CanHarmScp(player) || !__instance.CanInteract)
{
return(false);
}
var allow = true;
EventHandler.Get.Scp.Scp106.InvokeScp106ContainmentEvent(player, ref allow);
return(allow);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: Scp106Containment failed!!\n{e}");
return(true);
}
}
private void Pickup(Synapse.Api.Events.SynapseEventArguments.PlayerPickUpItemEventArgs ev)
{
if (IsScp035Item(ev.Item))
{
if (!SynapseExtensions.CanHarmScp(ev.Player) || ev.Player.RoleID == (int)RoleType.Tutorial)
{
ev.Player.SendBroadcast(8, PluginClass.Translation.ActiveTranslation.ScpPickup035);
}
else
{
ev.Allow = false;
var players = Server.Get.GetPlayers(x => x.RoleID == (int)RoleType.Spectator && !x.OverWatch);
if (players.Count == 0)
{
ev.Player.SendBroadcast(8, PluginClass.Translation.ActiveTranslation.Survived035);
RemoveScp035Items(true);
return;
}
players = players.OrderBy(x => x.DeathTime).ToList();
Player player;
if (PluginClass.Config.DeathTime)
{
player = players.FirstOrDefault();
}
else
{
player = players.ElementAt(UnityEngine.Random.Range(0, players.Count));
}
player.CustomRole = new Scp035PlayerScript(ev.Player);
RemoveScp035Items(true);
}
}
}
private static bool DealDamagePatch(PlayerStats __instance, DamageHandlerBase handler)
{
try
{
if (!__instance._hub.characterClassManager.IsAlive ||
__instance._hub.characterClassManager.GodMode)
{
return(false);
}
var standardhandler = handler as StandardDamageHandler;
var type = handler.GetDamageType();
var victim = __instance.GetPlayer();
var attacker = handler is AttackerDamageHandler ahandler?ahandler.Attacker.GetPlayer() : null;
var damage = standardhandler.Damage;
if (type == DamageType.PocketDecay)
{
attacker = Server.Get.Players.FirstOrDefault(x => x.Scp106Controller.PocketPlayers.Contains(victim));
if (attacker != null && !SynapseExtensions.GetHarmPermission(attacker, victim))
{
return(false);
}
}
SynapseController.Server.Events.Player.InvokePlayerDamageEvent(victim, attacker, ref damage, type, out var allow);
standardhandler.Damage = damage;
return(allow);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerDamage event failed!!\n{e}");
return(true);
}
}
private static bool DistanceChanged(TantrumEnvironmentalHazard __instance, ReferenceHub player)
{
try
{
if (player == null || __instance.DisableEffect || __instance._correctPosition == null)
{
return(false);
}
var synapseplayer = player.GetPlayer();
if (Vector3.Distance(player.transform.position, __instance._correctPosition.position) > __instance.DistanceToBeAffected)
{
return(false);
}
var allow = true;
if ((__instance.SCPImmune && synapseplayer.Team == (int)Team.SCP) || !SynapseExtensions.CanHarmScp(synapseplayer, false) || synapseplayer.GodMode)
{
allow = false;
}
Synapse.Api.Events.EventHandler.Get.Player.InvokeTantrum(synapseplayer, __instance, ref allow);
if (allow)
{
Synapse.Api.Logger.Get.Debug("ALLOW TANTRUM");
synapseplayer.PlayerEffectsController.EnableEffect <CustomPlayerEffects.Stained>(2f, false);
}
return(false);
}
catch (Exception ex)
{
Synapse.Api.Logger.Get.Error("Synapse-Event: PlayerWalkOnSinkholeEvent failed!!\n" + ex);
return(true);
}
}
public static bool Prefix(Generator079 __instance, GameObject person)
{
try
{
var player = person.GetPlayer();
var generator = __instance.GetGenerator();
if (player.VanillaInventory == null || __instance._doorAnimationCooldown > 0f || __instance._deniedCooldown > 0f)
{
return(false);
}
if (!generator.Locked)
{
var allow = true;
if (!generator.Open)
{
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.OpenDoor, ref allow);
}
else
{
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.CloseDoor, ref allow);
}
if (!allow)
{
__instance.RpcDenied();
return(false);
}
generator.Open = !generator.Open;
return(false);
}
if (!SynapseExtensions.CanHarmScp(player))
{
__instance.RpcDenied();
return(false);
}
//Unlock The Generator
var flag = player.Bypass;
var items = new List <Synapse.Api.Items.SynapseItem>();
if (Server.Get.Configs.SynapseConfiguration.RemoteKeyCard)
{
items.AddRange(player.Inventory.Items.Where(x => x.ItemCategory == ItemCategory.Keycard));
}
else if (player.ItemInHand != null && player.ItemInHand.ItemCategory == ItemCategory.Keycard)
{
items.Add(player.ItemInHand);
}
foreach (var item in items)
{
var keycardcanopen = false;
var permissions = player.VanillaInventory.GetItemByID(item.ItemType).permissions;
foreach (var t in permissions)
{
if (t == "ARMORY_LVL_2")
{
keycardcanopen = true;
}
}
try
{
Server.Get.Events.Player.InvokePlayerItemUseEvent(player, item, Api.Events.SynapseEventArguments.ItemInteractState.Finalizing, ref keycardcanopen);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerItemUseEvent(Keycard) failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
if (keycardcanopen)
{
flag = true;
break;
}
}
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.Unlocked, ref flag);
if (flag)
{
generator.Locked = false;
return(false);
}
__instance.RpcDenied();
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: DoorInteract failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
private static bool Prefix(Generator079 __instance, GameObject person, PlayerInteract.Generator079Operations command)
{
try
{
var player = person.GetPlayer();
var generator = __instance.GetGenerator();
switch (command)
{
case PlayerInteract.Generator079Operations.Tablet:
if (generator.IsTabletConnected || !generator.Open || __instance._localTime <= 0f || Generator079.mainGenerator.forcedOvercharge || !SynapseExtensions.CanHarmScp(player))
{
return(false);
}
Inventory component = person.GetComponent <Inventory>();
using (SyncList <Inventory.SyncItemInfo> .SyncListEnumerator enumerator = component.items.GetEnumerator())
{
while (enumerator.MoveNext())
{
Inventory.SyncItemInfo syncItemInfo = enumerator.Current;
if (syncItemInfo.id == ItemType.WeaponManagerTablet)
{
bool allow2 = true;
var item = syncItemInfo.GetSynapseItem();
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.TabletInjected, ref allow2);
Server.Get.Events.Player.InvokePlayerItemUseEvent(player, item, Api.Events.SynapseEventArguments.ItemInteractState.Finalizing, ref allow2);
if (!allow2)
{
break;
}
generator.ConnectedTablet = item;
break;
}
}
}
return(false);
case PlayerInteract.Generator079Operations.Cancel:
if (!generator.IsTabletConnected)
{
return(false);
}
bool allow = true;
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.TabledEjected, ref allow);
return(allow);
}
return(true);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerGenerator failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
private static bool HitObject(PlayableScps.Scp096 __instance, GameObject target, out bool __result)
{
try
{
__result = false;
if (target.TryGetComponent <BreakableWindow>(out var window))
{
__result = window.Damage(500f, new Scp096DamageHandler(__instance, 500f, Scp096DamageHandler.AttackType.Slap), target.transform.position);
return(false);
}
if (target.TryGetComponent <DoorVariant>(out var door) && (object)door is IDamageableDoor damageable && !door.IsConsideredOpen())
{
__result = damageable.ServerDamage(250f, DoorDamageType.Scp096);
return(false);
}
if (!ReferenceHub.TryGetHub(target, out var hub) || hub == null || hub == __instance.Hub || hub.characterClassManager.IsAnyScp())
{
return(false);
}
var scp = __instance.GetPlayer();
var player = hub.GetPlayer();
if (Physics.Linecast(scp.Position, player.Position, PlayableScps.Scp096._solidObjectMask))
{
return(false);
}
if (Vector3.Distance(scp.Position, player.Position) > 5f)
{
return(false);
}
if (!SynapseExtensions.GetHarmPermission(scp, player))
{
return(false);
}
try
{
ev.Get.Scp.InvokeScpAttack(scp, player, Api.Enum.ScpAttackType.Scp096_Tear, out var allow);
if (!allow)
{
return(false);
}
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp096-Charge) failed!!\n{e}");
}
if (hub.playerStats.DealDamage(new Scp096DamageHandler(__instance, 9696f, Scp096DamageHandler.AttackType.Slap)))
{
__instance._targets.Remove(hub);
NetworkServer.SendToAll(default(PlayableScps.Messages.Scp096OnKillMessage), 0, false);
}
__result = true;
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(HitObject) failed!!\n{e}");
__result = false;
return(true);
}
}
private static bool OnInteract(Scp079Generator __instance, ReferenceHub ply, byte colliderId)
{
try
{
var gen = __instance.GetGenerator();
var player = ply.GetPlayer();
if (__instance._cooldownStopwatch.IsRunning && __instance._cooldownStopwatch.Elapsed.TotalSeconds < __instance._targetCooldown)
{
return(false);
}
if (colliderId != 0 && !gen.Open)
{
return(false);
}
__instance._cooldownStopwatch.Stop();
switch (colliderId)
{
case 0:
if (!gen.Locked)
{
var allow = true;
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, gen,
gen.Open ? GeneratorInteraction.CloseDoor : GeneratorInteraction.OpenDoor, ref allow);
if (!allow)
{
return(false);
}
gen.Open = !gen.Open;
__instance._targetCooldown = __instance._doorToggleCooldownTime;
}
else
{
if (!SynapseExtensions.CanHarmScp(player))
{
__instance.RpcDenied();
return(false);
}
var items = new List <SynapseItem>();
if (player.ItemInHand.ID != -1)
{
items.Add(player.ItemInHand);
}
if (Server.Get.Configs.synapseConfiguration.RemoteKeyCard)
{
items.AddRange(player.Inventory.Items.Where(x => x != player.ItemInHand));
}
var canOpen = false;
foreach (var item in items.Where(x => x.ItemCategory == ItemCategory.Keycard))
{
if ((item.ItemBase as KeycardItem).Permissions.HasFlagFast(__instance._requiredPermission))
{
canOpen = true;
Server.Get.Events.Player.InvokePlayerItemUseEvent(player, item, Api.Events.SynapseEventArguments.ItemInteractState.Finalizing, ref canOpen);
break;
}
}
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, gen, GeneratorInteraction.Unlocked, ref canOpen);
if (canOpen)
{
gen.Locked = false;
}
else
{
__instance.RpcDenied();
}
__instance._targetCooldown = __instance._unlockCooldownTime;
}
break;
case 1:
if ((__instance.Activating || SynapseExtensions.CanHarmScp(player)) && !__instance.Engaged)
{
var allow = true;
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, gen,
gen.Active ? GeneratorInteraction.Disabled : GeneratorInteraction.Activated, ref allow);
if (!allow)
{
return(false);
}
__instance.Activating = !__instance.Activating;
if (__instance.Activating)
{
__instance._leverStopwatch.Restart();
}
__instance._targetCooldown = __instance._doorToggleCooldownTime;
}
break;
case 2:
if (__instance.Activating && !__instance.Engaged)
{
var allow = true;
Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, gen,
GeneratorInteraction.Disabled, ref allow);
if (!allow)
{
return(false);
}
gen.Active = false;
__instance._targetCooldown = __instance._unlockCooldownTime;
}
break;
default:
__instance._targetCooldown = 1;
break;
}
__instance._cooldownStopwatch.Restart();
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerGeneratorInteract event failed!!\n{e}");
return(true);
}
}
private static bool MovePlayer(Scp106PlayerScript __instance, GameObject ply, int t)
{
try
{
if (!__instance._iawRateLimit.CanExecute(true) || ply == null || !__instance.iAm106)
{
return(false);
}
var scp = __instance.GetPlayer();
var player = ply.GetPlayer();
if (player == null || player.GodMode || !ServerTime.CheckSynchronization(t) || !player.ClassManager.IsHuman())
{
return(false);
}
if (!SynapseExtensions.GetHarmPermission(scp, player))
{
return(false);
}
var pos = player.Position;
var num = Vector3.Distance(scp.Position, pos);
var num2 = Math.Abs(scp.Position.y - pos.y);
if ((num >= 1.818f && num2 < 1.02f) || (num >= 3.4f && num2 < 1.95f) || (num >= 3.7f && num2 < 2.2f) || (num >= 3.9f && num2 < 3f) || num >= 4.2f)
{
__instance._hub.characterClassManager.TargetConsolePrint(scp.Connection, string.Format("106 MovePlayer command rejected - too big distance (code: T1). Distance: {0}, Y Diff: {1}.", num, num2), "gray");
return(false);
}
if (Physics.Linecast(scp.Position, player.Position, MicroHIDItem.WallMask))
{
__instance._hub.characterClassManager.TargetConsolePrint(scp.Connection, string.Format("106 MovePlayer command rejected - collider found between you and the target (code: T2). Distance: {0}, Y Diff: {1}.", num, num2), "gray");
return(false);
}
EventHandler.Get.Scp.InvokeScpAttack(scp, player, Api.Enum.ScpAttackType.Scp106_Grab, out var allow);
if (!allow)
{
return(false);
}
scp.ClassManager.RpcPlaceBlood(player.Position, 1, 2f);
__instance.TargetHitMarker(scp.Connection, __instance.captureCooldown);
__instance._currentServerCooldown = __instance.captureCooldown;
if (Scp106PlayerScript._blastDoor.isClosed)
{
__instance._hub.characterClassManager.RpcPlaceBlood(player.Position, 1, 2f);
player.PlayerStats.DealDamage(new ScpDamageHandler(__instance._hub, PlayerStatsSystem.DeathTranslations.PocketDecay));
}
else
{
EventHandler.Get.Scp.Scp106.InvokePocketDimensionEnterEvent(player, scp, ref allow);
if (!allow)
{
return(false);
}
foreach (var script in Scp079PlayerScript.instances)
{
script.ServerProcessKillAssist(player.Hub, ExpGainType.PocketAssist);
}
player.Hub.scp106PlayerScript.GrabbedPosition = player.Hub.playerMovementSync.RealModelPosition;
player.PlayerStats.DealDamage(new ScpDamageHandler(__instance._hub, 40f, PlayerStatsSystem.DeathTranslations.PocketDecay));
player.Position = Vector3.down * 1998.5f;
scp.Scp106Controller.PocketPlayers.Add(player);
}
player.PlayerEffectsController.EnableEffect <CustomPlayerEffects.Corroding>(0f, false);
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PocketDimEnter/ScpAttackEvent(106) failed!!\n{e}");
return(true);
}
}
private static bool TransmitData(PlayerPositionManager __instance)
{
try
{
__instance._frame++;
if (__instance._frame != __instance._syncFrequency)
{
return(false);
}
__instance._frame = 0;
var players = Server.Get.Players;
players.AddRange(Synapse.Api.Map.Get.Dummies.Select(x => x.Player));
__instance._usedData = players.Count;
if (__instance.ReceivedData == null || __instance.ReceivedData.Length < __instance._usedData)
{
__instance.ReceivedData = new PlayerPositionData[__instance._usedData * 2];
}
for (var i = 0; i < __instance._usedData; i++)
{
__instance.ReceivedData[i] = new PlayerPositionData(players[i].Hub);
}
if (__instance._transmitBuffer == null || __instance._transmitBuffer.Length < __instance._usedData)
{
__instance._transmitBuffer = new PlayerPositionData[__instance._usedData * 2];
}
foreach (var player in players)
{
if (player.Connection == null)
{
continue;
}
Array.Copy(__instance.ReceivedData, __instance._transmitBuffer, __instance._usedData);
for (int k = 0; k < __instance._usedData; k++)
{
var showinvoid = false;
var playerToShow = players[k];
if (playerToShow == player)
{
continue;
}
var vector = __instance._transmitBuffer[k].position - player.Position;
if (player.RoleType == RoleType.Spectator)
{
continue;
}
if (player.RoleType == RoleType.Scp173)
{
if (player.Scp173Controller.IgnoredPlayers.Contains(playerToShow))
{
showinvoid = true;
goto AA_001;
}
else if ((playerToShow.RealTeam == Team.SCP && player.CustomRole != null && !Server.Get.Configs.synapseConfiguration.ScpTrigger173) || Server.Get.Configs.synapseConfiguration.CantLookAt173.Contains(playerToShow.RoleID) || player.Scp173Controller.TurnedPlayers.Contains(playerToShow) || playerToShow.Invisible)
{
var posinfo = __instance._transmitBuffer[k];
var rot = Quaternion.LookRotation(playerToShow.Position - player.Position).eulerAngles.y;
__instance._transmitBuffer[k] = new PlayerPositionData(posinfo.position, rot, posinfo.playerID);
}
}
else if (player.RoleID == (int)RoleType.Scp93953 || player.RoleID == (int)RoleType.Scp93989)
{
if (__instance._transmitBuffer[k].position.y < 800f && SynapseExtensions.CanHarmScp(playerToShow, false) && playerToShow.RealTeam != Team.RIP && !playerToShow.GetComponent <Scp939_VisionController>().CanSee(player.PlayerEffectsController.GetEffect <CustomPlayerEffects.Visuals939>()))
{
showinvoid = true;
goto AA_001;
}
}
if (playerToShow.Invisible && !player.HasPermission("synapse.see.invisible"))
{
showinvoid = true;
goto AA_001;
}
if (Math.Abs(vector.y) > 35f)
{
showinvoid = true;
goto AA_001;
}
else
{
var sqrMagnitude = vector.sqrMagnitude;
if (player.Position.y < 800f)
{
if (sqrMagnitude >= 1764f)
{
showinvoid = true;
goto AA_001;
}
}
else if (sqrMagnitude >= 7225f)
{
showinvoid = true;
goto AA_001;
}
if (playerToShow != null)
{
var scp = player.Hub.scpsController.CurrentScp as Scp096;
if (scp != null && scp.Enraged && !scp.HasTarget(playerToShow.Hub) && SynapseExtensions.CanHarmScp(playerToShow, false))
{
showinvoid = true;
goto AA_001;
}
if (playerToShow.Hub.playerEffectsController.GetEffect <Invisible>().IsEnabled)
{
var flag = false;
if (scp != null)
{
flag = scp.HasTarget(playerToShow.Hub);
}
if (player.RoleType == RoleType.Scp079 || flag)
{
if (Server.Get.Configs.synapseConfiguration.Better268)
{
showinvoid = true;
}
}
else
{
showinvoid = true;
}
}
}
}
AA_001:
var posData = __instance._transmitBuffer[k];
var rotation = posData.rotation;
var pos = posData.position;
Server.Get.Events.Server.InvokeTransmitPlayerDataEvent(player, playerToShow, ref pos, ref rotation, ref showinvoid);
if (showinvoid)
{
__instance._transmitBuffer[k] = new PlayerPositionData(Vector3.up * 6000f, 0.0f, playerToShow.PlayerId);
}
else
{
__instance._transmitBuffer[k] = new PlayerPositionData(pos, rotation, playerToShow.PlayerId);
}
}
var conn = player.Connection;
if (__instance._usedData <= 20)
{
conn.Send(new PositionPPMMessage(__instance._transmitBuffer, (byte)__instance._usedData, 0), 1);
}
else
{
byte b = 0;
while ((int)b < __instance._usedData / 20)
{
conn.Send(new PositionPPMMessage(__instance._transmitBuffer, 20, b), 1);
b += 1;
}
byte b2 = (byte)(__instance._usedData % (int)(b * 20));
if (b2 > 0)
{
conn.Send(new PositionPPMMessage(__instance._transmitBuffer, b2, b), 1);
}
}
}
return(false);
}
catch (Exception e)
{
Api.Logger.Get.Error($"Synapse-InvisibleMode: TransmitData failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
private static bool Prefix(PlayerStats __instance, out bool __result, PlayerStats.HitInfo info, GameObject go, bool noTeamDamage = false, bool IsValidDamage = true)
{
try
{
__result = false;
var player = go?.GetPlayer();
var killer = __instance?.GetPlayer();
if (player == null)
{
return(false);
}
if (info.GetDamageType() == DamageTypes.Grenade)
{
killer = SynapseController.Server.GetPlayer(info.PlayerId);
}
else if (info.GetDamageType() == DamageTypes.Pocket)
{
killer = Server.Get.Players.FirstOrDefault(x => x.Scp106Controller.PocketPlayers.Contains(player));
if (SynapseExtensions.CanNotHurtByScp(player))
{
return(false);
}
}
bool flag = false;
bool flag2 = false;
bool flag3 = go == null;
ReferenceHub referenceHub = flag3 ? null : ReferenceHub.GetHub(go);
if (info.Amount < 0f)
{
if (flag3)
{
info.Amount = Mathf.Abs(999999f);
}
else
{
info.Amount = ((referenceHub.playerStats != null) ? Mathf.Abs(referenceHub.playerStats.Health + referenceHub.playerStats.syncArtificialHealth + 10f) : Mathf.Abs(999999f));
}
}
if (__instance._burned.Enabled)
{
info.Amount *= __instance._burned.DamageMult;
}
if (info.Amount > 2.14748365E+09f)
{
info.Amount = 2.14748365E+09f;
}
if (info.GetDamageType().isWeapon&& referenceHub.characterClassManager.IsAnyScp() && info.GetDamageType() != DamageTypes.MicroHid)
{
info.Amount *= __instance.weaponManager.weapons[(int)__instance.weaponManager.curWeapon].scpDamageMultiplier;
}
if (flag3)
{
__result = false;
return(false);
}
PlayerStats playerStats = referenceHub.playerStats;
CharacterClassManager characterClassManager = referenceHub.characterClassManager;
if (playerStats == null || characterClassManager == null)
{
__result = false;
return(false);
}
if (characterClassManager.GodMode)
{
__result = false;
return(false);
}
if (__instance.ccm.CurRole.team == Team.SCP && __instance.ccm.Classes.SafeGet(characterClassManager.CurClass).team == Team.SCP && __instance.ccm != characterClassManager)
{
__result = false;
return(false);
}
if (characterClassManager.SpawnProtected && !__instance._allowSPDmg)
{
__result = false;
return(false);
}
bool flag4 = !noTeamDamage && info.IsPlayer && referenceHub != info.RHub && referenceHub.characterClassManager.Fraction == info.RHub.characterClassManager.Fraction;
if (flag4)
{
info.Amount *= PlayerStats.FriendlyFireFactor;
}
float health = playerStats.Health;
if (__instance.lastHitInfo.Attacker == "ARTIFICIALDEGEN")
{
playerStats.unsyncedArtificialHealth -= info.Amount;
if (playerStats.unsyncedArtificialHealth < 0f)
{
playerStats.unsyncedArtificialHealth = 0f;
}
}
else
{
var allow = true;
try
{
Server.Get.Events.Player.InvokePlayerDamageEvent(player, killer, ref info, out allow);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerDamage Event failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
if (!allow)
{
__result = false;
return(false);
}
if (playerStats.unsyncedArtificialHealth > 0f)
{
float num = info.Amount * playerStats.artificialNormalRatio;
float num2 = info.Amount - num;
playerStats.unsyncedArtificialHealth -= num;
if (playerStats.unsyncedArtificialHealth < 0f)
{
num2 += Mathf.Abs(playerStats.unsyncedArtificialHealth);
playerStats.unsyncedArtificialHealth = 0f;
}
playerStats.Health -= num2;
if (playerStats.Health > 0f && playerStats.Health - num <= 0f && characterClassManager.CurRole.team != Team.SCP)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "didntevenfeelthat");
}
}
else
{
playerStats.Health -= info.Amount;
}
if (playerStats.Health < 0f)
{
playerStats.Health = 0f;
}
playerStats.lastHitInfo = info;
}
PlayableScpsController component = go.GetComponent <PlayableScpsController>();
if (component != null && (object)component.CurrentScp is PlayableScps.Interfaces.IDamagable damagable)
{
damagable.OnDamage(info);
}
if (playerStats.Health < 1f && characterClassManager.CurClass != RoleType.Spectator)
{
if (component != null && (object)component.CurrentScp is PlayableScps.Interfaces.IImmortalScp immortalScp && !immortalScp.OnDeath(info, __instance.gameObject))
{
__result = false;
return(false);
}
foreach (Scp079PlayerScript scp079PlayerScript in Scp079PlayerScript.instances)
{
Scp079Interactable.ZoneAndRoom otherRoom = go.GetComponent <Scp079PlayerScript>().GetOtherRoom();
bool flag5 = false;
foreach (Scp079Interaction scp079Interaction in scp079PlayerScript.ReturnRecentHistory(12f, __instance._filters))
{
foreach (Scp079Interactable.ZoneAndRoom zoneAndRoom in scp079Interaction.interactable.currentZonesAndRooms)
{
if (zoneAndRoom.currentZone == otherRoom.currentZone && zoneAndRoom.currentRoom == otherRoom.currentRoom)
{
flag5 = true;
}
}
}
if (flag5)
{
scp079PlayerScript.RpcGainExp(ExpGainType.KillAssist, characterClassManager.CurClass);
}
}
if (RoundSummary.RoundInProgress() && RoundSummary.roundTime < 60 && IsValidDamage)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "wowreally");
}
if (__instance.isLocalPlayer && info.PlayerId != referenceHub.queryProcessor.PlayerId)
{
RoundSummary.Kills++;
}
flag = true;
if (characterClassManager.CurClass == RoleType.Scp096)
{
ReferenceHub hub = ReferenceHub.GetHub(go);
if (hub != null && hub.scpsController.CurrentScp is PlayableScps.Scp096 && (hub.scpsController.CurrentScp as PlayableScps.Scp096).PlayerState == PlayableScps.Scp096PlayerState.Enraging)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "unvoluntaryragequit");
}
}
else if (info.GetDamageType() == DamageTypes.Pocket)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "newb");
}
else if (info.GetDamageType() == DamageTypes.Scp173)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "firsttime");
}
else if (info.GetDamageType() == DamageTypes.Grenade && info.PlayerId == referenceHub.queryProcessor.PlayerId)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "iwanttobearocket");
}
else if (info.GetDamageType().isWeapon)
{
Inventory inventory = referenceHub.inventory;
if (characterClassManager.CurClass == RoleType.Scientist)
{
Item itemByID = inventory.GetItemByID(inventory.curItem);
if (itemByID != null && itemByID.itemCategory == ItemCategory.Keycard && __instance.GetComponent <CharacterClassManager>().CurClass == RoleType.ClassD)
{
__instance.TargetAchieve(__instance.connectionToClient, "betrayal");
}
}
if (Time.realtimeSinceStartup - __instance._killStreakTime > 30f || __instance._killStreak == 0)
{
__instance._killStreak = 0;
__instance._killStreakTime = Time.realtimeSinceStartup;
}
if (__instance.GetComponent <WeaponManager>().GetShootPermission(characterClassManager, true))
{
__instance._killStreak++;
}
if (__instance._killStreak >= 5)
{
__instance.TargetAchieve(__instance.connectionToClient, "pewpew");
}
if ((__instance.ccm.CurRole.team == Team.MTF || __instance.ccm.Classes.SafeGet(__instance.ccm.CurClass).team == Team.RSC) && characterClassManager.CurClass == RoleType.ClassD)
{
__instance.TargetStats(__instance.connectionToClient, "dboys_killed", "justresources", 50);
}
}
else if (__instance.ccm.CurRole.team == Team.SCP && go.GetComponent <MicroHID>().CurrentHidState != MicroHID.MicroHidState.Idle)
{
__instance.TargetAchieve(__instance.connectionToClient, "illpassthanks");
}
if (player.RealTeam == Team.RSC && player.RealTeam == Team.SCP)
{
__instance.TargetAchieve(__instance.connectionToClient, "timetodoitmyself");
}
bool flag6 = info.IsPlayer && referenceHub == info.RHub;
flag2 = flag4;
if (flag6)
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, string.Concat(new string[]
{
referenceHub.LoggedNameFromRefHub(),
" playing as ",
referenceHub.characterClassManager.CurRole.fullName,
" committed a suicide using ",
info.GetDamageName(),
"."
}), ServerLogs.ServerLogType.Suicide, false);
}
else
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, string.Concat(new string[]
{
referenceHub.LoggedNameFromRefHub(),
" playing as ",
referenceHub.characterClassManager.CurRole.fullName,
" has been killed by ",
info.Attacker,
" using ",
info.GetDamageName(),
info.IsPlayer ? (" playing as " + info.RHub.characterClassManager.CurRole.fullName + ".") : "."
}), flag2 ? ServerLogs.ServerLogType.Teamkill : ServerLogs.ServerLogType.KillLog, false);
}
if (info.GetDamageType().isScp || info.GetDamageType() == DamageTypes.Pocket)
{
RoundSummary.kills_by_scp++;
}
else if (info.GetDamageType() == DamageTypes.Grenade)
{
RoundSummary.kills_by_frag++;
}
try
{
Server.Get.Events.Player.InvokePlayerDeathEvent(player, killer, info);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerDeath Event failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
if (!__instance._pocketCleanup || info.GetDamageType() != DamageTypes.Pocket)
{
referenceHub.inventory.ServerDropAll();
PlayerMovementSync playerMovementSync = referenceHub.playerMovementSync;
if (characterClassManager.Classes.CheckBounds(characterClassManager.CurClass) && info.GetDamageType() != DamageTypes.RagdollLess)
{
__instance.GetComponent <RagdollManager>().SpawnRagdoll(go.transform.position, go.transform.rotation, (playerMovementSync == null) ? Vector3.zero : playerMovementSync.PlayerVelocity, (int)characterClassManager.CurClass, info, characterClassManager.CurRole.team > Team.SCP, go.GetComponent <Dissonance.Integrations.MirrorIgnorance.MirrorIgnorancePlayer>().PlayerId, referenceHub.nicknameSync.DisplayName, referenceHub.queryProcessor.PlayerId);
}
}
else
{
referenceHub.inventory.Clear();
}
characterClassManager.NetworkDeathPosition = go.transform.position;
if (characterClassManager.CurRole.team == Team.SCP)
{
if (characterClassManager.CurClass == RoleType.Scp0492)
{
NineTailedFoxAnnouncer.CheckForZombies(go);
}
else
{
GameObject x = null;
foreach (GameObject gameObject in PlayerManager.players)
{
if (gameObject.GetComponent <RemoteAdmin.QueryProcessor>().PlayerId == info.PlayerId)
{
x = gameObject;
}
}
if (x != null)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, string.Empty);
}
else
{
DamageTypes.DamageType damageType = info.GetDamageType();
if (damageType == DamageTypes.Tesla)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "TESLA");
}
else if (damageType == DamageTypes.Nuke)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "WARHEAD");
}
else if (damageType == DamageTypes.Decont)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "DECONTAMINATION");
}
else if (characterClassManager.CurClass != RoleType.Scp079)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "UNKNOWN");
}
}
}
}
playerStats.SetHPAmount(100);
characterClassManager.SetClassID(RoleType.Spectator);
player.CustomRole = null;
foreach (var larry in Server.Get.Players.Where(x => x.Scp106Controller.PocketPlayers.Contains(player)))
{
larry.Scp106Controller.PocketPlayers.Remove(player);
}
}
else
{
Vector3 pos = Vector3.zero;
float num3 = 40f;
if (info.GetDamageType().isWeapon)
{
GameObject playerOfID = __instance.GetPlayerOfID(info.PlayerId);
if (playerOfID != null)
{
pos = go.transform.InverseTransformPoint(playerOfID.transform.position).normalized;
num3 = 100f;
}
}
else if (info.GetDamageType() == DamageTypes.Pocket)
{
PlayerMovementSync component2 = __instance.ccm.GetComponent <PlayerMovementSync>();
if (component2.RealModelPosition.y > -1900f)
{
component2.OverridePosition(Vector3.down * 1998.5f, 0f, true);
}
}
__instance.TargetBloodEffect(go.GetComponent <NetworkIdentity>().connectionToClient, pos, Mathf.Clamp01(info.Amount / num3));
}
Respawning.RespawnTickets singleton = Respawning.RespawnTickets.Singleton;
Team team = characterClassManager.CurRole.team;
byte b = (byte)team;
if (b != 0)
{
if (b == 3)
{
if (flag)
{
Team team2 = __instance.ccm.Classes.SafeGet(characterClassManager.CurClass).team;
if (team2 == Team.CDP && team2 == Team.CHI)
{
singleton.GrantTickets(Respawning.SpawnableTeamType.ChaosInsurgency, __instance._respawn_tickets_ci_scientist_died_count, false);
}
}
}
}
else if (characterClassManager.CurClass != RoleType.Scp0492)
{
for (float num4 = 1f; num4 > 0f; num4 -= __instance._respawn_tickets_mtf_scp_hurt_interval)
{
float num5 = (float)playerStats.maxHP * num4;
if (health > num5 && playerStats.Health < num5)
{
singleton.GrantTickets(Respawning.SpawnableTeamType.NineTailedFox, __instance._respawn_tickets_mtf_scp_hurt_count, false);
}
}
}
if (component != null && (object)component.CurrentScp is PlayableScps.Interfaces.IDamagable damagable2)
{
damagable2.OnDamage(info);
}
if (!flag4 || FriendlyFireConfig.PauseDetector || PermissionsHandler.IsPermitted(info.RHub.serverRoles.Permissions, PlayerPermissions.FriendlyFireDetectorImmunity))
{
__result = flag;
return(false);
}
if (FriendlyFireConfig.IgnoreClassDTeamkills && referenceHub.characterClassManager.CurRole.team == Team.CDP && info.RHub.characterClassManager.CurRole.team == Team.CDP)
{
__result = flag;
return(false);
}
if (flag2)
{
if (info.RHub.FriendlyFireHandler.Respawn.RegisterKill())
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Window.RegisterKill())
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Life.RegisterKill())
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Round.RegisterKill())
{
__result = flag;
return(false);
}
}
if (info.RHub.FriendlyFireHandler.Respawn.RegisterDamage(info.Amount))
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Window.RegisterDamage(info.Amount))
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Life.RegisterDamage(info.Amount))
{
__result = flag;
return(false);
}
info.RHub.FriendlyFireHandler.Round.RegisterDamage(info.Amount);
__result = flag;
return(false);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerDamage Patch failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
__result = false;
return(true);
}
}
public void SendRAConsoleMessage(string message, bool success = true, RaCategory type = RaCategory.None) => SynapseExtensions.RaMessage(CommandSender, message, success, type);
private static bool TriggerEnter(PocketDimensionTeleport __instance, Collider other)
{
try
{
var component = other.GetComponent <NetworkIdentity>();
if (component == null)
{
return(false);
}
var type = __instance._type;
var player = component.GetPlayer();
var pos = Vector3.zero;
if (player == null)
{
return(false);
}
var forceEscape = !SynapseExtensions.CanHarmScp(player, false);
if (player.Hub.scp106PlayerScript.GrabbedPosition == Vector3.zero)
{
player.Hub.scp106PlayerScript.GrabbedPosition = new Vector3(0f, -1997f, 0f);
}
var identifier = MapGeneration.RoomIdUtils.RoomAtPosition(player.Hub.scp106PlayerScript.GrabbedPosition);
if (identifier.Zone == FacilityZone.Surface)
{
foreach (var player2 in Server.Get.Players)
{
if (player2.RoleType == RoleType.Scp106)
{
Vector3 objPos = (player2 == null)
? Vector3.zero
: player2.PlayerMovementSync.RealModelPosition;
SafeTeleportPosition componentInChildren = identifier.GetComponentInChildren <SafeTeleportPosition>();
float num = Vector3.Distance(objPos, componentInChildren.SafePositions[0].position);
float num2 = Vector3.Distance(objPos, componentInChildren.SafePositions[1].position);
pos = (num2 < num) ? componentInChildren.SafePositions[0].position : componentInChildren.SafePositions[1].position;
break;
}
}
}
else
{
var hashSet = MapGeneration.RoomIdUtils.FindRooms(MapGeneration.RoomName.Unnamed, identifier.Zone, MapGeneration.RoomShape.Undefined);
/*hashSet.RemoveWhere((MapGeneration.RoomIdentifier room) =>
* room.Name == MapGeneration.RoomName.Hcz106 || room.Name == MapGeneration.RoomName.EzGateA ||
* room.Name == MapGeneration.RoomName.EzGateB || room.Name == MapGeneration.RoomName.EzEvacShelter ||
* (room.Zone == MapGeneration.FacilityZone.LightContainment && room.Shape == MapGeneration.RoomShape.Curve) ||
* room.Zone == MapGeneration.FacilityZone.None || room.Name == MapGeneration.RoomName.Pocket ||
* room.Name == MapGeneration.RoomName.HczTesla);*/
try
{
while (hashSet.Count > 0)
{
MapGeneration.RoomIdentifier roomIdentifier2 = hashSet.ElementAt(UnityEngine.Random.Range(0, hashSet.Count));
var safepos = roomIdentifier2.transform.position;
var safeTeleport = roomIdentifier2.GetComponentInChildren <SafeTeleportPosition>();
if (safeTeleport != null && safeTeleport.SafePositions?.Length != 0)
{
safepos = safeTeleport.SafePositions[UnityEngine.Random.Range(0, safeTeleport.SafePositions.Length)].position;
}
if (PlayerMovementSync.FindSafePosition(safepos, out pos, false, true))
{
break;
}
hashSet.Remove(roomIdentifier2);
}
}
catch (Exception ex)
{
//I don't know how but for some Reason this fails sometimes and the method is called a second time
//Logger.Get.Debug(ex);
return(false);
}
}
EventHandler.Get.Scp.Scp106.InvokePocketDimensionLeaveEvent(player, ref pos, ref type, out var allow);
if (!allow)
{
return(false);
}
if (!forceEscape && (type == PocketDimensionTeleport.PDTeleportType.Killer || Synapse.Api.Nuke.Get.Detonated))
{
player.PlayerStats.DealDamage(new UniversalDamageHandler(-1f, DeathTranslations.PocketDecay));
return(false);
}
else
{
player.Position = pos;
player.PlayerEffectsController.EnableEffect <CustomPlayerEffects.Disabled>(10f, true);
player.PlayerEffectsController.GetEffect <CustomPlayerEffects.Corroding>().Intensity = 0;
Achievements.AchievementHandlerBase.ServerAchieve(component.connectionToClient, AchievementName.LarryFriend);
}
MapGeneration.ImageGenerator.pocketDimensionGenerator.GenerateRandom();
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PocketDimLeave failed!!\n{e}");
return(true);
}
}
