init

scripts/Commandeer/Trigger/CCTrigger.ts

@@ -0,0 +1,13 @@
+import { Trigger } from "./trigger";
+import { Maker } from "./maker";
+import { Manager } from "./manager";
+
+export * from "./trigger";
+export * from "./maker";
+export * from "./manager";
+
+export const CCTrigger = {
+  Trigger,
+  Maker,
+  Manager,
+};

scripts/Commandeer/Trigger/maker.ts

@@ -0,0 +1,204 @@
+import { Trigger } from "./trigger";
+
+import {
+  Block,
+  ChatSendAfterEvent,
+  PaletteColor,
+  EntityInventoryComponent,
+  ItemStack,
+  ItemUseOnBeforeEvent,
+  MolangVariableMap,
+  Player,
+  Vector3,
+  world,
+} from "@minecraft/server";
+import { vector3, vector3Distance } from "../utils/vectorUtils";
+import { Mindkeeper, StoreType } from "../mindKeeper";
+import { spawnParticle } from "../utils/particleUtils";
+import { Manager } from "./manager";
+
+export class Maker {
+  private manager: Manager;
+
+  log: Map<string, number> = new Map();
+
+  currentTrigger: Trigger | null = null;
+  waitingForPoint2: boolean = false;
+  point1: Vector3 = vector3(0, 0, 0);
+  point2: Vector3 = vector3(0, 0, 0);
+
+  mindKeeper: Mindkeeper;
+
+  constructor(mindKeeper: Mindkeeper, manager: Manager) {
+    this.mindKeeper = mindKeeper;
+    this.manager = manager;
+  }
+
+  OnChat(event: ChatSendAfterEvent) {
+    if (event.message === "!toggleTriggers") {
+      this.mindKeeper.set("ShowTriggers", (this.mindKeeper.get("ShowTriggers") as boolean) ? false : true);
+    }
+    if (event.message === "!TWand") {
+      const item = new ItemStack("minecraft:stick");
+      item.nameTag = "MakeTrigger";
+      ((event.sender as Player).getComponent("inventory") as EntityInventoryComponent).container!.addItem(item);
+      world.sendMessage("Thou shall have the Powah");
+    }
+
+    if (event.message === "!deleteCurrentTrigger") {
+      let currentTriggerdTrigger = this.manager
+        .GetTriggers()
+        .filter((trigger) => trigger.IsPlayerInside(event.sender as Player));
+      if (currentTriggerdTrigger.length > 0) {
+        this.manager.GetTriggers().splice(this.manager.GetTriggers().indexOf(currentTriggerdTrigger[0]), 1);
+        world.sendMessage("Trigger deleted");
+      } else {
+        world.sendMessage("No trigger to delete");
+      }
+      this.manager.Save();
+    }
+    const command = event.message.split(" ")[0];
+    if (command == "!setFunction") {
+      const name = event.message.split(" ")[1];
+      const trigger = this.manager.GetCurrentActiveTriggers()[0];
+
+      if (trigger === undefined) {
+        world.sendMessage("No trigger selected");
+        return;
+      }
+
+      trigger.eventToDispatch = name;
+      this.manager.Save();
+      world.sendMessage(`Function set to ${name}`);
+    }
+  }
+
+  OnItemUse(event: ItemUseOnBeforeEvent) {
+    const currentItemHeld: ItemStack = event.itemStack;
+    const blockInteracted: Block = event.block;
+    const player: Player = event.source as Player;
+    const oldLog = this.log.get(player.name)!;
+    this.log.set(player.name, Date.now());
+    if (oldLog + 150 >= Date.now()) return;
+
+    if (currentItemHeld.typeId == "minecraft:stick" && currentItemHeld.nameTag == "MakeTrigger") {
+      if (this.waitingForPoint2) {
+        this.point2 = vector3(blockInteracted.location.x, blockInteracted.location.y, blockInteracted.location.z);
+
+        let minX = Math.min(this.point1.x, this.point2.x);
+        let maxX = Math.max(this.point1.x, this.point2.x) + 1;
+        let minY = Math.min(this.point1.y, this.point2.y);
+        let maxY = Math.max(this.point1.y, this.point2.y) + 1;
+        let minZ = Math.min(this.point1.z, this.point2.z);
+        let maxZ = Math.max(this.point1.z, this.point2.z) + 1;
+
+        //Take the outer bounds of the two points
+        this.point1 = vector3(minX, minY, minZ);
+        this.point2 = vector3(maxX, maxY, maxZ);
+
+        this.currentTrigger = new Trigger(this.point1, this.point2);
+
+        this.manager.AddTrigger(this.currentTrigger!);
+        this.currentTrigger = null;
+        this.waitingForPoint2 = false;
+        world.sendMessage(`Trigger added`);
+        this.manager.Save();
+        return;
+      } else {
+        this.point1 = vector3(event.block.location.x, event.block.location.y, event.block.location.z);
+        this.waitingForPoint2 = true;
+        world.sendMessage(`Select a second point`);
+      }
+    }
+  }
+
+  DrawLine(pos1: Vector3, pos2: Vector3, color: PaletteColor): void {
+    if (pos1 != null && pos2 != null) {
+      //draw a line with particles
+      const xStep = pos2.x - pos1.x;
+      const yStep = pos2.y - pos1.y;
+      const zStep = pos2.z - pos1.z;
+
+      const steps = Math.max(Math.abs(xStep), Math.abs(yStep), Math.abs(zStep));
+      for (let i = 0; i <= steps; i++) {
+        const x = pos1.x + (xStep / steps) * i;
+        const y = pos1.y + (yStep / steps) * i;
+        const z = pos1.z + (zStep / steps) * i;
+
+        //make the ends and starts a different color
+        let map = new MolangVariableMap();
+        if (i == 0 || i == steps) {
+          map.setColorRGB("variable.color", { red: 0, green: 255, blue: 0 });
+          const particleData: MolangVariableMap = new MolangVariableMap();
+          particleData.setColorRGB("variable.color", {
+            red: 0,
+            green: 1,
+            blue: 0,
+          });
+          spawnParticle(vector3(x, y + 0.1, z), "codecosmos:point", particleData);
+        } else {
+          map.setColorRGB("variable.color", { red: 0, green: 255, blue: 0 });
+          const particleData: MolangVariableMap = new MolangVariableMap();
+          particleData.setColorRGB("variable.color", {
+            red: 1,
+            green: 1,
+            blue: 1,
+          });
+          spawnParticle(vector3(x, y + 0.1, z), "codecosmos:point", particleData);
+        }
+      }
+    }
+  }
+
+  Update() {
+    let shouldRender = this.mindKeeper.get("ShowTriggers") as boolean;
+    this.manager.GetTriggers().forEach((trigger: Trigger) => {
+      trigger.Update();
+
+      if (shouldRender) {
+        const players = world.getAllPlayers();
+        const triggerCenter = vector3(
+          (trigger.point1.x + trigger.point2.x) / 2,
+          (trigger.point1.y + trigger.point2.y) / 2,
+          (trigger.point1.z + trigger.point2.z) / 2
+        );
+        const distnaces = players.map((player) => {
+          return {
+            player: player,
+            distance: vector3Distance(player.location, triggerCenter),
+          };
+        });
+
+        distnaces.sort((a, b) => a.distance - b.distance);
+        const closestPlayer = distnaces[0].player;
+        const distance = distnaces[0].distance;
+
+        if (distance > 25) return;
+
+        const p1 = trigger.point1;
+        const p2 = vector3(trigger.point1.x, trigger.point2.y, trigger.point1.z);
+        const p3 = vector3(trigger.point2.x, trigger.point1.y, trigger.point1.z);
+        const p4 = vector3(trigger.point2.x, trigger.point2.y, trigger.point1.z);
+        const p5 = vector3(trigger.point1.x, trigger.point1.y, trigger.point2.z);
+        const p6 = vector3(trigger.point1.x, trigger.point2.y, trigger.point2.z);
+        const p7 = vector3(trigger.point2.x, trigger.point1.y, trigger.point2.z);
+        const p8 = trigger.point2;
+
+        //is there a player inside this trigger
+        const color = trigger.IsAnyPlayerInside() ? PaletteColor.Red : PaletteColor.White;
+        this.DrawLine(p1, p2, color);
+        this.DrawLine(p2, p4, color);
+        this.DrawLine(p4, p3, color);
+        this.DrawLine(p3, p1, color);
+        this.DrawLine(p5, p6, color);
+        this.DrawLine(p6, p8, color);
+        this.DrawLine(p8, p7, color);
+        this.DrawLine(p7, p5, color);
+        this.DrawLine(p1, p5, color);
+        this.DrawLine(p2, p6, color);
+        this.DrawLine(p3, p7, color);
+        this.DrawLine(p4, p8, color);
+      }
+    });
+  }
+}

scripts/Commandeer/Trigger/manager.ts

@@ -0,0 +1,117 @@
+import { ChatSendAfterEvent, ItemUseOnBeforeEvent, Player, system, world } from "@minecraft/server";
+import { Mindkeeper, StoreType } from "../mindKeeper";
+import { vector3 } from "../utils/vectorUtils";
+import { Maker } from "./maker";
+import { Trigger } from "./trigger";
+
+export class TriggerEvent {
+  player: Player;
+  trigger: Trigger;
+
+  constructor(player: Player, trigger: Trigger) {
+    this.player = player;
+    this.trigger = trigger;
+  }
+}
+
+export type TriggerEventHandler = (event: TriggerEvent) => void;
+
+export class Manager {
+  private triggers: Trigger[] = [];
+  private functionTriggers: Map<string, TriggerEventHandler> = new Map();
+  private mindKeeper: Mindkeeper;
+  private maker: Maker;
+
+  constructor(mindKeeper: Mindkeeper) {
+    this.mindKeeper = mindKeeper;
+    this.maker = new Maker(mindKeeper, this);
+  }
+
+  RegisterStores() {
+    this.mindKeeper.registerStore("triggers", StoreType.string);
+    this.mindKeeper.registerStore("ShowTriggers", StoreType.boolean);
+  }
+
+  OnItemUse(event: ItemUseOnBeforeEvent) {
+    this.maker.OnItemUse(event);
+  }
+
+  OnChat(event: ChatSendAfterEvent) {
+    this.maker.OnChat(event);
+  }
+  //the func should have a TriggerEvent as a parameter
+  RegisterFunctionTrigger(name: string, func: TriggerEventHandler) {
+    this.functionTriggers.set(name, func);
+  }
+
+  //#region Loading / Saving
+
+  Load() {
+    this.LoadTriggers();
+  }
+
+  Save() {
+    this.SaveTriggers();
+  }
+
+  private LoadTriggers() {
+    const triggers = this.mindKeeper.get("triggers") as string;
+    if (triggers === undefined) return;
+
+    const data = JSON.parse(triggers);
+    data.forEach((trigger: any) => {
+      let point1 = vector3(trigger.point1.x, trigger.point1.y, trigger.point1.z);
+      let point2 = vector3(trigger.point2.x, trigger.point2.y, trigger.point2.z);
+      let eventToDispatch = trigger.eventToDispatch;
+
+      let newTrigger = new Trigger(point1, point2);
+      newTrigger.eventToDispatch = eventToDispatch;
+
+      this.triggers.push(newTrigger);
+    });
+  }
+
+  private SaveTriggers() {
+    this.mindKeeper.set("triggers", JSON.stringify(this.triggers));
+  }
+
+  //#endregion
+
+  AddTrigger(trigger: Trigger) {
+    this.triggers.push(trigger);
+  }
+
+  GetCurrentActiveTriggers(): Trigger[] {
+    return this.triggers.filter((trigger) => trigger.IsAnyPlayerInside());
+  }
+
+  Update() {
+    const players = world.getAllPlayers();
+
+    this.maker.Update();
+    this.triggers.forEach((trigger: Trigger) => {
+      trigger.Update();
+
+      players.forEach((player) => {
+        // player.sendMessage(`Player ${player.name} is in trigger ${trigger.IsPlayerInside(player)}`);
+        if (trigger.hasPlayerEnterdTrigger(player)) {
+          world.sendMessage(`Player ${player.name} entered trigger`);
+          //Check if a function trigger is set
+          const isFunctionSet = this.functionTriggers.has(trigger.eventToDispatch);
+
+          if (isFunctionSet) {
+            const event = new TriggerEvent(player, trigger);
+
+            this.functionTriggers.get(trigger.eventToDispatch)!(event);
+          } else {
+            world.sendMessage(`Triggered ${trigger.eventToDispatch}`);
+          }
+        }
+      });
+    });
+  }
+
+  GetTriggers(): Trigger[] {
+    return this.triggers;
+  }
+}

scripts/Commandeer/Trigger/trigger.ts

@@ -0,0 +1,82 @@
+import { Player, Vector3, world } from "@minecraft/server";
+import { vector3 } from "../utils/vectorUtils";
+
+export class Trigger {
+  point1: Vector3 = vector3(0, 0, 0);
+  point2: Vector3 = vector3(0, 0, 0);
+  eventToDispatch: string = "";
+
+  isPlayerInTrigger: Map<string, boolean> = new Map();
+
+  hasTriggerd: boolean = false;
+
+  constructor(point1: Vector3, point2: Vector3) {
+    this.point1 = point1;
+    this.point2 = point2;
+  }
+
+  hasPlayerEnterdTrigger(player: Player): boolean {
+    const minX = Math.min(this.point1.x, this.point2.x);
+    const maxX = Math.max(this.point1.x, this.point2.x);
+    const minY = Math.min(this.point1.y, this.point2.y);
+    const maxY = Math.max(this.point1.y, this.point2.y);
+    const minZ = Math.min(this.point1.z, this.point2.z);
+    const maxZ = Math.max(this.point1.z, this.point2.z);
+
+    const playerPos = player.location;
+
+    const inside =
+      playerPos.x >= minX &&
+      playerPos.x <= maxX &&
+      playerPos.y >= minY &&
+      playerPos.y + 1 <= maxY &&
+      playerPos.z >= minZ &&
+      playerPos.z <= maxZ;
+
+    let entererdTrigger = false;
+    if (!this.isPlayerInTrigger.get(player.name) && inside) {
+      entererdTrigger = true;
+    }
+
+    this.isPlayerInTrigger.set(player.name, inside);
+
+    return entererdTrigger;
+  }
+
+  IsPlayerInside(player: Player): boolean {
+    return this.isPlayerInTrigger.get(player.name) || false;
+  }
+
+  IsAnyPlayerInside(): boolean {
+    let isInside = false;
+    world.getAllPlayers().forEach((player) => {
+      if (this.isPlayerInTrigger.get(player.name)) {
+        isInside = true;
+      }
+    });
+    return isInside;
+  }
+
+  ShouldTrigger(): boolean {
+    let isSomethingInTrigger = false;
+    const players = world.getAllPlayers();
+    players.forEach((player) => {
+      if (this.hasPlayerEnterdTrigger(player)) {
+        isSomethingInTrigger = true;
+      }
+    });
+    return isSomethingInTrigger;
+  }
+
+  Update() {
+    world
+      .getDimension("overworld")
+      .getEntities({ type: "minecraft:player" })
+      .forEach((player) => {
+        //Check if the distance between the player and the trigger is less than the width of the trigger
+        // if (this.hasPlayerEnterdTrigger(player.location)) {
+        //   world.sendMessage(`Player ${player.nameTag} is in trigger`);
+        // }
+      });
+  }
+}