/**
* Recursively expand the search area so we can define the number of blocks that are in the
* cauldron. The search will not exceed 24 blocks as no pot will ever use up that many blocks. The
* Y are bounded both directions so we don't ever search the lava or anything above, although in
* the case of non-wall blocks, we also make sure that there is standing lava underneath.
*
* @param pt
* @param minY
* @param maxY
* @param visited
* @throws Cauldron.NotACauldronException
*/
public void findCauldronContents(
World world, BlockVector pt, int minY, int maxY, Map<BlockVector, CraftBookItem> visited)
throws NotACauldronException {
// Don't want to go too low or high
if (pt.getBlockY() < minY) {
return;
}
if (pt.getBlockY() > maxY) {
return;
}
// There is likely a leak in the cauldron (or this isn't a cauldron)
if (visited.size() > 24) {
throw new NotACauldronException("Cauldron has a leak");
}
// Prevent infinite looping
if (visited.containsKey(pt)) {
return;
}
int type = CraftBook.getBlockID(world, pt);
int data = CraftBook.getBlockData(world, pt);
if (BlockType.isDirectionBlock(type)) data = 0;
// Make water work reliably
if (type == 9) {
type = 8;
}
// Make lava work reliably
if (type == 11) {
type = 10;
}
visited.put(pt, new CraftBookItem(type, data));
// It's a wall -- we only needed to remember that we visited it but
// we don't need to recurse
if (type == BlockType.STONE) {
return;
}
// Must have a lava floor
Vector lavaPos = pt.subtract(0, pt.getBlockY() - minY + 1, 0);
if (!BlockType.isLava(CraftBook.getBlockID(world, lavaPos))) {
throw new NotACauldronException("Cauldron lacks lava below");
}
// Now we recurse!
findCauldronContents(world, pt.add(1, 0, 0).toBlockVector(), minY, maxY, visited);
findCauldronContents(world, pt.add(-1, 0, 0).toBlockVector(), minY, maxY, visited);
findCauldronContents(world, pt.add(0, 0, 1).toBlockVector(), minY, maxY, visited);
findCauldronContents(world, pt.add(0, 0, -1).toBlockVector(), minY, maxY, visited);
findCauldronContents(world, pt.add(0, 1, 0).toBlockVector(), minY, maxY, visited);
findCauldronContents(world, pt.add(0, -1, 0).toBlockVector(), minY, maxY, visited);
}
/**
* Attempt to perform a cauldron recipe.
*
* @param pt
* @param player
* @param recipes
*/
private void performCauldron(BlockVector pt, Player player) {
// Gotta start at a root Y then find our orientation
int rootY = pt.getBlockY();
// Used to store cauldron blocks -- walls are counted
Map<BlockVector, CraftBookItem> visited = new HashMap<BlockVector, CraftBookItem>();
World world = player.getWorld();
try {
// The following attempts to recursively find adjacent blocks so
// that it can find all the blocks used within the cauldron
findCauldronContents(world, pt, rootY - 1, rootY, visited);
// We want cauldrons of a specific shape and size, and 24 is just
// the right number of blocks that the cauldron we want takes up --
// nice and cheap check
if (visited.size() != 24) {
throw new NotACauldronException("Cauldron is too small");
}
// Key is the block ID and the value is the amount
Map<CraftBookItem, Integer> contents = new HashMap<CraftBookItem, Integer>();
// Now we have to ignore stone blocks so that we get the real
// contents of the cauldron
for (Map.Entry<BlockVector, CraftBookItem> entry : visited.entrySet()) {
if (entry.getValue().id() != BlockType.STONE) {
if (!contents.containsKey(entry.getValue())) {
contents.put(entry.getValue(), 1);
} else {
contents.put(entry.getValue(), contents.get(entry.getValue()) + 1);
}
}
}
// Find the recipe
CauldronRecipe recipe = recipes.find(contents);
if (recipe != null) {
String[] groups = recipe.getGroups();
if (groups != null) {
boolean found = false;
for (String group : groups) {
if (player.isInGroup(group)) {
found = true;
break;
}
}
if (!found) {
player.sendMessage(Colors.Red + "Doesn't seem as if you have the ability...");
return;
}
}
player.sendMessage(
Colors.Gold + "In a poof of smoke, you've made " + recipe.getName() + ".");
List<CraftBookItem> ingredients = new ArrayList<CraftBookItem>(recipe.getIngredients());
List<BlockVector> removeQueue = new ArrayList<BlockVector>();
// Get rid of the blocks in world
for (Map.Entry<BlockVector, CraftBookItem> entry : visited.entrySet()) {
// This is not a fast operation, but we should not have
// too many ingredients
if (ingredients.contains(entry.getValue())) {
// Some blocks need to removed first otherwise they will
// drop an item, so let's remove those first
if (!BlockType.isBottomDependentBlock(entry.getValue().id())) {
removeQueue.add(entry.getKey());
} else {
CraftBook.setBlockID(world, entry.getKey(), 0);
}
ingredients.remove(entry.getValue());
}
}
for (BlockVector v : removeQueue) {
CraftBook.setBlockID(world, v, 0);
}
// Give results
for (CraftBookItem cbitem : recipe.getResults()) {
Item item = new Item(cbitem.id(), 1, -1, cbitem.color());
if (cbitem.hasEnchantments()) {
for (int i = 0; i < cbitem.enchantments().length; i++) {
CraftBookEnchantment cbenchant = cbitem.enchantment(i);
// since this is from a server created recipe we can assume it is allowed
// if(!cbenchant.enchantment().allowed)
// continue;
Enchantment enchant =
new Enchantment(
Enchantment.Type.fromId(cbenchant.enchantment().getId()), cbenchant.level());
if (!enchant.isValid()) continue;
item.addEnchantment(enchant);
}
}
player.giveItem(item);
}
// Didn't find a recipe
} else {
player.sendMessage(Colors.Red + "Hmm, this doesn't make anything...");
}
} catch (NotACauldronException e) {
}
}
