summaryrefslogtreecommitdiff
path: root/src/SMAPI.Mods.ConsoleCommands/Framework/ItemRepository.cs
blob: e678d0577cd3b73eccf63a47d557e7afc68f5c1d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData;
using StardewValley;
using StardewValley.Objects;
using StardewValley.Tools;
using SObject = StardewValley.Object;

namespace StardewModdingAPI.Mods.ConsoleCommands.Framework
{
    /// <summary>Provides methods for searching and constructing items.</summary>
    internal class ItemRepository
    {
        /*********
        ** Properties
        *********/
        /// <summary>The custom ID offset for items don't have a unique ID in the game.</summary>
        private readonly int CustomIDOffset = 1000;


        /*********
        ** Public methods
        *********/
        /// <summary>Get all spawnable items.</summary>
        public IEnumerable<SearchableItem> GetAll()
        {
            // get tools
            for (int quality = Tool.stone; quality <= Tool.iridium; quality++)
            {
                yield return new SearchableItem(ItemType.Tool, ToolFactory.axe, ToolFactory.getToolFromDescription(ToolFactory.axe, quality));
                yield return new SearchableItem(ItemType.Tool, ToolFactory.hoe, ToolFactory.getToolFromDescription(ToolFactory.hoe, quality));
                yield return new SearchableItem(ItemType.Tool, ToolFactory.pickAxe, ToolFactory.getToolFromDescription(ToolFactory.pickAxe, quality));
                yield return new SearchableItem(ItemType.Tool, ToolFactory.wateringCan, ToolFactory.getToolFromDescription(ToolFactory.wateringCan, quality));
                if (quality != Tool.iridium)
                    yield return new SearchableItem(ItemType.Tool, ToolFactory.fishingRod, ToolFactory.getToolFromDescription(ToolFactory.fishingRod, quality));
            }
            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset, new MilkPail()); // these don't have any sort of ID, so we'll just assign some arbitrary ones
            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset + 1, new Shears());
            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset + 2, new Pan());

            // wallpapers
            for (int id = 0; id < 112; id++)
                yield return new SearchableItem(ItemType.Wallpaper, id, new Wallpaper(id));

            // flooring
            for (int id = 0; id < 40; id++)
                yield return new SearchableItem(ItemType.Flooring, id, new Wallpaper(id, isFloor: true));

            // equipment
            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\Boots").Keys)
                yield return new SearchableItem(ItemType.Boots, id, new Boots(id));
            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\hats").Keys)
                yield return new SearchableItem(ItemType.Hat, id, new Hat(id));
            foreach (int id in Game1.objectInformation.Keys)
            {
                if (id >= Ring.ringLowerIndexRange && id <= Ring.ringUpperIndexRange)
                    yield return new SearchableItem(ItemType.Ring, id, new Ring(id));
            }

            // weapons
            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\weapons").Keys)
            {
                Item weapon = (id >= 32 && id <= 34)
                    ? (Item)new Slingshot(id)
                    : new MeleeWeapon(id);
                yield return new SearchableItem(ItemType.Weapon, id, weapon);
            }

            // furniture
            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\Furniture").Keys)
            {
                if (id == 1466 || id == 1468)
                    yield return new SearchableItem(ItemType.Furniture, id, new TV(id, Vector2.Zero));
                else
                    yield return new SearchableItem(ItemType.Furniture, id, new Furniture(id, Vector2.Zero));
            }

            // fish
            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\Fish").Keys)
                yield return new SearchableItem(ItemType.Fish, id, new SObject(id, 999));

            // craftables
            foreach (int id in Game1.bigCraftablesInformation.Keys)
                yield return new SearchableItem(ItemType.BigCraftable, id, new SObject(Vector2.Zero, id));

            // secret notes
            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\SecretNotes").Keys)
            {
                SObject note = new SObject(79, 1);
                note.name = $"{note.name} #{id}";
                yield return new SearchableItem(ItemType.Object, this.CustomIDOffset + id, note);
            }

            // objects
            foreach (int id in Game1.objectInformation.Keys)
            {
                if (id == 79)
                    continue; // secret note handled above
                if (id >= Ring.ringLowerIndexRange && id <= Ring.ringUpperIndexRange)
                    continue; // handled separated

                SObject item = new SObject(id, 1);
                yield return new SearchableItem(ItemType.Object, id, item);

                // fruit products
                if (item.category == SObject.FruitsCategory)
                {
                    // wine
                    SObject wine = new SObject(348, 1)
                    {
                        Name = $"{item.Name} Wine",
                        Price = item.price * 3
                    };
                    wine.preserve.Value = SObject.PreserveType.Wine;
                    wine.preservedParentSheetIndex.Value = item.parentSheetIndex;
                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 2 + id, wine);

                    // jelly
                    SObject jelly = new SObject(344, 1)
                    {
                        Name = $"{item.Name} Jelly",
                        Price = 50 + item.Price * 2
                    };
                    jelly.preserve.Value = SObject.PreserveType.Jelly;
                    jelly.preservedParentSheetIndex.Value = item.parentSheetIndex;
                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 3 + id, jelly);
                }

                // vegetable products
                else if (item.category == SObject.VegetableCategory)
                {
                    // juice
                    SObject juice = new SObject(350, 1)
                    {
                        Name = $"{item.Name} Juice",
                        Price = (int)(item.price * 2.25d)
                    };
                    juice.preserve.Value = SObject.PreserveType.Juice;
                    juice.preservedParentSheetIndex.Value = item.parentSheetIndex;
                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 4 + id, juice);

                    // pickled
                    SObject pickled = new SObject(342, 1)
                    {
                        Name = $"Pickled {item.Name}",
                        Price = 50 + item.Price * 2
                    };
                    pickled.preserve.Value = SObject.PreserveType.Pickle;
                    pickled.preservedParentSheetIndex.Value = item.parentSheetIndex;
                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 5 + id, pickled);
                }

                // flower honey
                else if (item.category == SObject.flowersCategory)
                {
                    // get honey type
                    SObject.HoneyType? type = null;
                    switch (item.parentSheetIndex)
                    {
                        case 376:
                            type = SObject.HoneyType.Poppy;
                            break;
                        case 591:
                            type = SObject.HoneyType.Tulip;
                            break;
                        case 593:
                            type = SObject.HoneyType.SummerSpangle;
                            break;
                        case 595:
                            type = SObject.HoneyType.FairyRose;
                            break;
                        case 597:
                            type = SObject.HoneyType.BlueJazz;
                            break;
                        case 421: // sunflower standing in for all other flowers
                            type = SObject.HoneyType.Wild;
                            break;
                    }

                    // yield honey
                    if (type != null)
                    {
                        SObject honey = new SObject(Vector2.Zero, 340, item.Name + " Honey", false, true, false, false)
                        {
                            Name = "Wild Honey"
                        };
                        honey.honeyType.Value = type;

                        if (type != SObject.HoneyType.Wild)
                        {
                            honey.Name = $"{item.Name} Honey";
                            honey.Price += item.Price * 2;
                        }
                        yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 5 + id, honey);
                    }
                }
            }
        }
    }
}