[PlusEMU R2] Wired help?

[Stee]

Hey so I've basically got the wired in. The right .cs for it and all. Went through and fixed all the errors. But now The effect works once in a room then the room needs to be :unload'ed for it to work again? Can anyone please for the life of me give me some insight into this.
If more info is needed JUST ASK FAM.

P.s, If ya'll can spend like 4 hours helping a noob set up his hotel plz for god sake take the time to help a brother out. I haven't found anything on these issues. Trust me I looked.

 

[cammy]

If we knew what wired you were trying to add/edit we'd be able to help more. Can you explain what you're currently using/adding. What EMU is it for? What's the wired meant to do?

 

[Stee]

If we knew what wired you were trying to add/edit we'd be able to help more. Can you explain what you're currently using/adding. What EMU is it for? What's the wired meant to do?

Emu is in the title and here is everything I have for it. I think I got it now tho.
The wired is TimerReset

Spoiler: TimerReset.cs

using System;
using System.Linq;
using System.Text;
using System.Collections.Generic;
using System.Collections.Concurrent;
using Plus.Communication.Packets.Outgoing.Moderation;
using Plus.Communication.Packets.Incoming;
using Plus.HabboHotel.Rooms;
using Plus.HabboHotel.Users;
using Plus.Communication.Packets.Outgoing.Rooms.Chat;

namespace Plus.HabboHotel.Items.Wired.Boxes.Effects
{
    class TimerReset : IWiredItem, IWiredCycle
    {
        public Room Instance { get; set; }
        public Item Item { get; set; }
        public WiredBoxType Type { get { return WiredBoxType.EffectTimerReset; } }
        public ConcurrentDictionary<int, Item> SetItems { get; set; }
        public int TickCount { get; set; }
        public string StringData { get; set; }
        public bool BoolData { get; set; }
        public int Delay { get { return this._delay; } set { this._delay = value; this.TickCount = value; } }
        public string ItemsData { get; set; }

        private long _next;
        private int _delay = 0;
        private bool Requested = false;

        public TimerReset(Room Instance, Item Item)
        {
            this.Instance = Instance;
            this.Item = Item;
            this.SetItems = new ConcurrentDictionary<int, Item>();
        }

        public void HandleSave(ClientPacket Packet)
        {
            this.SetItems.Clear();
            int Unknown = Packet.PopInt();
            string Unknown2 = Packet.PopString();

            int FurniCount = Packet.PopInt();
            for (int i = 0; i < FurniCount; i++)
            {
                Item SelectedItem = Instance.GetRoomItemHandler().GetItem(Packet.PopInt());
                if (SelectedItem != null)
                    SetItems.TryAdd(SelectedItem.Id, SelectedItem);
            }

            int Delay = Packet.PopInt();
            this.Delay = Delay;
        }

        public bool Execute(params object[] Params)
        {
            if (this._next == 0 || this._next < PlusEnvironment.Now())
                this._next = PlusEnvironment.Now() + this.Delay;


            this.Requested = true;
            this.TickCount = Delay;
            return true;
        }

        public bool OnCycle()
        {
            if (this.SetItems.Count == 0 || !Requested)
                return false;

            long Now = PlusEnvironment.Now();
            if (_next < Now)
            {
                foreach (Item Item in this.SetItems.Values.ToList())
                {
                    if (Item == null)
                        continue;

                    if (!Instance.GetRoomItemHandler().GetFloor.Contains(Item))
                    {
                        SetItems.TryRemove(Item.Id, out Item n);
                        continue;
                    }

                    Item.Interactor.OnWiredTrigger(Item);
                }

                Requested = false;

                this._next = 5;
                this.TickCount = Delay;

            }
            return true;
        }
    }
}

Spoiler: WiredBoxTypeUtility.cs

using System;
using System.Linq;
using System.Text;
using System.Collections.Generic;

namespace Plus.HabboHotel.Items.Wired
{
    static class WiredBoxTypeUtility
    {
        public static WiredBoxType FromWiredId(int Id)
        {
            switch (Id)
            {
                default:
                    return WiredBoxType.None;
                case 1:
                    return WiredBoxType.TriggerUserSays;
                case 2:
                    return WiredBoxType.TriggerStateChanges;
                case 3:
                    return WiredBoxType.TriggerRepeat;
                case 4:
                    return WiredBoxType.TriggerRoomEnter;
                case 8:
                    return WiredBoxType.TriggerWalkOnFurni;
                case 9:
                    return WiredBoxType.TriggerWalkOffFurni;
                case 5:
                    return WiredBoxType.EffectShowMessage;
                case 6:
                    return WiredBoxType.EffectTeleportToFurni;
                case 7:
                    return WiredBoxType.EffectToggleFurniState;
                case 10:
                    return WiredBoxType.EffectKickUser;
                case 11:
                    return WiredBoxType.ConditionFurniHasUsers;
                case 12:
                    return WiredBoxType.ConditionFurniHasFurni;
                case 13:
                    return WiredBoxType.ConditionTriggererOnFurni;
                case 14:
                    return WiredBoxType.EffectMatchPosition;
                case 21:
                    return WiredBoxType.ConditionIsGroupMember;
                case 22:
                    return WiredBoxType.ConditionIsNotGroupMember;
                case 23:
                    return WiredBoxType.ConditionTriggererNotOnFurni;
                case 24:
                    return WiredBoxType.ConditionFurniHasNoUsers;
                case 25:
                    return WiredBoxType.ConditionIsWearingBadge;
                case 26:
                    return WiredBoxType.ConditionIsWearingFX;
                case 27:
                    return WiredBoxType.ConditionIsNotWearingBadge;
                case 28:
                    return WiredBoxType.ConditionIsNotWearingFX;
                case 29:
                    return WiredBoxType.ConditionMatchStateAndPosition;
                case 30:
                    return WiredBoxType.ConditionUserCountInRoom;
                case 31:
                    return WiredBoxType.ConditionUserCountDoesntInRoom;
                case 32:
                    return WiredBoxType.EffectMoveAndRotate;
                case 33:
                    return WiredBoxType.ConditionDontMatchStateAndPosition;
                case 34:
                    return WiredBoxType.ConditionFurniTypeMatches;
                case 35:
                    return WiredBoxType.ConditionFurniTypeDoesntMatch;
                case 36:
                    return WiredBoxType.ConditionFurniHasNoFurni;
                case 37:
                    return WiredBoxType.EffectMoveFurniToNearestUser;
                case 38:
                    return WiredBoxType.EffectMoveFurniFromNearestUser;
                case 39:
                    return WiredBoxType.EffectMuteTriggerer;
                case 40:
                    return WiredBoxType.EffectGiveReward;
                case 41:
                    return WiredBoxType.AddonRandomEffect;
                case 42:
                    return WiredBoxType.TriggerGameStarts;
                case 43:
                    return WiredBoxType.TriggerGameEnds;
                case 44:
                    return WiredBoxType.TriggerUserFurniCollision;
                case 45:
                    return WiredBoxType.EffectMoveFurniToNearestUser;
                case 46:
                    return WiredBoxType.EffectExecuteWiredStacks;
                case 47:
                    return WiredBoxType.EffectTeleportBotToFurniBox;
                case 48:
                    return WiredBoxType.EffectBotChangesClothesBox;
                case 49:
                    return WiredBoxType.EffectBotMovesToFurniBox;
                case 50:
                    return WiredBoxType.EffectBotCommunicatesToAllBox;
                case 51:
                    return WiredBoxType.EffectBotCommunicatesToUserBox;
                case 52:
                    return WiredBoxType.EffectBotFollowsUserBox;
                case 53:
                    return WiredBoxType.EffectBotGivesHanditemBox;
                case 54:
                    return WiredBoxType.ConditionActorHasHandItemBox;
                case 55:
                    return WiredBoxType.ConditionActorIsInTeamBox;
                case 56:
                    return WiredBoxType.EffectAddActorToTeam;
                case 57:
                    return WiredBoxType.EffectRemoveActorFromTeam;
                case 58:
                    return WiredBoxType.TriggerUserSaysCommand;
                case 59:
                    return WiredBoxType.EffectSetRollerSpeed;
                case 60:
                    return WiredBoxType.EffectRegenerateMaps;
                case 61:
                    return WiredBoxType.EffectGiveUserBadge;
                case 62:
                    return WiredBoxType.EffectTimerReset;
            }
        }

        public static int GetWiredId(WiredBoxType Type)
        {
            switch (Type)
            {
                case WiredBoxType.TriggerUserSays:
                case WiredBoxType.TriggerUserSaysCommand:
                case WiredBoxType.ConditionMatchStateAndPosition:
                    return 0;
                case WiredBoxType.TriggerWalkOnFurni:
                case WiredBoxType.TriggerWalkOffFurni:
                case WiredBoxType.ConditionFurniHasUsers:
                case WiredBoxType.ConditionFurniHasFurni:
                case WiredBoxType.ConditionTriggererOnFurni:
                    return 1;
                case WiredBoxType.EffectMatchPosition:
                    return 3;
                case WiredBoxType.EffectMoveAndRotate:
                case WiredBoxType.TriggerStateChanges:
                    return 4;
                case WiredBoxType.ConditionUserCountInRoom:
                    return 5;
                case WiredBoxType.ConditionActorIsInTeamBox:
                case WiredBoxType.TriggerRepeat:
                    return 6;
                case WiredBoxType.TriggerRoomEnter:
                case WiredBoxType.EffectShowMessage:
                    return 7;
                case WiredBoxType.TriggerGameStarts:
                case WiredBoxType.TriggerGameEnds:
                case WiredBoxType.EffectTeleportToFurni:
                case WiredBoxType.EffectToggleFurniState:
                case WiredBoxType.ConditionFurniTypeMatches:
                    return 8;
                case WiredBoxType.EffectGiveUserBadge:
                case WiredBoxType.EffectRegenerateMaps:
                case WiredBoxType.EffectKickUser:
                case WiredBoxType.EffectSetRollerSpeed:
                    return 7;
                case WiredBoxType.EffectAddActorToTeam:
                    return 9;
                case WiredBoxType.EffectRemoveActorFromTeam:
                case WiredBoxType.ConditionIsGroupMember:
                    return 10;
                case WiredBoxType.TriggerUserFurniCollision:
                case WiredBoxType.ConditionIsWearingBadge:
                case WiredBoxType.EffectMoveFurniToNearestUser:
                    return 11;
                case WiredBoxType.ConditionIsWearingFX:
                case WiredBoxType.EffectMoveFurniFromNearestUser:
                    return 12;
                case WiredBoxType.ConditionFurniHasNoUsers:
                    return 14;
                case WiredBoxType.ConditionTriggererNotOnFurni:
                    return 15;
                case WiredBoxType.ConditionUserCountDoesntInRoom:
                    return 16;
                case WiredBoxType.EffectGiveReward:
                    return 17;
                case WiredBoxType.EffectExecuteWiredStacks:
                case WiredBoxType.ConditionFurniHasNoFurni:
                    return 18;
                case WiredBoxType.ConditionFurniTypeDoesntMatch:
                    return 19;
                case WiredBoxType.EffectMuteTriggerer:
                    return 20;
                case WiredBoxType.ConditionIsNotGroupMember:
                case WiredBoxType.EffectTeleportBotToFurniBox:
                    return 21;
                case WiredBoxType.ConditionIsNotWearingBadge:
                case WiredBoxType.EffectBotMovesToFurniBox:
                    return 22;
                case WiredBoxType.ConditionIsNotWearingFX:
                case WiredBoxType.EffectBotCommunicatesToAllBox:
                    return 23;
                case WiredBoxType.EffectBotGivesHanditemBox:
                    return 24;
                case WiredBoxType.EffectBotFollowsUserBox:
                case WiredBoxType.ConditionActorHasHandItemBox:
                    return 25;
                case WiredBoxType.EffectBotChangesClothesBox:
                    return 26;
                case WiredBoxType.EffectBotCommunicatesToUserBox:
                    return 27;
            }
            return 0;
        }

        public static List<int> ContainsBlockedTrigger(IWiredItem Box, ICollection<IWiredItem> Triggers)
        {
            List<int> BlockedItems = new List<int>();

            if (Box.Type != WiredBoxType.EffectShowMessage && Box.Type != WiredBoxType.EffectMuteTriggerer && Box.Type != WiredBoxType.EffectTeleportToFurni && Box.Type != WiredBoxType.EffectKickUser && Box.Type != WiredBoxType.ConditionTriggererOnFurni)
                return BlockedItems;

            foreach (IWiredItem Item in Triggers)
            {
                if (Item.Type == WiredBoxType.TriggerRepeat)
                {
                    if (!BlockedItems.Contains(Item.Item.GetBaseItem().SpriteId))
                        BlockedItems.Add(Item.Item.GetBaseItem().SpriteId);
                    else continue;
                }
                else continue;
            }

            return BlockedItems;
        }

        public static List<int> ContainsBlockedEffect(IWiredItem Box,  ICollection<IWiredItem> Effects)
        {
            List<int> BlockedItems = new List<int>();

            if (Box.Type != WiredBoxType.TriggerRepeat)
                return BlockedItems;

            bool HasMoveRotate = Effects.Where(x => x.Type == WiredBoxType.EffectMoveAndRotate).ToList().Count > 0;
            bool HasMoveNear = Effects.Where(x => x.Type == WiredBoxType.EffectMoveFurniToNearestUser).ToList().Count > 0;

            foreach (IWiredItem Item in Effects)
            {
                if (Item.Type == WiredBoxType.EffectKickUser || Item.Type == WiredBoxType.EffectMuteTriggerer || Item.Type == WiredBoxType.EffectShowMessage || Item.Type == WiredBoxType.EffectTeleportToFurni || Item.Type == WiredBoxType.EffectBotFollowsUserBox)
                {
                    if (!BlockedItems.Contains(Item.Item.GetBaseItem().SpriteId))
                        BlockedItems.Add(Item.Item.GetBaseItem().SpriteId);
                    else continue;
                }
                else if((Item.Type == WiredBoxType.EffectMoveFurniToNearestUser && HasMoveRotate) || (Item.Type == WiredBoxType.EffectMoveAndRotate && HasMoveNear))
                {
                    if (!BlockedItems.Contains(Item.Item.GetBaseItem().SpriteId))
                        BlockedItems.Add(Item.Item.GetBaseItem().SpriteId);
                    else continue;
                }
            }

            return BlockedItems;
        }
    }
}