Code Overhaul

Removed hardcoded values and added their respective configurable constants
Expanded Player polyfill with all dictionaries that were managed outside of the player object
Made all sounds play in the world instead of only the player making them hearing them
Added dash cooldown

Author: SalticHash

scripts/addons/lightFruit/lightFruit.ts

@@ -1,38 +1,60 @@
-import { AimAssistTargetMode, ButtonState, EffectTypes, EntityDamageCause, EntityHealthComponent, EntityInventoryComponent, EquipmentSlot, InputButton, InputPermissionCategory, ItemLockMode, ItemStack, MolangVariableMap, Player, RGBA, StartupEvent, system, Vector3, world } from "@minecraft/server";
+import { ButtonState, EntityDamageCause, EntityHealthComponent, EntityInventoryComponent, EquipmentSlot, InputButton, InputPermissionCategory, ItemLockMode, ItemStack, MolangVariableMap, Player, StartupEvent, system, Vector3, world } from "@minecraft/server";
 import { MinecraftEffectTypes } from "@minecraft/vanilla-data";
-import { directionVector, drawLine, entityCenter, entityGetSlot, entityHasSlotTag, spawnLine } from "../../utility";
+import { directionVector, drawLine, EFFECT_INFINITE, entityCenter, entityHasSlotTag, playSoundFrom } from "../../utility";
 import { V3 } from "../../math/vectorUtils";
 import { deg2Rad, PI, remap, TAU } from "../../math/general";
-import { VECTOR2_ZERO, VECTOR3_BACK, VECTOR3_ZERO } from "@minecraft/math";
+import { VECTOR3_ZERO } from "@minecraft/math";
 
-let light: ItemStack
-const maxAirJumps: number = 10
-const lightTrailThickness: number = 0.15
-const lightTrailLengthMax: number = 10.0
-const lightTrailLengthMin: number = 1.5
-const fCooldownTime = 80
-const flyTurnThreshold = Math.cos(deg2Rad(60));
 enum States {
     NORMAL,
     FLYING,
     MOON_JUMP,
     DASH
 }
 
-class LightVisual {
+let light: ItemStack
+const maxAirJumps: number = 10
+const lightTrailThickness: number = 0.15
+const lightSpinTrailThickness: number = 0.075
+const fCooldownTime = 80
+const flyTurnThreshold = Math.cos(deg2Rad(60));
+const flyTurnCooldownTime: number = 10
+const airborneAirtime = 3
+
+const moonJumpForce = 0.75
+const moonJumpSize1 = 0.5
+const moonJumpSize2 = 1.3 / 2
+const moonJumpSize3 = 1.5 / 2
+const moonJumpPos1 = -0.0
+const moonJumpPos2 = -0.2
+const moonJumpPos3 = -0.4
+
+const dashCooldownTime = 5
+const dashForce = 1.0
+const dashLift = 0.1
+const dashSlowFallTime = 5
+
+const flightSpeedMin = 0.1
+const flightSpeedMax = 1.0
+const flightStarSize = 2.0
+const flightStarFrames = 5
+const spinTrailTurnsPerSecond = 1.5
+const spinTrailRadius = 0.5
+const flySoundDuration = 7 //8.58
+
+class LightFlightVisual {
     lastSpin1: Vector3 | undefined
     lastSpin2: Vector3 | undefined
     lastTrail: Vector3 | undefined
     angle: number = 0.0
 }
-const flyTurnCooldownTime: number = 10
 const flyTurnCooldown: Map<string, number> = new Map()
 const flySoundCooldown: Map<string, number> = new Map()
 const airTime: Map<string, number> = new Map()
 const ignoreFall: Map<string, boolean> = new Map()
-const airJumps: Map<string, number> = new Map()
+const dashCooldown: Map<string, number> = new Map()
 const flyingAngles: Map<string, Vector3> = new Map()
-const visuals: Map<string, LightVisual> = new Map()
+const lightFlightVisuals: Map<string, LightFlightVisual> = new Map()
 
 // Defining setters for ability cooldowns
 Object.defineProperties(Player.prototype, {
@@ -60,6 +82,41 @@ Object.defineProperties(Player.prototype, {
         get() {return this.getDynamicProperty("whynot:light_state") ?? States.NORMAL},
         set(state: number) {this.setDynamicProperty("whynot:light_state", state)},
     },
+    flyTurnCooldown: {
+        get() {return flyTurnCooldown.get(this.id) ?? 0},
+        set(v: number) {flyTurnCooldown.set(this.id, v)}
+    },
+    center: {
+        get() {return entityCenter(this) ?? this.location}
+    },
+    flySoundCooldown: {
+        get() {return flySoundCooldown.get(this.id) ?? 0},
+        set(v: number) {flySoundCooldown.set(this.id, v)}
+    },
+    airTime: {
+        get() {return airTime.get(this.id) ?? 0},
+        set(v: number) {airTime.set(this.id, v)}
+    },
+    ignoreFall: {
+        get() {return ignoreFall.get(this.id) ?? false},
+        set(v: boolean) {ignoreFall.set(this.id, v)}
+    },
+    airJumps: {
+        get() {return this.getDynamicProperty("whynot:air_jumps") ?? 10},
+        set(v: number) {this.setDynamicProperty("whynot:air_jumps", v)},
+    },
+    flyingAngles: {
+        get() {return flyingAngles.get(this.id) ?? VECTOR3_ZERO},
+        set(v: Vector3) {flyingAngles.set(this.id, v)}
+    },
+    lightFlightVisuals: {
+        get() {return lightFlightVisuals.get(this.id) ?? new LightFlightVisual()},
+        set(v: LightFlightVisual) {lightFlightVisuals.set(this.id, v)}
+    },
+    dashCooldown: {
+        get() {return dashCooldown.get(this.id) ?? 0},
+        set(v: number) {dashCooldown.set(this.id, v)}
+    }
 });
 
 // Eat fruit component
@@ -87,43 +144,47 @@ function changeState(player: Player, state: States) {
     switch (player.state) {
         case States.FLYING:
             player.triggerEvent("whynot:add_static_player");
-            flyingAngles.set(player.id, player.getViewDirection());
-            player.addEffect(MinecraftEffectTypes.Invisibility, 20000000, {showParticles: false})
-
-            player.playSound("light_dash")
-            player.playSound("light_beam_start")
-            visuals.set(player.id, new LightVisual())
-            flySoundCooldown.set(player.id, 0)
-            flyTurnCooldown.set(player.id, 0)
+            player.addEffect(MinecraftEffectTypes.Invisibility, EFFECT_INFINITE, {showParticles: false})
+            
+            playSoundFrom(player, "light_dash")
+            playSoundFrom(player, "light_beam_start")
+            player.flyingAngles = player.getViewDirection()
+            player.lightFlightVisuals = new LightFlightVisual()
+            player.flySoundCooldown = 0
+            player.flyTurnCooldown = 0
             player.inputPermissions.setPermissionCategory(InputPermissionCategory.Movement, false)
         break;
 
         case States.MOON_JUMP:
-            ignoreFall.set(player.id, true)
-            player.applyImpulse(V3.make(0, -player.getVelocity().y + 0.75, 0))
-            let molangSize1 = new MolangVariableMap(); molangSize1.setFloat("size", 1.0 / 2.0)
-            let molangSize2 = new MolangVariableMap(); molangSize2.setFloat("size", 1.3 / 2.0)
-            let molangSize3 = new MolangVariableMap(); molangSize3.setFloat("size", 1.5 / 2.0)
-            player.spawnParticle("whynot:moon_jump", V3.add(player.location, V3.make(0, 0, 0)), molangSize1)
-            player.spawnParticle("whynot:moon_jump", V3.add(player.location, V3.make(0, -0.2, 0)), molangSize2)
-            player.spawnParticle("whynot:moon_jump", V3.add(player.location, V3.make(0, -0.4, 0)), molangSize3)
-            player.playSound("moon_jump")
-            airJumps.set(player.id, (airJumps.get(player.id) ?? 0) - 1)
+            player.airJumps--
+            player.ignoreFall = true
+            player.applyImpulse(V3.make(0, -player.getVelocity().y + moonJumpForce, 0))
+            playSoundFrom(player, "moon_jump")
+
+            // Particles
+            let molangSize1 = new MolangVariableMap(); molangSize1.setFloat("size", moonJumpSize1)
+            let molangSize2 = new MolangVariableMap(); molangSize2.setFloat("size", moonJumpSize2)
+            let molangSize3 = new MolangVariableMap(); molangSize3.setFloat("size", moonJumpSize3)
+            const pos = player.location
+            player.spawnParticle("whynot:moon_jump", V3.make(pos.x, pos.y + moonJumpPos1, pos.z), molangSize1)
+            player.spawnParticle("whynot:moon_jump", V3.make(pos.x, pos.y + moonJumpPos2, pos.z), molangSize2)
+            player.spawnParticle("whynot:moon_jump", V3.make(pos.x, pos.y + moonJumpPos3, pos.z), molangSize3)
 
             changeState(player, States.NORMAL)
         break;
 
         case States.DASH:
             const dir = player.getViewDirection()
-            let vel = V3.normalize(V3.make(dir.x, 0, dir.z ))
+            const vel = V3.normalize(V3.make(dir.x, 0, dir.z))
             const dirMap = new MolangVariableMap();
             dirMap.setVector3("direction", V3.scale(vel, -1))
-            player.spawnParticle("whynot:dash", entityCenter(player) ?? player.location, dirMap)
-            player.addEffect(MinecraftEffectTypes.SlowFalling, 5, {showParticles: false})
-            player.playSound("dash")
+            player.spawnParticle("whynot:dash", player.center, dirMap)
+            player.addEffect(MinecraftEffectTypes.SlowFalling, dashSlowFallTime, {showParticles: false})
+            playSoundFrom(player, "dash")
 
+            player.dashCooldown = dashCooldownTime
             player.clearVelocity()
-            player.applyImpulse(V3.add(V3.scale(vel, 1.0), V3.make(0,0.1,0)))
+            player.applyImpulse(V3.make(vel.x * dashForce, dashLift, vel.z * dashForce))
 
             changeState(player, States.NORMAL)
         break;
@@ -148,26 +209,29 @@ export function main() {
     world.getAllPlayers().forEach(player => changeState(player, States.NORMAL))
     world.beforeEvents.entityHurt.subscribe(ev => {
         if (ev.damageSource.cause != EntityDamageCause.fall) return
-        if (!ev.hurtEntity.isValid || ev.hurtEntity.typeId != "minecraft:player") return
-        if (!ignoreFall.get(ev.hurtEntity.id)) return
+
+        const player = ev.hurtEntity as Player
+        if (!player.isValid || player.typeId != "minecraft:player") return
+        if (!player.ignoreFall) return
 
         ev.cancel = true
     })
     world.afterEvents.playerButtonInput.subscribe(({button, newButtonState, player}) => {
         const pressed = newButtonState == ButtonState.Pressed
         if (!entityHasSlotTag(player, EquipmentSlot.Mainhand, "whynot:light")) return;
 
-        if (button == InputButton.Sneak && newButtonState == ButtonState.Pressed && player.state == States.NORMAL) {
+        if (button == InputButton.Sneak && newButtonState == ButtonState.Pressed &&
+            player.state == States.NORMAL && player.dashCooldown <= 0) {
             changeState(player, States.DASH)
         }
         if (button != InputButton.Jump) return
-        if (((airTime.get(player.id) ?? 0) > 2) && pressed && player.state == States.NORMAL) {
+        if (player.airTime >= airborneAirtime && pressed && player.state == States.NORMAL) {
             // Activate fly
             if (player.fCooldown <= 0 && player.isSneaking) {
                 changeState(player, States.FLYING)
             }
             // Moon jump
-            else if ((airJumps.get(player.id) ?? 0) > 0) {
+            else if (player.airJumps > 0) {
                 changeState(player, States.MOON_JUMP)
             }
         }
@@ -189,55 +253,54 @@ function mainTick() {
         // Set Airtime
         if (player.isOnGround) {
             if (player.state != States.FLYING) {
-                airJumps.set(player.id, maxAirJumps)
-                ignoreFall.set(player.id, false)
-
+                player.airJumps = maxAirJumps
+                player.ignoreFall = false
             }
-            airTime.set(player.id, 0)
+            player.airTime = 0
         }
-        else airTime.set(player.id, (airTime.get(player.id) ?? 0) + 1)
+        else player.airTime++
 
         if (player.state == States.FLYING) {
-            ignoreFall.set(player.id, true)
+            player.ignoreFall = true
             player.fCooldown = fCooldownTime
 
             // get move dir
             const viewDir = player.getViewDirection();
-            const addVel = V3.normalize(flyingAngles.get(player.id) ?? viewDir);
+            const addVel = V3.normalize(player.flyingAngles);
 
             // Scale speed from health
             const health = player.getComponent(EntityHealthComponent.componentId) as EntityHealthComponent;
-            const speed = remap(health.currentValue, health.effectiveMin, health.effectiveMax, 0.1, 1.0);
+            const speed = remap(health.currentValue, health.effectiveMin, health.effectiveMax, flightSpeedMin, flightSpeedMax);
             const vel = V3.scale(addVel, speed)
             player.clearVelocity();
             player.applyImpulse(vel);
 
             // Particles
             const starMap = new MolangVariableMap()
-            const center = entityCenter(player) ?? player.location
-            starMap.setFloat("size", 2.0)
-            starMap.setFloat("frame", system.currentTick % 5)
+            const center = player.center
+            starMap.setFloat("size", flightStarSize)
+            starMap.setFloat("frame", system.currentTick % flightStarFrames)
             player.spawnParticle(
                 "whynot:light_star",
                 center,
                 starMap
             )
 
             // Visuals
-            const playerVisuals = visuals.get(player.id)
+            const playerVisuals = player.lightFlightVisuals
             if (playerVisuals) {
                 const matrix = V3.getBasisMatrix(addVel)
-                playerVisuals.angle += (1 / 20.0) * TAU * 1.5 * speed
+                playerVisuals.angle += (1 / 20.0) * TAU * spinTrailTurnsPerSecond * speed
 
                 let angle = playerVisuals.angle
-                const spin1 = V3.make(Math.cos(angle) * 0.5, Math.sin(angle) * 0.5, 0)
-                const spin2 = V3.make(Math.cos(angle + PI) * 0.5, Math.sin(angle + PI) * 0.5, 0)
+                const spin1 = V3.make(Math.cos(angle) * spinTrailRadius, Math.sin(angle) * spinTrailRadius, 0)
+                const spin2 = V3.make(Math.cos(angle + PI) * spinTrailRadius, Math.sin(angle + PI) * spinTrailRadius, 0)
 
                 const add1 = V3.add(V3.multiplyVectorByMatrix(spin1, matrix), center)
                 const add2 = V3.add(V3.multiplyVectorByMatrix(spin2, matrix), center)
                 if (playerVisuals.lastSpin1 && playerVisuals.lastSpin2) {
-                    drawLine("whynot:light_trail", player.dimension, add1, playerVisuals.lastSpin1, 0.075)
-                    drawLine("whynot:light_trail", player.dimension, add2, playerVisuals.lastSpin2, 0.075)
+                    drawLine("whynot:light_trail", player.dimension, add1, playerVisuals.lastSpin1, lightSpinTrailThickness)
+                    drawLine("whynot:light_trail", player.dimension, add2, playerVisuals.lastSpin2, lightSpinTrailThickness)
                 }
                 if (playerVisuals.lastTrail)
                     drawLine("whynot:light_trail", player.dimension, center, playerVisuals.lastTrail, lightTrailThickness)
@@ -247,29 +310,26 @@ function mainTick() {
             }
 
             // Get block in path and bounce if needed
-            const blockHit = player.dimension.getBlockFromRay(entityCenter(player) ?? player.location, vel, {maxDistance: 4, includeLiquidBlocks:false, includePassableBlocks: false})
+            const blockHit = player.dimension.getBlockFromRay(player.location, addVel, {maxDistance: 4, includeLiquidBlocks:false, includePassableBlocks: false})
             if (blockHit && blockHit.block.isSolid) {
                 const bounced = V3.reflect(vel, directionVector(blockHit.face));
-                flyingAngles.set(player.id, bounced);
-                flyTurnCooldown.set(player.id, flyTurnCooldownTime)
-                player.playSound("light_dash")
+                player.flyingAngles = bounced
+                player.flyTurnCooldown = flyTurnCooldownTime
+                playSoundFrom(player, "light_dash")
             }
 
             // If viewing angle change is significant change direction and did not bounce
-            else if (V3.dot(viewDir, addVel) < flyTurnThreshold && (flyTurnCooldown.get(player.id) ?? 0) <= 0) {
-                flyingAngles.set(player.id, viewDir);
-                player.playSound("light_dash")
+            else if (V3.dot(viewDir, addVel) < flyTurnThreshold && player.flyTurnCooldown <= 0) {
+                player.flyingAngles = viewDir;
+                playSoundFrom(player, "light_dash")
             }
 
             // Reduce fly turn cooldown
-            let currFlyTurnCooldown = flyTurnCooldown.get(player.id) ?? 0;
-            if (currFlyTurnCooldown > 0) flyTurnCooldown.set(player.id, currFlyTurnCooldown - 1);
-
-            let currSoundCooldon = flySoundCooldown.get(player.id) ?? 0;
-            if (currSoundCooldon > 0) flySoundCooldown.set(player.id, currSoundCooldon - 1);
+            if (player.flyTurnCooldown > 0) player.flyTurnCooldown--;
+            if (player.flySoundCooldown > 0) player.flySoundCooldown--;
             else {
-                player.playSound("light_beam_loop", {volume: 10})
-                flySoundCooldown.set(player.id, 7) //8.58
+                playSoundFrom(player, "light_beam_loop")
+                flySoundCooldown.set(player.id, flySoundDuration) 
             }
         }
 
@@ -279,6 +339,7 @@ function mainTick() {
         if (player.cCooldown > 0) player.cCooldown--;
         if (player.vCooldown > 0) player.vCooldown--;
         if (player.fCooldown > 0) player.fCooldown--;
+        if (player.dashCooldown > 0) player.dashCooldown--;
 
         // If player is holding light display cooldowns
         if (!entityHasSlotTag(player, EquipmentSlot.Mainhand, "whynot:light")) {

scripts/addons/lightFruit/lightFruitType.d.ts

@@ -1,4 +1,12 @@
-import { Player } from "@minecraft/server";
+import { Player, Vector3 } from "@minecraft/server";
+
+class LightFlightVisual {
+    lastSpin1: Vector3 | undefined
+    lastSpin2: Vector3 | undefined
+    lastTrail: Vector3 | undefined
+    angle: number
+}
+
 declare module "@minecraft/server" {
     interface Player {
         zCooldown: number;
@@ -7,5 +15,15 @@ declare module "@minecraft/server" {
         vCooldown: number;
         fCooldown: number;
         state: number;
+
+        flyTurnCooldown: number;
+        center: Vector3;
+        flySoundCooldown: number;
+        airTime: number;
+        ignoreFall: boolean;
+        airJumps: number;
+        dashCooldown: number;
+        flyingAngles: Vector3;
+        lightFlightVisuals: LightFlightVisual;
     }
 }

scripts/utility.ts

@@ -1,4 +1,4 @@
-import { ContainerSlot, Dimension, Direction, Entity, EntityEquippableComponent, EquipmentSlot, MolangVariableMap, RGBA, Vector3 } from "@minecraft/server";
+import { ContainerSlot, Dimension, Direction, Entity, EntityEquippableComponent, EquipmentSlot, MolangVariableMap, RGBA, Vector3, WorldSoundOptions } from "@minecraft/server";
 import { V3 } from "./math/vectorUtils";
 import { VECTOR3_DOWN, VECTOR3_EAST, VECTOR3_NORTH, VECTOR3_SOUTH, VECTOR3_UP, VECTOR3_WEST } from "@minecraft/math";
 
@@ -59,4 +59,10 @@ export function directionVector(face: Direction): Vector3 {
 export function entityCenter(entity: Entity): Vector3 | undefined {
     if (!entity || !entity.isValid) return
     return V3.shrink(V3.add(entity.location, entity.getHeadLocation()), 2)
-}
+}
+
+export function playSoundFrom(entity: Entity, soundId: string, soundOptions?: WorldSoundOptions) {
+    entity.dimension.playSound(soundId, entity.location, soundOptions)
+}
+
+export const EFFECT_INFINITE = 20000000