so://phie

poppy

A feature-rich Minecraft plugin which enhances gaming experience
git clone git://soophie.de/poppy

blob: a160f95c29ec31d57a271e34d6e3fbb04b4ff323 (6929 bytes)[doc][blame][raw]

1package poppy.modules;

2

3import java.util.HashSet;

4import java.util.Iterator;

5

6import org.bukkit.Bukkit;

7import org.bukkit.Material;

8import org.bukkit.Tag;

9import org.bukkit.block.Block;

10import org.bukkit.block.BlockFace;

11import org.bukkit.block.BlockState;

12import org.bukkit.block.Chest;

13import org.bukkit.block.Dispenser;

14import org.bukkit.block.data.Ageable;

15import org.bukkit.block.data.Directional;

16import org.bukkit.enchantments.Enchantment;

17import org.bukkit.event.EventHandler;

18import org.bukkit.event.Listener;

19import org.bukkit.event.block.BlockDispenseEvent;

20import org.bukkit.inventory.Inventory;

21import org.bukkit.inventory.ItemStack;

22import org.bukkit.inventory.meta.Damageable;

23import org.bukkit.inventory.meta.ItemMeta;

24import org.bukkit.plugin.Plugin;

25

26import poppy.Utils;

27

28public class AutoBreakerModule implements Listener

29{

30 private Plugin plugin;

31

32 public AutoBreakerModule(Plugin plugin)

33 {

34 this.plugin = plugin;

35 }

36

37 @EventHandler

38 public void onBlockDispenseEvent(BlockDispenseEvent event)

39 {

40 final Block block = event.getBlock();

41 final BlockState blockState = block.getState();

42 final ItemStack item = event.getItem();

43

44 if(blockState instanceof Dispenser)

45 {

46 final Dispenser dispenser = (Dispenser) blockState;

47

48 if(dispenser.getCustomName() != null && dispenser.getCustomName().toLowerCase().equals("breaker"))

49 {

50 event.setCancelled(true);

51

52 if(block.getBlockData() instanceof Directional)

53 {

54 final Directional direction = (Directional) dispenser.getBlockData();

55 final Block faceBlock = dispenser.getBlock().getRelative(direction.getFacing());

56

57 final HashSet<ItemStack> drops = new HashSet<ItemStack>(faceBlock.getDrops(item));

58

59 if(Tag.CROPS.isTagged(faceBlock.getType()) || Tag.MINEABLE_AXE.isTagged(faceBlock.getType()))

60 {

61 if(faceBlock.getBlockData() instanceof Ageable)

62 {

63 final Ageable ageable = (Ageable) faceBlock.getBlockData();

64

65 if(ageable.getAge() == ageable.getMaximumAge())

66 {

67 if(!addItemToChest(direction, dispenser, drops))

68 {

69 faceBlock.breakNaturally(item);

70 }

71 else

72 {

73 faceBlock.setType(Material.AIR);

74 }

75 }

76 else if(!Tag.CROPS.isTagged(faceBlock.getType()))

77 {

78 if(!addItemToChest(direction, dispenser, drops))

79 {

80 faceBlock.breakNaturally(item);

81 }

82 else

83 {

84 faceBlock.setType(Material.AIR);

85 }

86 }

87 }

88 }

89

90 if(item.getType().toString().endsWith("_PICKAXE"))

91 {

92 if(Tag.MINEABLE_PICKAXE.isTagged(faceBlock.getType()))

93 {

94 if(!addItemToChest(direction, dispenser, drops))

95 {

96 setDamage(item, dispenser);

97 faceBlock.breakNaturally(item);

98 }

99 else

100 {

101 setDamage(item, dispenser);

102 faceBlock.setType(Material.AIR);

103 }

104 }

105 }

106

107 if(item.getType().toString().endsWith("_AXE"))

108 {

109 if(Tag.MINEABLE_AXE.isTagged(faceBlock.getType()))

110 {

111 if(!addItemToChest(direction, dispenser, drops))

112 {

113 setDamage(item, dispenser);

114 faceBlock.breakNaturally(item);

115 }

116 else

117 {

118 setDamage(item, dispenser);

119 faceBlock.setType(Material.AIR);

120 }

121 }

122 }

123

124 if(item.getType().toString().endsWith("_SHOVEL"))

125 {

126 if(Tag.MINEABLE_SHOVEL.isTagged(faceBlock.getType()))

127 {

128 if(!addItemToChest(direction, dispenser, drops))

129 {

130 setDamage(item, dispenser);

131 faceBlock.breakNaturally(item);

132 }

133 else

134 {

135 setDamage(item, dispenser);

136 faceBlock.setType(Material.AIR);

137 }

138 }

139 }

140

141 if(item.getType().toString().endsWith("_HOE"))

142 {

143 if(Tag.MINEABLE_HOE.isTagged(faceBlock.getType()))

144 {

145 if(!addItemToChest(direction, dispenser, drops))

146 {

147 setDamage(item, dispenser);

148 faceBlock.breakNaturally(item);

149 }

150 else

151 {

152 setDamage(item, dispenser);

153 faceBlock.setType(Material.AIR);

154 }

155 }

156 }

157

158 if(item.getType().toString().endsWith("_PICKAXE") && !Utils.isAir(faceBlock.getType())

159 && !Tag.MINEABLE_PICKAXE.isTagged(faceBlock.getType())

160 && !Tag.MINEABLE_HOE.isTagged(faceBlock.getType())

161 && !Tag.MINEABLE_AXE.isTagged(faceBlock.getType())

162 && !Tag.MINEABLE_SHOVEL.isTagged(faceBlock.getType()))

163 {

164 setDamage(item, dispenser);

165 faceBlock.breakNaturally(item);

166 }

167 }

168 }

169 }

170 }

171

172 public boolean isInventoryFullList(Inventory inventory, HashSet<ItemStack> items)

173 {

174 final HashSet<ItemStack> itemsCopy = new HashSet<ItemStack>(items);

175 final Iterator<ItemStack> it = itemsCopy.iterator();

176

177 while(it.hasNext())

178 {

179 ItemStack item = it.next();

180

181 if(!Utils.isInventoryFull(inventory, item))

182 {

183 it.remove();

184 }

185 }

186 return itemsCopy.size() != 0;

187 }

188

189 public boolean addItemToChest(Directional direction, Dispenser dispenser, HashSet<ItemStack> items)

190 {

191 Chest chest = null;

192 boolean succeeded = false;

193

194 for(BlockFace face : faces)

195 {

196 if(!face.equals(direction.getFacing()) && chest == null)

197 {

198 final Block blockAtFacing = dispenser.getBlock().getRelative(face);

199 final BlockState blockStateAtFacing = blockAtFacing.getState();

200

201 if(blockAtFacing.getType().equals(Material.CHEST) && blockStateAtFacing instanceof Chest)

202 {

203 final Chest chestBlock = (Chest) blockStateAtFacing;

204

205 if(!isInventoryFullList(chestBlock.getInventory(), items))

206 {

207 for(ItemStack item : items)

208 {

209 chestBlock.getInventory().addItem(item);

210 }

211 succeeded = true;

212 break;

213 }

214 chest = chestBlock;

215 }

216 }

217 }

218 return succeeded;

219 }

220

221 public void setDamage(ItemStack item, Dispenser dispenser)

222 {

223 Bukkit.getScheduler().runTaskLater(plugin, () -> {

224 if(Utils.randomlyReduceDurability(item.getEnchantmentLevel(Enchantment.DURABILITY)))

225 {

226 final ItemMeta itemMeta = item.getItemMeta();

227 final int slot = dispenser.getInventory().first(item);

228

229 if(itemMeta instanceof Damageable && slot != -1)

230 {

231 final ItemStack itemstack = dispenser.getInventory().getItem(slot);

232 final Damageable itemDamage = (Damageable) itemstack.getItemMeta();

233

234 if(itemDamage.getDamage() == 0)

235 {

236 itemDamage.setDamage(1);

237 }

238 else if(itemDamage.getDamage() != 0)

239 {

240 final int addedDamage = itemDamage.getDamage() + 1;

241

242 if(addedDamage < itemstack.getType().getMaxDurability())

243 {

244 itemDamage.setDamage(addedDamage);

245 }

246 else

247 {

248 itemstack.setType(Material.AIR);

249 }

250 }

251 itemstack.setItemMeta(itemDamage);

252 dispenser.getInventory().setItem(slot, itemstack);

253 }

254 }

255 }, 1);

256 }

257

258 private static final BlockFace[] faces = {

259 BlockFace.DOWN,

260 BlockFace.UP,

261 BlockFace.NORTH,

262 BlockFace.EAST,

263 BlockFace.SOUTH,

264 BlockFace.WEST

265 };

266}