Format/import cleanup

author: bculkin2442 <bjculkin@mix.wvu.edu> 2019-08-22 20:01:40 -0400
committer: bculkin2442 <bjculkin@mix.wvu.edu> 2019-08-22 20:01:40 -0400
commit: 20bef6e26d948698398bd16aeab8c9e6b89110e4 (patch)
tree: 8a21e17f78b330435f4ce2d4355d72b773230aa7 /src/main/java/darkknight/jewelrycraft/api
parent: 26fb28edd1ebb6390f8803fed3876d222cb8fdba (diff)
3 files changed, 183 insertions, 242 deletions
diff --git a/src/main/java/darkknight/jewelrycraft/api/Curse.java b/src/main/java/darkknight/jewelrycraft/api/Curse.java
index dd220f1..6bf37ee 100755
--- a/src/main/java/darkknight/jewelrycraft/api/Curse.java
+++ b/src/main/java/darkknight/jewelrycraft/api/Curse.java
@@ -19,21 +19,21 @@ import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
 import net.minecraftforge.event.world.BlockEvent;
 
 public abstract class Curse {
-	protected int			textureID, ticksActive;
-	protected String		name, description, texturePackName;
+	protected int textureID, ticksActive;
+	protected String name, description, texturePackName;
 
-	protected Random		rand		= new Random();
+	protected Random rand = new Random();
 
-	private static ArrayList<Curse>	curses		= new ArrayList<>();
-	public static ArrayList<Curse>	availableCurses	= new ArrayList<>();
+	private static ArrayList<Curse> curses = new ArrayList<>();
+	public static ArrayList<Curse> availableCurses = new ArrayList<>();
 
 	/**
 	 * @param name
-	 *                The name of the curse
+	 *            The name of the curse
 	 * @param txtID
-	 *                The texture ID of it
+	 *            The texture ID of it
 	 * @param texturepack
-	 *                The texturepack location
+	 *            The texturepack location
 	 */
 	protected Curse(String name, int txtID, String texturepack) {
 		this.name = name;
@@ -62,7 +62,7 @@ public abstract class Curse {
 
 	/**
 	 * @param desc
-	 *                description of the curse
+	 *            description of the curse
 	 * @return The class
 	 */
 	public Curse setDescription(String desc) {
@@ -88,9 +88,9 @@ public abstract class Curse {
 	 * This runs every tick
 	 * 
 	 * @param world
-	 *                The worldthe player is in
+	 *            The worldthe player is in
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 */
 	public void action(World world, EntityPlayer player) {
 		ticksActive++;
@@ -108,14 +108,13 @@ public abstract class Curse {
 	 * This runs when the player dies
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The thing that killed the player
+	 *            The thing that killed the player
 	 */
-	public void playerDeathAction(World world, EntityPlayer player,
-			LivingDeathEvent event) {
+	public void playerDeathAction(World world, EntityPlayer player, LivingDeathEvent event) {
 		// Do nothing
 	}
 
@@ -123,30 +122,27 @@ public abstract class Curse {
 	 * This runs when the player is healed
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The event that the player is healing from
+	 *            The event that the player is healing from
 	 */
-	public void playerHealAction(World world, EntityPlayer player,
-			LivingHealEvent event) {
+	public void playerHealAction(World world, EntityPlayer player, LivingHealEvent event) {
 		// Do nothing
 	}
 
 	/**
-	 * This runs when an entity is killed (whether by a player or other
-	 * causes)
+	 * This runs when an entity is killed (whether by a player or other causes)
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param target
-	 *                The entity that died
+	 *            The entity that died
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 */
-	public void entityDeathAction(World world, EntityLivingBase target,
-			EntityPlayer player) {
+	public void entityDeathAction(World world, EntityLivingBase target, EntityPlayer player) {
 		// Do nothing
 	}
 
@@ -154,67 +150,63 @@ public abstract class Curse {
 	 * This runs when the player respawns
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 */
 	public void respawnAction(World world, EntityPlayer player) {
 		// Do nothing
 	}
 
 	/**
-	 * This runs when a player gets attacked by anything but another
-	 * player
+	 * This runs when a player gets attacked by anything but another player
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The event that attacked the player
+	 *            The event that attacked the player
 	 * @param attacker
-	 *                The entity that attacked the player
+	 *            The entity that attacked the player
 	 */
-	public void attackedAction(World world, EntityPlayer player,
-			LivingAttackEvent event, Entity attacker) {
+	public void attackedAction(World world, EntityPlayer player, LivingAttackEvent event, Entity attacker) {
 		// Do nothing
 	}
 
 	/**
-	 * This runs when an entity is attacked by a player (this includes
-	 * other players)
+	 * This runs when an entity is attacked by a player (this includes other
+	 * players)
 	 * 
 	 * @param event
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param player
-	 *                The player that caused the damage
+	 *            The player that caused the damage
 	 * @param target
-	 *                The entity damaged
+	 *            The entity damaged
 	 */
-	public void attackedByPlayerAction(LivingAttackEvent event,
-			World world, EntityPlayer player, Entity target) {
+	public void attackedByPlayerAction(LivingAttackEvent event, World world, EntityPlayer player, Entity target) {
 		// Do nothing
 	}
 
 	/**
-	 * This runs when an entity is attacked by a player (this includes
-	 * other players). This can cancel the damaging event.
+	 * This runs when an entity is attacked by a player (this includes other
+	 * players). This can cancel the damaging event.
 	 * 
 	 * @param event
 	 * 
 	 * @param world
-	 *                The world the player is in
+	 *            The world the player is in
 	 * @param player
-	 *                The player that caused the damage
+	 *            The player that caused the damage
 	 * @param target
-	 *                The entity damaged
+	 *            The entity damaged
 	 * @return Whether or not to cancel the event
 	 */
-	public boolean attackedByPlayerActionCancelable(
-			LivingAttackEvent event, World world,
-			EntityPlayer player, Entity target) {
+	public boolean attackedByPlayerActionCancelable(LivingAttackEvent event, World world, EntityPlayer player,
+			Entity target) {
 		return false;
 	}
 
@@ -222,60 +214,54 @@ public abstract class Curse {
 	 * This runs when an item is dropped by an entity
 	 * 
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param target
-	 *                The entity that drops the item
+	 *            The entity that drops the item
 	 * @param drops
-	 *                An array list containing the dropped items
+	 *            An array list containing the dropped items
 	 */
-	public void entityDropItems(EntityPlayer player, Entity target,
-			ArrayList<EntityItem> drops) {
+	public void entityDropItems(EntityPlayer player, Entity target, ArrayList<EntityItem> drops) {
 		// Do nothing
 	}
 
 	/**
-	 * This is for rendering special things on the player in 3rd person
-	 * (meaning you won't see this render); This will also render in
-	 * the inventory.
+	 * This is for rendering special things on the player in 3rd person (meaning you
+	 * won't see this render); This will also render in the inventory.
 	 * 
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The event used for this
+	 *            The event used for this
 	 */
 	@SideOnly(Side.CLIENT)
-	public void playerRender(EntityPlayer player,
-			RenderPlayerEvent.Specials.Post event) {
+	public void playerRender(EntityPlayer player, RenderPlayerEvent.Specials.Post event) {
 		// Do nothing
 	}
 
 	/**
-	 * This is for rendering special things on the player in 1st and
-	 * 3rd person, but not in the player inventory.
+	 * This is for rendering special things on the player in 1st and 3rd person, but
+	 * not in the player inventory.
 	 * 
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The event used for this
+	 *            The event used for this
 	 */
 	@SideOnly(Side.CLIENT)
-	public void playerHandRender(EntityPlayer player,
-			RenderHandEvent event) {
+	public void playerHandRender(EntityPlayer player, RenderHandEvent event) {
 		// Do nothing
 	}
 
 	/**
-	 * This runs when a block drops an item (such as breaking a block
-	 * and dropping itself, or breaking like a Diamond ore and dropping
-	 * diamonds)
+	 * This runs when a block drops an item (such as breaking a block and dropping
+	 * itself, or breaking like a Diamond ore and dropping diamonds)
 	 * 
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The BlockEvent that triggers this
+	 *            The BlockEvent that triggers this
 	 */
-	public void onBlockItemsDrop(EntityPlayer player,
-			BlockEvent.HarvestDropsEvent event) {
+	public void onBlockItemsDrop(EntityPlayer player, BlockEvent.HarvestDropsEvent event) {
 		// Do nothing
 	}
 
@@ -283,44 +269,41 @@ public abstract class Curse {
 	 * This runs when a block is destroyed
 	 * 
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param event
-	 *                The BlockEvent that runs this
+	 *            The BlockEvent that runs this
 	 */
-	public void onBlockDestroyed(EntityPlayer player,
-			BlockEvent.BreakEvent event) {
+	public void onBlockDestroyed(EntityPlayer player, BlockEvent.BreakEvent event) {
 		// Do nothing
 	}
 
 	/**
 	 * This determines if the player can toss an item or not (with Q)
 	 * 
-	 * @return True if the player can no longer toss items; False if he
-	 *         can. (by default false)
+	 * @return True if the player can no longer toss items; False if he can. (by
+	 *         default false)
 	 */
 	public boolean itemToss() {
 		return false;
 	}
 
 	/**
-	 * This controls whether a curse can be activated or not (makes it
-	 * easy to do things like disable certain curses if in hardcore)
+	 * This controls whether a curse can be activated or not (makes it easy to do
+	 * things like disable certain curses if in hardcore)
 	 * 
 	 * @param world
-	 *                The world the player is in
-	 * @return True for curses to be used; False otherwise (by default
-	 *         true)
+	 *            The world the player is in
+	 * @return True for curses to be used; False otherwise (by default true)
 	 */
 	public boolean canCurseBeActivated(World world) {
 		return canCurseBeActivated();
 	}
 
 	/**
-	 * This controls whether a curse can be activated or not (makes it
-	 * easy to do things like disable certain curses if in hardcore)
+	 * This controls whether a curse can be activated or not (makes it easy to do
+	 * things like disable certain curses if in hardcore)
 	 * 
-	 * @return True for curses to be used; False otherwise (by default
-	 *         true)
+	 * @return True for curses to be used; False otherwise (by default true)
 	 */
 	public boolean canCurseBeActivated() {
 		return true;
@@ -336,26 +319,24 @@ public abstract class Curse {
 	}
 
 	/**
-	 * This is the weight of the curse when it chooses it. The lower
-	 * the value, the less it gets chosen; the higher the value, the
-	 * higher the chance of it getting picked.
+	 * This is the weight of the curse when it chooses it. The lower the value, the
+	 * less it gets chosen; the higher the value, the higher the chance of it
+	 * getting picked.
 	 * 
 	 * @param world
-	 *                The world the player is currently in
+	 *            The world the player is currently in
 	 * @param player
-	 *                The cursed player
+	 *            The cursed player
 	 * @param random
-	 *                A random class
+	 *            A random class
 	 * @return The weight of the curse (by default 10)
 	 */
-	public int weight(World world, EntityPlayer player,
-			Random random) {
+	public int weight(World world, EntityPlayer player, Random random) {
 		return 10;
 	}
 
 	/*
-	 * This stat is used to determine the chance of certain actions
-	 * happening
+	 * This stat is used to determine the chance of certain actions happening
 	 */
 	public int luck() {
 		return 0;
@@ -365,14 +346,13 @@ public abstract class Curse {
 	 * This event is called whenever the player attempts to sleep.
 	 * 
 	 * @param worldObj
-	 *                the world
+	 *            the world
 	 * @param player
-	 *                the cursed player
+	 *            the cursed player
 	 * @param event
-	 *                the sleeping event
+	 *            the sleeping event
 	 */
-	public void playerSleepAction(World worldObj, EntityPlayer player,
-			PlayerSleepInBedEvent event) {
+	public void playerSleepAction(World worldObj, EntityPlayer player, PlayerSleepInBedEvent event) {
 
 	}
 }
diff --git a/src/main/java/darkknight/jewelrycraft/api/IJewelryItem.java b/src/main/java/darkknight/jewelrycraft/api/IJewelryItem.java
index ad15c7a..878ceee 100755
--- a/src/main/java/darkknight/jewelrycraft/api/IJewelryItem.java
+++ b/src/main/java/darkknight/jewelrycraft/api/IJewelryItem.java
@@ -15,8 +15,8 @@ import net.minecraftforge.event.entity.player.PlayerEvent;
  */
 public interface IJewelryItem {
 	/**
-	 * @return Returns the id of the type, 0 is for ring, 1 is for
-	 *         bracelet, 2 is for necklace and 3 is for earrings
+	 * @return Returns the id of the type, 0 is for ring, 1 is for bracelet, 2 is
+	 *         for necklace and 3 is for earrings
 	 */
 	public int type();
 
@@ -24,84 +24,76 @@ public interface IJewelryItem {
 	 * This is the action performed each player tick
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 * @param player
-	 *                The player wearing the jewelry
+	 *            The player wearing the jewelry
 	 */
 	public void onWearAction(ItemStack item, EntityPlayer player);
 
 	/**
-	 * This performs an action whenever a player gets attacked by an
-	 * entity besides another Player
+	 * This performs an action whenever a player gets attacked by an entity besides
+	 * another Player
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 * @param player
-	 *                The player that was attacked
+	 *            The player that was attacked
 	 * @param source
-	 *                Source of the damage
+	 *            Source of the damage
 	 * @param amount
-	 *                The amount of damage taken
+	 *            The amount of damage taken
 	 */
-	public void onPlayerAttackedAction(ItemStack item,
-			EntityPlayer player, DamageSource source,
-			float amount);
+	public void onPlayerAttackedAction(ItemStack item, EntityPlayer player, DamageSource source, float amount);
 
 	/**
-	 * This does an action whenever an Entity gets attacked by a
-	 * player, this includes other Players
+	 * This does an action whenever an Entity gets attacked by a player, this
+	 * includes other Players
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 * @param player
-	 *                The attacking player
+	 *            The attacking player
 	 * @param entity
-	 *                The target entity
+	 *            The target entity
 	 * @param amount
-	 *                The amount of damage dealt
+	 *            The amount of damage dealt
 	 */
-	public void onEntityAttackedByPlayer(ItemStack item,
-			EntityPlayer player, EntityLivingBase entity,
-			float amount);
+	public void onEntityAttackedByPlayer(ItemStack item, EntityPlayer player, EntityLivingBase entity, float amount);
 
 	/**
 	 * This runs whenever a player dies
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 * @param player
-	 *                The player that died
+	 *            The player that died
 	 * @param source
-	 *                The damage source that caused the death
+	 *            The damage source that caused the death
 	 */
-	public void onPlayerDeadAction(ItemStack item, EntityPlayer player,
-			DamageSource source);
+	public void onPlayerDeadAction(ItemStack item, EntityPlayer player, DamageSource source);
 
 	/**
-	 * Runs whenever a player respawns (switches dimensions or actually
-	 * respawns)
+	 * Runs whenever a player respawns (switches dimensions or actually respawns)
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 * @param event
-	 *                The clone event that runs whenever a player
-	 *                respawns, either because he died or switched
-	 *                dimensions
+	 *            The clone event that runs whenever a player respawns, either
+	 *            because he died or switched dimensions
 	 */
-	public void onPlayerRespawnAction(ItemStack item,
-			PlayerEvent.Clone event);
+	public void onPlayerRespawnAction(ItemStack item, PlayerEvent.Clone event);
 
 	/**
 	 * This runs when the item is equipped
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 */
 	public void onJewelryEquipped(ItemStack item);
 
@@ -109,8 +101,8 @@ public interface IJewelryItem {
 	 * This runs when the item is unequipped
 	 * 
 	 * @param item
-	 *                The item stack of the item (allows for fine item
-	 *                search, like metadata and nbt)
+	 *            The item stack of the item (allows for fine item search, like
+	 *            metadata and nbt)
 	 */
 	public void onJewelryUnequipped(ItemStack item);
 }
diff --git a/src/main/java/darkknight/jewelrycraft/api/ModifierEffects.java b/src/main/java/darkknight/jewelrycraft/api/ModifierEffects.java
index 389bafc..7b89b8c 100755
--- a/src/main/java/darkknight/jewelrycraft/api/ModifierEffects.java
+++ b/src/main/java/darkknight/jewelrycraft/api/ModifierEffects.java
@@ -11,13 +11,13 @@ import net.minecraft.util.DamageSource;
 import net.minecraftforge.event.entity.player.PlayerEvent;
 
 public class ModifierEffects {
-	protected ItemStack				modifier;
-	protected Random				rand	= new Random();
-	protected static ArrayList<ModifierEffects>	effects	= new ArrayList<>();
+	protected ItemStack modifier;
+	protected Random rand = new Random();
+	protected static ArrayList<ModifierEffects> effects = new ArrayList<>();
 
 	/**
 	 * @param modifier
-	 *                The item to use as modifier
+	 *            The item to use as modifier
 	 */
 	public ModifierEffects(ItemStack modifier) {
 		this.modifier = modifier;
@@ -42,116 +42,97 @@ public class ModifierEffects {
 	 * This runs every tick
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param player
-	 *                The player wearing the jewelry wearing a jewelry
-	 *                with this modifier on it
+	 *            The player wearing the jewelry wearing a jewelry with this
+	 *            modifier on it
 	 * @param jewelry
-	 *                The actual jewelry item (used by me to determine
-	 *                the type of jewelry so I don't have to call
-	 *                item.getItem() blah blah blah)
+	 *            The actual jewelry item (used by me to determine the type of
+	 *            jewelry so I don't have to call item.getItem() blah blah blah)
 	 */
-	public void action(ItemStack item, EntityPlayer player,
-			Item jewelry) {
+	public void action(ItemStack item, EntityPlayer player, Item jewelry) {
 		// Do nothing
 	};
 
 	/**
-	 * This runs when an entity is attacked. This event can be
-	 * canceled.
+	 * This runs when an entity is attacked. This event can be canceled.
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param player
-	 *                The player wearing the jewelry wearing a jewelry
-	 *                with this modifier on it
+	 *            The player wearing the jewelry wearing a jewelry with this
+	 *            modifier on it
 	 * @param target
-	 *                The attacked entity
+	 *            The attacked entity
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 * @param amount
-	 *                The amount of damage the entity took
+	 *            The amount of damage the entity took
 	 * @return The state of the event (true to cancel it, false to not)
 	 */
-	public boolean onEntityAttackedCancellable(ItemStack item,
-			EntityPlayer player, Entity target, Item jewelry,
+	public boolean onEntityAttackedCancellable(ItemStack item, EntityPlayer player, Entity target, Item jewelry,
 			float amount) {
 		return false;
 	}
 
 	/**
-	 * This runs when a player gets damaged. This event can be
-	 * canceled.
+	 * This runs when a player gets damaged. This event can be canceled.
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param player
-	 *                The attacked player wearing a jewelry with this
-	 *                modifier on it
+	 *            The attacked player wearing a jewelry with this modifier on it
 	 * @param source
-	 *                The source of the damage
+	 *            The source of the damage
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 * @param amount
-	 *                The amount of damage the player took
+	 *            The amount of damage the player took
 	 * @return The state of the event (true to cancel it, false to not)
 	 */
-	public boolean onPlayerAttackedCancellable(ItemStack item,
-			EntityPlayer player, DamageSource source,
-			Item jewelry, float amount) {
+	public boolean onPlayerAttackedCancellable(ItemStack item, EntityPlayer player, DamageSource source, Item jewelry,
+			float amount) {
 		return false;
 	}
 
 	/**
-	 * This is the same as onEntityAttackedCacellable, but this can not
-	 * be canceled. I recommend using this over
-	 * onEntityAttackedCacellable, as it is more reliable.
+	 * This is the same as onEntityAttackedCacellable, but this can not be canceled.
+	 * I recommend using this over onEntityAttackedCacellable, as it is more
+	 * reliable.
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param player
-	 *                The player wearing the jewelry wearing a jewelry
-	 *                with this modifier on it
+	 *            The player wearing the jewelry wearing a jewelry with this
+	 *            modifier on it
 	 * @param target
-	 *                The attacked entity
+	 *            The attacked entity
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 * @param amount
-	 *                The amount of damage the entity took
+	 *            The amount of damage the entity took
 	 */
-	public void onEntityAttacked(ItemStack item, EntityPlayer player,
-			Entity target, Item jewelry, float amount) {
+	public void onEntityAttacked(ItemStack item, EntityPlayer player, Entity target, Item jewelry, float amount) {
 		// Do nothing
 	}
 
 	/**
-	 * This is just like onPlayerAttackedCacellable, only that this can
-	 * not be canceled. I recommend using this over
-	 * onPlayerAttackedCacellable, as it is more reliable.
+	 * This is just like onPlayerAttackedCacellable, only that this can not be
+	 * canceled. I recommend using this over onPlayerAttackedCacellable, as it is
+	 * more reliable.
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param player
-	 *                The attacked player wearing a jewelry with this
-	 *                modifier on it
+	 *            The attacked player wearing a jewelry with this modifier on it
 	 * @param source
-	 *                The source of the damage
+	 *            The source of the damage
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 * @param amount
-	 *                The amount of damage the player took
+	 *            The amount of damage the player took
 	 */
-	public void onPlayerAttacked(ItemStack item, EntityPlayer player,
-			DamageSource source, Item jewelry, float amount) {
+	public void onPlayerAttacked(ItemStack item, EntityPlayer player, DamageSource source, Item jewelry, float amount) {
 		// Do nothing
 	}
 
@@ -159,19 +140,15 @@ public class ModifierEffects {
 	 * This runs when the player dies
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param player
-	 *                The player that died wearing a jewelry with this
-	 *                modifier on it
+	 *            The player that died wearing a jewelry with this modifier on it
 	 * @param source
-	 *                The source of the killing blow
+	 *            The source of the killing blow
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 */
-	public void onPlayerDead(ItemStack item, EntityPlayer player,
-			DamageSource source, Item jewelry) {
+	public void onPlayerDead(ItemStack item, EntityPlayer player, DamageSource source, Item jewelry) {
 		// Do nothing
 	}
 
@@ -179,18 +156,14 @@ public class ModifierEffects {
 	 * This runs when the player respawns
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param event
-	 *                The PlayerEvent that runs when the player
-	 *                respawns (this is also called when a player moves
-	 *                between dimensions)
+	 *            The PlayerEvent that runs when the player respawns (this is also
+	 *            called when a player moves between dimensions)
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 */
-	public void onPlayerRespawn(ItemStack item,
-			PlayerEvent.Clone event, Item jewelry) {
+	public void onPlayerRespawn(ItemStack item, PlayerEvent.Clone event, Item jewelry) {
 		// Do nothing
 	}
 
@@ -198,11 +171,9 @@ public class ModifierEffects {
 	 * This runs when the item containing this modifier is equipped
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 */
 	public void onJewelryEquipped(ItemStack item, Item jewelry) {
 		// Do nothing
@@ -212,11 +183,9 @@ public class ModifierEffects {
 	 * This runs when the item containing this modifier is unquipped
 	 * 
 	 * @param item
-	 *                The ItemStack representing the jewelry that runs
-	 *                the effect
+	 *            The ItemStack representing the jewelry that runs the effect
 	 * @param jewelry
-	 *                The actual jewelry item (aka item.getItem(),
-	 *                almost)
+	 *            The actual jewelry item (aka item.getItem(), almost)
 	 */
 	public void onJewelryUnequipped(ItemStack item, Item jewelry) {
 		// Do nothing
author	bculkin2442 <bjculkin@mix.wvu.edu>	2019-08-22 20:01:40 -0400
committer	bculkin2442 <bjculkin@mix.wvu.edu>	2019-08-22 20:01:40 -0400
commit	20bef6e26d948698398bd16aeab8c9e6b89110e4 (patch)
tree	8a21e17f78b330435f4ce2d4355d72b773230aa7 /src/main/java/darkknight/jewelrycraft/api
parent	26fb28edd1ebb6390f8803fed3876d222cb8fdba (diff)