Precise Interaction

import { Direction } from "@minecraft/server";

const isInRange = (value, min, max) => value >= min && value <= max;

export default class FaceSelectionPlains {
  /**
   * Allows you to define 2D areas on a block's face and get the selected plain.
   *
   * @param {Object[]} plains Spread array defining the 2D areas on a block's face which may be selected.
   * @param {[number, number]} plains[].origin [U, V] array defining the offset of the plain from the top left of the block face in pixels.
   * @param {[number, number]} plains[].size [U, V] array defining the size of the plain, extending from the top left in pixels.
   * @param {string} [plains[].name] Custom name to easily identify this plain when it is selected.
   */
  constructor(...plains) {
    this.plains = plains;
  }
  /**
   * @param {{ blockFace: Direction, faceLocation: Record<"x" | "y" | "z", number> }} selection
   *
   * @param {Object} [options] Optionally configure how the selected plain is calculated.
   * @param {boolean} [options.invertU] Horizontal axis extends `right -> left` rather than `left -> right` if true.
   * @param {boolean} [options.invertV] Vertical axis extends `bottom -> top` rather than `top -> bottom` if true.
   *
   * @returns Selected plain ID, or plain index if an ID is not provided. If no plains apply to the selection, `undefined` is returned.
   */
  getSelected(selection, options) {
    const face = selection.blockFace;
    // Create a new object so the original is not mutated
    let location = { ...selection.faceLocation };

    const horizontalAxis = face === Direction.East || face === Direction.West ? "z" : "x";
    const verticalAxis = face === Direction.Up || face === Direction.Down ? "z" : "y";

    if (face !== Direction.Down) location[verticalAxis] = 1 - location[verticalAxis];
    if (face !== Direction.South && face !== Direction.West) location[horizontalAxis] = 1 - location[horizontalAxis];

    if (options?.invertU) location[horizontalAxis] = 1 - location[horizontalAxis];
    if (options?.invertV) location[verticalAxis] = 1 - location[verticalAxis];

    for (let i = 0; i < this.plains.length; i++) {
      const plain = this.plains[i];

      const inHorizontalRange = isInRange(location[horizontalAxis], plain.origin[0] / 16, (plain.origin[0] + plain.size[0]) / 16);
      const inVerticalRange = isInRange(location[verticalAxis], plain.origin[1] / 16, (plain.origin[1] + plain.size[1]) / 16);

      if (inHorizontalRange && inVerticalRange) return plain.name ?? i;
    }
  }
}

const isInRange = (value, min, max) => value >= min && value <= max;

export default class SelectionBoxes {
  /**
   * Allows you to define 3D areas in a block and get the box which the face selection lies within.
   *
   * @param {Object[]} boxes Array defining the 3D areas within a block which may be selected.
   * @param {[number, number, number]} boxes[].origin [X, Y, Z] array defining the offset of the box from the block's horizontal middle and vertical bottom in pixels, extending from the north-east.
   * @param {[number, number, number]} boxes[].size [X, Y, Z] array defining the size of the box in pixels, extending from the north-east.
   * @param {string} [boxes[].name] Custom name to easily identify this box when it is selected.
   */
  constructor(...boxes) {
    this.boxes = boxes;
  }
  /**
   * Get the box which the `faceLocation` lies within.
   *
   * @param {Record<"x" | "y" | "z", number>} faceLocation Selection location relative to the bottom north-west corner of the block.
   *
   * @param {Object} [options] Optionally configure how the selected box is calculated.
   * @param {boolean} [options.invertX] X axis extends `west -> east` rather than `east -> west` if true, following [Blockbench](https://blockbench.net)'s displayed positions.
   * @param {boolean} [options.invertY] Y axis extends `up -> down` rather than `down -> up` if true.
   * @param {boolean} [options.invertZ] Z axis extends `south -> north` rather than `north -> south` if true.
   *
   * @returns {(string|number|undefined)} Selected box name, or box index if a name is not provided. If no boxes apply to the selection, `undefined` is returned.
   */
  getSelected(faceLocation, options) {
    // Create a new object so the original is not mutated
    let location = { ...faceLocation };

    // X is inverted to ensure measurements are relative to the bottom north-east.
    if (!options?.invertX) location.x = 1 - location.x;
    if (options?.invertY) location.y = 1 - location.y;
    if (options?.invertZ) location.z = 1 - location.z;

    for (let i = 0; i < this.boxes.length; i++) {
      const box = this.boxes[i];

      const origin = {
        x: box.origin[0] + 8,
        y: box.origin[1],
        z: box.origin[2] + 8,
      };

      const inXRange = isInRange(location.x, origin.x / 16, (origin.x + box.size[0]) / 16);
      const inYRange = isInRange(location.y, origin.y / 16, (origin.y + box.size[1]) / 16);
      const inZRange = isInRange(location.z, origin.z / 16, (origin.z + box.size[2]) / 16);

      if (inXRange && inYRange && inZRange) return box.name ?? i;
    }
  }
}

import { world, ItemStack } from "@minecraft/server";
import FaceSelectionPlains from "../utils/face_selection_plains"; // Import the FaceSelectionPlains class to use it

// Slot bounds
const slots = new FaceSelectionPlains(
  { origin: [0, 0], size: [6, 8] },
  { origin: [6, 0], size: [5, 8] },
  { origin: [11, 0], size: [5, 8] },
  { origin: [0, 8], size: [6, 8] },
  { origin: [6, 8], size: [5, 8] },
  { origin: [11, 8], size: [5, 8] }
);

const isFrontFace = (block, face) => block.permutation.getState("minecraft:cardinal_direction") === face.toLowerCase();

const isSlotOccupied = (block, slot) => block.permutation.getState(`wiki:slot_${slot}_occupied`);

const occupySlot = (block, slot) => block.setPermutation(block.permutation.withState(`wiki:slot_${slot}_occupied`, true));

// Cancel the use if a slot was not selected, is occupied, or if not interacting with paper
world.beforeEvents.itemUseOn.subscribe((e) => {
  if (e.block.typeId !== "wiki:pigeonholes" || !isFrontFace(e.block, e.blockFace) || (e.itemStack.typeId !== "minecraft:paper" && e.source.isSneaking)) return;

  // Get the selected slot index
  const slot = slots.getSelected(e);

  if (slot === undefined || isSlotOccupied(e.block, slot) || e.itemStack.typeId !== "minecraft:paper") e.cancel = true;
});

// ------------------------------
//    Insert paper on interact
// ------------------------------
world.afterEvents.itemUseOn.subscribe((e) => {
  if (e.block.typeId !== "wiki:pigeonholes" || e.itemStack.typeId !== "minecraft:paper") return;

  // Set block state and play an insert sound. The stack is decremented in the block JSON event.
  occupySlot(e.block, slots.getSelected(e));
  e.source.runCommand(`playsound insert.chiseled_bookshelf @a ${Object.values(e.block.location).join(" ")}`);
});

// ------------------------------
//  Release paper on destruction
// ------------------------------
function releasePaper(e) {
  // Get the number of states with the value `true`. This is the amount of paper stored in the block
  const storageAmount = Object.values((e.brokenBlockPermutation ?? e.explodedBlockPermutation).getAllStates()).filter((v) => v === true).length;

  // If no paper is stored, stop here
  if (storageAmount === 0) return;

  // Centre loot in block
  const lootLocation = {
    x: e.block.location.x + 0.5,
    y: e.block.location.y + 0.5,
    z: e.block.location.z + 0.5,
  };

  // Create an item entity for every stored paper
  for (let i = 0; i < storageAmount; i++) {
    e.block.dimension.spawnItem(new ItemStack("minecraft:paper"), lootLocation);
  }
}

// Release paper on block break and explode
world.afterEvents.playerBreakBlock.subscribe((e) => {
  if (e.brokenBlockPermutation.type.id !== "wiki:pigeonholes") return;
  releasePaper(e);
});
world.afterEvents.blockExplode.subscribe((e) => {
  if (e.explodedBlockPermutation.type.id !== "wiki:pigeonholes") return;
  releasePaper(e);
});

import { world, ItemStack } from "@minecraft/server";
import SelectionBoxes from "../utils/selection_boxes"; // Import the SelectionBoxes class to use it

// Support orientation along both horizontal axes
const pots = {
  x: new SelectionBoxes({ origin: [-7, 0, -3], size: [6, 6, 6] }, { origin: [1, 0, -3], size: [6, 6, 6] }),
  z: new SelectionBoxes({ origin: [-3, 0, -7], size: [6, 6, 6] }, { origin: [-3, 0, 1], size: [6, 6, 6] }),
};

// The state value and sound associated with each plant
const plants = {
  "minecraft:yellow_flower": {
    value: "dandelion",
    sound: "dig.grass",
  },
  "minecraft:cactus": {
    value: "cactus",
    sound: "dig.cloth",
  },
};

// Get the selected pot for the appropriate axis
const getSelectedPot = (e) => pots[e.block.permutation.getState("wiki:axis")].getSelected(e.faceLocation);

const isPotOccupied = (block, pot) => block.permutation.getState(`wiki:pot_${pot}_plant`) !== "none";

const setPotPlant = (block, pot, plant) => block.setPermutation(block.permutation.withState(`wiki:pot_${pot}_plant`, plant));

// Our flower pots even have sound effects!
const playPlantSound = (dimension, location, sound) => dimension.runCommand(`playsound ${sound} @a ${location.x} ${location.y} ${location.z} 0.5`);

// If a pot is not selected (the inbetween area is targeted) or is already filled, the item use is cancelled.
world.beforeEvents.itemUseOn.subscribe((e) => {
  if (e.block.typeId !== "wiki:double_flower_pot" || !plants[e.itemStack.typeId]) return;

  const selectedPot = getSelectedPot(e);

  if (selectedPot === undefined || isPotOccupied(e.block, selectedPot)) e.cancel = true;
});

// -------------------------------
//    Plant in the selected pot
// -------------------------------
world.afterEvents.itemUseOn.subscribe((e) => {
  if (e.block.typeId !== "wiki:double_flower_pot" || !plants[e.itemStack.typeId] || e.source.isSneaking) return;

  const selectedPot = getSelectedPot(e);
  const plant = plants[e.itemStack.typeId];

  setPotPlant(e.block, selectedPot, plant.value);
  playPlantSound(e.block.dimension, e.block.location, plant.sound);
});

// -------------------------------
//  Release plants on destruction
// -------------------------------
function releasePlants(e) {
  const states = (e.brokenBlockPermutation ?? e.explodedBlockPermutation).getAllStates();

  // Array of plant state values e.g. ["cactus", "dandelion"]
  const storedPlants = Object.entries(states)
    .filter(([state, value]) => state.startsWith("wiki:pot") && value !== "none")
    .map(([state, value]) => value);

  if (storedPlants.length === 0) return;

  // Centre loot in block
  const lootLocation = {
    x: e.block.location.x + 0.5,
    y: e.block.location.y + 0.5,
    z: e.block.location.z + 0.5,
  };

  // Create an item entity for every potted plant
  for (const plant of storedPlants) {
    const plantId = Object.keys(plants).find((key) => plants[key].value === plant);

    e.dimension.spawnItem(new ItemStack(plantId), lootLocation);
    playPlantSound(e.dimension, e.block.location, plants[plantId].sound);
  }
}

world.afterEvents.playerBreakBlock.subscribe((e) => {
  if (e.brokenBlockPermutation.type.id === "wiki:double_flower_pot") releasePlants(e);
});
world.afterEvents.blockExplode.subscribe((e) => {
  if (e.explodedBlockPermutation.type.id === "wiki:double_flower_pot") releasePlants(e);
});