Example #1
0
        public static void DoDepositAll(Player player)
        {
            //this shouldn't happen if method is called correctly
            if (player.chest == -1)
            {
                return;
            }
            bool sendNetMsg = player.chest > -1;

            if (IHPlayer.ActionLocked(TIH.DepositAll))
            {
                for (int i = R_START; i >= R_END; i--)
                {
                    if (IHPlayer.SlotLocked(i) || player.inventory[i].IsBlank())
                    {
                        continue;
                    }
                    MoveItemToChest(i, sendNetMsg);
                }
                Recipe.FindRecipes(); // !ref:Main:#22640.36#
                return;
            }

            for (int i = R_START; i >= R_END; i--)
            {
                if (!player.inventory[i].IsBlank())
                {
                    MoveItemToChest(i, sendNetMsg);
                }
            }
            Recipe.FindRecipes(); // !ref:Main:#22640.36#
        } //\DoDepositAll()
Example #2
0
        /// Locks/unlocks indicated slot depending on current status.
        public static void ToggleLock(Player player, int slotIndex)
        {
            if (slotIndex < 10 || slotIndex > 49)
            {
                return;
            }
            IHPlayer mp = player.GetSubClass <IHPlayer>();

            mp.lockedSlots[slotIndex - 10] = !mp.lockedSlots[slotIndex - 10];
        }
Example #3
0
        /// Only valid for the 40 Player inventory slots below the hotbar.
        /// <returns>True if indicated slot is locked</returns>
        public static bool SlotLocked(Player player, int slotIndex)
        {
            // pull IHPlayer subclass from the current Player-object's
            // list of subclasses
            IHPlayer mp = player.GetSubClass <IHPlayer>();

            // subtract 10 since our array only contains 40 items and
            // we're ignoring the first 10 actual slots (the hotbar).
            return(slotIndex > 9 && slotIndex < 50 && mp.lockedSlots[slotIndex - 10]);
        }
Example #4
0
        public override void Initialize()
        {
            Instance = this;

            // MUST use "new", as tAPI derps with clearing (quoth: Miraimai)
            lockedSlots = new bool[40]; //not the hotbar

            // init "locked" status of all available actions;
            // not all actions are affected by this flag
            LockedActions = new Dictionary <TIH, bool>();
            foreach (TIH aID in Enum.GetValues(typeof(TIH)))
            {
                LockedActions.Add(aID, false);
            }
        }
Example #5
0
 public override void PostDrawItemSlotBackground(SpriteBatch sb, ItemSlot slot)
 {
     if (IHBase.ModOptions["LockingEnabled"] && slot.type == "Inventory" && IHPlayer.SlotLocked(slot.index))
     {
         sb.Draw(IHBase.LockedIcon,      // the texture to draw
                 slot.pos,               // (Vector2) location in screen coords to draw sprite
                 null,                   // Rectangle to specifies source texels from texture; null draws whole texture
                 Color.Firebrick,        // color to tint sprite; color.white=full color, no tint
                 0f,                     // angle in radians to rotate sprite around its center
                 default(Vector2),       // (Vector2) sprite origin, default=(0,0) i.e. upper left corner
                 slot.scale,             // (Vector2) scale factor
                 SpriteEffects.None,     // effects to apply
                 0f                      // layer depth; 0=front layer, 1=backlayer; SpriteSortMode can sort sprites
                 );
     }
 }
Example #6
0
        private void OnWorldLoad()
        {
            isLocked = IHPlayer.ActionLocked(Client.Action);

            if (isLocked)
            {
                Client.Hooks.PostDraw += PostDraw; // draw lock indicator
                // Client.Label = lockedLabel;
            }
            else
            {
                // List<>.Remove() doesn't fail on missing keys,
                // so this is safe
                Client.Hooks.PostDraw -= PostDraw;
                // Client.Label = initialLabel;
            }
        }
Example #7
0
        // Shift + Right Click on inventory slot toggles the lock state
        public override bool PreItemSlotRightClick(ItemSlot slot, ref bool release)
        {
            if (!KState.Special.Shift.Down())
            {
                return(true);
            }

            if (IHBase.ModOptions["LockingEnabled"] && slot.modBase == null && Main.playerInventory && release)
            {
                if (slot.type == "Inventory" && slot.index >= 10) //not in the hotbar
                {
                    IHPlayer.ToggleLock(slot.index);              //toggle lock state
                    Sound.Lock.Play();
                }
            }
            return(false);
        }
Example #8
0
        /****************************************************
         *   This will compare the categories of items in the player's
         *  inventory to those of items in the open container and
         *  deposit any items of matching categories.
         */
        public static void SmartDeposit()
        {
            if (Main.localPlayer.chest == -1)
            {
                return;
            }

            var pInventory = Main.localPlayer.inventory;  //Item[]
            var chestItems = Main.localPlayer.chestItems; //Item[]
            var sendNetMsg = Main.localPlayer.chest > -1; //bool

            // define a query that creates category groups for the items in the chests,
            // then pulls out the category keys into a distinct list (List<ItemCat>)
            var catList =
                (from item in chestItems
                 where !item.IsBlank()
                 group item by item.GetCategory() into catGroup
                 from cat in catGroup
                 select catGroup.Key).Distinct()     //no duplicates
                .ToList();                           //store the query results

            if (IHBase.ModOptions["LockingEnabled"]) //slot locking on
            {
                for (int i = 49; i >= 10; i--)       // reverse through player inv
                {
                    if (!pInventory[i].IsBlank() && !IHPlayer.SlotLocked(i) &&
                        catList.Contains(pInventory[i].GetCategory()))
                    {
                        IHUtils.MoveItemToChest(i, sendNetMsg);
                    }
                }
            }
            else //no locking
            {
                for (int i = 49; i >= 10; i--)
                {
                    // if chest contains a matching category
                    if (!pInventory[i].IsBlank() && catList.Contains(pInventory[i].GetCategory()))
                    {
                        IHUtils.MoveItemToChest(i, sendNetMsg);
                    }
                }
            }
            Recipe.FindRecipes();
        }
Example #9
0
        public static void DoQuickStack(Player player)
        {
            if (player.chest == -1)
            {
                return;
            }

            var  inventory   = player.inventory;
            var  container   = player.chestItems;
            bool sendMessage = player.chest > -1;
            var  checkLocks  = IHPlayer.ActionLocked(TIH.QuickStack); //boolean


            for (int iC = 0; iC < Chest.maxItems; iC++)                                         // go through entire chest inventory.
            {                                                                                   //if chest item is not blank && not a full stack, then
                if (!container[iC].IsBlank() && container[iC].stack < container[iC].maxStack)
                {                                                                               //for each item in inventory (including coins, ammo, hotbar),
                    for (int iP = 0; iP < 58; iP++)
                    {
                        if (checkLocks && IHPlayer.SlotLocked(iP))
                        {
                            continue;                                                           // if we're checking locks ignore the locked ones
                        }
                        if (container[iC].IsTheSameAs(inventory[iP]))                           //if chest item matches inv. item...
                        {
                            // RingBell();                                                       //...play "item-moved" sound and...
                            Sound.ItemMoved.Play();
                            // ...merge inv. item stack to chest item stack
                            if (StackMerge(ref inventory[iP], container, iC))
                            {                                                                   // do merge & check return (inv stack empty) status
                                inventory[iP] = new Item();                                     // reset slot if all inv stack moved
                            }
                            else if (container[iC].IsBlank())
                            {                                                                   // else, inv stack not empty after merge, but (because of DoCoins() call),
                                                                                                // chest stack could be.
                                container[iC] = inventory[iP].Clone();                          // move inv item to chest slot
                                inventory[iP] = new Item();                                     // and reset inv slot
                            }
                            // if (sendMessage) SendNetMessage(iC);                             //send net message if regular chest
                        }
                    }
                }
            }
            Recipe.FindRecipes(); // !ref:Main:#22640.36#
        }
Example #10
0
        protected override void AddButtonsToBases()
        {
            var bgColor = Constants.InvSlotColor * 0.8f;

            Func <TIH, string> getLabel = a => a.DefaultLabelForAction(true);

            Func <TIH, string> getTtip;

            if (IHBase.ModOptions["ShowTooltips"])
            {
                getTtip = a => getLabel(a) + (IHBase.ModOptions["ShowKeyBind"] ? a.GetKeyTip() : "");
            }
            else
            {
                getTtip = a => "";
            }

            Func <TIH, TIH, TexturedButton> getButton
                = (base_by_action, a)
                  => TexturedButton.New((ButtonSlot <TexturedButton>)ButtonBases[base_by_action],
                                        action: a,
                                        label: getLabel(a),
                                        tooltip: getTtip(a),
                                        bg_color: bgColor);

            // put buttons together
            var sort  = getButton(TIH.Sort, TIH.Sort);
            var rsort = getButton(TIH.Sort, TIH.ReverseSort);
            var clean = getButton(TIH.CleanStacks, TIH.CleanStacks);

            // add services/actions

            sort.AddSortToggle(rsort);
            //for funsies let's just make that whole toggle thing pointless
            sort.Hooks.OnRightClick  += () => IHPlayer.Sort(true);
            rsort.Hooks.OnRightClick += () => IHPlayer.Sort();

            // TODO: make right-click throw all of the player's items on the ground.
            // Haha j/k.
            //           Maybe.
            clean.EnableDefault();
        }
Example #11
0
 private bool PreDraw(SpriteBatch sb)
 {
     // don't run unless there's a change to avoid adding/removing
     // the event every frame
     if (IHPlayer.ActionLocked(Client.Action) != isLocked)
     {
         isLocked = !isLocked;
         if (isLocked)
         {
             Client.Hooks.PostDraw += PostDraw;
             // Client.Label = lockedLabel;
         }
         else
         {
             Client.Hooks.PostDraw -= PostDraw;
             // Client.Label = initialLabel;
         }
     }
     return(true);
 }
Example #12
0
        /// <summary>
        /// Construct a list containing cloned copies of items in the given
        /// container, skipping blank (and optionally locked) slots.
        /// </summary>
        /// <param name="source_container">The Item[] array of the container</param>
        /// <param name="source_is_chest">Is the source container a chest? </param>
        /// <param name="range">Starting and ending indices defining the subset of the
        /// source's slots to be searched for items.</param>
        /// <returns> The new list of copied items, or null if no items were
        /// applicable to be copied (NOT an empty list!).</returns>
        public static List <Item> GetItemCopies(Item[] source_container, bool source_is_chest, Tuple <int, int> range = null)
        {
            if (range == null)
            {
                range = new Tuple <int, int>(0, source_container.Length - 1);
            }

            // initialize the list that will hold the copied items
            var itemList = new List <Item>();

            int count = 0; //having trouble with empty lists...

            // get copies of viable items from container.
            // will need a different list if locking is enabled
            if (!source_is_chest && IHBase.ModOptions["LockingEnabled"])
            {
                for (int i = range.Item1; i <= range.Item2; i++)
                {
                    if (IHPlayer.SlotLocked(i) || source_container[i].IsBlank())
                    {
                        continue;
                    }

                    itemList.Add(source_container[i].Clone());
                    count++;
                }
            }
            else //only skip blank slots
            {
                for (int i = range.Item1; i <= range.Item2; i++)
                {
                    if (!source_container[i].IsBlank())
                    {
                        itemList.Add(source_container[i].Clone());
                    }
                    count++;
                }
            }
            // return null if no items were copied to new list
            return(count > 0 ? itemList : null);
        }
        // // // // // // //
        // Makin buttons
        // // // // // // //

        private void addTextButtons()
        {
            // just feels right, man.
            var lockOffset = new Vector2(-20, -18);

            // get original or default label
            Func <TIH, string> getLabel = a => a.DefaultLabelForAction(true)
                                          + (IHBase.ModOptions["ShowKeyBind"] ? a.GetKeyTip() : "");

            // put it all together, add to base
            Func <TIH, TIH, TextButton> getButton
                = (base_by_action, a)
                  => TextButton.New((ButtonSlot <TextButton>)ButtonBases[base_by_action],
                                    action: a,
                                    label: getLabel(a)
                                    );

            // putting these 2 on same base; see below
            var loot = getButton(TIH.LootAll, TIH.LootAll);
            var sort = getButton(TIH.LootAll, TIH.Sort);

            var depo = getButton(TIH.DepositAll, TIH.DepositAll);
            var sdep = getButton(TIH.DepositAll, TIH.SmartDeposit);
            var qstk = getButton(TIH.QuickStack, TIH.QuickStack);
            var sloo = getButton(TIH.QuickStack, TIH.SmartLoot);

            // * we're going to leave the vanilla buttons for these
            // var rena  = getButton(TIH.Rename,     TIH.Rename);
            // var save  = getButton(TIH.Rename,     TIH.SaveName);


            // here's an IDEA: Have LootAll toggle to Sort on shift.
            // Sort will reverse-sort on right-click.
            sort.EnableDefault().Hooks.OnRightClick += () => IHPlayer.Sort(true);
            loot.EnableDefault().AddToggle(sort);

            depo.EnableDefault().MakeLocking(lockOffset).AddToggle(sdep.EnableDefault());
            qstk.EnableDefault().MakeLocking(lockOffset).AddToggle(sloo.EnableDefault());
        }
Example #14
0
 public SortingToggleService(ICoreButton forward, ICoreButton reverse, KState.Special toggle_key) : base(forward, reverse, toggle_key)
 {
     sortAction    = () => IHPlayer.Sort();
     revSortAction = () => IHPlayer.Sort(true);
 }
Example #15
0
        static Constants()
        {
            LangInterIndices = new Dictionary <TIH, int>
            {
                { TIH.LootAll, 29 },
                { TIH.DepositAll, 30 },
                { TIH.QuickStack, 31 },
                { TIH.Rename, 61 },
                { TIH.SaveName, 47 },
                { TIH.CancelEdit, 63 }
            };


            DefaultButtonLabels = new Dictionary <TIH, string>
            {
                // Player Inventory
                { TIH.None, "" },
                { TIH.Sort, "Sort" },
                { TIH.ReverseSort, "Sort (Reverse)" },

                { TIH.CleanStacks, "Clean Stacks" },
                // Chests
                { TIH.SmartLoot, "Restock" },
                { TIH.QuickStack, "Quick Stack" },
                { TIH.SmartDeposit, "Smart Deposit" },
                { TIH.DepositAll, "Deposit All" },
                { TIH.LootAll, "Loot All" },
                { TIH.Rename, "Rename" },
                { TIH.SaveName, "Save" },
                { TIH.CancelEdit, "Cancel" }
            };

            DefaultClickActions = new Dictionary <TIH, Action>
            {
                { TIH.None, None },  // now unused. Remove?

                { TIH.Sort, () => IHPlayer.Sort() },
                { TIH.ReverseSort, () => IHPlayer.Sort(true) },
                { TIH.CleanStacks, IHPlayer.CleanStacks },
                // Chest-only
                { TIH.SmartLoot, IHSmartStash.SmartLoot },
                { TIH.QuickStack, IHUtils.DoQuickStack },
                { TIH.SmartDeposit, IHSmartStash.SmartDeposit },
                { TIH.DepositAll, IHUtils.DoDepositAll },
                { TIH.LootAll, IHUtils.DoLootAll },
                { TIH.Rename, EditChest.DoChestEdit },
                { TIH.SaveName, EditChest.DoChestEdit },
                { TIH.CancelEdit, EditChest.CancelRename }
            };

            /************************************************
             * Make getting a button's texture (texels) easier
             */
            ButtonGridIndexByActionType = new Dictionary <TIH, int>
            {
                { TIH.Sort, 0 },

                { TIH.ReverseSort, 1 },

                { TIH.LootAll, 2 },

                { TIH.DepositAll, 3 },

                { TIH.SmartDeposit, 4 },

                { TIH.CleanStacks, 5 },

                { TIH.QuickStack, 6 },

                { TIH.SmartLoot, 7 },

                { TIH.Rename, 8 },
                { TIH.SaveName, 8 }     // this just varies by background color from Rename
            };

            /*************************************************
             * Map action types to the string used for the corresponding
             * keybind in Modoptions.json
             */
            ButtonActionToKeyBindOption = new Dictionary <TIH, string>()
            {
                { TIH.CleanStacks, "cleanStacks" },

                { TIH.DepositAll, "depositAll" },
                { TIH.SmartDeposit, "depositAll" },

                { TIH.LootAll, "lootAll" },

                { TIH.QuickStack, "quickStack" },
                { TIH.SmartLoot, "quickStack" },

                { TIH.Sort, "sort" },
                { TIH.ReverseSort, "sort" },
                // edit chest doesn't get a keyboard shortcut. So there.
            };
        }
Example #16
0
        /// <returns>True if indicated action is set to respect locked slots.</returns>
        public static bool ActionLocked(Player player, TIH actionID)
        {
            IHPlayer mp = player.GetSubClass <IHPlayer>();

            return(mp.LockedActions[actionID]);
        }
Example #17
0
        // TODO: Here are my thoughts on making sure shift-click syncs correctly with
        // the server: obviously, blindly placing the NetMessage update calls
        // wherever it seemed like Vanilla indicated they should go didn't work.
        // Now that I have a better understanding of what all that rigamarole is
        // supposed to do, I think that the most efficient way to handle this
        // would be to have any function that modifies a slot or slots in a
        // container record or return a list of the indices of those slots.
        // Numerous methods in IHUtils already return an int to indicate the
        // effect of their run, but only under certain conditions does that int
        // indicate the affected index. Other return statuses (statii?) could
        // indicate a modified slot or even multiple slots, but since I didn't
        // think I had any immediate need to know which slots those were, that
        // information was not recorded.

        // Now, it wouldn't be too hard to whip up a small data-transfer-object
        // that can be passed between method calls and hold both the return
        // status as it is now and a record of any slots which were modified
        // along the way; this would prevent us from having to take a
        // sledgehammer approach like we did with the calls that modify
        // chest-item-slot en-masse. While the sledge may be the best or
        // most-effective tool when many slots are likely to be modified at
        // once, this shift-click isn't likely to affect more than a few during
        // any one run, and looping over the entire container atleast twice for
        // each click is probably something we should avoid if we can.

        // Of course this is all obvious and I'm just being verbose for
        // absolute-clarity's sake. My point--and the catch--is that even
        // though the DTO would be simple to create and use, the code in IHUtils
        // is much more of a tangled mass of spaghetti-code than I realized, and
        // tracing down every spot where we'd need to make changes (though
        // likely small) to the code to integrate the object will be a delicate
        // job very prone to breaking things in unexpected ways. At least with
        // my luch it would be.  Anyway, that's why, for now, I'm going to take
        // the sledgehammer to this and hope it doesn't affect performance too
        // badly.

        /// <summary>
        /// Shift + Left Click on item slot to move it between inventory and chest
        /// </summary>
        /// <param name="slot"> </param>
        /// <param name="release"> </param>
        /// <returns>True if shift not held while left-clicking, or if no applicable
        /// recipient is present to move item into. </returns>
        public override bool PreItemSlotLeftClick(ItemSlot slot, ref bool release)
        {
            if (!(bool)IHBase.Instance.options["enableShiftMove"].Value)
            {
                return(true);
            }

            if (slot.modBase == null && release && KState.Special.Shift.Down())
            {
                if (Main.localPlayer.chestItems != null && !slot.MyItem.IsBlank()) //chests and banks
                {
                    // Moving inventory item -> chest
                    if (slot.type == "Inventory" || slot.type == "Coin" || slot.type == "Ammo")
                    {
                        IHPlayer.DoChestUpdateAction(
                            () => {
                            if (IHUtils.ShiftToChest(ref slot))
                            {
                                Recipe.FindRecipes(); // !ref:Main:#22640.36#
                            }
                        });
                    }
                    // Moving chest item -> inventory
                    else if (slot.type == "Chest")
                    {
                        if (IHUtils.ShiftToPlayer(ref slot, Main.localPlayer.chest > -1))
                        {
                            Recipe.FindRecipes();

                            // We can take the easy route here since there's only
                            // one chest slot that could have been affected.
                            if (Main.netMode == 1 && Main.localPlayer.chest > -1) //non-bank
                            {
                                IHUtils.SendNetMessage(slot.index);
                            }
                        }
                    }
                    return(false);
                }
                if (Main.craftGuide) //the Guide's crafting info slot
                {
                    if (Main.guideItem.IsBlank() && !slot.MyItem.IsBlank() && (slot.type == "Inventory" || slot.type == "Coin" || slot.type == "Ammo"))
                    {
                        if (slot.MyItem.material && !slot.MyItem.notMaterial)
                        {
                            Sound.ItemMoved.Play();
                            Main.guideItem = slot.MyItem.Clone();
                            slot.MyItem    = new Item();
                            Recipe.FindRecipes();
                        }
                    }
                    else if (!Main.guideItem.IsBlank() && slot.type == "CraftGuide")
                    {
                        if (IHUtils.ShiftToPlayer(ref slot, false))
                        {
                            Main.guideItem = new Item();
                        }
                        Recipe.FindRecipes();
                    }
                    return(false);
                }
                if (Main.reforge) //Item reforging
                {
                    if (Main.reforgeItem.IsBlank() && slot.type == "Inventory" && !slot.MyItem.IsBlank())
                    {
                        if (slot.MyItem.maxStack == 1 && Prefix.CanHavePrefix(slot.MyItem))
                        {
                            Sound.ItemMoved.Play();
                            Main.reforgeItem = slot.MyItem.Clone();
                            slot.MyItem      = new Item();
                            Recipe.FindRecipes();
                        }
                    }
                    else if (!Main.reforgeItem.IsBlank() && slot.type == "Reforge")
                    {
                        if (IHUtils.ShiftToPlayer(ref slot, false))
                        {
                            Main.reforgeItem = new Item();
                        }
                        Recipe.FindRecipes();
                    }
                    return(false);
                }
            }
            return(true);
        }
Example #18
0
        /// Set indicated action to respect/not-respect locked slots,
        /// depending on current status.
        public static void ToggleActionLock(Player p, TIH actionID)
        {
            IHPlayer mp = p.GetSubClass <IHPlayer>();

            mp.LockedActions[actionID] = !mp.LockedActions[actionID];
        }
        private void addIconButtons()
        {
            // offset of lock indicator
            var lockOffset = new Vector2(-(float)(int)((float)Constants.ButtonW / 2) - 4,
                                         -(float)(int)((float)Constants.ButtonH / 2) + 8);

            Func <TIH, string> getLabel = a => Constants.DefaultButtonLabels[a];
            Func <TIH, Color>  getBGcol = (a) => (a == TIH.SaveName)
                                                ? Constants.EquipSlotColor * 0.85f
                                                : Constants.ChestSlotColor * 0.85f;
            Func <TIH, string> getTtip;

            if (IHBase.ModOptions["ShowTooltips"])
            {
                if (IHBase.ModOptions["ShowKeyBind"])
                {
                    getTtip = a => getLabel(a) + IHUtils.GetKeyTip(a);
                }
                else
                {
                    getTtip = a => getLabel(a);
                }
            }
            else
            {
                getTtip = a => "";
            }

            Func <TIH, TIH, TexturedButton> getButton
                = (base_by_action, a)
                  => TexturedButton.New((ButtonSlot <TexturedButton>)ButtonBases[base_by_action],
                                        action: a,
                                        label: getLabel(a),
                                        tooltip: getTtip(a),
                                        bg_color: getBGcol(a),
                                        texture: IHBase.ButtonGrid,
                                        inactive_rect: IHUtils.GetSourceRect(a),
                                        active_rect: IHUtils.GetSourceRect(a, true)
                                        );

            // Btn obj            Socket Action   Button Action
            // -------            -------------   -------------
            var sort  = getButton(TIH.Sort, TIH.Sort);
            var rsort = getButton(TIH.Sort, TIH.ReverseSort);
            var loot  = getButton(TIH.LootAll, TIH.LootAll);
            var depo  = getButton(TIH.DepositAll, TIH.DepositAll);
            var sdep  = getButton(TIH.DepositAll, TIH.SmartDeposit);
            var qstk  = getButton(TIH.QuickStack, TIH.QuickStack);
            var sloo  = getButton(TIH.QuickStack, TIH.SmartLoot);
            var rena  = getButton(TIH.Rename, TIH.Rename);
            var save  = getButton(TIH.Rename, TIH.SaveName);

            var cancel = TextButton.New(CancelEditBase, TIH.CancelEdit, getLabel(TIH.CancelEdit));


            // Add Services //

            // sort enables default action for sort/rsort by ... default.
            sort.AddSortToggle(rsort);
            //for funsies let's just make that whole toggle thing pointless
            sort.Hooks.OnRightClick  += () => IHPlayer.Sort(true);
            rsort.Hooks.OnRightClick += () => IHPlayer.Sort();


            // add default click, let rClick lock it, and make shift switch buttons
            depo.EnableDefault().MakeLocking(lockOffset, Color.Firebrick).AddToggle(sdep.EnableDefault());
            qstk.EnableDefault().MakeLocking(lockOffset, Color.Firebrick).AddToggle(sloo.EnableDefault());

            // these just need their default actions enabled.
            loot.EnableDefault().Hooks.OnRightClick += () => IHPlayer.CleanStacks();  //why not
            cancel.EnableDefault();
            // this prevents the "Cancel" text from being too big when the player
            // goes back into the rename interface (though it seems the vanilla
            // "Cancel" text behaves the same way...improvement!)
            cancel.Hooks.OnClick += CancelEditBase.ResetScale;

            // make Rename Chest button change to Save Name button when
            // clicked, and vice-versa. Well, technically, the buttons will
            // switch automatically when Main.editChest changes state, but
            // since that's what clicking these buttons does...
            save.EnableDefault().AddDynamicToggle(rena.EnableDefault(), () => Main.editChest);
        }
Example #20
0
        public static void Sort(Item[] container, bool chest, bool reverse, Tuple <int, int> range = null)
        {
            // if range param not specified, set it to whole container
            if (range == null)
            {
                range = new Tuple <int, int>(0, container.Length - 1);
            }

            // for clarity
            var checkLocks = IHBase.ModOptions["LockingEnabled"]; //boolean

            // get copies of the items and send them off to be sorted
            var sortedItemList = OrganizeItems(GetItemCopies(container, chest, range));

            if (sortedItemList == null)
            {
                return;
            }

            if (reverse)
            {
                sortedItemList.Reverse();          //reverse on user request
            }
            // depending on user settings, decide if we copy items to end or beginning of container
            var fillFromEnd = chest ? IHBase.ModOptions["RearSortChest"] : IHBase.ModOptions["RearSortPlayer"]; //boolean

            // set up the functions that will be used in the iterators ahead
            Func <int, int>  getIndex, getIter;
            Func <int, bool> getCond, getWhileCond;

            if (fillFromEnd)    // use decrementing iterators
            {
                getIndex     = x => range.Item2 - x;
                getIter      = x => x - 1;
                getCond      = x => x >= range.Item1;
                getWhileCond = x => x > range.Item1 && IHPlayer.SlotLocked(x);
            }
            else        // use incrementing iterators
            {
                getIndex     = y => range.Item1 + y;
                getIter      = y => y + 1;
                getCond      = y => y <= range.Item2;
                getWhileCond = y => y < range.Item2 && IHPlayer.SlotLocked(y);
            }

            int filled = 0;           // num of slots filled (or locked) so far

            if (!chest && checkLocks) // player inv with locking enabled
            {
                // copy the sorted items back to the original container
                // (overwriting the current, unsorted contents)
                foreach (var item in sortedItemList)
                {
                    // find the first unlocked slot. this would throw an
                    // exception if range.Item1+filled somehow went over 49, but
                    // if the categorizer and slot-locker are functioning
                    // correctly, that _shouldn't_ be possible. Shouldn't.
                    // Probably.
                    while (IHPlayer.SlotLocked(getIndex(filled)))
                    {
                        filled++;
                    }

                    // now that we've found an unlocked slot, clone
                    // the next sorted item into it.
                    container[getIndex(filled++)] = item.Clone();
                    Sound.ItemMoved.Play();
                }
                // and the rest of the slots should be empty
                for (int i = getIndex(filled); getCond(i); i = getIter(i))
                {
                    // find the first unlocked slot.
                    if (IHPlayer.SlotLocked(i))
                    {
                        continue;
                    }

                    container[i] = new Item();
                }
            }
            else // just run through 'em all
            {
                foreach (var item in sortedItemList)
                {
                    container[getIndex(filled++)] = item.Clone();
                    Sound.ItemMoved.Play();
                }
                // and the rest of the slots should be empty
                for (int i = getIndex(filled); getCond(i); i = getIter(i))
                {
                    container[i] = new Item();
                }
            }
        } // sort()
Example #21
0
 private void ToggleLock()
 {
     Sound.Lock.Play();
     IHPlayer.ToggleActionLock(Client.Action);
 }