Make many rules async and separate slimeChunk & moonPhase

Canopy [BP]/scripts/lib/canopy/Command.js

@@ -143,10 +143,10 @@ class Command {
 }
 
 world.beforeEvents.chatSend.subscribe((ev) => {
-	const { message, sender } = ev;
+	const { sender, message } = ev;
 
 	let [name, ...args] = ArgumentParser.parseArgs(message);
-	if (!name.startsWith(Command.prefix)) 
+	if (!String(name).startsWith(Command.prefix))
 		return;
 	ev.cancel = true;
 	if (!commands[name])

Canopy [BP]/scripts/lib/canopy/Rule.js

@@ -90,6 +90,10 @@ class Rule {
         }
     }
 
+    getDependentRuleIDs() {
+        return Object.values(rules).filter(rule => rule.#contingentRules.includes(this.#identifier)).map(rule => rule.#identifier);
+    }
+
     static exists(identifier) {
         return rules[identifier] !== undefined;
     }
@@ -98,6 +102,10 @@ class Rule {
         return await Rule.getRule(identifier).getValue();
     }
 
+    static getNativeValue(identifier) {
+        return Rule.getRule(identifier).parseString(world.getDynamicProperty(identifier));
+    }
+
     static setValue(identifier, value) {
         Rule.getRule(identifier).setValue(value);
     }

Canopy [BP]/scripts/src/classes/ProbeManager.js

@@ -116,7 +116,7 @@ class ProbeManager {
 
     removeProbe(player) {
         const probe = this.probeMap[player.id];
-        if (!probe) return console.warn(`[Probe Manager] Error while removing: No probe found for player ${player?.name}`);
+        if (!probe) return;
         probe.detachFromPlayer();
         if (probe.entity.isValid())
             probe.entity.remove();

Canopy [BP]/scripts/src/commands/camera.js

@@ -70,22 +70,22 @@ class BeforeSpectatorPlayer {
     }
 }
 
-world.beforeEvents.playerGameModeChange.subscribe((ev) => {
-    const player = ev.player;
-    if (player.getDynamicProperty('isSpectating') && ev.fromGameMode === 'spectator' && ev.toGameMode !== 'spectator') {
+world.beforeEvents.playerGameModeChange.subscribe((event) => {
+    const player = event.player;
+    if (player.getDynamicProperty('isSpectating') && event.fromGameMode === 'spectator' && event.toGameMode !== 'spectator') {
         system.run(() => {
-            player.setGameMode(ev.fromGameMode);
+            player.setGameMode(event.fromGameMode);
             player.onScreenDisplay.setActionBar('§cYou cannot change your gamemode while spectating.');
         });
     }
 });
 
-world.beforeEvents.playerLeave.subscribe((ev) => {
-    ev.player.setDynamicProperty('isViewingCamera', false);
+world.beforeEvents.playerLeave.subscribe((event) => {
+    event.player.setDynamicProperty('isViewingCamera', false);
 });
 
-world.afterEvents.playerDimensionChange.subscribe((ev) => {
-    const player = ev.player;
+world.afterEvents.playerDimensionChange.subscribe((event) => {
+    const player = event.player;
     if (!player.getDynamicProperty('isViewingCamera')) return;
     player.camera.clear();
     player.setDynamicProperty('isViewingCamera', false);

Canopy [BP]/scripts/src/commands/canopy.js

@@ -30,8 +30,11 @@ async function canopyCommand(sender, args) {
     if (ruleID === 'hopperCounters' && !enable)
         resetCounterMap();
 
-    updateRules(sender, rule.getContigentRuleIDs(), enable);
-    updateRules(sender, rule.getIndependentRuleIDs(), !enable);
+    if (!enable)
+        await updateRules(sender, rule.getDependentRuleIDs(), enable);
+    else
+        await updateRules(sender, rule.getContigentRuleIDs(), enable);
+    await updateRules(sender, rule.getIndependentRuleIDs(), false);
 
     updateRule(sender, ruleID, ruleValue, enable);
 }
@@ -42,9 +45,8 @@ function updateRule(sender, ruleID, ruleValue, enable) {
     sender.sendMessage(`§7${ruleID} is now ${enable ? '§l§aenabled' : '§l§cdisabled'}§r§7.`);
 }
 
-function updateRules(sender, ruleIDs, enable) {
+async function updateRules(sender, ruleIDs, enable) {
     for (const ruleID of ruleIDs) {
-        const rule = Rule.getRule(ruleID);
-        updateRule(sender, rule, enable);
+        updateRule(sender, ruleID, await Rule.getValue(ruleID), enable);
     }
 }

Canopy [BP]/scripts/src/commands/info.js

@@ -43,7 +43,10 @@ function infoCommand(sender, args) {
         clearInfoDisplay(sender);
 
     const rule = InfoDisplayRule.getRule(ruleID);
-    updateRules(sender, rule.getContigentRuleIDs(), enable);
+    if (!enable)
+        updateRules(sender, rule.getDependentRuleIDs(), enable);
+    else
+        updateRules(sender, rule.getContigentRuleIDs(), enable);
     updateRules(sender, rule.getIndependentRuleIDs(), !enable);
 
     updateRule(sender, ruleID, InfoDisplayRule.getValue(sender, ruleID), enable);
@@ -70,6 +73,6 @@ function updateRule(sender, ruleID, ruleValue, enable) {
 function updateRules(sender, ruleIDs, enable) {
     for (const ruleID of ruleIDs) {
         const rule = InfoDisplayRule.getRule(ruleID);
-        updateRule(sender, rule, enable);
+        updateRule(sender, ruleID, InfoDisplayRule.getValue(sender, ruleID), enable);
     }
 }

Canopy [BP]/scripts/src/commands/jump.js

@@ -22,11 +22,11 @@ new Command({
     helpHidden: true
 })
 
-function jumpCommand(sender) {
+async function jumpCommand(sender) {
     let blockRayResult;
     let maxDistance = 64*16;
     let jumpLocation;
-    if (!Rule.getValue('commandJumpSurvival') && sender.getGameMode() === 'survival')
+    if (!await Rule.getValue('commandJumpSurvival') && sender.getGameMode() === 'survival')
         return sender.sendMessage('§cThe commandJumpSurvival feature is disabled.');
 
     blockRayResult = Data.getLookingAtBlock(sender, maxDistance);

Canopy [BP]/scripts/src/commands/scriptevents/counter.js

@@ -3,9 +3,9 @@ import { Rule } from 'lib/canopy/Canopy';
 import { channelMap, formatColor, query, queryAll } from 'src/commands/counter';
 import Utils from 'stickycore/utils';
 
-system.afterEvents.scriptEventReceive.subscribe((event) => {
+system.afterEvents.scriptEventReceive.subscribe(async (event) => {
     if (event.id !== 'canopy:counter') return;
-    if (!Rule.getValue('hopperCounters')) return Utils.broadcastActionBar('§cThe hopperCounters feature is disabled.');
+    if (!await Rule.getValue('hopperCounters')) return Utils.broadcastActionBar('§cThe hopperCounters feature is disabled.');
     const sourceName = Utils.getScriptEventSourceName(event);
     const message = event.message;
 

Canopy [BP]/scripts/src/commands/spawn.js

@@ -42,11 +42,11 @@ let isMocking = false;
 let currMobIds = [];
 let currActiveArea = null;
 
-world.afterEvents.entitySpawn.subscribe((event) => {
+world.afterEvents.entitySpawn.subscribe(async (event) => {
     const entity = event.entity;
     if (worldSpawns && entity.typeId !== 'minecraft:item') worldSpawns.sendMobToTrackers(event.entity);
 
-    if (!isMocking || event.cause === 'Loaded' || !Rule.getValue('commandSpawnMocking')) return;
+    if (!isMocking || event.cause === 'Loaded' || !await Rule.getValue('commandSpawnMocking')) return;
     let shouldCancelSpawn = false;
     for (const category in categoryToMobMap) {
         if (categoryToMobMap[category].includes(event.entity.typeId.replace('minecraft:', ''))) shouldCancelSpawn = true;
@@ -82,8 +82,8 @@ function printAllEntities(sender) {
     });
 }
 
-function handleMockingCmd(sender, enable) {
-    if (!Rule.getValue('commandSpawnMocking')) return sender.sendMessage('§cThe commandSpawnMocking rule is disabled.');
+async function handleMockingCmd(sender, enable) {
+    if (!await Rule.getValue('commandSpawnMocking')) return sender.sendMessage('§cThe commandSpawnMocking rule is disabled.');
     if (enable === null) return sender.sendMessage('§cUsage: ./spawn mocking <true/false>');
     isMocking = enable;
     const messageColor = enable ? '§c' : '§a';

Canopy [BP]/scripts/src/commands/tick.js

@@ -30,8 +30,8 @@ let targetMSPT = 50.0;
 let shouldReset = false;
 let shouldStep = 0;
 
-system.beforeEvents.watchdogTerminate.subscribe((event) => {
-    if (!Rule.getValue('commandTick')) return;
+system.beforeEvents.watchdogTerminate.subscribe(async (event) => {
+    if (!await Rule.getValue('commandTick')) return;
     if (event.terminateReason === 'Hang' && targetMSPT > 50.0) {
         console.warn(`[Watchdog] Terminate hang ignored.`);
         event.cancel = true;

Canopy [BP]/scripts/src/commands/tntfuse.js

@@ -20,11 +20,11 @@ const cmd = new Command({
     contingentRules: ['commandTntFuse']
 });
 
-world.afterEvents.entitySpawn.subscribe(event => {
+world.afterEvents.entitySpawn.subscribe(async (event) => {
     if (event.entity.typeId !== 'minecraft:tnt') return;
     const fuseTimeProperty = world.getDynamicProperty('tntFuseTime');
     let fuseTime = 80;
-    if (fuseTimeProperty !== undefined && Rule.getValue('commandTntFuse'))
+    if (fuseTimeProperty !== undefined && await Rule.getValue('commandTntFuse'))
         fuseTime = fuseTimeProperty;
 
     if (fuseTime === 80) {

Canopy [BP]/scripts/src/commands/warp.js

@@ -65,8 +65,8 @@ class Warps {
     }
 }
 
-function warpActionCommand(sender, args) {
-    if (!Rule.getValue('commandWarpSurvival') && ['survival', 'adventure'].includes(sender.getGameMode()))
+async function warpActionCommand(sender, args) {
+    if (!await Rule.getValue('commandWarpSurvival') && ['survival', 'adventure'].includes(sender.getGameMode()))
         return sender.sendMessage('§cThe commandWarpSurvival rule is disabled.');
 
     let { action, name } = args;
@@ -139,10 +139,8 @@ function setWarpMap(newWarpMap) {
     world.setDynamicProperty(`warps`, JSON.stringify(warps));
 }
 
-function warpListCommand(sender) {
-    if (!Rule.getValue('commandWarp'))
-        return sender.sendMessage('§cThe commandWarp rule is disabled.');
-    else if (!Rule.getValue('commandWarpSurvival') && sender.getGameMode() === 'survival')
+async function warpListCommand(sender) {
+    if (!await Rule.getValue('commandWarpSurvival') && sender.getGameMode() === 'survival')
         return sender.sendMessage('§cThe commandWarpSurvival rule is disabled.');
 
     let warpMap = getWarpMapCopy();

Canopy [BP]/scripts/src/rules/InfoDisplay.js

@@ -115,6 +115,7 @@ function InfoDisplay(player) {
 function parseCoordsAndFacing(player) {
 	const showCoords = InfoDisplayRule.getValue(player, 'coords');
 	const showFacing = InfoDisplayRule.getValue(player, 'facing');
+	if (!showCoords && !showFacing) return '';
 	let coords = player.location;
 	let facing;
 	let output = '';
@@ -131,6 +132,7 @@ function parseCoordsAndFacing(player) {
 function parseTPSAndEntities(player) {
 	const showTPS = InfoDisplayRule.getValue(player, 'tps');
 	const showEntities = InfoDisplayRule.getValue(player, 'entities');
+	if (!showTPS && !showEntities) return '';
 	let tpsData;
 	let tps;
 	let fovEntities;
@@ -151,6 +153,7 @@ function parseTPSAndEntities(player) {
 function parseLightAndBiome(player) {
 	const showLight = InfoDisplayRule.getValue(player, 'light');
 	const showBiome = InfoDisplayRule.getValue(player, 'biome');
+	if (!showLight && !showBiome) return '';
 	let lightLevel;
 	let biome;
 	let output = '';
@@ -167,6 +170,7 @@ function parseLightAndBiome(player) {
 function parseDayAndTime(player) {
 	const showDay = InfoDisplayRule.getValue(player, 'worldDay');
 	const showTimeOfDay = InfoDisplayRule.getValue(player, 'timeOfDay');
+	if (!showDay && !showTimeOfDay) return '';
 	let day;
 	let dayTime;
 	let output = '';
@@ -196,13 +200,17 @@ function parseSessionTime(player) {
 function parseMoonPhaseAndSlimeChunk(player) {
 	const showMoonPhase = InfoDisplayRule.getValue(player, 'moonPhase');
 	const showSlimeChunk = InfoDisplayRule.getValue(player, 'slimeChunk');
-	const isSlime = player.dimension.id === "minecraft:overworld" && Data.isSlime(player.location.x, player.location.z);
+	if (!showMoonPhase && !showSlimeChunk) return '';
+	let isSlime = false;
 	let moonPhase;
 	let slimeChunk;
 	let output = '';
 
 	if (showMoonPhase) moonPhase = Data.getMoonPhase();
-	if (showSlimeChunk) slimeChunk = isSlime ? '§7(§aSlime Chunk§7)§r' : '';
+	if (showSlimeChunk) {
+		isSlime = player.dimension.id === "minecraft:overworld" && Data.isSlime(player.location.x, player.location.z);
+		slimeChunk = isSlime ? '§7(§aSlime Chunk§7)§r' : '';
+	} 
 	if (showMoonPhase && showSlimeChunk) output += `§rMoon: §7${moonPhase}§r ${slimeChunk}\n`;
 	else if (showMoonPhase) output += `§rMoon: §7${moonPhase}§r\n`;
 	else if (showSlimeChunk && isSlime) output += `§r${slimeChunk}\n`;
@@ -225,6 +233,7 @@ function parseHopperCounters(player) {
 function parseLookingAtAndPeek(player) {
 	const showLookingAt = InfoDisplayRule.getValue(player, 'lookingAt');
 	const showPeekInventory = InfoDisplayRule.getValue(player, 'peekInventory');
+	// if (!showLookingAt && !showPeekInventory) return '';
 	let blockRayResult;
 	let entityRayResult;
 	let lookingAtName;

Canopy [BP]/scripts/src/rules/armorStandRespawning.js

@@ -7,8 +7,8 @@ new Rule({
     description: 'Armor stands respawn when hit by a projectile, dropping their items.',
 });
 
-world.afterEvents.projectileHitEntity.subscribe((event) => {
-    if (!Rule.getValue('armorStandRespawning') || event.projectile.typeId === "minecraft:fishing_hook") return;
+world.afterEvents.projectileHitEntity.subscribe(async (event) => {
+    if (!await Rule.getValue('armorStandRespawning') || event.projectile.typeId === "minecraft:fishing_hook") return;
     const entity = event.getEntityHit().entity;
     if (entity?.typeId === "minecraft:armor_stand") {
         const hasCleanedItem = cleanDroppedItem(event);

Canopy [BP]/scripts/src/rules/autoItemPickup.js

@@ -14,15 +14,15 @@ system.runInterval(() => {
     brokenBlockEventsThisTick = [];
 });
 
-world.afterEvents.playerBreakBlock.subscribe(blockEvent => {
-    if (!Rule.getValue('autoItemPickup')) return;
+world.afterEvents.playerBreakBlock.subscribe(async (blockEvent) => {
+    if (!await Rule.getValue('autoItemPickup')) return;
     if (blockEvent.player.getGameMode() === 'creative') return;
     brokenBlockEventsThisTick.push(blockEvent);
 });
 
-world.afterEvents.entitySpawn.subscribe(entityEvent => {
+world.afterEvents.entitySpawn.subscribe(async (entityEvent) => {
     if (entityEvent.cause !== 'Spawned' || entityEvent.entity.typeId !== 'minecraft:item') return;
-    if (!Rule.getValue('autoItemPickup')) return;
+    if (!await Rule.getValue('autoItemPickup')) return;
 
     const item = entityEvent.entity;
     let brokenBlockEvent;

Canopy [BP]/scripts/src/rules/dupeTnt.js

@@ -16,13 +16,13 @@ system.runInterval(() => {
 }, 1);
 
 world.afterEvents.entitySpawn.subscribe((event) => {
-	if (event.entity.typeId !== 'minecraft:tnt' || !Rule.getValue('dupeTnt')) return;
+	if (event.entity.typeId !== 'minecraft:tnt' || !Rule.getNativeValue('dupeTnt')) return;
     const entity = event.entity;
     spawnedEntitiesThisTick.push(entity);
 });
 
 world.afterEvents.pistonActivate.subscribe((event) => {
-    if (!Rule.getValue('dupeTnt')) return;
+    if (!Rule.getNativeValue('dupeTnt')) return;
     const block = event.block;
     const direction = block.permutation.getState('facing_direction');
     let pistonState;

Canopy [BP]/scripts/src/rules/entityInstantDeath.js

@@ -8,7 +8,7 @@ new Rule({
 });
 
 world.afterEvents.entityDie.subscribe(async (event) => {
-    if (!await Rule.getValue('entityInstantDeath')) return;
+    if (!await Rule.getNativeValue('entityInstantDeath')) return;
     try {
         event.deadEntity.remove();
     } catch {} // already dead

Canopy [BP]/scripts/src/rules/explosionChainReactionOnly.js

@@ -5,11 +5,11 @@ new Rule({
     category: 'Rules',
     identifier: 'explosionChainReactionOnly',
     description: 'Makes explosion only affect TNT blocks.',
-    independentRules: ['explosionNoBlockDamage']
+    independentRules: ['explosionNoBlockDamage', 'explosionOff']
 });
 
 world.beforeEvents.explosion.subscribe((event) => {
-    if (!Rule.getValue('explosionChainReactionOnly')) return;
+    if (!Rule.getNativeValue('explosionChainReactionOnly')) return;
     const explodedTntBlocks = event.getImpactedBlocks().filter(block => block.typeId === 'minecraft:tnt');
     event.setImpactedBlocks(explodedTntBlocks);
 });

Canopy [BP]/scripts/src/rules/explosionNoBlockDamage.js

@@ -5,10 +5,10 @@ new Rule({
     category: 'Rules',
     identifier: 'explosionNoBlockDamage',
     description: 'Makes explosions not affect blocks.',
-    independantRules: ['explosionChainReactionOnly']
+    independentRules: ['explosionChainReactionOnly', 'explosionOff']
 });
 
-world.beforeEvents.explosion.subscribe(ev => {
-    if (!Rule.getValue('explosionNoBlockDamage')) return;
-    ev.setImpactedBlocks([]);
+world.beforeEvents.explosion.subscribe((event) => {
+    if (!Rule.getNativeValue('explosionNoBlockDamage')) return;
+    event.setImpactedBlocks([]);
 });

Canopy [BP]/scripts/src/rules/explosionOff.js

@@ -5,9 +5,10 @@ new Rule({
     category: 'Rules',
     identifier: 'explosionOff',
     description: 'Disables explosions entirely.',
+    independentRules: ['explosionChainReactionOnly', 'explosionNoBlockDamage']
 });
 
 world.beforeEvents.explosion.subscribe((event) => {
-    if (!Rule.getValue('explosionOff')) return;
+    if (!Rule.getNativeValue('explosionOff')) return;
     event.cancel = true;
 });