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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
|
package org.bukkit.entity;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.inventory.EntityEquipment;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
/**
* Represents a living entity, such as a monster or player
*/
public interface LivingEntity extends Entity {
/**
* Gets the entity's health from 0 to {@link #getMaxHealth()}, where 0 is dead
*
* @return Health represented from 0 to max
*/
public int getHealth();
/**
* Sets the entity's health from 0 to {@link #getMaxHealth()}, where 0 is dead
*
* @param health New health represented from 0 to max
* @throws IllegalArgumentException Thrown if the health is < 0 or > max
*/
public void setHealth(int health);
/**
* Gets the maximum health this entity may have
*
* @return Maximum health
*/
public int getMaxHealth();
/**
* Gets the height of the entity's head above its Location
*
* @return Height of the entity's eyes above its Location
*/
public double getEyeHeight();
/**
* Gets the height of the entity's head above its Location
*
* @param ignoreSneaking If set to true, the effects of sneaking will be ignored
* @return Height of the entity's eyes above its Location
*/
public double getEyeHeight(boolean ignoreSneaking);
/**
* Get a Location detailing the current eye position of the LivingEntity.
*
* @return a Location at the eyes of the LivingEntity.
*/
public Location getEyeLocation();
/**
* Gets all blocks along the player's line of sight
* List iterates from player's position to target inclusive
*
* @param transparent HashSet containing all transparent block IDs. If set to null only air is considered transparent.
* @param maxDistance This is the maximum distance to scan. This may be further limited by the server, but never to less than 100 blocks.
* @return List containing all blocks along the player's line of sight
*/
public List<Block> getLineOfSight(HashSet<Byte> transparent, int maxDistance);
/**
* Gets the block that the player has targeted
*
* @param transparent HashSet containing all transparent block IDs. If set to null only air is considered transparent.
* @param maxDistance This is the maximum distance to scan. This may be further limited by the server, but never to less than 100 blocks.
* @return Block that the player has targeted
*/
public Block getTargetBlock(HashSet<Byte> transparent, int maxDistance);
/**
* Gets the last two blocks along the player's line of sight.
* The target block will be the last block in the list.
*
* @param transparent HashSet containing all transparent block IDs. If set to null only air is considered transparent.
* @param maxDistance This is the maximum distance to scan. This may be further limited by the server, but never to less than 100 blocks
* @return List containing the last 2 blocks along the player's line of sight
*/
public List<Block> getLastTwoTargetBlocks(HashSet<Byte> transparent, int maxDistance);
/**
* Throws an egg from the entity.
*
* @deprecated Use launchProjectile(Egg.class) instead
* @return The egg thrown.
*/
@Deprecated
public Egg throwEgg();
/**
* Throws a snowball from the entity.
*
* @deprecated Use launchProjectile(Snowball.class) instead
* @return The snowball thrown.
*/
@Deprecated
public Snowball throwSnowball();
/**
* Shoots an arrow from the entity.
*
* @deprecated Use launchProjectile(Arrow.class) instead
* @return The arrow shot.
*/
@Deprecated
public Arrow shootArrow();
/**
* Launches a {@link Projectile} from the entity.
*
* @param projectile Class of the projectile to launch
*
* @return The launched projectile.
*/
public <T extends Projectile> T launchProjectile(Class<? extends T> projectile);
/**
* Returns the amount of air that this entity has remaining, in ticks
*
* @return Amount of air remaining
*/
public int getRemainingAir();
/**
* Sets the amount of air that this entity has remaining, in ticks
*
* @param ticks Amount of air remaining
*/
public void setRemainingAir(int ticks);
/**
* Returns the maximum amount of air this entity can have, in ticks
*
* @return Maximum amount of air
*/
public int getMaximumAir();
/**
* Sets the maximum amount of air this entity can have, in ticks
*
* @param ticks Maximum amount of air
*/
public void setMaximumAir(int ticks);
/**
* Deals the given amount of damage to this entity
*
* @param amount Amount of damage to deal
*/
public void damage(int amount);
/**
* Deals the given amount of damage to this entity, from a specified entity
*
* @param amount Amount of damage to deal
* @param source Entity which to attribute this damage from
*/
public void damage(int amount, Entity source);
/**
* Returns the entities current maximum noDamageTicks
* This is the time in ticks the entity will become unable to take
* equal or less damage than the lastDamage
*
* @return noDamageTicks
*/
public int getMaximumNoDamageTicks();
/**
* Sets the entities current maximum noDamageTicks
*
* @param ticks maximumNoDamageTicks
*/
public void setMaximumNoDamageTicks(int ticks);
/**
* Returns the entities lastDamage taken in the current noDamageTicks time.
* Only damage higher than this amount will further damage the entity.
*
* @return lastDamage
*/
public int getLastDamage();
/**
* Sets the entities current maximum noDamageTicks
*
* @param damage last damage
*/
public void setLastDamage(int damage);
/**
* Returns the entities current noDamageTicks
*
* @return noDamageTicks
*/
public int getNoDamageTicks();
/**
* Sets the entities current noDamageTicks
*
* @param ticks NoDamageTicks
*/
public void setNoDamageTicks(int ticks);
/**
* Gets the player identified as the killer of this entity.
* <p />
* May be null.
*
* @return Killer player, or null if none found.
*/
public Player getKiller();
/**
* Adds the given {@link PotionEffect} to this entity.
* Only one potion effect can be present for a given {@link PotionEffectType}.
*
* @param effect PotionEffect to be added
* @return Whether the effect could be added
*/
public boolean addPotionEffect(PotionEffect effect);
/**
* Adds the given {@link PotionEffect} to this entity.
* Only one potion effect can be present for a given {@link PotionEffectType}.
*
* @param effect PotionEffect to be added
* @param force Whether conflicting effects should be removed
* @return Whether the effect could be added
*/
public boolean addPotionEffect(PotionEffect effect, boolean force);
/**
* Attempts to add all of the given {@link PotionEffect} to this entity.
*
* @param effects The effects to add
* @return Whether all of the effects could be added
*/
public boolean addPotionEffects(Collection<PotionEffect> effects);
/**
* Returns whether the entity already has an existing
* effect of the given {@link PotionEffectType} applied to it.
*
* @param type The potion type to check
* @return Whether the player has this potion effect active on them.
*/
public boolean hasPotionEffect(PotionEffectType type);
/**
* Removes any effects present of the given {@link PotionEffectType}.
*
* @param type The potion type to remove
*/
public void removePotionEffect(PotionEffectType type);
/**
* Returns all currently active {@link PotionEffect}s on this entity.
*
* @return A collection of {@link PotionEffect}s
*/
public Collection<PotionEffect> getActivePotionEffects();
/**
* Checks whether the entity has block line of sight to another.<br />
* This uses the same algorithm that hostile mobs use to find the closest player.
*
* @param other The entity to determine line of sight to.
* @return true if there is a line of sight, false if not.
*/
public boolean hasLineOfSight(Entity other);
/**
* Returns if the entity despawns when away from players or not.<br />
* By default animals are not removed while other mobs are.
*
* @return true if the entity is removed when away from players
*/
public boolean getRemoveWhenFarAway();
/**
* Sets whether or not the entity despawns when away from players or not.
*
* @param remove The remove status
*/
public void setRemoveWhenFarAway(boolean remove);
/**
* Gets the inventory with the equipment worn by this entity.
*
* @return the entities inventory.
*/
public EntityEquipment getEquipment();
/**
* Sets whether or not the entity can pick up items
*
* @param pickup Whether or not the entity can pick up items
*/
public void setCanPickupItems(boolean pickup);
/**
* Gets if the entity can pick up items
*
* @return whether or not the entity can pick up items
*/
public boolean getCanPickupItems();
}
|