blob: 2a276246a6294dd48b6655b8f3dbe76c9af12fd5 (
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
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
package org.bukkit.inventory;
import java.util.HashMap;
import org.bukkit.Material;
/**
* Interface to the various inventories
*/
public interface Inventory {
/**
* Returns the size of the inventory
*
* @return The inventory size
*/
public int getSize();
/**
* Return the name of the inventory
*
* @return The inventory name
*/
public String getName();
/**
* Get the ItemStack found in the slot at the given index
*
* @param index The index of the Slot's ItemStack to return
* @return The ItemStack in the slot
*/
public ItemStack getItem(int index);
/**
* Stores the ItemStack at the given index
*
* @param index The index where to put the ItemStack
* @param item The ItemStack to set
*/
public void setItem(int index, ItemStack item);
/**
* Stores the given ItemStacks in the inventory.
* This will try to fill existing stacks and empty slots as good as it can.
* It will return a HashMap of what it couldn't fit.
*
* @param items The ItemStacks to add
* @return The items that didn't fit.
*/
public HashMap<Integer, ItemStack> addItem(ItemStack... items);
/**
* Removes the given ItemStacks from the inventory.
* <p />
* It will try to remove 'as much as possible' from the types and amounts you
* give as arguments. It will return a HashMap of what it couldn't remove.
*
* @param items The ItemStacks to remove
* @return The items that couldn't be removed.
*/
public HashMap<Integer, ItemStack> removeItem(ItemStack... items);
/**
* Get all ItemStacks from the inventory
*
* @return All the ItemStacks from all slots
*/
public ItemStack[] getContents();
/**
* Set the inventory's contents
*
* @param items A complete replacement for the contents; the length must be equal to {@link #getSize()}.
*/
public void setContents(ItemStack[] items);
/**
* Check if the inventory contains any ItemStacks with the given materialId
*
* @param materialId The materialId to check for
* @return If any ItemStacks were found
*/
public boolean contains(int materialId);
/**
* Check if the inventory contains any ItemStacks with the given material
*
* @param material The material to check for
* @return If any ItemStacks were found
*/
public boolean contains(Material material);
/**
* Check if the inventory contains any ItemStacks matching the given ItemStack
* This will only match if both the type and the amount of the stack match
*
* @param item The ItemStack to match against
* @return If any matching ItemStacks were found
*/
public boolean contains(ItemStack item);
/**
* Check if the inventory contains any ItemStacks with the given materialId and at least the minimum amount specified
*
* @param materialId The materialId to check for
* @param amount The minimum amount to look for
* @return If any ItemStacks were found
*/
public boolean contains(int materialId, int amount);
/**
* Check if the inventory contains any ItemStacks with the given material and at least the minimum amount specified
*
* @param material The material to check for
* @param amount The minimum amount
* @return If any ItemStacks were found
*/
public boolean contains(Material material, int amount);
/**
* Check if the inventory contains any ItemStacks matching the given ItemStack and at least the minimum amount specified
* This will only match if both the type and the amount of the stack match
*
* @param item The ItemStack to match against
* @param amount The minimum amount
* @return If any matching ItemStacks were found
*/
public boolean contains(ItemStack item, int amount);
/**
* Find all slots in the inventory containing any ItemStacks with the given materialId
*
* @param materialId The materialId to look for
* @return The Slots found.
*/
public HashMap<Integer, ? extends ItemStack> all(int materialId);
/**
* Find all slots in the inventory containing any ItemStacks with the given material
*
* @param material The material to look for
* @return The Slots found.
*/
public HashMap<Integer, ? extends ItemStack> all(Material material);
/**
* Find all slots in the inventory containing any ItemStacks with the given ItemStack
* This will only match slots if both the type and the amount of the stack match
*
* @param item The ItemStack to match against
* @return The Slots found.
*/
public HashMap<Integer, ? extends ItemStack> all(ItemStack item);
/**
* Find the first slot in the inventory containing an ItemStack with the given materialId
*
* @param materialId The materialId to look for
* @return The Slot found.
*/
public int first(int materialId);
/**
* Find the first slot in the inventory containing an ItemStack with the given material
*
* @param material The material to look for
* @return The Slot found.
*/
public int first(Material material);
/**
* Find the first slot in the inventory containing an ItemStack with the given stack
* This will only match a slot if both the type and the amount of the stack match
*
* @param item The ItemStack to match against
* @return The Slot found.
*/
public int first(ItemStack item);
/**
* Find the first empty Slot.
*
* @return The first empty Slot found.
*/
public int firstEmpty();
/**
* Remove all stacks in the inventory matching the given materialId.
*
* @param materialId The material to remove
*/
public void remove(int materialId);
/**
* Remove all stacks in the inventory matching the given material.
*
* @param material The material to remove
*/
public void remove(Material material);
/**
* Remove all stacks in the inventory matching the given stack.
* This will only match a slot if both the type and the amount of the stack match
*
* @param item The ItemStack to match against
*/
public void remove(ItemStack item);
/**
* Clear out a particular slot in the index
*
* @param index The index to empty.
*/
public void clear(int index);
/**
* Clear out the whole index
*/
public void clear();
}
|
