Upstream
/
Brewery
mirror of https://github.com/DieReicheErethons/Brewery.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Started api and events

This commit is contained in:
Sn0wStorm 2016-07-09 00:01:31 +02:00
parent a1897d085c
commit 24cf758691
32 changed files with 1440 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/com/dre/brewery/BCauldron.java
View File

@ -2,6 +2,7 @@ package com.dre.brewery;
import java.util.concurrent.CopyOnWriteArrayList;
import com.dre.brewery.api.events.IngedientAddEvent;
import org.bukkit.entity.Player;
import org.bukkit.Material;
import org.bukkit.block.Block;
@ -13,16 +14,15 @@ import org.bukkit.material.Cauldron;
import org.bukkit.material.MaterialData;
public class BCauldron {
public static CopyOnWriteArrayList<BCauldron> bcauldrons = new CopyOnWriteArrayList<>();
public static CopyOnWriteArrayList<BCauldron> bcauldrons = new CopyOnWriteArrayList<>(); // TODO find best Collection
private BIngredients ingredients = new BIngredients();
private Block block;
private final Block block;
private int state = 1;
private boolean someRemoved = false;
public BCauldron(Block block, ItemStack ingredient) {
public BCauldron(Block block) {
this.block = block;
add(ingredient);
bcauldrons.add(this);
}
@ -49,7 +49,8 @@ public class BCauldron {
// add an ingredient to the cauldron
public void add(ItemStack ingredient) {
if (someRemoved) {
if (ingredient == null || ingredient.getType() == Material.AIR) return;
if (someRemoved) { // TODO no need to clone
ingredients = ingredients.clone();
someRemoved = false;
}
@ -72,16 +73,22 @@ public class BCauldron {
}
// get cauldron from block and add given ingredient
public static boolean ingredientAdd(Block block, ItemStack ingredient) {
// Calls the IngredientAddEvent and may be cancelled or changed
public static boolean ingredientAdd(Block block, ItemStack ingredient, Player player) {
// if not empty
if (getFillLevel(block) != 0) {
BCauldron bcauldron = get(block);
if (bcauldron != null) {
bcauldron.add(ingredient);
return true;
if (bcauldron == null) {
bcauldron = new BCauldron(block);
}
IngedientAddEvent event = new IngedientAddEvent(player, block, bcauldron, ingredient);
P.p.getServer().getPluginManager().callEvent(event);
if (!event.isCancelled()) {
bcauldron.add(event.getIngredient());
return event.shouldTakeItem();
} else {
new BCauldron(block, ingredient);
return true;
return false;
}
}
return false;
@ -160,13 +167,16 @@ public class BCauldron {
}
// reset to normal cauldron
public static void remove(Block block) {
public static boolean remove(Block block) {
if (block.getType() != Material.CAULDRON) return false;
if (getFillLevel(block) != 0) {
BCauldron bcauldron = get(block);
if (bcauldron != null) {
bcauldrons.remove(bcauldron);
return true;
}
}
return false;
}
// unloads cauldrons that are in a unloading world

14
src/com/dre/brewery/BEffect.java
View File

@ -2,6 +2,7 @@ package com.dre.brewery;
import org.bukkit.entity.Player;
import org.bukkit.inventory.meta.PotionMeta;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class BEffect {
@ -81,17 +82,24 @@ public class BEffect {
}
}
public void apply(int quality, Player player) {
public PotionEffect generateEffect(int quality) {
int duration = calcDuration(quality);
int lvl = calcLvl(quality);
if (lvl < 1 || (duration < 1 && !type.isInstant())) {
return;
return null;
}
duration *= 20;
duration /= type.getDurationModifier();
type.createEffect(duration, lvl - 1).apply(player);
return type.createEffect(duration, lvl - 1);
}
public void apply(int quality, Player player) {
PotionEffect effect = generateEffect(quality);
if (effect != null) {
effect.apply(player);
}
}
public int calcDuration(float quality) {

6
src/com/dre/brewery/BIngredients.java
View File

@ -1,5 +1,6 @@
package com.dre.brewery;
import com.dre.brewery.api.events.brew.BrewModifyEvent;
import com.dre.brewery.lore.BrewLore;
import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
@ -120,6 +121,11 @@ public class BIngredients {
cookedName = P.p.languageReader.get("Brew_Undefined");
Brew.PotionColor.CYAN.colorBrew(potionMeta, potion, true);
}
BrewModifyEvent modifyEvent = new BrewModifyEvent(brew, BrewModifyEvent.Type.FILL);
P.p.getServer().getPluginManager().callEvent(modifyEvent);
if (modifyEvent.isCancelled()) {
return null;
}
potionMeta.setDisplayName(P.p.color("&f" + cookedName));
// This effect stores the UID in its Duration

130
src/com/dre/brewery/BPlayer.java
View File

@ -1,5 +1,10 @@
package com.dre.brewery;
import com.dre.brewery.api.events.PlayerAlcEffectEvent;
import com.dre.brewery.api.events.PlayerDrinkEffectEvent;
import com.dre.brewery.api.events.PlayerPukeEvent;
import com.dre.brewery.api.events.PlayerPushEvent;
import com.dre.brewery.api.events.brew.BrewDrinkEvent;
import org.apache.commons.lang.mutable.MutableInt;
import org.bukkit.Location;
import org.bukkit.Material;
@ -10,13 +15,20 @@ import org.bukkit.entity.Item;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.util.Vector;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
public class BPlayer {
private static Map<String, BPlayer> players = new HashMap<>();// Players name/uuid and BPlayer
@ -120,9 +132,10 @@ public class BPlayer {
}
public void remove() {
for (Map.Entry<String, BPlayer> entry : players.entrySet()) {
for (Iterator<Map.Entry<String, BPlayer>> iterator = players.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<String, BPlayer> entry = iterator.next();
if (entry.getValue() == this) {
players.remove(entry.getKey());
iterator.remove();
return;
}
}
@ -133,32 +146,46 @@ public class BPlayer {
}
// Drink a brew and apply effects, etc.
public static void drink(Brew brew, Player player) {
int brewAlc = brew.calcAlcohol();
if (brewAlc == 0) {
//no alcohol so we dont need to add a BPlayer
addBrewEffects(brew, player);
return;
}
public static boolean drink(Brew brew, Player player) {
BPlayer bPlayer = get(player);
if (bPlayer == null) {
bPlayer = addPlayer(player);
}
BrewDrinkEvent drinkEvent = new BrewDrinkEvent(brew, player, bPlayer);
P.p.getServer().getPluginManager().callEvent(drinkEvent);
if (drinkEvent.isCancelled()) {
if (bPlayer.drunkeness <= 0) {
bPlayer.remove();
}
return false;
}
int brewAlc = drinkEvent.getAddedAlcohol();
int quality = drinkEvent.getQuality();
List<PotionEffect> effects = getBrewEffects(brew.getEffects(), quality);
if (brewAlc < 1) {
//no alcohol so we dont need to add a BPlayer
applyDrinkEffects(effects, player);
if (bPlayer.drunkeness <= 0) {
bPlayer.remove();
}
return true;
}
effects.addAll(getQualityEffects(drinkEvent.getQuality(), brewAlc));
bPlayer.drunkeness += brewAlc;
if (brew.getQuality() > 0) {
bPlayer.quality += brew.getQuality() * brewAlc;
if (quality > 0) {
bPlayer.quality += quality * brewAlc;
} else {
bPlayer.quality += brewAlc;
}
applyDrinkEffects(effects, player);
if (bPlayer.drunkeness <= 100) {
addBrewEffects(brew, player);
addQualityEffects(brew.getQuality(), brewAlc, player);
} else {
if (bPlayer.drunkeness > 100) {
bPlayer.drinkCap(player);
}
return true;
}
// Player has drunken too much
@ -240,6 +267,13 @@ public class BPlayer {
push.setX(Math.random() - 0.5);
push.setZ(Math.random() - 0.5);
}
PlayerPushEvent pushEvent = new PlayerPushEvent(player, push, this);
P.p.getServer().getPluginManager().callEvent(pushEvent);
push = pushEvent.getPush();
if (pushEvent.isCancelled() || push.lengthSquared() <= 0) {
time = -10;
return;
}
player.setVelocity(push);
} else if (time < 0 && time > -10) {
// push him some more in the same direction
@ -378,6 +412,12 @@ public class BPlayer {
return;
}
PlayerPukeEvent event = new PlayerPukeEvent(player, count);
P.p.getServer().getPluginManager().callEvent(event);
if (event.isCancelled() || event.getCount() < 1) {
return;
}
if (pTasks.isEmpty()) {
taskId = P.p.getServer().getScheduler().scheduleSyncRepeatingTask(P.p, new Runnable() {
public void run() {
@ -385,7 +425,7 @@ public class BPlayer {
}
}, 1L, 1L);
}
pTasks.put(player, new MutableInt(count));
pTasks.put(player, new MutableInt(event.getCount()));
}
public static void pukeTask() {
@ -462,6 +502,18 @@ public class BPlayer {
// #### Effects ####
public static void applyDrinkEffects(List<PotionEffect> effects, Player player) {
PlayerDrinkEffectEvent event = new PlayerDrinkEffectEvent(player, effects);
P.p.getServer().getPluginManager().callEvent(event);
effects = event.getEffects();
if (event.isCancelled() || effects == null) {
return;
}
for (PotionEffect effect : effects) {
effect.apply(player);
}
}
public void drunkEffects(Player player) {
int duration = 10 - getQuality();
duration += drunkeness / 2;
@ -471,10 +523,22 @@ public class BPlayer {
} else if (duration < 460) {
duration = 460;
}
PotionEffectType.CONFUSION.createEffect(duration, 0).apply(player);
List<PotionEffect> l = new ArrayList<>(1);
l.add(PotionEffectType.CONFUSION.createEffect(duration, 0));
PlayerAlcEffectEvent event = new PlayerAlcEffectEvent(player, l);
P.p.getServer().getPluginManager().callEvent(event);
l = event.getEffects();
if (event.isCancelled() || l == null) {
return;
}
for (PotionEffect effect : l) {
effect.apply(player);
}
}
public static void addQualityEffects(int quality, int brewAlc, Player player) {
public static List<PotionEffect> getQualityEffects(int quality, int brewAlc) {
List<PotionEffect> out = new ArrayList<>(2);
int duration = 7 - quality;
if (quality == 0) {
duration *= 500;
@ -487,7 +551,7 @@ public class BPlayer {
}
}
if (duration > 0) {
PotionEffectType.POISON.createEffect(duration, 0).apply(player);
out.add(PotionEffectType.POISON.createEffect(duration, 0));
}
if (brewAlc > 10) {
@ -498,8 +562,28 @@ public class BPlayer {
} else {
duration = 120;
}
PotionEffectType.BLINDNESS.createEffect(duration, 0).apply(player);
out.add(PotionEffectType.BLINDNESS.createEffect(duration, 0));
}
return out;
}
public static void addQualityEffects(int quality, int brewAlc, Player player) {
for (PotionEffect effect : getQualityEffects(quality, brewAlc)) {
effect.apply(player);
}
}
public static List<PotionEffect> getBrewEffects(List<BEffect> effects, int quality) {
List<PotionEffect> out = new ArrayList<>();
if (effects != null) {
for (BEffect effect : effects) {
PotionEffect e = effect.generateEffect(quality);
if (e != null) {
out.add(e);
}
}
}
return out;
}
public static void addBrewEffects(Brew brew, Player player) {

72
src/com/dre/brewery/BUtil.java
View File

@ -1,5 +1,9 @@
package com.dre.brewery;
import com.dre.brewery.api.events.barrel.BarrelDestroyEvent;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import java.util.List;
public class BUtil {
@ -25,4 +29,72 @@ public class BUtil {
}
return -1;
}
/*
---- Barrel ----
*/
// Returns true if the Block can be destroyed by the Player or something else (null)
public static boolean blockDestroy(Block block, Player player, BarrelDestroyEvent.Reason reason) {
switch (block.getType()) {
case CAULDRON:
// will only remove when existing
BCauldron.remove(block);
return true;
case FENCE:
case NETHER_FENCE:
case ACACIA_FENCE:
case BIRCH_FENCE:
case DARK_OAK_FENCE:
case IRON_FENCE:
case JUNGLE_FENCE:
case SPRUCE_FENCE:
// remove barrel and throw potions on the ground
Barrel barrel = Barrel.getBySpigot(block);
if (barrel != null) {
if (barrel.hasPermsDestroy(player, block, reason)) {
barrel.remove(null, player);
return true;
} else {
return false;
}
}
return true;
case SIGN_POST:
case WALL_SIGN:
// remove small Barrels
Barrel barrel2 = Barrel.getBySpigot(block);
if (barrel2 != null) {
if (!barrel2.isLarge()) {
if (barrel2.hasPermsDestroy(player, block, reason)) {
barrel2.remove(null, player);
return true;
} else {
return false;
}
} else {
barrel2.destroySign();
}
}
return true;
case WOOD:
case WOOD_STAIRS:
case BIRCH_WOOD_STAIRS:
case JUNGLE_WOOD_STAIRS:
case SPRUCE_WOOD_STAIRS:
case ACACIA_STAIRS:
case DARK_OAK_STAIRS:
Barrel barrel3 = Barrel.getByWood(block);
if (barrel3 != null) {
if (barrel3.hasPermsDestroy(player, block, reason)) {
barrel3.remove(block, player);
} else {
return false;
}
}
default:
break;
}
return true;
}
}

183
src/com/dre/brewery/Barrel.java
View File

@ -1,21 +1,24 @@
package com.dre.brewery;
import java.util.ArrayList;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Map;
import com.dre.brewery.api.events.barrel.BarrelAccessEvent;
import com.dre.brewery.api.events.barrel.BarrelCreateEvent;
import com.dre.brewery.api.events.barrel.BarrelDestroyEvent;
import com.dre.brewery.api.events.barrel.BarrelRemoveEvent;
import com.dre.brewery.integration.LWCBarrel;
import com.dre.brewery.integration.LogBlockBarrel;
import com.dre.brewery.lore.BrewLore;
import org.apache.commons.lang.ArrayUtils;
import org.bukkit.Material;
import org.bukkit.TreeSpecies;
import org.bukkit.block.Block;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.block.Block;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.PotionMeta;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.material.MaterialData;
import org.bukkit.material.Stairs;
import org.bukkit.material.Tree;
@ -23,15 +26,13 @@ import org.bukkit.material.Wood;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import com.dre.brewery.integration.GriefPreventionBarrel;
import com.dre.brewery.integration.LWCBarrel;
import com.dre.brewery.integration.LogBlockBarrel;
import org.apache.commons.lang.ArrayUtils;
import java.util.ArrayList;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
public class Barrel implements InventoryHolder {
public static CopyOnWriteArrayList<Barrel> barrels = new CopyOnWriteArrayList<>();
public static CopyOnWriteArrayList<Barrel> barrels = new CopyOnWriteArrayList<>(); // TODO find best collection
private static int check = 0;
private Block spigot;
@ -45,6 +46,11 @@ public class Barrel implements InventoryHolder {
public Barrel(Block spigot, byte signoffset) {
this.spigot = spigot;
this.signoffset = signoffset;
if (isLarge()) {
inventory = P.p.getServer().createInventory(this, 27, P.p.languageReader.get("Etc_Barrel"));
} else {
inventory = P.p.getServer().createInventory(this, 9, P.p.languageReader.get("Etc_Barrel"));
}
}
// load from file
@ -52,9 +58,9 @@ public class Barrel implements InventoryHolder {
this.spigot = spigot;
this.signoffset = sign;
if (isLarge()) {
this.inventory = org.bukkit.Bukkit.createInventory(this, 27, P.p.languageReader.get("Etc_Barrel"));
this.inventory = P.p.getServer().createInventory(this, 27, P.p.languageReader.get("Etc_Barrel"));
} else {
this.inventory = org.bukkit.Bukkit.createInventory(this, 9, P.p.languageReader.get("Etc_Barrel"));
this.inventory = P.p.getServer().createInventory(this, 9, P.p.languageReader.get("Etc_Barrel"));
}
if (items != null) {
for (String slot : items.keySet()) {
@ -122,39 +128,13 @@ public class Barrel implements InventoryHolder {
}
}
if (P.p.useWG) {
Plugin plugin = P.p.getServer().getPluginManager().getPlugin("WorldGuard");
if (plugin != null) {
try {
if (!P.p.wg.checkAccess(player, spigot, plugin)) {
return false;
}
} catch (Throwable e) {
P.p.errorLog("Failed to Check WorldGuard for Barrel Open Permissions!");
P.p.errorLog("Brewery was tested with version 5.8 to 6.1 of WorldGuard!");
P.p.errorLog("Disable the WorldGuard support in the config and do /brew reload");
e.printStackTrace();
P.p.msg(player, "&cError opening Barrel, please report to an Admin!");
return false;
}
}
}
if (P.p.useGP) {
if (P.p.getServer().getPluginManager().isPluginEnabled("GriefPrevention")) {
try {
if (!GriefPreventionBarrel.checkAccess(player, spigot)) {
return false;
}
} catch (Throwable e) {
P.p.errorLog("Failed to Check GriefPrevention for Barrel Open Permissions!");
P.p.errorLog("Brewery was tested with GriefPrevention 14.5.4");
P.p.errorLog("Disable the GriefPrevention support in the config and do /brew reload");
e.printStackTrace();
P.p.msg(player, "&cError opening Barrel, please report to an Admin!");
return false;
}
}
// Call event
BarrelAccessEvent accessEvent = new BarrelAccessEvent(this, player, event.getClickedBlock());
// Listened to by WGBarrelNew, WGBarrelOld, GriefPreventionBarrel (IntegrationListener)
P.p.getServer().getPluginManager().callEvent(accessEvent);
if (accessEvent.isCancelled()) {
P.p.msg(player, P.p.languageReader.get("Error_NoBarrelAccess"));
return false;
}
if (event != null && P.p.useLWC) {
@ -184,48 +164,21 @@ public class Barrel implements InventoryHolder {
return true;
}
// Ask for permission to destroy barrel, remove protection if has
public boolean hasPermsDestroy(Player player) {
if (player == null) {
willDestroy();
return true;
}
if (P.p.useLWC) {
try {
return LWCBarrel.checkDestroy(player, this);
} catch (Throwable e) {
P.p.errorLog("Failed to Check LWC for Barrel Break Permissions!");
P.p.errorLog("Brewery was tested with version 4.5.0 of LWC!");
P.p.errorLog("Disable the LWC support in the config and do /brew reload");
e.printStackTrace();
P.p.msg(player, "&cError breaking Barrel, please report to an Admin!");
return false;
}
}
return true;
}
// If something other than the Player is destroying the barrel, inform protection plugins
public void willDestroy() {
if (P.p.useLWC) {
try {
LWCBarrel.remove(this);
} catch (Throwable e) {
P.p.errorLog("Failed to Remove LWC Lock from Barrel!");
P.p.errorLog("Brewery was tested with version 4.5.0 of LWC!");
e.printStackTrace();
}
}
// Ask for permission to destroy barrel
public boolean hasPermsDestroy(Player player, Block block, BarrelDestroyEvent.Reason reason) {
// Listened to by LWCBarrel (IntegrationListener)
BarrelDestroyEvent destroyEvent = new BarrelDestroyEvent(this, block, reason, player);
P.p.getServer().getPluginManager().callEvent(destroyEvent);
return !destroyEvent.isCancelled();
}
// player opens the barrel
public void open(Player player) {
if (inventory == null) {
if (isLarge()) {
inventory = org.bukkit.Bukkit.createInventory(this, 27, P.p.languageReader.get("Etc_Barrel"));
inventory = P.p.getServer().createInventory(this, 27, P.p.languageReader.get("Etc_Barrel"));
} else {
inventory = org.bukkit.Bukkit.createInventory(this, 9, P.p.languageReader.get("Etc_Barrel"));
inventory = P.p.getServer().createInventory(this, 9, P.p.languageReader.get("Etc_Barrel"));
}
} else {
if (time > 0) {
@ -270,6 +223,14 @@ public class Barrel implements InventoryHolder {
return inventory;
}
public Block getSpigot() {
return spigot;
}
public float getTime() {
return time;
}
// Returns true if this Block is part of this Barrel
public boolean hasBlock(Block block) {
if (block != null) {
@ -439,8 +400,12 @@ public class Barrel implements InventoryHolder {
return false;
}
}
barrels.add(barrel);
return true;
BarrelCreateEvent createEvent = new BarrelCreateEvent(barrel, player);
P.p.getServer().getPluginManager().callEvent(createEvent);
if (!createEvent.isCancelled()) {
barrels.add(barrel);
return true;
}
}
} else {
if (barrel.signoffset == 0 && signoffset != 0) {
@ -453,6 +418,10 @@ public class Barrel implements InventoryHolder {
// removes a barrel, throwing included potions to the ground
public void remove(Block broken, Player breaker) {
BarrelRemoveEvent event = new BarrelRemoveEvent(this);
// Listened to by LWCBarrel (IntegrationListener)
P.p.getServer().getPluginManager().callEvent(event);
if (inventory != null) {
for (HumanEntity human : inventory.getViewers()) {
human.closeInventory();
@ -467,25 +436,27 @@ public class Barrel implements InventoryHolder {
e.printStackTrace();
}
}
for (ItemStack item : items) {
if (item != null) {
Brew brew = Brew.get(item);
if (brew != null) {
// Brew before throwing
brew.age(item, time, getWood());
PotionMeta meta = (PotionMeta) item.getItemMeta();
if (BrewLore.hasColorLore(meta)) {
BrewLore lore = new BrewLore(brew, meta);
lore.convertLore(false);
lore.write();
item.setItemMeta(meta);
if (event.shouldItemsDrop()) {
for (ItemStack item : items) {
if (item != null) {
Brew brew = Brew.get(item);
if (brew != null) {
// Brew before throwing
brew.age(item, time, getWood());
PotionMeta meta = (PotionMeta) item.getItemMeta();
if (BrewLore.hasColorLore(meta)) {
BrewLore lore = new BrewLore(brew, meta);
lore.convertLore(false);
lore.write();
item.setItemMeta(meta);
}
}
// "broken" is the block that destroyed, throw them there!
if (broken != null) {
broken.getWorld().dropItem(broken.getLocation(), item);
} else {
spigot.getWorld().dropItem(spigot.getLocation(), item);
}
}
// "broken" is the block that destroyed, throw them there!
if (broken != null) {
broken.getWorld().dropItem(broken.getLocation(), item);
} else {
spigot.getWorld().dropItem(spigot.getLocation(), item);
}
}
}
@ -617,7 +588,12 @@ public class Barrel implements InventoryHolder {
// is this a Large barrel?
public boolean isLarge() {
return !isSign(spigot);
return !isSmall();
}
// is this a Small barrel?
public boolean isSmall() {
return isSign(spigot);
}
// true for small barrels
@ -950,7 +926,6 @@ public class Barrel implements InventoryHolder {
P.p.debugLog("Barrel at " + broken.getWorld().getName() + "/" + broken.getX() + "/" + broken.getY() + "/" + broken.getZ()
+ " has been destroyed unexpectedly, contents will drop");
// remove the barrel if it was destroyed
barrel.willDestroy();
barrel.remove(broken, null);
} else {
// Dont check this barrel again, its enough to check it once after every restart

7
src/com/dre/brewery/Brew.java
View File

@ -1,5 +1,6 @@
package com.dre.brewery;
import com.dre.brewery.api.events.brew.BrewModifyEvent;
import com.dre.brewery.lore.*;
import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
@ -454,6 +455,9 @@ public class Brew {
// distill custom potion in given slot
public void distillSlot(ItemStack slotItem, PotionMeta potionMeta) {
if (immutable) return;
BrewModifyEvent modifyEvent = new BrewModifyEvent(this, BrewModifyEvent.Type.DISTILL);
P.p.getServer().getPluginManager().callEvent(modifyEvent);
if (modifyEvent.isCancelled()) return;
distillRuns += 1;
BrewLore lore = new BrewLore(this, potionMeta);
@ -508,6 +512,9 @@ public class Brew {
public void age(ItemStack item, float time, byte woodType) {
if (immutable) return;
BrewModifyEvent modifyEvent = new BrewModifyEvent(this, BrewModifyEvent.Type.AGE);
P.p.getServer().getPluginManager().callEvent(modifyEvent);
if (modifyEvent.isCancelled()) return;
PotionMeta potionMeta = (PotionMeta) item.getItemMeta();
BrewLore lore = new BrewLore(this, potionMeta);

110
src/com/dre/brewery/P.java
View File

@ -1,13 +1,28 @@
package com.dre.brewery;
import com.dre.brewery.filedata.*;
import com.dre.brewery.filedata.ConfigUpdater;
import com.dre.brewery.filedata.DataSave;
import com.dre.brewery.filedata.DataUpdater;
import com.dre.brewery.filedata.LanguageReader;
import com.dre.brewery.filedata.UpdateChecker;
import com.dre.brewery.integration.IntegrationListener;
import com.dre.brewery.integration.LogBlockBarrel;
import com.dre.brewery.integration.WGBarrel;
import com.dre.brewery.integration.WGBarrelNew;
import com.dre.brewery.integration.WGBarrelOld;
import com.dre.brewery.listeners.*;
import com.dre.brewery.listeners.BlockListener;
import com.dre.brewery.listeners.CauldronListener;
import com.dre.brewery.listeners.CommandListener;
import com.dre.brewery.listeners.EntityListener;
import com.dre.brewery.listeners.InventoryListener;
import com.dre.brewery.listeners.PlayerListener;
import com.dre.brewery.listeners.WorldListener;
import org.apache.commons.lang.math.NumberUtils;
import org.bukkit.*;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
@ -18,8 +33,17 @@ import org.bukkit.event.HandlerList;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.*;
import java.util.*;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.UUID;
public class P extends JavaPlugin {
public static P p;
@ -43,6 +67,7 @@ public class P extends JavaPlugin {
public EntityListener entityListener;
public InventoryListener inventoryListener;
public WorldListener worldListener;
public IntegrationListener integrationListener;
// Language
public String language;
@ -330,6 +355,7 @@ public class P extends JavaPlugin {
entityListener = new EntityListener();
inventoryListener = new InventoryListener();
worldListener = new WorldListener();
integrationListener = new IntegrationListener();
getCommand("Brewery").setExecutor(new CommandListener());
p.getServer().getPluginManager().registerEvents(blockListener, p);
@ -337,6 +363,7 @@ public class P extends JavaPlugin {
p.getServer().getPluginManager().registerEvents(entityListener, p);
p.getServer().getPluginManager().registerEvents(inventoryListener, p);
p.getServer().getPluginManager().registerEvents(worldListener, p);
p.getServer().getPluginManager().registerEvents(integrationListener, p);
if (use1_9) {
p.getServer().getPluginManager().registerEvents(new CauldronListener(), p);
}
@ -495,6 +522,11 @@ public class P extends JavaPlugin {
// Third-Party
useWG = config.getBoolean("useWorldGuard", true) && getServer().getPluginManager().isPluginEnabled("WorldGuard");
useLWC = config.getBoolean("useLWC", true) && getServer().getPluginManager().isPluginEnabled("LWC");
useGP = config.getBoolean("useGriefPrevention", true) && getServer().getPluginManager().isPluginEnabled("GriefPrevention");
useLB = config.getBoolean("useLogBlock", false) && getServer().getPluginManager().isPluginEnabled("LogBlock");
hasVault = getServer().getPluginManager().isPluginEnabled("Vault");
if (useWG) {
try {
try {
@ -511,10 +543,6 @@ public class P extends JavaPlugin {
e.printStackTrace();
}
}
useLWC = config.getBoolean("useLWC", true) && getServer().getPluginManager().isPluginEnabled("LWC");
useGP = config.getBoolean("useGriefPrevention", true) && getServer().getPluginManager().isPluginEnabled("GriefPrevention");
useLB = config.getBoolean("useLogBlock", false) && getServer().getPluginManager().isPluginEnabled("LogBlock");
hasVault = getServer().getPluginManager().isPluginEnabled("Vault");
// various Settings
DataSave.autosave = config.getInt("autosave", 3);
@ -929,70 +957,6 @@ public class P extends JavaPlugin {
}
}
// Returns true if the Block can be destroyed by the Player or something else (null)
public boolean blockDestroy(Block block, Player player) {
switch (block.getType()) {
case CAULDRON:
// will only remove when existing
BCauldron.remove(block);
return true;
case FENCE:
case NETHER_FENCE:
case ACACIA_FENCE:
case BIRCH_FENCE:
case DARK_OAK_FENCE:
case IRON_FENCE:
case JUNGLE_FENCE:
case SPRUCE_FENCE:
// remove barrel and throw potions on the ground
Barrel barrel = Barrel.getBySpigot(block);
if (barrel != null) {
if (barrel.hasPermsDestroy(player)) {
barrel.remove(null, player);
return true;
} else {
return false;
}
}
return true;
case SIGN_POST:
case WALL_SIGN:
// remove small Barrels
Barrel barrel2 = Barrel.getBySpigot(block);
if (barrel2 != null) {
if (!barrel2.isLarge()) {
if (barrel2.hasPermsDestroy(player)) {
barrel2.remove(null, player);
return true;
} else {
return false;
}
} else {
barrel2.destroySign();
}
}
return true;
case WOOD:
case WOOD_STAIRS:
case BIRCH_WOOD_STAIRS:
case JUNGLE_WOOD_STAIRS:
case SPRUCE_WOOD_STAIRS:
case ACACIA_STAIRS:
case DARK_OAK_STAIRS:
Barrel barrel3 = Barrel.getByWood(block);
if (barrel3 != null) {
if (barrel3.hasPermsDestroy(player)) {
barrel3.remove(block, player);
} else {
return false;
}
}
default:
break;
}
return true;
}
public String color(String msg) {
if (msg != null) {
msg = ChatColor.translateAlternateColorCodes('&', msg);

150
src/com/dre/brewery/api/BreweryApi.java Normal file
View File

@ -0,0 +1,150 @@
package com.dre.brewery.api;
import com.dre.brewery.BCauldron;
import com.dre.brewery.BRecipe;
import com.dre.brewery.Barrel;
import com.dre.brewery.Brew;
import org.apache.commons.lang.NotImplementedException;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
public class BreweryApi {
/*
* Convenience methods to get common objects or do common things
*/
/*
* Remove any data that this Plugin may associate with the given Block
* Currently Cauldrons and Barrels (Cauldron, Wood, Woodstairs, Fence, Sign)
* Does not remove any actual Blocks
* Returns true if anything was removed
*/
public static boolean removeAny(Block block) {
if (removeCauldron(block)) return true;
return removeBarrel(block);
}
/*
* Like removeAny() but removes data as if the given player broke the Block
* Currently only makes a difference for Logging
*/
public static boolean removeAnyByPlayer(Block block, Player player) {
if (removeCauldron(block)) return true;
return removeBarrelByPlayer(block, player);
}
// # # # # # Brew # # # # #
/*
* Get a Brew from an ItemStack
* Reads the Brew data from the saved data on the item
* Checks if item is actually a Brew
* Returns null if item is not a Brew
*/
public static Brew getBrew(ItemStack item) {
return Brew.get(item);
}
/*
* Get a Brew from an ItemMeta
* Reads the Brew data from the saved data in the Meta
* Checks if meta has a Brew saved
* Returns null if meta is not a Brew
*/
public static Brew getBrew(ItemMeta meta) {
return Brew.get(meta);
}
// # # # # # Barrel # # # # #
/*
* Get a Barrel from a Block
* May be any Wood, Fence, Sign that is part of a Barrel
* Returns null if block is not part of a Barrel
*/
public static Barrel getBarrel(Block block) {
return Barrel.get(block);
}
/*
* Get the Inventory of a Block part of a Barrel
* May be any Wood, Fence or Sign that is part of a Barrel
* Returns null if block is not part of a Barrel
*/
public static Inventory getBarrelInventory(Block block) {
Barrel barrel = Barrel.get(block);
if (barrel != null) {
return barrel.getInventory();
}
return null;
}
/*
* Remove any Barrel that this Block may be Part of
* Returns true if a Barrel was removed
* Does not remove any actual Block
*/
public static boolean removeBarrel(Block block) { // TODO add dropItems flag
return removeBarrelByPlayer(block, null);
}
/*
* Remove any Barrel that this Block may be Part of, as if broken by the Player
* Returns true if a Barrel was removed
* Does not remove any actual Block
*/
public static boolean removeBarrelByPlayer(Block block, Player player) {
Barrel barrel = Barrel.get(block);
if (barrel != null) {
barrel.remove(block, player);
return true;
}
return false;
}
// # # # # # Cauldron # # # # #
/*
* Get a BCauldron from a Block
* Returns null if block is not a BCauldron
*/
public static BCauldron getCauldron(Block block) {
return BCauldron.get(block);
}
/*
* Remove any data associated with a Cauldron at that given Block
* Returns true if a Cauldron was removed
* Does not actually remove the Block
*/
public static boolean removeCauldron(Block block) {
return BCauldron.remove(block);
}
// # # # # # Recipe # # # # #
/*
* Get a BRecipe by its name
* The name is the middle one of the three if three are set in the config
* Returns null if recipe with that name does not exist
*/
public static BRecipe getRecipe(String name) {
return BRecipe.get(name);
}
/*
* Add a new recipe
* Not Implemented yet
*/
public static boolean addRecipe(BRecipe recipe) {
throw new NotImplementedException(); // TODO implement
}
}

103
src/com/dre/brewery/api/events/IngedientAddEvent.java Normal file
View File

@ -0,0 +1,103 @@
package com.dre.brewery.api.events;
import com.dre.brewery.BCauldron;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.material.Cauldron;
import org.bukkit.material.MaterialData;
/*
* Player adding an ingredient to a cauldron
* Always one item added at a time
* If needed use the caudrons add method to manually add more Items
*/
public class IngedientAddEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Block block;
private final BCauldron cauldron;
private ItemStack ingredient;
private boolean cancelled;
private boolean takeItem = true;
public IngedientAddEvent(Player who, Block block, BCauldron bCauldron, ItemStack ingredient) {
super(who);
this.block = block;
cauldron = bCauldron;
this.ingredient = ingredient.clone();
}
public Block getBlock() {
return block;
}
public BCauldron getCauldron() {
return cauldron;
}
// Get the item currently being added to the cauldron by the player
// Can be changed directly or with the setter
// The amount is ignored and always one added
public ItemStack getIngredient() {
return ingredient;
}
// Set the ingredient added to the cauldron to something else
// Will always be accepted, even when not in a recipe or the cooked list
// The amount is ignored and always one added
public void setIngredient(ItemStack ingredient) {
this.ingredient = ingredient;
}
// If the amount of the item in the players hand should be decreased
// Default true
public boolean shouldTakeItem() {
return takeItem;
}
// Set if the amount of the item in the players hand should be decreased
public void setTakeItem(boolean takeItem) {
this.takeItem = takeItem;
}
// Get the MaterialData of the Cauldron
// May be null if the Cauldron does not exist anymore
public Cauldron getCauldronData() {
BlockState state = block.getState();
if (state != null) {
MaterialData data = state.getData();
if (data instanceof Cauldron) {
return ((Cauldron) state);
}
}
return null;
}
// 0 = empty, 1 = something in, 2 = full
public int getFillLevel() {
return BCauldron.getFillLevel(block);
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

54
src/com/dre/brewery/api/events/PlayerAlcEffectEvent.java Normal file
View File

@ -0,0 +1,54 @@
package com.dre.brewery.api.events;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
import org.bukkit.potion.PotionEffect;
import java.util.List;
/*
* Called when the Alcohol in the Player demands its toll
* These effects are applied regularly to the Player depending on his alcohol level
* By default it is just one Confusion effect
* Can be changed or cancelled
*/
public class PlayerAlcEffectEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private List<PotionEffect> effects;
private boolean cancelled;
public PlayerAlcEffectEvent(Player who, List<PotionEffect> effects) {
super(who);
this.effects = effects;
}
public List<PotionEffect> getEffects() {
return effects;
}
public void setEffects(List<PotionEffect> effects) {
this.effects = effects;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

52
src/com/dre/brewery/api/events/PlayerDrinkEffectEvent.java Normal file
View File

@ -0,0 +1,52 @@
package com.dre.brewery.api.events;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
import org.bukkit.potion.PotionEffect;
import java.util.List;
/*
* Called when the Effects of a Brew are applied to the player (drinking the Brew)
* These depend on alcohol and quality of the brew
* Can be changed or cancelled
*/
public class PlayerDrinkEffectEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private List<PotionEffect> effects;
private boolean cancelled;
public PlayerDrinkEffectEvent(Player who, List<PotionEffect> effects) {
super(who);
this.effects = effects;
}
public List<PotionEffect> getEffects() {
return effects;
}
public void setEffects(List<PotionEffect> effects) {
this.effects = effects;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

60
src/com/dre/brewery/api/events/PlayerPukeEvent.java Normal file
View File

@ -0,0 +1,60 @@
package com.dre.brewery.api.events;
import com.dre.brewery.BPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
/*
* The player pukes (throws puke items to the ground)
* Those items can never be picked up and despawn after the time set in the config
* Number of items to drop can be changed with count
*/
public class PlayerPukeEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private int count;
private boolean cancelled;
private BPlayer bPlayer;
public PlayerPukeEvent(Player who, int count) {
super(who);
this.count = count;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public BPlayer getBPlayer() {
if (bPlayer == null) {
bPlayer = BPlayer.get(player);
}
return bPlayer;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

64
src/com/dre/brewery/api/events/PlayerPushEvent.java Normal file
View File

@ -0,0 +1,64 @@
package com.dre.brewery.api.events;
import com.dre.brewery.BPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
import org.bukkit.util.Vector;
/*
* The Players movement is hindered because of drunkeness
* Called each time before pushing the Player with the Vector push 10 times
* The Push Vector can be changed or multiplied
*/
public class PlayerPushEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final BPlayer bPlayer;
private Vector push;
private boolean cancelled;
public PlayerPushEvent(Player who, Vector push, BPlayer bPlayer) {
super(who);
this.push = push;
this.bPlayer = bPlayer;
}
public BPlayer getbPlayer() {
return bPlayer;
}
// The Vector in which direction and magnitude the player is Pushed
// Can be changed directly or through setPush
public Vector getPush() {
return push;
}
// Set the Push vector, can not be null
public void setPush(Vector push) {
if (push == null) {
throw new NullPointerException("Push Vector is null");
}
this.push = push;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

54
src/com/dre/brewery/api/events/barrel/BarrelAccessEvent.java Normal file
View File

@ -0,0 +1,54 @@
package com.dre.brewery.api.events.barrel;
import com.dre.brewery.Barrel;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
/*
* A Player opens a Barrel by rightclicking it
* The PlayerInteractEvent on the Barrel may be cancelled. In that case this never gets called
* Can be cancelled to silently deny opening the Barrel
*/
public class BarrelAccessEvent extends BarrelEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Player player;
private final Block clickedBlock;
private boolean isCancelled;
public BarrelAccessEvent(Barrel barrel, Player player, Block clickedBlock) {
super(barrel);
this.player = player;
this.clickedBlock = clickedBlock;
}
// Gets the Block that was actually clicked.
// For access Permissions getSpigot() should be used
public Block getClickedBlock() {
return clickedBlock;
}
@Override
public boolean isCancelled() {
return isCancelled;
}
@Override
public void setCancelled(boolean cancelled) {
isCancelled = cancelled;
}
public Player getPlayer() {
return player;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

44
src/com/dre/brewery/api/events/barrel/BarrelCreateEvent.java Normal file
View File

@ -0,0 +1,44 @@
package com.dre.brewery.api.events.barrel;
import com.dre.brewery.Barrel;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
/*
* Called when a Barrel is created by a Player by placing a Sign
* Cancelling this will silently fail the Barrel creation
*/
public class BarrelCreateEvent extends BarrelEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Player player;
private boolean cancelled;
public BarrelCreateEvent(Barrel barrel, Player player) {
super(barrel);
this.player = player;
}
public Player getPlayer() {
return player;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

71
src/com/dre/brewery/api/events/barrel/BarrelDestroyEvent.java Normal file
View File

@ -0,0 +1,71 @@
package com.dre.brewery.api.events.barrel;
import com.dre.brewery.Barrel;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
/*
* A Barrel is being destroyed by something, may not be by a Player
* A BarrelRemoveEvent will be called after this, if this is not cancelled
* Use the BarrelRemoveEvent to monitor any and all barrels being removed in a non cancellable way
*/
public class BarrelDestroyEvent extends BarrelEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Block broken;
private final Reason reason;
private final Player player;
private boolean cancelled;
public BarrelDestroyEvent(Barrel barrel, Block broken, Reason reason, Player player) {
super(barrel);
this.broken = broken;
this.player = player;
this.reason = reason;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public Block getBroken() {
return broken;
}
public Reason getReason() {
return reason;
}
public boolean hasPlayer() {
return player != null;
}
// MAY BE NULL if no Player is involved
public Player getPlayerOptional() {
return player;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
public enum Reason {
PLAYER, // A Player Broke the Barrel
BROKEN, // A Block was broken by something
BURNED, // A Block burned away
EXPLODED, // The Barrel exploded somehow
UNKNOWN // The Barrel was broken somehow else
}
}

27
src/com/dre/brewery/api/events/barrel/BarrelEvent.java Normal file
View File

@ -0,0 +1,27 @@
package com.dre.brewery.api.events.barrel;
import com.dre.brewery.Barrel;
import org.bukkit.block.Block;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.inventory.Inventory;
public abstract class BarrelEvent extends Event {
protected final Barrel barrel;
public BarrelEvent(Barrel barrel) {
this.barrel = barrel;
}
public Barrel getBarrel() {
return barrel;
}
public Inventory getInventory() {
return barrel.getInventory();
}
public Block getSpigot() {
return barrel.getSpigot();
}
}

34
src/com/dre/brewery/api/events/barrel/BarrelRemoveEvent.java Normal file
View File

@ -0,0 +1,34 @@
package com.dre.brewery.api.events.barrel;
import com.dre.brewery.Barrel;
import org.bukkit.event.HandlerList;
/*
* A Barrel is being removed. There may have been a BarrelDestroyEvent before
* If not, Worldedit, other Plugins etc may be the cause for unexpected removal
*/
public class BarrelRemoveEvent extends BarrelEvent {
private static final HandlerList handlers = new HandlerList();
private boolean itemsDrop = true;
public BarrelRemoveEvent(Barrel barrel) {
super(barrel);
}
public boolean shouldItemsDrop() {
return itemsDrop;
}
public void setShouldItemsDrop(boolean itemsDrop) {
this.itemsDrop = itemsDrop;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

79
src/com/dre/brewery/api/events/brew/BrewDrinkEvent.java Normal file
View File

@ -0,0 +1,79 @@
package com.dre.brewery.api.events.brew;
import com.dre.brewery.BEffect;
import com.dre.brewery.BPlayer;
import com.dre.brewery.Brew;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.potion.PotionEffect;
import java.util.List;
/*
* A Player Drinks a Brew
* The amount of alcohol and quality that will be added to the player can be get/set here
* If cancelled the drinking will fail silently
*/
public class BrewDrinkEvent extends BrewEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Player player;
private final BPlayer bPlayer;
private int alc;
private int quality;
private boolean cancelled;
public BrewDrinkEvent(Brew brew, Player player, BPlayer bPlayer) {
super(brew);
this.player = player;
this.bPlayer = bPlayer;
alc = brew.calcAlcohol();
quality = brew.getQuality();
}
public Player getPlayer() {
return player;
}
public BPlayer getbPlayer() {
return bPlayer;
}
public int getAddedAlcohol() {
return alc;
}
public void setAddedAlcohol(int alc) {
this.alc = alc;
}
public int getQuality() {
return quality;
}
public void setQuality(int quality) {
if (quality > 10 || quality < 0) {
throw new IllegalArgumentException("Quality must be in range from 0 to 10");
}
this.quality = quality;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

17
src/com/dre/brewery/api/events/brew/BrewEvent.java Normal file
View File

@ -0,0 +1,17 @@
package com.dre.brewery.api.events.brew;
import com.dre.brewery.Brew;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public abstract class BrewEvent extends Event {
protected final Brew brew;
public BrewEvent(Brew brew) {
this.brew = brew;
}
public Brew getBrew() {
return brew;
}
}

53
src/com/dre/brewery/api/events/brew/BrewModifyEvent.java Normal file
View File

@ -0,0 +1,53 @@
package com.dre.brewery.api.events.brew;
import com.dre.brewery.Brew;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
/*
* A Brew is created or modified
* Usually happens on Filling from cauldron, distilling and aging.
*/
public class BrewModifyEvent extends BrewEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Type type;
private boolean cancelled;
public BrewModifyEvent(Brew brew, Type type) {
super(brew);
this.type = type;
}
public Type getType() {
return type;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
public enum Type {
//CREATE, // A new Brew is created with arbitrary ways, like the create command
FILL, // Filled from a Cauldron into a new Brew
DISTILL, // Distilled in the Brewing stand
AGE, // Aged in a Barrel
UNLABEL, // Unlabeling Brew with command
STATIC, // Making Brew static with command
UNKNOWN // Unknown modification, unused
}
}

13
src/com/dre/brewery/integration/GriefPreventionBarrel.java
View File

@ -1,18 +1,19 @@
package com.dre.brewery.integration;
import com.dre.brewery.P;
import com.dre.brewery.api.events.barrel.BarrelAccessEvent;
import me.ryanhamshire.GriefPrevention.Claim;
import me.ryanhamshire.GriefPrevention.GriefPrevention;
import me.ryanhamshire.GriefPrevention.PlayerData;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
public class GriefPreventionBarrel {
static P brewery = P.p;
static GriefPrevention griefPrevention = GriefPrevention.instance;
private static P brewery = P.p;
public static boolean checkAccess(Player player, Block sign) {
public static boolean checkAccess(BarrelAccessEvent event) {
GriefPrevention griefPrevention = GriefPrevention.instance;
Player player = event.getPlayer();
PlayerData playerData = griefPrevention.dataStore.getPlayerData(player.getUniqueId());
if (!griefPrevention.claimsEnabledForWorld(player.getWorld()) || playerData.ignoreClaims || !griefPrevention.config_claims_preventTheft) {
@ -21,17 +22,15 @@ public class GriefPreventionBarrel {
// block container use during pvp combat
if (playerData.inPvpCombat()) {
brewery.msg(player, brewery.languageReader.get("Error_NoBarrelAccess"));
return false;
}
// check permissions for the claim the Barrel is in
Claim claim = griefPrevention.dataStore.getClaimAt(sign.getLocation(), false, playerData.lastClaim);
Claim claim = griefPrevention.dataStore.getClaimAt(event.getSpigot().getLocation(), false, playerData.lastClaim);
if (claim != null) {
playerData.lastClaim = claim;
String noContainersReason = claim.allowContainers(player);
if (noContainersReason != null) {
brewery.msg(player, brewery.languageReader.get("Error_NoBarrelAccess"));
return false;
}
}

122
src/com/dre/brewery/integration/IntegrationListener.java Normal file
View File

@ -0,0 +1,122 @@
package com.dre.brewery.integration;
import com.dre.brewery.Barrel;
import com.dre.brewery.P;
import com.dre.brewery.api.events.barrel.BarrelAccessEvent;
import com.dre.brewery.api.events.barrel.BarrelDestroyEvent;
import com.dre.brewery.api.events.barrel.BarrelRemoveEvent;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.plugin.Plugin;
public class IntegrationListener implements Listener {
@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onBarrelAccessLowest(BarrelAccessEvent event) {
if (P.p.useWG) {
Plugin plugin = P.p.getServer().getPluginManager().getPlugin("WorldGuard");
if (plugin != null) {
try {
if (!P.p.wg.checkAccess(event.getPlayer(), event.getSpigot(), plugin)) {
event.setCancelled(true);
}
} catch (Throwable e) {
event.setCancelled(true);
P.p.errorLog("Failed to Check WorldGuard for Barrel Open Permissions!");
P.p.errorLog("Brewery was tested with version 5.8 to 6.1 of WorldGuard!");
P.p.errorLog("Disable the WorldGuard support in the config and do /brew reload");
e.printStackTrace();
P.p.msg(event.getPlayer(), "&cError opening Barrel, please report to an Admin!");
}
}
}
}
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onBarrelAccess(BarrelAccessEvent event) {
if (P.p.useGP) {
if (P.p.getServer().getPluginManager().isPluginEnabled("GriefPrevention")) {
try {
if (!GriefPreventionBarrel.checkAccess(event)) {
event.setCancelled(true);
}
} catch (Throwable e) {
event.setCancelled(true);
P.p.errorLog("Failed to Check GriefPrevention for Barrel Open Permissions!");
P.p.errorLog("Brewery was tested with GriefPrevention 14.5.4");
P.p.errorLog("Disable the GriefPrevention support in the config and do /brew reload");
e.printStackTrace();
P.p.msg(event.getPlayer(), "&cError opening Barrel, please report to an Admin!");
}
}
}
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.LOW)
public void onBarrelDestroy(BarrelDestroyEvent event) {
if (!P.p.useLWC) return;
if (event.hasPlayer()) {
try {
if (LWCBarrel.denyDestroy(event.getPlayerOptional(), event.getBarrel())) {
event.setCancelled(true);
}
} catch (Throwable e) {
event.setCancelled(true);
P.p.errorLog("Failed to Check LWC for Barrel Break Permissions!");
P.p.errorLog("Brewery was tested with version 4.5.0 of LWC!");
P.p.errorLog("Disable the LWC support in the config and do /brew reload");
e.printStackTrace();
P.p.msg(event.getPlayerOptional(), "&cError breaking Barrel, please report to an Admin!");
}
} else {
try {
if (event.getReason() == BarrelDestroyEvent.Reason.EXPLODED) {
if (LWCBarrel.denyExplosion(event.getBarrel())) {
event.setCancelled(true);
}
} else {
if (LWCBarrel.denyDestroyOther(event.getBarrel())) {
event.setCancelled(true);
}
}
} catch (Throwable e) {
event.setCancelled(true);
P.p.errorLog("Failed to Check LWC on Barrel Destruction!");
P.p.errorLog("Brewery was tested with version 4.5.0 of LWC!");
P.p.errorLog("Disable the LWC support in the config and do /brew reload");
e.printStackTrace();
}
}
}
@EventHandler
public void onBarrelRemove(BarrelRemoveEvent event) {
if (!P.p.useLWC) return;
try {
LWCBarrel.remove(event.getBarrel());
} catch (Throwable e) {
P.p.errorLog("Failed to Remove LWC Lock from Barrel!");
P.p.errorLog("Brewery was tested with version 4.5.0 of LWC!");
e.printStackTrace();
}
}
@EventHandler
public void onInventoryClose(InventoryCloseEvent event) {
if (P.p.useLB) {
if (event.getInventory().getHolder() instanceof Barrel) {
try {
LogBlockBarrel.closeBarrel(event.getPlayer(), event.getInventory());
} catch (Exception e) {
P.p.errorLog("Failed to Log Barrel to LogBlock!");
P.p.errorLog("Brewery was tested with version 1.94 of LogBlock!");
e.printStackTrace();
}
}
}
}
}

40
src/com/dre/brewery/integration/LWCBarrel.java
View File

@ -1,13 +1,5 @@
package com.dre.brewery.integration;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventException;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.RegisteredListener;
import com.dre.brewery.Barrel;
import com.dre.brewery.P;
import com.griefcraft.listeners.LWCPlayerListener;
@ -15,11 +7,18 @@ import com.griefcraft.lwc.LWC;
import com.griefcraft.model.Flag;
import com.griefcraft.model.Protection;
import com.griefcraft.scripting.event.LWCProtectionDestroyEvent;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventException;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.RegisteredListener;
public class LWCBarrel {
public static boolean checkDestroy(Player player, Barrel barrel) {
public static boolean denyDestroy(Player player, Barrel barrel) {
LWC lwc = LWC.getInstance();
Block sign = barrel.getSignOfSpigot();
//if (!Boolean.parseBoolean(lwc.resolveProtectionConfiguration(sign, "ignoreBlockDestruction"))) {
@ -33,18 +32,18 @@ public class LWCBarrel {
lwc.getModuleLoader().dispatchEvent(evt);
if (evt.isCancelled()) {
return false;
return true;
}
} catch (Exception e) {
lwc.sendLocale(player, "protection.internalerror", "id", "BLOCK_BREAK");
P.p.errorLog("Failed to dispatch LWCProtectionDestroyEvent");
e.printStackTrace();
return false;
return true;
}
}
//}
return true;
return false;
}
public static boolean checkAccess(Player player, Block sign, PlayerInteractEvent event, Plugin plugin) {
@ -86,19 +85,14 @@ public class LWCBarrel {
}
// Returns true if the block that exploded should not be removed
public static boolean blockExplosion(Barrel barrel, Block block) {
public static boolean denyExplosion(Barrel barrel) {
Protection protection = LWC.getInstance().findProtection(barrel.getSignOfSpigot());
if (protection == null) {
barrel.remove(block, null);
return false;
}
return protection != null && !protection.hasFlag(Flag.Type.ALLOWEXPLOSIONS);
}
if (protection.hasFlag(Flag.Type.ALLOWEXPLOSIONS)) {
protection.remove();
barrel.remove(block, null);
return false;
}
return true;
// Returns true if the block that was destroyed should not be removed
public static boolean denyDestroyOther(Barrel barrel) {
return LWC.getInstance().findProtection(barrel.getSignOfSpigot()) != null;
}
}

14
src/com/dre/brewery/integration/WGBarrelNew.java
View File

@ -1,15 +1,13 @@
package com.dre.brewery.integration;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import com.dre.brewery.P;
import com.sk89q.worldguard.bukkit.RegionQuery;
import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
import com.sk89q.worldguard.bukkit.permission.RegionPermissionModel;
import com.sk89q.worldguard.protection.flags.DefaultFlag;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
public class WGBarrelNew implements WGBarrel {
@ -21,12 +19,8 @@ public class WGBarrelNew implements WGBarrel {
RegionQuery query = wg.getRegionContainer().createQuery();
if (!query.testBuild(spigot.getLocation(), player, DefaultFlag.USE, DefaultFlag.CHEST_ACCESS)) {
P.p.msg(player, P.p.languageReader.get("Error_NoBarrelAccess"));
return false;
}
return query.testBuild(spigot.getLocation(), player, DefaultFlag.USE, DefaultFlag.CHEST_ACCESS);
return true;
}
}

1
src/com/dre/brewery/integration/WGBarrelOld.java
View File

@ -44,7 +44,6 @@ public class WGBarrelOld implements WGBarrel {
if (!(Boolean) allows.invoke(region, DefaultFlag.CHEST_ACCESS, localPlayer)) {
if (!(Boolean) canBuild.invoke(region, localPlayer)) {
P.p.msg(player, P.p.languageReader.get("Error_NoBarrelAccess"));
return false;
}
}

17
src/com/dre/brewery/listeners/BlockListener.java
View File

@ -1,20 +1,21 @@
package com.dre.brewery.listeners;
import com.dre.brewery.BPlayer;
import com.dre.brewery.BUtil;
import com.dre.brewery.Barrel;
import com.dre.brewery.P;
import com.dre.brewery.Words;
import com.dre.brewery.api.events.barrel.BarrelDestroyEvent;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockPistonExtendEvent;
import org.bukkit.event.block.BlockPistonRetractEvent;
import org.bukkit.event.block.SignChangeEvent;
import org.bukkit.event.block.BlockBreakEvent;
import com.dre.brewery.Barrel;
import com.dre.brewery.BPlayer;
import com.dre.brewery.Words;
import com.dre.brewery.P;
public class BlockListener implements Listener {
@ -45,14 +46,14 @@ public class BlockListener implements Listener {
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
if (!P.p.blockDestroy(event.getBlock(), event.getPlayer())) {
if (!BUtil.blockDestroy(event.getBlock(), event.getPlayer(), BarrelDestroyEvent.Reason.PLAYER)) {
event.setCancelled(true);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBurn(BlockBurnEvent event) {
P.p.blockDestroy(event.getBlock(), null);
BUtil.blockDestroy(event.getBlock(), null, BarrelDestroyEvent.Reason.BURNED);
}
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)

11
src/com/dre/brewery/listeners/CommandListener.java
View File

@ -2,6 +2,7 @@ package com.dre.brewery.listeners;
import java.util.ArrayList;
import com.dre.brewery.api.events.brew.BrewModifyEvent;
import org.bukkit.Material;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
@ -457,6 +458,11 @@ public class CommandListener implements CommandExecutor {
if (hand != null) {
Brew brew = Brew.get(hand);
if (brew != null) {
BrewModifyEvent modifyEvent = new BrewModifyEvent(brew, BrewModifyEvent.Type.STATIC);
P.p.getServer().getPluginManager().callEvent(modifyEvent);
if (modifyEvent.isCancelled()) {
return;
}
if (brew.isStatic()) {
if (!brew.isPersistent()) {
brew.setStatic(false, hand);
@ -489,6 +495,11 @@ public class CommandListener implements CommandExecutor {
if (hand != null) {
Brew brew = Brew.get(hand);
if (brew != null) {
BrewModifyEvent modifyEvent = new BrewModifyEvent(brew, BrewModifyEvent.Type.UNLABEL);
P.p.getServer().getPluginManager().callEvent(modifyEvent);
if (modifyEvent.isCancelled()) {
return;
}
brew.unLabel(hand);
brew.touch();
brew.save(hand);

79
src/com/dre/brewery/listeners/EntityListener.java
View File

@ -1,25 +1,26 @@
package com.dre.brewery.listeners;
import java.util.ListIterator;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.entity.ItemDespawnEvent;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Item;
import org.bukkit.inventory.ItemStack;
import com.dre.brewery.Barrel;
import com.dre.brewery.Brew;
import com.dre.brewery.P;
import com.dre.brewery.integration.LWCBarrel;
import com.dre.brewery.api.events.barrel.BarrelDestroyEvent;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Item;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.entity.ItemDespawnEvent;
import org.bukkit.inventory.ItemStack;
import java.util.HashSet;
import java.util.ListIterator;
import java.util.Set;
public class EntityListener implements Listener {
@ -50,31 +51,33 @@ public class EntityListener implements Listener {
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onExplode(EntityExplodeEvent event) {
ListIterator<Block> iter = event.blockList().listIterator();
Barrel barrel = null;
boolean removedBarrel = false;
while (iter.hasNext()) {
Block block = iter.next();
if (barrel == null || !barrel.hasBlock(block)) {
barrel = Barrel.get(block);
removedBarrel = false;
}
if (!removedBarrel) {
if (barrel != null) {
if (P.p.useLWC) {
try {
if (LWCBarrel.blockExplosion(barrel, block)) {
iter.remove();
} else {
removedBarrel = true;
}
} catch (Exception e) {
P.p.errorLog("Failed to Check LWC on Barrel Explosion!");
e.printStackTrace();
removedBarrel = true;
if (!iter.hasNext()) return;
Set<BarrelDestroyEvent> breakEvents = new HashSet<>(6);
Block block;
blocks: while (iter.hasNext()) {
block = iter.next();
if (!breakEvents.isEmpty()) {
for (BarrelDestroyEvent breakEvent : breakEvents) {
if (breakEvent.getBarrel().hasBlock(block)) {
if (breakEvent.isCancelled()) {
iter.remove();
}
continue blocks;
}
}
}
Barrel barrel = Barrel.get(block);
if (barrel != null) {
BarrelDestroyEvent breakEvent = new BarrelDestroyEvent(barrel, block, BarrelDestroyEvent.Reason.EXPLODED, null);
// Listened to by LWCBarrel (IntegrationListener)
P.p.getServer().getPluginManager().callEvent(breakEvent);
breakEvents.add(breakEvent);
if (breakEvent.isCancelled()) {
iter.remove();
} else {
barrel.remove(block, null);
}
}
}
}

32
src/com/dre/brewery/listeners/InventoryListener.java
View File

@ -1,7 +1,10 @@
package com.dre.brewery.listeners;
import com.dre.brewery.*;
import com.dre.brewery.integration.LogBlockBarrel;
import com.dre.brewery.BPlayer;
import com.dre.brewery.BRecipe;
import com.dre.brewery.Barrel;
import com.dre.brewery.Brew;
import com.dre.brewery.P;
import com.dre.brewery.lore.BrewLore;
import org.bukkit.Bukkit;
import org.bukkit.Material;
@ -12,7 +15,15 @@ import org.bukkit.entity.HumanEntity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.*;
import org.bukkit.event.inventory.BrewEvent;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.inventory.InventoryPickupItemEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.BrewerInventory;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemFlag;
@ -379,19 +390,4 @@ public class InventoryListener implements Listener {
event.setCancelled(true);
}
}
@EventHandler
public void onInventoryClose(InventoryCloseEvent event) {
if (P.p.useLB) {
if (event.getInventory().getHolder() instanceof Barrel) {
try {
LogBlockBarrel.closeBarrel(event.getPlayer(), event.getInventory());
} catch (Exception e) {
P.p.errorLog("Failed to Log Barrel to LogBlock!");
P.p.errorLog("Brewery was tested with version 1.94 of LogBlock!");
e.printStackTrace();
}
}
}
}
}

19
src/com/dre/brewery/listeners/PlayerListener.java
View File

@ -1,6 +1,13 @@
package com.dre.brewery.listeners;
import com.dre.brewery.*;
import com.dre.brewery.BCauldron;
import com.dre.brewery.BIngredients;
import com.dre.brewery.BPlayer;
import com.dre.brewery.Barrel;
import com.dre.brewery.Brew;
import com.dre.brewery.P;
import com.dre.brewery.Wakeup;
import com.dre.brewery.Words;
import com.dre.brewery.filedata.UpdateChecker;
import org.bukkit.GameMode;
import org.bukkit.Material;
@ -115,7 +122,7 @@ public class PlayerListener implements Listener {
if (BIngredients.possibleIngredients.contains(materialInHand)) {
if (player.hasPermission("brewery.cauldron.insert")) {
if (BCauldron.ingredientAdd(clickedBlock, item)) {
if (BCauldron.ingredientAdd(clickedBlock, item, player)) {
boolean isBucket = item.getType().equals(Material.WATER_BUCKET)
|| item.getType().equals(Material.LAVA_BUCKET)
|| item.getType().equals(Material.MILK_BUCKET);
@ -213,10 +220,10 @@ public class PlayerListener implements Listener {
if (item.getType() == Material.POTION) {
Brew brew = Brew.get(item);
if (brew != null) {
BPlayer.drink(brew, player);
/*if (player.getGameMode() != GameMode.CREATIVE) {
brew.remove(item);
}*/
if (!BPlayer.drink(brew, player)) {
event.setCancelled(true);
return;
}
if (P.use1_9) {
if (player.getGameMode() != GameMode.CREATIVE) {
// replace the potion with an empty potion to avoid effects