private static void OnSpawning(SpawningEventArgs ev)
{
if (!(Scp457.Get(ev.Player) is Scp457 scp457))
{
return;
}
if (ev.RoleType != RoleType.Scp0492)
{
scp457.Destroy();
return;
}
Door door = Map.GetDoorByName(Plugin.Instance.Config.Scp457Settings.SpawnDoor);
if (door == null)
{
Log.Error("Could not find the spawn door for Scp457!");
return;
}
if (PlayerMovementSync.FindSafePosition(door.Base.transform.position, out Vector3 pos, true))
{
ev.Position = pos;
}
}
public static Vector3 FindSpawnPosition(Player ply, DamageHandler info)
{
if (ply.Role == RoleType.Scp106 && info.Type == DamageType.Recontainment)
{
if (PlayerMovementSync.FindSafePosition(ply.Position, out Vector3 safePos))
{
return(safePos);
}
else
{
return(ply.Position + new Vector3(0, 5, 0));
}
}
else if (ply.CurrentRoom.Type == RoomType.Pocket)
{
return(new Vector3(0, -1998.67f, 2));
}
else if (ply.Role == RoleType.Spectator || ply.Role == RoleType.None)
{
return(new Vector3(0, 1001, 8));
}
else
{
return(ply.Position);
}
}
public static void Postfix(PlayerMovementSync __instance)
{
try
{
if (Pets.TryGetValue(__instance._hub, out var pets))
{
var position = __instance.RealModelPosition;
Timing.CallDelayed(0.25f, () =>
{
foreach (var pet in pets)
{
var rotation = Quaternion.LookRotation(__instance.RealModelPosition - pet.playerMovementSync._realModelPosition);
pet.playerMovementSync.Rotations = new Vector2(rotation.eulerAngles.x, rotation.eulerAngles.y);
if (Vector3.Distance(position, __instance.RealModelPosition) <= 0.5)
{
continue;
}
pet.playerMovementSync._realModelPosition = position;
}
});
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private static bool Prefix(PlayerMovementSync __instance, Vector3 pos, bool __result)
{
try
{
int num = 0;
switch (__instance._hub.characterClassManager.CurClass)
{
case RoleType.Scp93953:
case RoleType.Scp93989:
var scp939Offset = PlayerMovementSync._yAxisOffset939 * __instance.transform.localScale.y;
num = Physics.OverlapCapsuleNonAlloc(pos - scp939Offset, pos + scp939Offset, 0.15f, PlayerMovementSync._sphereHits, PlayerMovementSync._r3CollidableSurfaces);
break;
case RoleType.ChaosInsurgency:
var ciOffset = PlayerMovementSync._yAxisOffsetCi * __instance.transform.localScale.y;
num = Physics.OverlapCapsuleNonAlloc(pos - ciOffset, pos + ciOffset, 0.32f, PlayerMovementSync._sphereHits, PlayerMovementSync._r3CollidableSurfaces);
break;
default:
var defOffset = PlayerMovementSync._yAxisOffset * __instance.transform.localScale.y;
num = Physics.OverlapCapsuleNonAlloc(pos - defOffset, pos + defOffset, 0.38f, PlayerMovementSync._sphereHits, PlayerMovementSync._r3CollidableSurfaces);
break;
}
for (int i = 0; i < num; i++)
{
PlayableScps.Scp096 scp;
if (
(__instance._hub.characterClassManager.CurClass == RoleType.Scp106 &&
(PlayerMovementSync._sphereHits[i].gameObject.layer == 27 ||
PlayerMovementSync._sphereHits[i].gameObject.layer == 14)) ||
(PlayerMovementSync._sphereHits[i].gameObject.layer == 27 &&
(scp = __instance._hub.scpsController.CurrentScp as PlayableScps.Scp096) != null &&
scp.Enraged))
{
continue;
}
if (PlayerMovementSync._sphereHits[i].gameObject.layer == 27)
{
DoorVariant componentInParent2 = PlayerMovementSync._sphereHits[i].GetComponentInParent <DoorVariant>();
if (componentInParent2 != null && componentInParent2.AnticheatPassageApproved(__instance._hub))
{
continue;
}
}
__result = true;
}
__result = false;
return(false);
}
catch (Exception ex)
{
Log.Error($"{typeof(AntiCheatTriggerByR3WithCustomScale).FullName}.{nameof(Prefix)}:\n{ex}");
return(true);
}
}
private static bool OverridePosition(PlayerMovementSync __instance, Vector3 pos, float rot, bool forceGround = false)
{
try
{
if (forceGround && Physics.Raycast(pos, Vector3.down, out var raycastHit, 100f, __instance.CollidableSurfaces))
{
pos = raycastHit.point + Vector3.up * 1.23f * __instance.transform.localScale.y;
}
__instance.ForcePosition(pos);
__instance.TargetSetRotation(__instance.connectionToClient, rot);
}
catch { }
return(false);
}
private static bool Prefix(PlayerMovementSync __instance, Vector3 pos, float rot, bool forceGround)
{
if (__instance.gameObject.GetComponent <ReplayPlayer>() == null)
{
return(true);
}
RaycastHit raycastHit;
if (forceGround && Physics.Raycast(pos, Vector3.down, out raycastHit, 100f, __instance.CollidableSurfaces))
{
pos = raycastHit.point + Vector3.up;
pos = new Vector3(pos.x, pos.y - (1f - __instance._hub.transform.localScale.y), pos.z);
}
__instance.ForcePosition(pos);
__instance.PlayScp173SoundIfTeleported();
return(false);
}
private static bool Prefix(PlayerMovementSync __instance, Vector3 pos, float rot, bool forceGround)
{
if (!Npc.Dictionary.ContainsKey(__instance.gameObject))
{
return(true);
}
RaycastHit raycastHit;
if (forceGround && Physics.Raycast(pos, Vector3.down, out raycastHit, 100f, __instance.CollidableSurfaces))
{
pos = raycastHit.point + Vector3.up * Plugin.Instance.Config.NpcSizePositionMultiplier;
pos = new Vector3(pos.x, pos.y - (1f - __instance._hub.transform.localScale.y) * Plugin.Instance.Config.NpcSizePositionMultiplier, pos.z);
}
__instance.ForcePosition(pos);
__instance.PlayScp173SoundIfTeleported();
return(false);
}
private static bool OverridePosition(PlayerMovementSync __instance, Vector3 pos, PlayerMovementSync.PlayerRotation?rot = null, bool forceGround = false)
{
try
{
if (forceGround && Physics.Raycast(pos, Vector3.down, out var raycastHit, 100f, __instance.CollidableSurfaces))
{
pos = raycastHit.point + Vector3.up * 1.23f * __instance.transform.localScale.y;
}
__instance.ForcePosition(pos);
if (rot != null)
{
__instance.ForceRotation(rot.Value);
}
}
catch { }
return(false);
}
private static List <ReferenceHub> GetNearbyPlayers(FFInfo ffInfo)
{
List <ReferenceHub> nearbyPlayers = new List <ReferenceHub>();
PlayerMovementSync pms = ffInfo.Attacker.playerMovementSync;
float distanceCheck = ffInfo.Attacker.playerMovementSync.RealModelPosition.y > 900 ? 90 : 40;
foreach (var hub in ReferenceHub.GetAllHubs().Values)
{
float angle = Vector3.Angle(pms.transform.forward, pms.transform.position - hub.playerMovementSync.transform.position);
float distance = Vector3.Distance(pms.RealModelPosition, hub.playerMovementSync.RealModelPosition);
if (distance <= distanceCheck && angle > 130 || distance < 5)
{
nearbyPlayers.Add(hub);
}
}
return(nearbyPlayers);
}
private static bool OnPlayerMovementSync(PlayerMovementSync __instance)
{
try
{
var player = __instance.GetPlayer();
var args = player.setClassEventArgs;
//It is null when someone is revived by 049 since the first patch is never called in this situation
if (args == null)
{
return(true);
}
Timing.RunCoroutine(__instance.SafelySpawnPlayer(args.Position, args.Rotation), Segment.FixedUpdate);
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerSetClass(Position) failed!!\n{e}");
return(true);
}
}
private static bool OnPlayerMovementSync(PlayerMovementSync __instance)
{
try
{
var player = __instance.GetPlayer();
var args = player.setClassEventArgs;
if (player.LiteRoleSet)
{
return(false);
}
if (args == null)
{
return(true);
}
var rot = new PlayerMovementSync.PlayerRotation?(new PlayerMovementSync.PlayerRotation(new float?(0f), new float?(args.Rotation)));
Timing.RunCoroutine(__instance.SafelySpawnPlayer(args.Position, rot), Segment.FixedUpdate);
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerSetClass(Position) failed!!\n{e}");
return(true);
}
}
private static void Prefix(PlayerMovementSync __instance, ref Vector3 offset) => offset.y *= __instance.transform.localScale.y;
private static bool Prefix(PocketDimensionTeleport __instance, Collider other)
{
try
{
NetworkIdentity component1 = other.GetComponent <NetworkIdentity>();
if (!(component1 != null))
{
return(false);
}
if (__instance.type == PocketDimensionTeleport.PDTeleportType.Killer || BlastDoor.OneDoor.isClosed)
{
if (__instance.type == PocketDimensionTeleport.PDTeleportType.Killer)
{
var ev = new FailingEscapePocketDimensionEventArgs(API.Features.Player.Get(other.gameObject), __instance);
Player.OnFailingEscapePocketDimension(ev);
if (!ev.IsAllowed)
{
return(false);
}
}
else
{
// warhead larry event goes here
}
component1.GetComponent <PlayerStats>()
.HurtPlayer(new PlayerStats.HitInfo(999990f, "WORLD", DamageTypes.Pocket, 0), other.gameObject);
}
else if (__instance.type == PocketDimensionTeleport.PDTeleportType.Exit)
{
__instance.tpPositions.Clear();
bool flag = false;
DecontaminationController.DecontaminationPhase[] decontaminationPhases =
DecontaminationController.Singleton.DecontaminationPhases;
if (DecontaminationController.GetServerTime >
decontaminationPhases[decontaminationPhases.Length - 2].TimeTrigger)
{
flag = true;
}
List <string> stringList =
ConfigFile.ServerConfig.GetStringList(flag
? "pd_random_exit_rids_after_decontamination"
: "pd_random_exit_rids");
if (stringList.Count > 0)
{
foreach (GameObject gameObject in GameObject.FindGameObjectsWithTag("RoomID"))
{
if (gameObject.GetComponent <Rid>() != null &&
stringList.Contains(gameObject.GetComponent <Rid>().id))
{
__instance.tpPositions.Add(gameObject.transform.position);
}
}
if (stringList.Contains("PORTAL"))
{
foreach (Scp106PlayerScript scp106PlayerScript in Object
.FindObjectsOfType <Scp106PlayerScript>())
{
if (scp106PlayerScript.portalPosition != Vector3.zero)
{
__instance.tpPositions.Add(scp106PlayerScript.portalPosition);
}
}
}
}
if (__instance.tpPositions == null || __instance.tpPositions.Count == 0)
{
foreach (GameObject gameObject in GameObject.FindGameObjectsWithTag("PD_EXIT"))
{
__instance.tpPositions.Add(gameObject.transform.position);
}
}
Vector3 tpPosition = __instance.tpPositions[Random.Range(0, __instance.tpPositions.Count)];
tpPosition.y += 2f;
PlayerMovementSync component2 = other.GetComponent <PlayerMovementSync>();
component2.SetSafeTime(2f);
var ev = new EscapingPocketDimensionEventArgs(API.Features.Player.Get(component2.gameObject), tpPosition);
Player.OnEscapingPocketDimension(ev);
if (ev.IsAllowed)
{
component2.OverridePosition(tpPosition, 0.0f, false);
__instance.RemoveCorrosionEffect(other.gameObject);
PlayerManager.localPlayer.GetComponent <PlayerStats>()
.TargetAchieve(component1.connectionToClient, "larryisyourfriend");
}
component2.OverridePosition(tpPosition, 0.0f, false);
__instance.RemoveCorrosionEffect(other.gameObject);
PlayerManager.localPlayer.GetComponent <PlayerStats>()
.TargetAchieve(component1.connectionToClient, "larryisyourfriend");
}
if (!__instance.RefreshExit)
{
return(false);
}
ImageGenerator.pocketDimensionGenerator.GenerateRandom();
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.EscapingAndFailingEscapePocketDimension: {e}\n{e.StackTrace}");
return(true);
}
}
public static bool Prefix(PlayerMovementSync __instance, string message)
{
Log.Warn($"{__instance._hub.GetNickname()}: {message}");
return(false);
}
public static void Prefix(PlayerMovementSync __instance, string message, string code) => Log.Warn($"[SanyaPlugin] AntiCheatKill Detect:{Player.Get(__instance._hub)?.Nickname} [{message}({code})]");
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 static void Run(List <string> args, int i)
{
if (args.Count < 1)
{
throw new InvalidArgumentLengthException("Expected 1 argument but got 0 for command \"teleport\" at line " + i + ".");
}
if (args.Count < 4)
{
var roleInfo = RoleInfo.parseRole(args[0], "teleport", i, 0);
var door = UnityEngine.Object.FindObjectsOfType <DoorNametagExtension>().FirstOrDefault(_door => _door.GetName.Trim().ToUpper() == args[1].Trim().ToUpper());
if (door == null)
{
throw new InvalidArgumentException("Invalid argument for command \"teleport\" on line " + i + ", argument 1. The door name specified is not valid.");
}
if (!PlayerMovementSync.FindSafePosition(door.transform.position, out var pos))
{
throw new CommandErrorException("No safe position could be found for door \"" + door.name + "\".");
}
if (args.Count == 3)
{
if (!int.TryParse(args[2].Trim(), out var delay))
{
throw new InvalidArgumentException("Invalid argument for command \"teleport\" on line " + i + ", argument 2. Expected \"INT\" but got \"" + args[2] + "\".");
}
ScriptActions.GetDelay(delay).teleportIds.Add(new TeleportData(pos, roleInfo));
}
else
{
ScriptActions.scriptData.teleportIds.Add(new TeleportData(pos, roleInfo));
}
}
else
{
var roleInfo = RoleInfo.parseRole(args[0], "teleport", i, 0);
if (!int.TryParse(args[1].Trim(), out var x))
{
throw new InvalidArgumentException("Invalid argument for command \"teleport\" on line " + i + ", argument 1. Expected \"INT\" but got \"" + args[1] + "\".");
}
if (!int.TryParse(args[2].Trim(), out var y))
{
throw new InvalidArgumentException("Invalid argument for command \"teleport\" on line " + i + ", argument 2. Expected \"INT\" but got \"" + args[2] + "\".");
}
if (!int.TryParse(args[3].Trim(), out var z))
{
throw new InvalidArgumentException("Invalid argument for command \"teleport\" on line " + i + ", argument 3. Expected \"INT\" but got \"" + args[3] + "\".");
}
if (args.Count == 5)
{
if (!int.TryParse(args[4].Trim(), out var delay))
{
throw new InvalidArgumentException("Invalid argument for command \"teleport\" on line " + i + ", argument 2. Expected \"INT\" but got \"" + args[2] + "\".");
}
ScriptActions.GetDelay(delay).teleportIds.Add(new TeleportData(new Vector3(x, y, z), roleInfo));
}
else
{
ScriptActions.scriptData.teleportIds.Add(new TeleportData(new Vector3(x, y, z), roleInfo));
}
}
}
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);
}
}
