Inheritance: MonoBehaviour
 public void PrepareForInteraction(PlayerInteract player)
 {
     playerInteract = player;
     playerInteract.Interacted += new InteractionHandler (Interact);
     playerInteract.ChangedPath += new ChangedPathHandler (CancelInteraction);
     Debug.Log (gameObject.name + " subscribed to interaction!");
 }
Beispiel #2
0
        public static bool Prefix(PlayerInteract __instance, string n)
        {
            if (EventPlugin.WarheadLockPatchDisable)
            {
                return(true);
            }

            try
            {
                bool allow = true;
                Events.InvokeWarheadEvent(__instance, ref n, ref allow);
                return(!EventPlugin.WarheadLocked && allow);
            }
            catch (Exception e)
            {
                Log.Error($"Warhead event error: {e}");
                return(true);
            }
        }
        public static bool Prefix(PlayerInteract __instance)
        {
            Better914Config Config = Better914Plugin.instance.Config;

            if (!Config.IsEnabled)
            {
                return(false);
            }
            if (!__instance._playerInteractRateLimit.CanExecute(true))
            {
                return(true);
            }
            if (__instance._hc.CufferId > 0 && (Config.OverrideHandcuffConfig ? !Config.CanDisarmedInteract : !PlayerInteract.CanDisarmedInteract))
            {
                return(true);
            }
            if (!Config.CanChangeKnobWhileWorking && Scp914Machine.singleton.working)
            {
                return(true);
            }
            if (!__instance.ChckDis(Scp914Machine.singleton.knob.position))
            {
                return(true);
            }
            if (Math.Abs(Scp914Machine.singleton.curKnobCooldown) > 0.001f)
            {
                return(true);
            }

            var ev = new ChangingKnobSettingEventArgs(Exiled.API.Features.Player.Get(__instance.gameObject), Scp914Machine.singleton.knobState + 1);

            Exiled.Events.Handlers.Scp914.OnChangingKnobSetting(ev);

            if (!ev.IsAllowed)
            {
                return(true);
            }

            Scp914Machine.singleton.curKnobCooldown  = Scp914Machine.singleton.knobCooldown;
            Scp914Machine.singleton.NetworkknobState = ev.KnobSetting;
            __instance.OnInteract();
            return(true);
        }
Beispiel #4
0
        private static bool Prefix(PlayerInteract __instance)
        {
            if (!__instance._playerInteractRateLimit.CanExecute(true) || (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract))
            {
                return(false);
            }

            GameObject gameObject = GameObject.Find("OutsitePanelScript");

            if (!__instance.ChckDis(gameObject.transform.position) || !AlphaWarheadOutsitePanel.nukeside.enabled)
            {
                return(false);
            }

            if (!gameObject.GetComponent <AlphaWarheadOutsitePanel>().keycardEntered || Recontainer079.isLocked)
            {
                return(false);
            }

            AlphaWarheadController.Host.doorsOpen = false;

            ServerLogs.AddLog(ServerLogs.Modules.Warhead, "Countdown started.", ServerLogs.ServerLogType.GameEvent);
            if ((AlphaWarheadController._resumeScenario == -1 && AlphaWarheadController.Host.scenarios_start[AlphaWarheadController._startScenario].SumTime() == AlphaWarheadController.Host.timeToDetonation) ||
                (AlphaWarheadController._resumeScenario != -1 && AlphaWarheadController.Host.scenarios_resume[AlphaWarheadController._resumeScenario].SumTime() == AlphaWarheadController.Host.timeToDetonation))
            {
                var ev = new StartingEventArgs(API.Features.Player.Get(__instance.gameObject) ?? API.Features.Server.Host);

                Warhead.OnStarting(ev);

                if (!ev.IsAllowed)
                {
                    return(false);
                }

                AlphaWarheadController.Host.NetworkinProgress = true;
            }

            ServerLogs.AddLog(ServerLogs.Modules.Warhead, __instance.GetComponent <NicknameSync>().MyNick + " (" + __instance.GetComponent <CharacterClassManager>().UserId + ") started the Alpha Warhead detonation.", ServerLogs.ServerLogType.GameEvent);

            __instance.OnInteract();

            return(false);
        }
Beispiel #5
0
        private static bool Prefix(PlayerInteract __instance, GameObject elevator)
        {
            try
            {
                if (!__instance._playerInteractRateLimit.CanExecute(true) ||
                    (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract) || elevator == null)
                {
                    return(false);
                }

                Lift component = elevator.GetComponent <Lift>();
                if (component == null)
                {
                    return(false);
                }

                foreach (Lift.Elevator elevator2 in component.elevators)
                {
                    if (__instance.ChckDis(elevator2.door.transform.position))
                    {
                        var ev = new InteractingElevatorEventArgs(API.Features.Player.Get(__instance.gameObject), elevator2);

                        Player.OnInteractingElevator(ev);

                        if (!ev.IsAllowed)
                        {
                            return(false);
                        }

                        elevator.GetComponent <Lift>().UseLift();
                        __instance.OnInteract();
                    }
                }

                return(false);
            }
            catch (Exception e)
            {
                Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.InteractingElevator: {e}\n{e.StackTrace}");

                return(true);
            }
        }
        private static bool Prefix(PlayerInteract __instance)
        {
            try
            {
                if (!__instance._playerInteractRateLimit.CanExecute() ||
                    (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract))
                {
                    return(false);
                }

                GameObject gameObject = GameObject.Find("OutsitePanelScript");

                if (!__instance.ChckDis(gameObject.transform.position))
                {
                    return(false);
                }

                Item itemById = __instance._inv.GetItemByID(__instance._inv.curItem);

                if (!__instance._sr.BypassMode &&
                    (itemById == null || !Enumerable.Contains(itemById.permissions, "CONT_LVL_3")))
                {
                    return(false);
                }

                var ev = new ActivatingWarheadPanelEventArgs(API.Features.Player.Get(__instance.gameObject), new List <string> {
                    "CONT_LVL_3"
                });

                Handlers.Player.OnActivatingWarheadPanel(ev);

                gameObject.GetComponentInParent <AlphaWarheadOutsitePanel>().NetworkkeycardEntered = true;
                __instance.OnInteract();

                return(false);
            }
            catch (Exception e)
            {
                Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.ActivatingWarheadPanel: {e}\n{e.StackTrace}");

                return(true);
            }
        }
        private static bool OnCmdDetonate(PlayerInteract __instance)
        {
            try
            {
                if (!__instance.CanInteract || !Nuke.Get.OutsidePanel.KeyCardEntered || !Nuke.Get.InsidePanel.Enabled)
                {
                    return(false);
                }
                var player = __instance.GetPlayer();

                Get.Map.InvokeWarheadStart(player, out var allow);

                return(allow);
            }
            catch (Exception e)
            {
                Logger.Get.Error($"Synapse-Event: WarheadStart Event failed!!\n{e}");
                return(true);
            }
        }
Beispiel #8
0
        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);
            }
        }
Beispiel #9
0
    public override bool Interact(PlayerInteract interactor)
    {
        if (interactor.heldBoba == null)
        {
            return(false);
        }
        if (interactor.heldBoba.state != Boba.State.Pearls)
        {
            return(false);
        }

        base.Interact(interactor);

        if (!interacting)
        {
            DispenseTea(interactor.heldBoba);
        }

        return(false);
    }
    void Awake()
    {
        if (instance == null)
        {
            instance = this;
        }
        else if (instance != this)
        {
            Destroy(gameObject);
        }
        DontDestroyOnLoad(gameObject);

        rb          = GetComponent <Rigidbody2D>();
        animator    = GetComponent <Animator>();
        health      = GetComponent <PlayerHealth>();
        melee       = GetComponent <PlayerMelee>();
        projectile  = GetComponent <PlayerProjectile>();
        interact    = GetComponent <PlayerInteract>();
        audioSource = GetComponent <AudioSource>();
    }
Beispiel #11
0
        private static bool Prefix(PlayerInteract __instance, UnityEngine.GameObject elevator)
        {
            try
            {
                if (!__instance.CanInteract || elevator is null)
                {
                    return(false);
                }

                Lift component = elevator.GetComponent <Lift>();
                if (component is null)
                {
                    return(false);
                }

                foreach (Lift.Elevator elevator1 in component.elevators)
                {
                    if (!__instance.ChckDis(elevator1.door.transform.position))
                    {
                        continue;
                    }

                    InteractingElevatorEventArgs interactingEventArgs = new(API.Features.Player.Get(__instance._hub), elevator1, component);
                    Handlers.Player.OnInteractingElevator(interactingEventArgs);

                    if (interactingEventArgs.IsAllowed)
                    {
                        elevator.GetComponent <Lift>().UseLift();
                        __instance.OnInteract();
                    }
                }

                return(false);
            }
            catch (System.Exception e)
            {
                API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.InteractingElevator:\n{e}");

                return(true);
            }
        }
 public void Action(GameObject other)
 {
     // Disable Players abilities and collider
     PlayerMovement = other.GetComponent <PlayerMovement>();
     PlayerInteract = other.GetComponent <PlayerInteract>();
     PlayerShoot    = other.GetComponent <PlayerShoot>();
     PlayerCollider = other.GetComponent <CapsuleCollider2D>();
     if (PlayerMovement && PlayerInteract && PlayerShoot && PlayerCollider)
     {
         Active = true;
         PlayerMovement.CanMove = false;
         PlayerInteract.enabled = false;
         PlayerShoot.AllowInput = false;
         PlayerCollider.enabled = false;
         SpecificAction();
     }
     else
     {
         Debug.Log("Error");
     }
 }
Beispiel #13
0
        private static bool Prefix(PlayerInteract __instance)
        {
            if (!__instance._playerInteractRateLimit.CanExecute(true) ||
                (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract) ||
                (Scp914Machine.singleton.working || !__instance.ChckDis(Scp914Machine.singleton.button.position)))
            {
                return(false);
            }

            var ev = new ActivatingEventArgs(API.Features.Player.Get(__instance.gameObject), 0);

            Scp914.OnActivating(ev);

            if (ev.IsAllowed)
            {
                Scp914Machine.singleton.RpcActivate(NetworkTime.time + ev.Duration);
                __instance.OnInteract();
            }

            return(false);
        }
Beispiel #14
0
    // Use this for initialization
    void Start()
    {
        PlayerInteract playerInteract = GameObject.Find("PickUpRange").GetComponent <PlayerInteract>();

        bool[] villagers = playerInteract.GetUnlockedVillagers();
        while (true)
        {
            int generateVillagerID = Random.Range(0, villagers.Length);
            if (villagers[generateVillagerID] == false)
            {
                npcId = generateVillagerID;
                break;
            }
        }

        _canvas = GameObject.FindGameObjectWithTag("Canvas").transform;
        okPanel = _canvas.Find("OkPanel").gameObject;
        okBtn   = okPanel.transform.Find("Panel").Find("Ok_Btn").GetComponent <Button>();
        content = okPanel.transform.Find("Text").GetComponent <Text>();
        okPanel.SetActive(false);
    }
        public static bool Prefix(PlayerInteract __instance)
        {
            if (EventPlugin.WarheadKeycardAccessEventDisable)
            {
                return(true);
            }

            try
            {
                if (!__instance._playerInteractRateLimit.CanExecute(true) || (__instance._hc.CufferId > 0 && !__instance.CanDisarmedInteract))
                {
                    return(false);
                }

                GameObject gameObject = GameObject.Find("OutsitePanelScript");

                if (!__instance.ChckDis(gameObject.transform.position))
                {
                    return(false);
                }

                bool   allow = true;
                string requiredPermission = "CONT_LVL_3";

                Events.InvokeWarheadKeycardAccess(__instance.gameObject, ref allow, ref requiredPermission);

                if (allow && __instance._inv.GetItemByID(__instance._inv.curItem).permissions.Contains(requiredPermission))
                {
                    gameObject.GetComponentInParent <AlphaWarheadOutsitePanel>().NetworkkeycardEntered = true;
                    __instance.OnInteract();
                }

                return(false);
            }
            catch (Exception exception)
            {
                Log.Error($"WarheadKeycardAccessEvent error: {exception}");
                return(true);
            }
        }
Beispiel #16
0
    public void PromptPlayer()
    {
        BarController barController = GameObject.Find("Captain").GetComponent <BarController>();

        if (barController.foundKey == true)
        {
            //UNLOCK THE NPC IN THE VILLAGE AND NOTIFY THE PLAYER OF THAT FACT
            Debug.Log("You have unlocked a new villager");
            PlayerInteract playerInteract = GameObject.Find("PickUpRange").GetComponent <PlayerInteract>();
            playerInteract.UnlockVillager(npcId);
            barController.foundKey = false;
            barController.challengeCounters[6]++;
            barController.InvokeSound(playerInteract.levelCompleteAudio);
            Destroy(this.gameObject);
        }
        else
        {
            okPanel.SetActive(true);
            content.text = "HEYYY YOUUU HELP ME. YOU CAN RELEASE ME IF YOU FIND THE KEY... MEET ME BACK HERE WHEN YOU DO";
            okBtn.onClick.AddListener(delegate { Ok(); });
        }
    }
    public IEnumerator Talk()
    {
        MessageWindow messageWindow = MessageSystem.GetWindow();

        PlayerInteract.InteractableStart();

        //会話文章の表示
        //display talk
        List <string> content = conversation;

        foreach (var item in content)
        {
            yield return(new WaitForEndOfFrame());

            yield return(StartCoroutine(messageWindow.ShowClick(item)));

            yield return(new WaitForEndOfFrame());
        }
        messageWindow.Close();

        PlayerInteract.InteractableEnd();
    }
    public IEnumerator OpenBox()
    {
        MessageWindow messageWindow = MessageSystem.GetWindow();

        PlayerInteract.InteractableStart();

        if (isOpen)
        {
            yield return(StartCoroutine(messageWindow.ShowClick("からっぽだ")));

            messageWindow.Close();
            PlayerInteract.InteractableEnd();
            yield break;
        }

        //お金が入っていた
        if (money > 0)
        {
            yield return(GetMony());
        }

        //アイテムが入っていた
        if (item != null)
        {
            yield return(GetItem());
        }

        //装備が入っていた
        if (equipment != null)
        {
            yield return(GetEqip());
        }

        //フラグの保存
        VariablePersister.SetBool(key, true);

        PlayerInteract.InteractableEnd();
        yield break;
    }
        public static bool Prefix(PlayerInteract __instance, GameObject elevator)
        {
            Plugin.Log.Debug("UseElevatorPatch");
            Player ply = Player.Get(__instance.gameObject);

            if (!Plugin.GhostList.Contains(ply))
            {
                return(true);
            }

            var lift = elevator.GetComponent <Lift>();

            Lift.Elevator[] elevators = lift.elevators;

            float     furthestDistance = -1;
            Transform furthestObject   = null;

            foreach (Lift.Elevator Object in elevators)
            {
                float objectDistance = Vector3.Distance(ply.Position, Object.target.position);
                if (!(objectDistance > furthestDistance))
                {
                    continue;
                }
                furthestObject   = Object.target;
                furthestDistance = objectDistance;
            }

            if (furthestObject != null)
            {
                ply.Position = (furthestObject.position + furthestObject.right * 4.5f);
            }

            ply.ClearBroadcasts();
            ply.Broadcast(3, Translation.Translation.GetText().ElevatorTeleport);

            return(false);
        }
Beispiel #20
0
    // Start is called before the first frame update
    void Start()
    {
        animator   = GetComponent <Animator>();
        waitTime   = startWaitTime;
        randomSpot = 0;
        lastSpot   = moveSpots.Length - 1;
        animator.SetFloat("Speed", speed);

        curfew        = false;
        checkPlayer   = false;
        taxCollected  = false;
        failedSteal   = false;
        taxChase      = false;
        criminalChase = false;
        activePatrol  = true;



        timeTracker        = clock.AddComponent <TimeTracker>();
        taxCollectorScript = taxCollector.GetComponent <TaxCollector>();
        mp3            = music.GetComponent <MusicPlayer>();
        playerInteract = Player.GetComponent <PlayerInteract>();
    }
Beispiel #21
0
        private static bool Prefix(PlayerInteract __instance)
        {
            if (!__instance._playerInteractRateLimit.CanExecute(true) ||
                (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract) ||
                Scp914Machine.singleton.working || !__instance.ChckDis(Scp914Machine.singleton.knob.position) ||
                Math.Abs(Scp914Machine.singleton.curKnobCooldown) > 0.001f)
            {
                return(false);
            }

            var ev = new ChangingKnobSettingEventArgs(API.Features.Player.Get(__instance.gameObject), Scp914Machine.singleton.knobState + 1);

            Scp914.OnChangingKnobSetting(ev);

            if (ev.IsAllowed)
            {
                Scp914Machine.singleton.NetworkknobState = ev.KnobSetting;
                Scp914Machine.singleton.curKnobCooldown  = Scp914Machine.singleton.knobCooldown;
                __instance.OnInteract();
            }

            return(false);
        }
Beispiel #22
0
    void Start()
    {
        if (itemsParent != null)
        {
            slots = itemsParent.GetComponentsInChildren <Slot>();
            SetStartingItems();
        }
        visualText        = visualTextObject;
        textBox           = textBoxObject;
        toolTip           = toolTipObject;
        compareToolTip    = compareToolTipObject;
        compareTextBox    = compareTextBoxObject;
        compareVisualText = compareVisualTextObject;
        plrInter          = plrInterObject;
        player            = GetComponent <Player>();
        followCamera      = GameObject.Find("Main Camera").GetComponent <CameraController>();
        invsOpen          = 0;

        for (int i = 0; i < totalSlots; i++)
        {
            slots[i].whichSlot = i;
        }
    }
    //Set up village by getting values from player interact
    public void SetUpVillage()
    {
        PlayerInteract playerInteract = GameObject.Find("PickUpRange").GetComponent <PlayerInteract>();

        unlockedVillagers = playerInteract.UnlockedVillagers;

        for (int i = 0; i < villagers.Length; i++)
        {
            if (unlockedVillagers[i] == true)
            {
                villagers[i].SetActive(true);
            }
        }

        //ShopNpc
        GameObject shop = Instantiate(GameObject.Find("ShopNPC"));

        villagers[4].GetComponent <ItemStore>().itemName   = shop.GetComponent <ItemStore>().itemName;
        villagers[4].GetComponent <ItemStore>().itemDesc   = shop.GetComponent <ItemStore>().itemDesc;
        villagers[4].GetComponent <ItemStore>().itemPrice  = shop.GetComponent <ItemStore>().itemPrice;
        villagers[4].GetComponent <ItemStore>().itemSprite = shop.GetComponent <ItemStore>().itemSprite;
        villagers[4].GetComponent <ItemStore>().StoreMenu  = shop.GetComponent <ItemStore>().StoreMenu;
    }
        public static bool Prefix(PlayerInteract __instance)
        {
            try
            {
                if (!__instance._playerInteractRateLimit.CanExecute(true) ||
                    __instance._hc.CufferId > 0 && !__instance.CanDisarmedInteract ||
                    (Scp914Machine.singleton.working || !__instance.ChckDis(Scp914Machine.singleton.knob.position)))
                {
                    return(false);
                }
                Scp914Knob knobSetting = Scp914Machine.singleton.knobState;
                if (knobSetting + 1 > Scp914Machine.knobStateMax)
                {
                    knobSetting = Scp914Machine.knobStateMin;
                }
                else
                {
                    knobSetting += 1;
                }
                bool allow = true;
                Events.InvokeScp914KnobChange(__instance.gameObject, ref allow, ref knobSetting);

                if (allow)
                {
                    Scp914Machine.singleton.ChangeKnobStatus();
                    __instance.OnInteract();
                }

                return(false);
            }
            catch (Exception e)
            {
                Log.Error($"SCP914Knob Error: {e}");
                return(true);
            }
        }
 public void DoInteract(PlayerInteract player)
 {
     Interact.Invoke();
     if (isFigure)
     {
         Debug.Log("------------------------------------------------");
         if (prompt_manager.GetComponent <Tick_tracker>().external_figure_interact() == true)
         {
             InteractSuccess.Invoke();
             GameObject.Destroy(gameObject);
         }
         else
         {
             InteractFail.Invoke();
         }
         prompt_manager.GetComponent <Tick_tracker>().prompt_user("");
     }
     else
     {
         prompt_manager.GetComponent <Tick_tracker>().external_ticket_update(ticket);
         GameObject.Destroy(gameObject);
         prompt_manager.GetComponent <Tick_tracker>().prompt_user("");
     }
 }
Beispiel #26
0
        public static bool Prefix(PlayerInteract __instance, int lockerId, int chamberNumber)
        {
            if (!__instance._playerInteractRateLimit.CanExecute(true) || (__instance._hc.CufferId > 0 && !__instance.CanDisarmedInteract))
            {
                return(false);
            }
            LockerManager singleton = LockerManager.singleton;

            if (lockerId < 0 || lockerId >= singleton.lockers.Length)
            {
                return(false);
            }
            if (!__instance.ChckDis(singleton.lockers[lockerId].gameObject.position) || !singleton.lockers[lockerId].supportsStandarizedAnimation)
            {
                return(false);
            }
            if (chamberNumber < 0 || chamberNumber >= singleton.lockers[lockerId].chambers.Length)
            {
                return(false);
            }
            if (singleton.lockers[lockerId].chambers[chamberNumber].doorAnimator == null)
            {
                return(false);
            }
            if (!singleton.lockers[lockerId].chambers[chamberNumber].CooldownAtZero())
            {
                return(false);
            }
            singleton.lockers[lockerId].chambers[chamberNumber].SetCooldown();
            string accessToken = singleton.lockers[lockerId].chambers[chamberNumber].accessToken;
            Item   itemByID    = __instance._inv.GetItemByID(__instance._inv.curItem);
            bool   allow       = string.IsNullOrEmpty(accessToken) || (itemByID != null && itemByID.permissions.Contains(accessToken)) || __instance._sr.BypassMode;

            Events.InvokeLockerInteract(__instance.gameObject, singleton.lockers[lockerId], lockerId, ref allow);
            if (allow)
            {
                bool flag = ((int)singleton.openLockers[lockerId] & 1 << chamberNumber) != 1 << chamberNumber;
                singleton.ModifyOpen(lockerId, chamberNumber, flag);
                singleton.RpcDoSound(lockerId, chamberNumber, flag);
                bool state = true;
                for (int i = 0; i < singleton.lockers[lockerId].chambers.Length; i++)
                {
                    if (((int)singleton.openLockers[lockerId] & 1 << i) == 1 << i)
                    {
                        state = false;
                        break;
                    }
                }
                singleton.lockers[lockerId].LockPickups(state);
                if (!string.IsNullOrEmpty(accessToken))
                {
                    singleton.RpcChangeMaterial(lockerId, chamberNumber, false);
                }
            }
            else
            {
                singleton.RpcChangeMaterial(lockerId, chamberNumber, true);
            }
            __instance.OnInteract();
            return(false);
        }
        public static bool Prefix(PlayerInteract __instance, GameObject doorId)
        {
            try
            {
                var  allowTheAccess = true;
                Door door           = null;

                if (!__instance._playerInteractRateLimit.CanExecute() || (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract))
                {
                    return(false);
                }

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

                if (__instance._ccm.CurClass == RoleType.None || __instance._ccm.CurClass == RoleType.Spectator)
                {
                    return(false);
                }

                if (!doorId.TryGetComponent(out door))
                {
                    return(false);
                }


                if ((door.Buttons.Count == 0) ? (!__instance.ChckDis(doorId.transform.position)) : Enumerable.All(door.Buttons, item => !__instance.ChckDis(item.button.transform.position)))
                {
                    return(false);
                }

                __instance.OnInteract();

                if (!__instance._sr.BypassMode && !(door.PermissionLevels.HasPermission(Door.AccessRequirements.Checkpoints) &&
                                                    __instance._ccm.CurRole.team == Team.SCP))
                {
                    try
                    {
                        if (door.PermissionLevels == 0)
                        {
                            allowTheAccess = !door.locked;
                        }
                        else if (!door.RequireAllPermissions)
                        {
                            var itemPerms = __instance._inv.GetItemByID(__instance._inv.curItem).permissions;
                            allowTheAccess = itemPerms.Any(p =>
                                                           Door.backwardsCompatPermissions.TryGetValue(p, out var flag) &&
                                                           door.PermissionLevels.HasPermission(flag));
                        }
                        else
                        {
                            allowTheAccess = false;
                        }
                    }
                    catch
                    {
                        allowTheAccess = false;
                    }
                }

                Events.InvokeDoorInteraction(__instance.gameObject.GetPlayer(), door, ref allowTheAccess);

                if (allowTheAccess)
                {
                    door.ChangeState(__instance._sr.BypassMode);
                }
                else
                {
                    __instance.RpcDenied(doorId);
                }

                return(false);
            }
            catch (Exception e)
            {
                Log.Error($"DoorInteraction Error: {e}");

                return(true);
            }
        }
    // Use this for initialization
    void Start()
    {
        spawnPoint = this.gameObject.transform;

        blockGenerator = GameObject.Find("BasePlatform").GetComponent <BlockGenerator>(); //Same with this one
        spawnManager   = GameObject.Find("_Manager").GetComponent <SpawnManager>();       //Change the reference to this object later

        if (blockGenerator.LastBlock == spawnID)
        {
            //SET UP PORTAL ROOM HERE
            GameObject newPortalObject = Instantiate(_Portal, spawnPoint.position, spawnPoint.rotation) as GameObject;
            newPortalObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
            newPortalObject.transform.rotation = Quaternion.Euler(0, 135, 0);
            GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
            newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
            newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            Debug.Log("Setting up portal here: " + blockGenerator.LastBlock);
        }
        else //enemy = 0, boss = 1, village = 2, resource = 3, event = 4, shop = 5, jailednpc = 6, puzzle = 7, pet room = 8, empty = 9, farm = 10
        {
            //EVERYTHING ELSE HERE
            getRoom = spawnManager.RoomType;

            PlayerInteract playerInteract = GameObject.Find("PickUpRange").GetComponent <PlayerInteract>();

            while (getRoom == 6)
            {
                if (playerInteract.AllVillagersUnlocked() == true)
                {
                    getRoom = spawnManager.RoomType;
                }
                else
                {
                    break;
                }
            }

            if (getRoom == 0) //ENEMY ROOM
            {
                int amountOfEnemies = Random.Range(3, 5);

                GameObject.Find("Captain").GetComponent <BarController>().enemyCount += amountOfEnemies;

                int chooseEnemy = Random.Range(0, _Enemies.Length);

                for (int i = 0; i < amountOfEnemies; i++)
                {
                    GameObject newObject = Instantiate(_Enemies[chooseEnemy], spawnPoint.position, spawnPoint.rotation) as GameObject;
                    newObject.transform.position = new Vector3(spawnPoint.position.x + Random.Range(-10, 11), 1, spawnPoint.position.z + Random.Range(-10, 11));
                    spawnManager.enemyCount++;
                }

                GameObject newWallObject = Instantiate(_WallGenerator[Random.Range(0, 5)], spawnPoint.position, spawnPoint.rotation) as GameObject;
                newWallObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
            else if (getRoom == 1) //BOSS ROOM
            {
                int chooseBoss = Random.Range(0, _Bosses.Length);

                GameObject newBossObject = Instantiate(_Bosses[chooseBoss], spawnPoint.position, spawnPoint.rotation) as GameObject;
                newBossObject.transform.position = new Vector3(spawnPoint.position.x, 2, spawnPoint.position.z - 0.5f);
                spawnManager.bossCount++;

                GameObject newPlatformObject = Instantiate(_BossPlatform, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newPlatformObject.transform.position = new Vector3(spawnPoint.position.x, 0.5f, spawnPoint.position.z);

                int amountOfEnemies = Random.Range(3, 5);

                GameObject.Find("Captain").GetComponent <BarController>().enemyCount += amountOfEnemies;

                int chooseEnemy = Random.Range(0, _Enemies.Length);

                for (int i = 0; i < amountOfEnemies; i++)
                {
                    GameObject newObject = Instantiate(_Enemies[chooseEnemy], spawnPoint.position, spawnPoint.rotation) as GameObject;
                    newObject.transform.position = new Vector3(spawnPoint.position.x + Random.Range(-10, 11), 1, spawnPoint.position.z + Random.Range(-10, 11));
                    spawnManager.enemyCount++;
                }
            }
            else if (getRoom == 2) //VILLAGE ROOM
            {
                GameObject newVillageObject = Instantiate(_Village, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVillageObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
            }
            else if (getRoom == 3) //RESOURCE ROOM
            {
                int mineralsAmount = Random.Range(5, 10);
                int treesAmount    = Random.Range(5, 10);

                //Here we want to spawn the minerals
                for (int i = 0; i < mineralsAmount; i++)
                {
                    int posX = GiveMePosition(1, 4);
                    int posY = GiveMePosition(1, 4);

                    GameObject newMineralObject = Instantiate(_Mineral, spawnPoint.position, spawnPoint.rotation) as GameObject;
                    newMineralObject.transform.position = new Vector3(spawnPoint.position.x + posX, 1, spawnPoint.position.z + posY);
                    spawnManager.rockCount++;
                }

                //Here spawn the trees (they will extend more than the minerals)
                for (int i = 0; i < treesAmount; i++)
                {
                    int posX = GiveMePosition(5, 10);
                    int posY = GiveMePosition(5, 10);

                    GameObject newTreeObject = Instantiate(_Tree, spawnPoint.position, spawnPoint.rotation) as GameObject;
                    newTreeObject.transform.position = new Vector3(spawnPoint.position.x + posX, 1, spawnPoint.position.z + posY);
                    spawnManager.treeCount++;
                }

                //Spawn Vegetation
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);

                //Spawn Mysterious Old Man NPC
                GameObject newNpcObject = Instantiate(_CreepyOldMan, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newNpcObject.transform.position = new Vector3(spawnPoint.position.x, 1, spawnPoint.position.z);

                GameObject newNpcObject2 = Instantiate(_NPC[Random.Range(0, _NPC.Length)], spawnPoint.position, spawnPoint.rotation) as GameObject;
                newNpcObject2.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
            }
            else if (getRoom == 4) //EVENT ROOM
            {
                GameObject newEventObject = Instantiate(_Event, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newEventObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
            else if (getRoom == 5) //SHOP ROOM
            {
                GameObject newShopObject = Instantiate(_Shop, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newShopObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
            else if (getRoom == 6) //CRAFT ROOM
            {
                GameObject newCraftObject = Instantiate(_Craft, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newCraftObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
            else if (getRoom == 7) //JAILED NPC
            {
                GameObject newJailedNpc = Instantiate(_JailedNpc, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newJailedNpc.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
            else if (getRoom == 8) //PUZZLE ROOM
            {
                int choosePuzzle = Random.Range(0, 3);

                GameObject newPuzzleObject = Instantiate(_Puzzle[choosePuzzle], spawnPoint.position, spawnPoint.rotation) as GameObject;
                newPuzzleObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
            }
            else if (getRoom == 9) //EMPTY ROOM
            {
                //GameObject newPetObject = Instantiate(_PetShop, spawnPoint.position, spawnPoint.rotation) as GameObject;
                //newPetObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);

                float randomChance = Random.value;
                if (randomChance >= 0.5f)
                {
                    GameObject newObject = Instantiate(_Object[Random.Range(0, _Object.Length)], spawnPoint.position, spawnPoint.rotation) as GameObject;
                    newObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);
                }
            }
            else if (getRoom == 10) // EMPTY ROOM + ENEMIES
            {
                int amountOfEnemies = Random.Range(3, 5);

                int chooseEnemy = Random.Range(0, _Enemies.Length);

                GameObject.Find("Captain").GetComponent <BarController>().enemyCount += amountOfEnemies;

                for (int i = 0; i < amountOfEnemies; i++)
                {
                    GameObject newObject = Instantiate(_Enemies[chooseEnemy], spawnPoint.position, spawnPoint.rotation) as GameObject;
                    newObject.transform.position = new Vector3(spawnPoint.position.x + Random.Range(-10, 11), 1, spawnPoint.position.z + Random.Range(-10, 11));
                    spawnManager.enemyCount++;
                }

                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
            else if (getRoom == 11) //NPC ROOM
            {
                GameObject newNpcObject = Instantiate(_NPC[Random.Range(0, _NPC.Length)], spawnPoint.position, spawnPoint.rotation) as GameObject;
                newNpcObject.transform.position = new Vector3(spawnPoint.position.x + 0, 1, spawnPoint.position.z + 0);

                GameObject newVegetationObject = Instantiate(_Vegetation, spawnPoint.position, spawnPoint.rotation) as GameObject;
                newVegetationObject.transform.position = new Vector3(spawnPoint.position.x + 0, 0.5f, spawnPoint.position.z + 0);
                newVegetationObject.transform.rotation = Quaternion.Euler(0, -45, 0);
            }
        }
    }
Beispiel #29
0
 private void Start()
 {
     playerInteract = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInteract>(); //Procura o jogador na scene
 }
Beispiel #30
0
 public virtual void interact(PlayerInteract pi = null)
 {
 }
Beispiel #31
0
        public PacketHandlers()
        {
            setPacketSizes();
            PacketHandler temp;

            temp = new ActionButton();
            handlers.Add(PacketId.CLOSE, temp); //Close
            handlers.Add(PacketId.ACTIONBUTTON, temp); //Actionbutton #1
            handlers.Add(PacketId.ACTIONBUTTON2, temp); //Actionbutton #2
            handlers.Add(PacketId.ACTIONBUTTON3, temp); //Actionbutton #3

            temp = new ClientAction();
            handlers.Add(PacketId.IDLE, temp); //Idle
            handlers.Add(PacketId.MOVE_CAMERA, temp); //Move camera
            handlers.Add(PacketId.PING, temp); //Ping
            handlers.Add(PacketId.FOCUS, temp); //Window focus
            handlers.Add(PacketId.CLICK_MOUSE, temp); //Mouse
            handlers.Add(PacketId.WINDOW_TYPE, temp); //Window type
            handlers.Add(PacketId.SOUND_SETTINGS, temp); //Toggle sound (sounds)

            temp = new Command();
            handlers.Add(PacketId.COMMAND, temp); //Commands

            temp = new Communication();
            handlers.Add(PacketId.ADD_FRIEND, temp); //Add friend
            handlers.Add(PacketId.DELETE_FRIEND, temp); //Delete friend
            handlers.Add(PacketId.ADD_IGNORE, temp); //Add ignore
            handlers.Add(PacketId.DELETE_IGNORE, temp); //Delete ignore
            handlers.Add(PacketId.SEND_PM, temp); //Send PM
            handlers.Add(PacketId.CLAN_RANKS, temp); //Set clan ranks
            handlers.Add(PacketId.CLAN_CHAT, temp); //Join clan chat
            handlers.Add(PacketId.PUBLIC, temp); //Public chat
            handlers.Add(PacketId.CLAN_KICK, temp); //Clan chat kick
            handlers.Add(PacketId.PRIVACY_SETTINGS, temp); //public/private/trade chat settings

            temp = new Walk();
            handlers.Add(PacketId.WALK_1, temp); //Walk
            handlers.Add(PacketId.WALK_2, temp); //Walk
            handlers.Add(PacketId.WALK_3, temp); //Walk

            temp = new PlayerInteract();
            handlers.Add(PacketId.ATTACK_PLAYER, temp); //Attack
            handlers.Add(PacketId.FOLLOW, temp); //Follow
            handlers.Add(PacketId.TRADE, temp); //Trade
            handlers.Add(PacketId.MAGIC_ON_PLAYER, temp); //Magic on player

            temp = new NPCInteract();
            handlers.Add(PacketId.NPC_FIRST_CLICK, temp); //Attack
            handlers.Add(PacketId.NPC_SECOND_CLICK, temp); //Second click
            handlers.Add(PacketId.NPC_THIRD_CLICK, temp); //Third click
            handlers.Add(PacketId.NPC_FOURTH_CLICK, temp); //Fourth click
            handlers.Add(PacketId.NPC_FIFTH_CLICK, temp); //Fifth click
            handlers.Add(PacketId.NPC_EXAMINE, temp); //Examine Npc
            handlers.Add(PacketId.MAGIC_ON_NPC, temp); //Magic on NPC
            handlers.Add(PacketId.ITEM_ON_NPC, temp); //Item on NPC

            temp = new ObjectInteract();
            handlers.Add(PacketId.OBJECT_FIRST_CLICK, temp); //First click
            handlers.Add(PacketId.OBJECT_SECOND_CLICK, temp); //Second click
            handlers.Add(PacketId.OBJECT_THIRD_CLICK, temp); //Third click
            handlers.Add(PacketId.OBJECT_FOURTH_CLICK, temp); //Fourth click
            handlers.Add(PacketId.OBJECT_EXAMINE, temp); //object examine

            temp = new ItemInteract();
            handlers.Add(PacketId.EQUIP, temp); //Equip item
            handlers.Add(PacketId.ITEM_ON_ITEM, temp); //Item used on item
            handlers.Add(PacketId.INV_CLICK, temp); //Inventory click item
            handlers.Add(PacketId.ITEM_ON_OBJECT, temp); //Item used on object
            handlers.Add(PacketId.ITEM_ON_GROUND_ITEM, temp); //Item used on ground item.
            handlers.Add(PacketId.INV_OPERATE, temp); //Operate option
            handlers.Add(PacketId.INV_DROP, temp); //Drop item
            handlers.Add(PacketId.PICKUP, temp); //Pick up item
            handlers.Add(PacketId.INV_SWAP_SLOT, temp); //Swap item slot 1
            handlers.Add(PacketId.INV_SWAP_SLOT2, temp); //Swap item slot 2
            handlers.Add(PacketId.INV_RIGHT_CLICK_OPTION1, temp); //Right click option 1
            handlers.Add(PacketId.INV_RIGHT_CLICK_OPTION2, temp); //Right click option 2
            handlers.Add(PacketId.INV_EXAMINE_ITEM, temp); //Inventory item examine

            temp = new InterfaceOptions();
            handlers.Add(PacketId.ENTER_AMOUNT, temp); //Enter amount
            handlers.Add(PacketId.ENTER_TEXT, temp); // Enter text
            handlers.Add(PacketId.INTERFACE_CLICK_1, temp); //Option 1
            handlers.Add(PacketId.INTERFACE_CLICK_2, temp); //Option 2
            handlers.Add(PacketId.INTERFACE_CLICK_3, temp); //Option 3
            handlers.Add(PacketId.INTERFACE_CLICK_4, temp); //Option 4
            handlers.Add(PacketId.INTERFACE_CLICK_5, temp); //Option 5
            handlers.Add(PacketId.INTERFACE_CLICK_6, temp); //Option 6
            handlers.Add(PacketId.INTERFACE_CLICK_7, temp); //Option 7
            handlers.Add(PacketId.INTERFACE_CLICK_8, temp); //Option 8
            handlers.Add(PacketId.INTERFACE_CLICK_9, temp); //Option 9
            handlers.Add(PacketId.INTERFACE_CLICK_10, temp); //Option 9
            handlers.Add(PacketId.GE_SEARCH, temp); //Grand exchange search

            temp = new Unused();
            handlers.Add(PacketId.REIGON_LOADING, temp); //Region loading, varied size
            handlers.Add(PacketId.PACKET_COUNT, temp); //Sent after any click which increases 'count' in getPackets
            handlers.Add(PacketId.CLIENT_VARIABLE_30, temp); //Sent if a client variable is 30..unknown
            handlers.Add(PacketId.DODGY_PACKET, temp); //Caused by a dodgy packet

            Console.WriteLine("Binded packetHandlers");
        }
 public static void OnPlayerInteract(PlayerInteractEventArgs args)
 {
     PlayerInteract?.Invoke(args);
 }