Example #1
0
        private static bool Prefix(PocketDimensionTeleport __instance, Collider other)
        {
            try
            {
                var component = other.GetComponent <NetworkIdentity>();
                if (!NetworkServer.active || component == null)
                {
                    return(false);
                }

                Events.InvokePocketDimensionLeave(component.GetPlayer(), ref __instance.type, out var allow);

                return(allow);
            }
            catch (Exception e)
            {
                Log.Error($"PocketDimExit Event Error: {e}");
                return(true);
            }
        }
Example #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="FailingEscapePocketDimensionEventArgs"/> class.
 /// </summary>
 /// <param name="player"><inheritdoc cref="Player"/></param>
 /// <param name="teleporter"><inheritdoc cref="Teleporter"/></param>
 /// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
 public FailingEscapePocketDimensionEventArgs(Player player, PocketDimensionTeleport teleporter, bool isAllowed = true)
 {
     Player     = player;
     Teleporter = teleporter;
     IsAllowed  = isAllowed;
 }
        private static bool Prefix(PocketDimensionTeleport __instance, Collider other)
        {
            try
            {
                if (!NetworkServer.active)
                {
                    return(false);
                }

                var component = other.GetComponent <NetworkIdentity>();
                if (component == null)
                {
                    return(false);
                }

                var type   = __instance.type;
                var player = component.GetPlayer();

                if (player == null)
                {
                    return(false);
                }

                __instance.tpPositions.Clear();
                var stringList = GameCore.ConfigFile.ServerConfig.GetStringList(Synapse.Api.Map.Get.Decontamination.IsDecontaminationInProgress ? "pd_random_exit_rids_after_decontamination" : "pd_random_exit_rids");
                foreach (GameObject gameObject in Server.Get.Map.Rooms.Select(x => x.GameObject))
                {
                    var component2 = gameObject.GetComponent <Rid>();
                    if (component2 != null && stringList.Contains(component2.id, StringComparison.Ordinal))
                    {
                        __instance.tpPositions.Add(gameObject.transform.position);
                    }
                }

                if (stringList.Contains("PORTAL"))
                {
                    foreach (Scp106PlayerScript scp106PlayerScript in UnityEngine.Object.FindObjectsOfType <Scp106PlayerScript>())
                    {
                        if (scp106PlayerScript.portalPosition != Vector3.zero)
                        {
                            __instance.tpPositions.Add(scp106PlayerScript.portalPosition);
                        }
                    }
                }

                if (__instance.tpPositions == null || __instance.tpPositions.Count == 0)
                {
                    foreach (GameObject gameObject2 in GameObject.FindGameObjectsWithTag("PD_EXIT"))
                    {
                        __instance.tpPositions.Add(gameObject2.transform.position);
                    }
                }

                var pos = __instance.tpPositions[UnityEngine.Random.Range(0, __instance.tpPositions.Count)];
                pos.y += 2f;

                if ((player.CustomRole != null && player.CustomRole.GetFriends().Any(x => x == Team.SCP)) || player.Team == Team.SCP)
                {
                    type = PocketDimensionTeleport.PDTeleportType.Exit;
                }

                EventHandler.Get.Scp.Scp106.InvokePocketDimensionLeaveEvent(player, ref pos, ref type, out var allow);

                if (!allow)
                {
                    return(false);
                }

                if (type == PocketDimensionTeleport.PDTeleportType.Killer || BlastDoor.OneDoor.isClosed)
                {
                    player.Hurt(9999, DamageTypes.Pocket, player);
                    return(false);
                }

                player.PlayerMovementSync.AddSafeTime(2f, false);
                player.Position = pos;
                __instance.RemoveCorrosionEffect(player.gameObject);
                PlayerManager.localPlayer.GetComponent <PlayerStats>().TargetAchieve(component.connectionToClient, "larryisyourfriend");
                if (PocketDimensionTeleport.RefreshExit)
                {
                    MapGeneration.ImageGenerator.pocketDimensionGenerator.GenerateRandom();
                }
                return(false);
            }
            catch (Exception e)
            {
                Logger.Get.Error($"Synapse-Event: PocketDimLeave failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
                return(true);
            }
        }
        public static bool Prefix(PocketDimensionTeleport __instance, Collider other)
        {
            try
            {
                NetworkIdentity component1 = other.GetComponent <NetworkIdentity>();
                if (component1 == null)
                {
                    return(false);
                }
                if (__instance.type == PocketDimensionTeleport.PDTeleportType.Killer ||
                    Object.FindObjectOfType <BlastDoor>().isClosed)
                {
                    component1.GetComponent <PlayerStats>()
                    .HurtPlayer(new PlayerStats.HitInfo(999990f, "WORLD", DamageTypes.Pocket, 0), other.gameObject);
                }
                else if (__instance.type == PocketDimensionTeleport.PDTeleportType.Exit)
                {
                    __instance.tpPositions.Clear();
                    List <string> stringList = ConfigFile.ServerConfig.GetStringList(
                        GameObject.Find("Host").GetComponent <DecontaminationLCZ>().GetCurAnnouncement() > 5
                ? "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;
                    PlyMovementSync component2 = other.GetComponent <PlyMovementSync>();
                    if (component2 == null)
                    {
                        return(false);
                    }
                    component2.SetSafeTime(2f);

                    bool allowEscape = true;
                    Events.InvokePocketDimEscaped(component2.gameObject, ref allowEscape);

                    if (allowEscape)
                    {
                        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)
            {
                Log.Error($"SCP106PocketEscape Error {e}");
                return(true);
            }
        }
Example #5
0
        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);
            }
        }
Example #6
0
        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);
            }
        }