Merge branch 'api-8' into api-9

Author: Daniel Naylor

src/main/java/org/spongepowered/api/command/manager/CommandMapping.java

@@ -27,6 +27,7 @@
 import org.spongepowered.api.command.registrar.CommandRegistrar;
 import org.spongepowered.plugin.PluginContainer;
 
+import java.util.Optional;
 import java.util.Set;
 
 /**
@@ -59,11 +60,11 @@ public interface CommandMapping {
     Set<String> allAliases();
 
     /**
-     * Gets the plugin that owns the command.
+     * Gets the plugin that owns the command, if known.
      *
      * @return The plugin.
      */
-    PluginContainer plugin();
+    Optional<PluginContainer> plugin();
 
     /**
      * Gets the {@link CommandRegistrar} that registered this command.

src/main/java/org/spongepowered/api/data/Keys.java

@@ -443,7 +443,7 @@ public final class Keys {
 
     /**
      * The {@link BossBar} displayed to the client by a {@link Boss}.
-     * Readonly but mutable?
+     * TODO Readonly but mutable?
      */
     public static final Key<Value<BossBar>> BOSS_BAR = Keys.key(ResourceKey.sponge("boss_bar"), BossBar.class);
 
@@ -603,11 +603,11 @@ public final class Keys {
     public static final Key<Value<SpellType>> CURRENT_SPELL = Keys.key(ResourceKey.sponge("current_spell"), SpellType.class);
 
     /**
-     * The damage dealt towards entities of a specific {@link EntityType} by a {@link DamagingProjectile}.
+     * The damage dealt towards entities of a specific {@link EntityType} by a {@link ArrowEntity}.
      *
      * <p>Note that in events, the damage defined for the provided
      * {@link EntityType} will take priority over the "default" damage as
-     * defined from {@link DamagingProjectile#attackDamage()}.</p>
+     * defined from {@link ArrowEntity#attackDamage()}.</p>
      *
      * <p>Types not present in this mapping will be
      * dealt damage to according to {@link #ATTACK_DAMAGE}.</p>
@@ -2585,7 +2585,7 @@ public final class Keys {
     public static final Key<Value<Boolean>> TRACKS_OUTPUT = Keys.key(ResourceKey.sponge("tracks_output"), Boolean.class);
 
     /**
-     * Tge {@link TradeOffer}s offered by a {@link Trader}.
+     * The {@link TradeOffer}s offered by a {@link Trader}.
      */
     public static final Key<ListValue<TradeOffer>> TRADE_OFFERS = Keys.listKey(ResourceKey.sponge("trade_offers"), TradeOffer.class);
 

src/main/java/org/spongepowered/api/entity/AreaEffectCloud.java

@@ -128,14 +128,4 @@ default Value.Mutable<Ticks> applicationDelay() {
     default ListValue.Mutable<PotionEffect> effects() {
         return this.requireValue(Keys.POTION_EFFECTS).asMutable();
     }
-
-    /**
-     * {@link Keys#AGE}
-     *
-     * @return The age of this cloud
-     */
-    default Value.Mutable<Integer> age() {
-        return this.requireValue(Keys.AGE).asMutable();
-    }
-
 }

src/main/java/org/spongepowered/api/entity/Entity.java

@@ -31,6 +31,7 @@
 import org.spongepowered.api.data.Keys;
 import org.spongepowered.api.data.SerializableDataHolder;
 import org.spongepowered.api.data.value.ListValue;
+import org.spongepowered.api.data.value.SetValue;
 import org.spongepowered.api.data.value.Value;
 import org.spongepowered.api.event.cause.entity.damage.source.DamageSource;
 import org.spongepowered.api.projectile.source.EntityProjectileSource;
@@ -376,7 +377,7 @@ default Optional<Value.Mutable<Entity>> vehicle() {
      *
      * @return The "base vehicle" of the entity vehicle riding chain
      */
-    default Optional<Value.Mutable<Entity>> baseVehicle() {
+    default Optional<Value<Entity>> baseVehicle() {
         return this.getValue(Keys.BASE_VEHICLE).map(Value::asMutable);
     }
 
@@ -385,7 +386,7 @@ default Optional<Value.Mutable<Entity>> baseVehicle() {
      *
      * @return Whether this entity is on the ground
      */
-    default Value.Mutable<Boolean> onGround() {
+    default Value<Boolean> onGround() {
         return this.requireValue(Keys.ON_GROUND).asMutable();
     }
 
@@ -437,7 +438,7 @@ default Optional<Value.Mutable<UUID>> notifier() {
     /**
      * {@link Keys#FIRE_TICKS}
      *
-     * @return The amount of time in ticks an Entity is will continue burn for.
+     * @return The amount of time in ticks the entity is will continue burn for
      */
     default Optional<Value.Mutable<Ticks>> fireTicks() {
         return this.getValue(Keys.FIRE_TICKS).map(Value::asMutable);
@@ -446,19 +447,208 @@ default Optional<Value.Mutable<Ticks>> fireTicks() {
     /**
      * {@link Keys#FIRE_DAMAGE_DELAY}
      *
-     * @return The amount of time to delay in ticks before an Entity will be burned by fire.
+     * @return The amount of time to delay in ticks before the entity will be burned by fire
      */
-    default Optional<Value.Mutable<Ticks>> fireImmuneTicks() {
-        return this.getValue(Keys.FIRE_DAMAGE_DELAY).map(Value::asMutable);
+    default Value.Mutable<Ticks> fireImmuneTicks() {
+        return this.requireValue(Keys.FIRE_DAMAGE_DELAY).asMutable();
     }
 
     /**
      * {@link Keys#TRANSIENT}
      *
      * @return The transient state
      */
-    default Optional<Value.Mutable<Boolean>> isTransient() {
-        return this.getValue(Keys.TRANSIENT).map(Value::asMutable);
+    default Value.Mutable<Boolean> isTransient() {
+        return this.requireValue(Keys.TRANSIENT).asMutable();
+    }
+
+    /**
+     * {@link Keys#AGE}
+     *
+     * @return The age of this entity
+     */
+    default Value.Mutable<Integer> age() {
+        return this.requireValue(Keys.AGE).asMutable();
+    }
+
+    /**
+     * {@link Keys#BASE_SIZE}
+     *
+     * @return The base size of the entity
+     */
+    default Value<Double> baseSize() {
+        return this.requireValue(Keys.BASE_SIZE);
+    }
+
+    /**
+     * {@link Keys#EYE_HEIGHT}
+     *
+     * @return The height of the eyes
+     */
+    default Value<Double> eyeHeight() {
+        return this.requireValue(Keys.EYE_HEIGHT);
+    }
+
+    /**
+     * {@link Keys#EYE_POSITION}
+     *
+     * @return The position of the eyes
+     */
+    default Value<Vector3d> eyePosition() {
+        return this.requireValue(Keys.EYE_POSITION);
+    }
+
+    /**
+     * {@link Keys#HEIGHT}
+     *
+     * @return The height of the entity
+     */
+    default Value<Double> height() {
+        return this.requireValue(Keys.HEIGHT);
+    }
+
+    /**
+     * {@link Keys#INVULNERABILITY_TICKS}
+     *
+     * @return The amount of ticks the entity will remain invulnerable for
+     */
+    default Value.Mutable<Ticks> invulnerabilityTicks() {
+        return this.requireValue(Keys.INVULNERABILITY_TICKS).asMutable();
+    }
+
+    /**
+     * {@link Keys#IS_CUSTOM_NAME_VISIBLE}
+     *
+     * @return Whether a custom name is visible on the entity
+     */
+    default Value.Mutable<Boolean> customNameVisible() {
+        return this.requireValue(Keys.IS_CUSTOM_NAME_VISIBLE).asMutable();
+    }
+
+    /**
+     * {@link Keys#IS_GLOWING}
+     *
+     * @return Whether the entity has a glowing outline
+     */
+    default Value.Mutable<Boolean> glowing() {
+        return this.requireValue(Keys.IS_GLOWING).asMutable();
+    }
+
+    /**
+     * {@link Keys#IS_INVISIBLE}
+     *
+     * @return Whether the entity is currently invisible
+     */
+    default Value.Mutable<Boolean> invisible() {
+        return this.requireValue(Keys.IS_INVISIBLE).asMutable();
+    }
+
+    /**
+     * {@link Keys#INVULNERABLE}
+     *
+     * @return Whether the entity is invulnerable
+     */
+    default Value.Mutable<Boolean> invulnerable() {
+        return this.requireValue(Keys.INVULNERABLE).asMutable();
+    }
+
+    /**
+     * {@link Keys#IS_SNEAKING}
+     *
+     * @return Whether the entity is sneaking
+     */
+    default Value.Mutable<Boolean> sneaking() {
+        return this.requireValue(Keys.IS_SNEAKING).asMutable();
+    }
+
+    /**
+     * {@link Keys#IS_SPRINTING}
+     *
+     * @return Whether the entity is sprinting
+     */
+    default Value.Mutable<Boolean> sprinting() {
+        return this.requireValue(Keys.IS_SPRINTING).asMutable();
+    }
+
+    /**
+     * {@link Keys#IS_WET}
+     *
+     * @return Whether the entity is wet
+     */
+    default Value<Boolean> wet() {
+        return this.requireValue(Keys.IS_WET).asMutable();
+    }
+
+    /**
+     * {@link Keys#MAX_AIR}
+     *
+     * @return The max air supply
+     */
+    default Value.Mutable<Integer> maxAir() {
+        return this.requireValue(Keys.MAX_AIR).asMutable();
+    }
+
+    /**
+     * {@link Keys#REMAINING_AIR}
+     *
+     * @return The remaining air supply
+     */
+    default Value.Mutable<Integer> remainingAir() {
+        return this.requireValue(Keys.REMAINING_AIR).asMutable();
+    }
+
+    /**
+     * {@link Keys#SCOREBOARD_TAGS}
+     *
+     * @return The scoreboard tags applied to the entity
+     */
+    default SetValue.Mutable<String> scoreboardTags() {
+        return this.requireValue(Keys.SCOREBOARD_TAGS).asMutable();
+    }
+
+    /**
+     * {@link Keys#VANISH}
+     *
+     * @return Whether the entity is vanished
+     */
+    default Value.Mutable<Boolean> vanish() {
+        return this.requireValue(Keys.VANISH).asMutable();
+    }
+
+    /**
+     * {@link Keys#VANISH_IGNORES_COLLISION}
+     *
+     * @return Whether the entity ignores collision with other entities
+     */
+    default Value.Mutable<Boolean> vanishIgnoresCollision() {
+        return this.requireValue(Keys.VANISH_IGNORES_COLLISION).asMutable();
+    }
+
+    /**
+     * {@link Keys#VANISH_PREVENTS_TARGETING}
+     *
+     * @return Whether the entity can be targeted for attack by another entity
+     */
+    default Value.Mutable<Boolean> vanishPreventsTargeting() {
+        return this.requireValue(Keys.VANISH_PREVENTS_TARGETING).asMutable();
+    }
+
+    /**
+     * {@link Keys#CUSTOM_NAME}
+     *
+     * @return The custom name of the entity
+     */
+    default Optional<Value.Mutable<Component>> customName() {
+        return this.getValue(Keys.CUSTOM_NAME).map(Value::asMutable);
+    }
+
+    /**
+     * {@link Keys#SWIFTNESS}
+     *
+     * @return The current swiftness of the entity
+     */
+    default Optional<Value.Mutable<Double>> swiftness() {
+        return this.getValue(Keys.SWIFTNESS).map(Value::asMutable);
     }
 
     @Override

src/main/java/org/spongepowered/api/entity/FallingBlock.java

@@ -38,7 +38,7 @@ public interface FallingBlock extends Entity {
     /**
      * {@link Keys#BLOCK_STATE}
      *
-     * @return The blockstate
+     * @return The block state of the falling block
      */
     default Value.Mutable<BlockState> blockState() {
         return this.requireValue(Keys.BLOCK_STATE).asMutable();

src/main/java/org/spongepowered/api/entity/Item.java

@@ -29,6 +29,7 @@
 import org.spongepowered.api.item.ItemType;
 import org.spongepowered.api.item.inventory.ItemStack;
 import org.spongepowered.api.item.inventory.ItemStackSnapshot;
+import org.spongepowered.api.util.Ticks;
 
 /**
  * Represents an Item.
@@ -43,4 +44,40 @@ public interface Item extends Entity {
     default Value.Mutable<ItemStackSnapshot> item() {
         return this.requireValue(Keys.ITEM_STACK_SNAPSHOT).asMutable();
     }
+
+    /**
+     * {@link Keys#DESPAWN_DELAY}
+     *
+     * @return The despawn delay (in ticks) of the item
+     */
+    default Value.Mutable<Ticks> despawnDelay() {
+        return this.requireValue(Keys.DESPAWN_DELAY).asMutable();
+    }
+
+    /**
+     * {@link Keys#INFINITE_DESPAWN_DELAY}
+     *
+     * @return Whether the item will not despawn for an infinite time
+     */
+    default Value.Mutable<Boolean> infiniteDespawnDelay() {
+        return this.requireValue(Keys.INFINITE_DESPAWN_DELAY).asMutable();
+    }
+
+    /**
+     * {@link Keys#INFINITE_PICKUP_DELAY}
+     *
+     * @return Whether the item has an infinite pickup delay
+     */
+    default Value.Mutable<Boolean> infinitePickupDelay() {
+        return this.requireValue(Keys.INFINITE_PICKUP_DELAY).asMutable();
+    }
+
+    /**
+     * {@link Keys#PICKUP_DELAY}
+     *
+     * @return The pickup delay (in ticks) of the item
+     */
+    default Value.Mutable<Ticks> pickupDelay() {
+        return this.requireValue(Keys.PICKUP_DELAY).asMutable();
+    }
 }

src/main/java/org/spongepowered/api/entity/explosive/EndCrystal.java

@@ -52,4 +52,13 @@ default Optional<Value.Mutable<Vector3i>> beamTarget() {
     default Value.Mutable<Boolean> showBottom() {
         return this.requireValue(Keys.SHOW_BOTTOM).asMutable();
     }
+
+    /**
+     * {@link Keys#HEALTH}
+     *
+     * @return The health of the end crystal
+     */
+    default Value.Mutable<Double> health() {
+        return this.requireValue(Keys.HEALTH).asMutable();
+    }
 }