321 lines
9.2 KiB
TypeScript
321 lines
9.2 KiB
TypeScript
import {
|
|
world,
|
|
system,
|
|
Vector3,
|
|
MolangVariableMap,
|
|
ChatSendAfterEvent,
|
|
Dimension,
|
|
TicksPerSecond,
|
|
BlockVolume,
|
|
} from "@minecraft/server";
|
|
import { Mindkeeper, StoreType } from "./Commandeer/mindKeeper";
|
|
import Pupeteer from "./Commandeer/pupeteer";
|
|
import { Vector3ToCommandString, Vector3ToFancyString, vector3 } from "./Commandeer/utils/vectorUtils";
|
|
import { delay } from "./Commandeer/utils/waitUtil";
|
|
import { spawnParticle } from "./Commandeer/utils/particleUtils";
|
|
import { TrailMaker } from "./Commandeer/trail/trailMaker";
|
|
import * as CCTrigger from "./Commandeer/Trigger/CCTrigger";
|
|
import { Commands } from "./Commandeer/command/command";
|
|
import { Trail } from "./Commandeer/trail/trailEngine";
|
|
import { startTrail } from "./trails/startTrail";
|
|
import level1 from "./levels/level1/mission1";
|
|
import level2 from "./levels/level2/mission1";
|
|
import level3 from "./levels/level2/mission2";
|
|
import level4 from "./levels/level2/mission3";
|
|
import level5 from "./levels/level3/mission1";
|
|
import { MinecraftBlockTypes } from "./vanilla-data/mojang-block";
|
|
import { TransitionTrailToLevel2 } from "./trails/TransitionTrailToLevel2";
|
|
import { TransitionTrailToLevel3 } from "./trails/TransitionTrailToLevel3";
|
|
import { TransitionTrailToLevel4 } from "./trails/TransitionTrailToLevel4";
|
|
import { TransitionTrailToLevel5 } from "./trails/TransitionTrailToLevel5";
|
|
import { TransitionTrailToTheEnd } from "./trails/TransitionTrailToTheEnd";
|
|
|
|
const mindKeeper = new Mindkeeper(world);
|
|
const trailMaker: TrailMaker.Maker = new TrailMaker.Maker();
|
|
const triggerManager = new CCTrigger.Manager(mindKeeper);
|
|
const CURRENT_LEVEL = "currentLevel";
|
|
const AGENT_ID = "agentid";
|
|
const PREFIX = "!";
|
|
export { mindKeeper, CURRENT_LEVEL, triggerManager };
|
|
|
|
let introTrail: Trail = new Trail("introTrail", 4, 4);
|
|
introTrail.fromTrail(startTrail);
|
|
|
|
let transitionTrail1 = new Trail("transitionTrail1", 2, 2);
|
|
transitionTrail1.fromTrail(TransitionTrailToLevel2);
|
|
|
|
let transitionTrail2 = new Trail("transitionTrail2", 2, 2);
|
|
transitionTrail2.fromTrail(TransitionTrailToLevel3);
|
|
|
|
let transitionTrail3 = new Trail("transitionTrail3", 2, 2);
|
|
transitionTrail3.fromTrail(TransitionTrailToLevel4);
|
|
|
|
let transitionTrail4 = new Trail("transitionTrail4", 2, 2);
|
|
transitionTrail4.fromTrail(TransitionTrailToLevel5);
|
|
|
|
let transitionTrail5 = new Trail("transitionTrail5", 2, 2);
|
|
transitionTrail5.fromTrail(TransitionTrailToTheEnd);
|
|
|
|
const frameDuration = 7;
|
|
let gateRoot = vector3(-226, 68, 223);
|
|
enum GateState {
|
|
open,
|
|
closed,
|
|
}
|
|
let gateState = GateState.closed;
|
|
|
|
const DEVELOPER_MODE = true;
|
|
let tickCounter = 0;
|
|
system.runInterval(async () => {
|
|
tickCounter++;
|
|
if (mindKeeper.initialised) {
|
|
trailMaker.Update();
|
|
if (tickCounter % 2 == 0) {
|
|
triggerManager.Update();
|
|
}
|
|
|
|
const currentLevel = mindKeeper.get(CURRENT_LEVEL);
|
|
switch (currentLevel) {
|
|
case 0:
|
|
Pupeteer.setActionBar("Leave the treehouse and go down the ladder.");
|
|
introTrail.spawnNext();
|
|
break;
|
|
case 1:
|
|
level1.update();
|
|
break;
|
|
|
|
case 2:
|
|
Pupeteer.setActionBar("Follow the trail to the next level.");
|
|
transitionTrail1.spawnNext();
|
|
break;
|
|
|
|
case 3:
|
|
level2.update();
|
|
break;
|
|
|
|
case 4:
|
|
Pupeteer.setActionBar("Follow the trail to the next level.");
|
|
transitionTrail2.spawnNext();
|
|
break;
|
|
|
|
case 5:
|
|
level3.update();
|
|
break;
|
|
|
|
case 6:
|
|
Pupeteer.setActionBar("Follow the trail to the next level.");
|
|
transitionTrail3.spawnNext();
|
|
break;
|
|
|
|
case 7:
|
|
level4.update();
|
|
break;
|
|
|
|
case 8:
|
|
Pupeteer.setActionBar("Follow the trail to the next level.");
|
|
transitionTrail4.spawnNext();
|
|
break;
|
|
|
|
case 9:
|
|
level5.update();
|
|
break;
|
|
case 10:
|
|
transitionTrail5.spawnNext();
|
|
if (gateState == GateState.closed) {
|
|
PlayGateOpenAnimation();
|
|
gateState = GateState.open;
|
|
}
|
|
break;
|
|
case 11:
|
|
Pupeteer.setActionBar("You completed the mission.");
|
|
}
|
|
}
|
|
});
|
|
|
|
world.afterEvents.chatSend.subscribe(async (event: ChatSendAfterEvent) => {
|
|
const command = event.message.split(" ")[0];
|
|
|
|
trailMaker.OnChat(event);
|
|
mindKeeper.chatCommands(event);
|
|
triggerManager.OnChat(event);
|
|
|
|
if (command === "!reset") {
|
|
world.sendMessage("Resetting");
|
|
level1.reset();
|
|
level2.reset();
|
|
level3.reset();
|
|
level4.reset();
|
|
level5.reset();
|
|
ResetGate();
|
|
world.getDimension("Overworld").runCommand("/fill -86 71 253 -86 75 275 barrier replace air");
|
|
world.getDimension("Overworld").runCommand("/fill -128 71 255 -128 74 276 barrier replace air");
|
|
world.getDimension("Overworld").runCommand("/fill -154 69 255 -154 74 276 barrier replace air");
|
|
world.getDimension("Overworld").runCommand("/fill -182 69 255 -182 74 276 barrier replace air");
|
|
mindKeeper.set(CURRENT_LEVEL, 0);
|
|
world.sendMessage("currentlevel = " + mindKeeper.get(CURRENT_LEVEL));
|
|
}
|
|
});
|
|
|
|
class ClonePos {
|
|
point1: Vector3;
|
|
point2: Vector3;
|
|
|
|
constructor(point1: Vector3, point2: Vector3) {
|
|
this.point1 = point1;
|
|
this.point2 = point2;
|
|
}
|
|
}
|
|
|
|
const gateFrames: ClonePos[] = [
|
|
{
|
|
point1: vector3(-226, 66, 223),
|
|
point2: vector3(-219, 62, 223),
|
|
},
|
|
{
|
|
point1: vector3(-226, 61, 223),
|
|
point2: vector3(-219, 57, 223),
|
|
},
|
|
{
|
|
point1: vector3(-226, 56, 223),
|
|
point2: vector3(-219, 52, 223),
|
|
},
|
|
{
|
|
point1: vector3(-226, 51, 223),
|
|
point2: vector3(-219, 47, 223),
|
|
},
|
|
{
|
|
point1: vector3(-226, 46, 223),
|
|
point2: vector3(-219, 42, 223),
|
|
},
|
|
];
|
|
|
|
let PlayGateOpenAnimation = async () => {
|
|
playAnimation(gateFrames, frameDuration, false, gateRoot);
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 0) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
};
|
|
|
|
let ResetGate = () => SetFrame(gateFrames[0], gateRoot);
|
|
|
|
async function SetFrame(frame: ClonePos, destination: Vector3) {
|
|
await world
|
|
.getDimension("overworld")
|
|
.runCommandAsync(
|
|
`/clone ${Vector3ToCommandString(frame.point1)} ${Vector3ToCommandString(frame.point2)} ${Vector3ToCommandString(
|
|
destination
|
|
)}`
|
|
);
|
|
}
|
|
|
|
let animationPlaying = false;
|
|
async function playAnimation(
|
|
frames: ClonePos[],
|
|
delayTime: number,
|
|
reverse: boolean,
|
|
destination: Vector3,
|
|
force: boolean = false
|
|
) {
|
|
if (animationPlaying && !force) {
|
|
world.sendMessage("Animation already playing");
|
|
return;
|
|
}
|
|
let frameCount = frames.length;
|
|
if (!force) {
|
|
animationPlaying = true;
|
|
}
|
|
|
|
for (let i = 0; i < frameCount; i++) {
|
|
let frame = reverse ? frames[frameCount - i - 1] : frames[i];
|
|
await world
|
|
.getDimension("overworld")
|
|
.runCommandAsync(
|
|
`/clone ${Vector3ToCommandString(frame.point1)} ${Vector3ToCommandString(
|
|
frame.point2
|
|
)} ${Vector3ToCommandString(destination)}`
|
|
);
|
|
await delay(delayTime);
|
|
}
|
|
if (!force) {
|
|
animationPlaying = false;
|
|
}
|
|
}
|
|
|
|
triggerManager.RegisterFunctionTrigger("BottomTreeHouse", async (event) => {
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 0) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
});
|
|
|
|
triggerManager.RegisterFunctionTrigger("PastLevel1", async (event) => {
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 2) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
});
|
|
|
|
triggerManager.RegisterFunctionTrigger("PastLevel2", async (event) => {
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 4) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
});
|
|
|
|
triggerManager.RegisterFunctionTrigger("PastLevel3", async (event) => {
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 6) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
});
|
|
|
|
triggerManager.RegisterFunctionTrigger("PastLevel4", async (event) => {
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 8) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
});
|
|
|
|
triggerManager.RegisterFunctionTrigger("CompletedTheMission", async (event) => {
|
|
if (mindKeeper.get(CURRENT_LEVEL) == 10) {
|
|
mindKeeper.increment(CURRENT_LEVEL);
|
|
}
|
|
});
|
|
|
|
Commands.register(PREFIX, "info", (arg) => {
|
|
world.sendMessage("-----------------");
|
|
world.sendMessage("Current level: " + mindKeeper.get(CURRENT_LEVEL));
|
|
world.sendMessage("Agent ID: " + mindKeeper.get(AGENT_ID));
|
|
world.sendMessage("Engine Version: 1.0.2");
|
|
world.sendMessage("Engine is running");
|
|
world.sendMessage("Active players: " + world.getPlayers().length);
|
|
world.sendMessage("Current dimension: " + arg.player.dimension.id);
|
|
world.sendMessage("Current position: " + Vector3ToFancyString(arg.player.location));
|
|
world.sendMessage("-----------------");
|
|
});
|
|
|
|
system.afterEvents.scriptEventReceive.subscribe((event) => {
|
|
if (event.id == "cc:getId") {
|
|
let id = event.message;
|
|
world.sendMessage("Script got the id " + id);
|
|
mindKeeper.set(AGENT_ID, id);
|
|
}
|
|
});
|
|
|
|
system.afterEvents.scriptEventReceive.subscribe((event) => {
|
|
if (event.id == "cc:getId") {
|
|
let id = event.message;
|
|
world.sendMessage("Script got the id " + id);
|
|
mindKeeper.set(AGENT_ID, id);
|
|
}
|
|
});
|
|
|
|
world.afterEvents.worldInitialize.subscribe(() => {
|
|
mindKeeper.registerStore(CURRENT_LEVEL, StoreType.number);
|
|
mindKeeper.registerStore(AGENT_ID, StoreType.string);
|
|
triggerManager.RegisterStores();
|
|
mindKeeper.registerToWorld();
|
|
|
|
triggerManager.Load();
|
|
});
|
|
|
|
world.beforeEvents.itemUseOn.subscribe((event) => {
|
|
trailMaker.OnItemUse(event);
|
|
triggerManager.OnItemUse(event);
|
|
});
|