minecraft-renderer 0.1.79 → 0.1.80

package/src/three/threeJsParticles.ts

@@ -3,23 +3,23 @@ import * as THREE from 'three'
 import type { SceneOrigin } from './sceneOrigin'
 
 interface ParticleMesh extends THREE.Mesh {
-  velocity: THREE.Vector3;
-  worldPos: THREE.Vector3;
+  velocity: THREE.Vector3
+  worldPos: THREE.Vector3
 }
 
 interface ParticleConfig {
-  fountainHeight: number;
-  resetHeight: number;
-  xVelocityRange: number;
-  zVelocityRange: number;
-  particleCount: number;
-  particleRadiusRange: { min: number; max: number };
-  yVelocityRange: { min: number; max: number };
+  fountainHeight: number
+  resetHeight: number
+  xVelocityRange: number
+  zVelocityRange: number
+  particleCount: number
+  particleRadiusRange: { min: number; max: number }
+  yVelocityRange: { min: number; max: number }
 }
 
 export interface FountainOptions {
-  position?: { x: number, y: number, z: number }
-  particleConfig?: Partial<ParticleConfig>;
+  position?: { x: number; y: number; z: number }
+  particleConfig?: Partial<ParticleConfig>
 }
 
 export class Fountain {
@@ -29,15 +29,17 @@ export class Fountain {
   private readonly sceneOrigin: SceneOrigin | undefined
   container: THREE.Object3D | undefined
 
-  constructor (public sectionId: string, options: FountainOptions = {}, sceneOrigin?: SceneOrigin) {
+  constructor(
+    public sectionId: string,
+    options: FountainOptions = {},
+    sceneOrigin?: SceneOrigin
+  ) {
     this.position = options.position ? new THREE.Vector3(options.position.x, options.position.y, options.position.z) : new THREE.Vector3(0, 0, 0)
     this.config = this.createConfig(options.particleConfig)
     this.sceneOrigin = sceneOrigin
   }
 
-  private createConfig (
-    particleConfigOverride?: Partial<ParticleConfig>
-  ): { particleConfig: ParticleConfig } {
+  private createConfig(particleConfigOverride?: Partial<ParticleConfig>): { particleConfig: ParticleConfig } {
     const particleConfig: ParticleConfig = {
       fountainHeight: 10,
       resetHeight: 0,
@@ -52,27 +54,26 @@ export class Fountain {
     return { particleConfig }
   }
 
-  private toSceneX (worldX: number): number {
+  private toSceneX(worldX: number): number {
     return this.sceneOrigin ? this.sceneOrigin.toSceneX(worldX) : worldX
   }
 
-  private toSceneY (worldY: number): number {
+  private toSceneY(worldY: number): number {
     return this.sceneOrigin ? this.sceneOrigin.toSceneY(worldY) : worldY
   }
 
-  private toSceneZ (worldZ: number): number {
+  private toSceneZ(worldZ: number): number {
     return this.sceneOrigin ? this.sceneOrigin.toSceneZ(worldZ) : worldZ
   }
 
-
-  createParticles (container: THREE.Object3D): void {
+  createParticles(container: THREE.Object3D): void {
     this.container = container
     const colorStart = new THREE.Color(0xff_ff_00)
     const colorEnd = new THREE.Color(0xff_a5_00)
 
     for (let i = 0; i < this.config.particleConfig.particleCount; i++) {
-      const radius = Math.random() *
-        (this.config.particleConfig.particleRadiusRange.max - this.config.particleConfig.particleRadiusRange.min) +
+      const radius =
+        Math.random() * (this.config.particleConfig.particleRadiusRange.max - this.config.particleConfig.particleRadiusRange.min) +
         this.config.particleConfig.particleRadiusRange.min
       const geometry = new THREE.SphereGeometry(radius)
       const material = new THREE.MeshBasicMaterial({
@@ -103,7 +104,7 @@ export class Fountain {
     }
   }
 
-  render (): void {
+  render(): void {
     for (const particle of this.particles) {
       particle.velocity.y -= 0.01 + Math.random() * 0.1
       particle.worldPos.add(particle.velocity)
@@ -121,15 +122,11 @@ export class Fountain {
         )
       }
 
-      particle.position.set(
-        this.toSceneX(particle.worldPos.x),
-        this.toSceneY(particle.worldPos.y),
-        this.toSceneZ(particle.worldPos.z)
-      )
+      particle.position.set(this.toSceneX(particle.worldPos.x), this.toSceneY(particle.worldPos.y), this.toSceneZ(particle.worldPos.z))
     }
   }
 
-  private updateParticleCount (newCount: number): void {
+  private updateParticleCount(newCount: number): void {
     if (newCount !== this.config.particleConfig.particleCount) {
       this.config.particleConfig.particleCount = newCount
       const currentCount = this.particles.length
@@ -142,7 +139,7 @@ export class Fountain {
     }
   }
 
-  private addParticles (count: number): void {
+  private addParticles(count: number): void {
     const geometry = new THREE.SphereGeometry(0.1)
     const material = new THREE.MeshBasicMaterial({ color: 0x00_ff_00 })
 
@@ -150,24 +147,18 @@ export class Fountain {
       const mesh = new THREE.Mesh(geometry, material)
       const particle = mesh as unknown as ParticleMesh
       particle.worldPos = this.position.clone()
-      particle.position.set(
-        this.toSceneX(this.position.x),
-        this.toSceneY(this.position.y),
-        this.toSceneZ(this.position.z)
-      )
+      particle.position.set(this.toSceneX(this.position.x), this.toSceneY(this.position.y), this.toSceneZ(this.position.z))
       particle.velocity = new THREE.Vector3(
-        Math.random() * this.config.particleConfig.xVelocityRange -
-        this.config.particleConfig.xVelocityRange / 2,
+        Math.random() * this.config.particleConfig.xVelocityRange - this.config.particleConfig.xVelocityRange / 2,
         Math.random() * 2,
-        Math.random() * this.config.particleConfig.zVelocityRange -
-        this.config.particleConfig.zVelocityRange / 2
+        Math.random() * this.config.particleConfig.zVelocityRange - this.config.particleConfig.zVelocityRange / 2
       )
       this.particles.push(particle)
       this.container!.add(particle)
     }
   }
 
-  private removeParticles (count: number): void {
+  private removeParticles(count: number): void {
     for (let i = 0; i < count; i++) {
       const particle = this.particles.pop()
       if (particle) {
@@ -176,7 +167,7 @@ export class Fountain {
     }
   }
 
-  public dispose (): void {
+  public dispose(): void {
     for (const particle of this.particles) {
       particle.geometry.dispose()
       if (Array.isArray(particle.material)) {

package/src/three/threeJsSound.ts

@@ -15,7 +15,7 @@ export class ThreeJsSound implements SoundSystem {
       this.stopAll()
     })
 
-    worldRenderer.onReactiveConfigUpdated('volume', (volume) => {
+    worldRenderer.onReactiveConfigUpdated('volume', volume => {
       this.changeVolume(volume)
     })
   }
@@ -26,7 +26,7 @@ export class ThreeJsSound implements SoundSystem {
     this.worldRenderer.camera.add(this.audioListener)
   }
 
-  playSound(position: { x: number, y: number, z: number }, path: string, volume = 1, pitch = 1, timeout = 500) {
+  playSound(position: { x: number; y: number; z: number }, path: string, volume = 1, pitch = 1, timeout = 500) {
     this.initAudioListener()
 
     const sound = new THREE.PositionalAudio(this.audioListener!)
@@ -35,7 +35,7 @@ export class ThreeJsSound implements SoundSystem {
 
     const audioLoader = new THREE.AudioLoader()
     const start = Date.now()
-    void audioLoader.loadAsync(path).then((buffer) => {
+    void audioLoader.loadAsync(path).then(buffer => {
       if (Date.now() - start > timeout) {
         console.warn('Ignored playing sound', path, 'due to timeout:', timeout, 'ms <', Date.now() - start, 'ms')
         return

package/src/three/threeJsUtils.ts

@@ -70,17 +70,17 @@ export const loadThreeJsTextureFromBitmap = (image: ImageBitmap) => {
 }
 
 /** Worker-safe sync handle; image loads via fetch + OffscreenCanvas (not TextureLoader). */
-export function loadNearestFilterTexture (imageUrl: string): THREE.Texture {
+export function loadNearestFilterTexture(imageUrl: string): THREE.Texture {
   const { texture, promise } = loadThreeJsTextureFromUrlSync(imageUrl)
   texture.magFilter = THREE.NearestFilter
   texture.minFilter = THREE.NearestFilter
-  void promise.catch((err) => {
+  void promise.catch(err => {
     console.error('[texture] failed to load', imageUrl, err)
   })
   return texture
 }
 
-export async function loadTexture (texture: string, cb: (texture: THREE.Texture) => void, onLoad?: () => void): Promise<void> {
+export async function loadTexture(texture: string, cb: (texture: THREE.Texture) => void, onLoad?: () => void): Promise<void> {
   const cached = textureCache[texture]
   if (!cached) {
     const { promise, resolve } = Promise.withResolvers<THREE.Texture>()

package/src/three/threeWorker.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 import { augmentWorkerMcData } from '../lib/buildWorkerMcDataIndexes'
 
-globalThis.structuredClone ??= (value) => JSON.parse(JSON.stringify(value))
+globalThis.structuredClone ??= value => JSON.parse(JSON.stringify(value))
 
 const applyWorkerMcData = (raw: Record<string, unknown>) => {
   augmentWorkerMcData(raw)
@@ -23,7 +23,7 @@ self.addEventListener('message', (event: MessageEvent) => {
 
   if (Array.isArray(data)) {
     // eslint-disable-next-line unicorn/no-array-for-each
-    data.forEach((msg) => {
+    data.forEach(msg => {
       if (msg.type === 'mcData') {
         applyWorkerMcData(msg.mcData)
       }

package/src/three/waypointSprite.ts

@@ -21,19 +21,19 @@ export const WAYPOINT_CONFIG = {
   LAYOUT: {
     DOT_Y: 0.3,
     NAME_Y: 0.45,
-    DISTANCE_Y: 0.55,
+    DISTANCE_Y: 0.55
   },
   // Multiplier for canvas internal resolution to keep text crisp
   CANVAS_SCALE: 2,
   ARROW: {
     enabledDefault: false,
     pixelSize: 50,
-    paddingPx: 50,
+    paddingPx: 50
   },
   // Default visual scale factor (can be overridden globally or per-waypoint)
   DEFAULT_VISUAL_SCALE: 1,
   // Default opacity (can be overridden globally or per-waypoint)
-  DEFAULT_OPACITY: 1,
+  DEFAULT_OPACITY: 1
 }
 
 export type WaypointSprite = {
@@ -43,12 +43,7 @@ export type WaypointSprite = {
   enableOffscreenArrow: (enabled: boolean) => void
   setArrowParent: (parent: THREE.Object3D | null) => void
   // Convenience combined updater
-  updateForCamera: (
-    cameraPosition: THREE.Vector3,
-    camera: THREE.PerspectiveCamera,
-    viewportWidthPx: number,
-    viewportHeightPx: number
-  ) => boolean
+  updateForCamera: (cameraPosition: THREE.Vector3, camera: THREE.PerspectiveCamera, viewportWidthPx: number, viewportHeightPx: number) => boolean
   // Utilities
   setColor: (color: number) => void
   setLabel: (label?: string) => void
@@ -58,33 +53,35 @@ export type WaypointSprite = {
   dispose: () => void
 }
 
-export function createWaypointSprite (options: {
-  position: THREE.Vector3 | { x: number, y: number, z: number },
-  color?: number,
-  label?: string,
-  depthTest?: boolean,
+export function createWaypointSprite(options: {
+  position: THREE.Vector3 | { x: number; y: number; z: number }
+  color?: number
+  label?: string
+  depthTest?: boolean
   // Y offset in world units used by updateScaleWorld only (screen-pixel API ignores this)
-  labelYOffset?: number,
-  metadata?: any,
-  visualScale?: number,
-  opacity?: number,
+  labelYOffset?: number
+  metadata?: any
+  visualScale?: number
+  opacity?: number
 }): WaypointSprite {
-  let displayColor = options.color ?? 0xFF_00_00
+  let displayColor = options.color ?? 0xff_00_00
   const depthTest = options.depthTest ?? false
 
   // Get visual scale from options, metadata, server metadata, or default
   // Priority: options.visualScale > metadata.visualScale > window.serverMetadata?.waypointVisualScale > DEFAULT
-  const visualScale = options.visualScale
-    ?? options.metadata?.visualScale
-    ?? (typeof window === 'undefined' ? undefined : (window as any).serverMetadata?.waypointVisualScale)
-    ?? WAYPOINT_CONFIG.DEFAULT_VISUAL_SCALE
+  const visualScale =
+    options.visualScale ??
+    options.metadata?.visualScale ??
+    (typeof window === 'undefined' ? undefined : (window as any).serverMetadata?.waypointVisualScale) ??
+    WAYPOINT_CONFIG.DEFAULT_VISUAL_SCALE
 
   // Get opacity from options, metadata, server metadata, or default
   // Priority: options.opacity > metadata.opacity > window.serverMetadata?.waypointOpacity > DEFAULT
-  const opacity = options.opacity
-    ?? options.metadata?.opacity
-    ?? (typeof window === 'undefined' ? undefined : (window as any).serverMetadata?.waypointOpacity)
-    ?? WAYPOINT_CONFIG.DEFAULT_OPACITY
+  const opacity =
+    options.opacity ??
+    options.metadata?.opacity ??
+    (typeof window === 'undefined' ? undefined : (window as any).serverMetadata?.waypointOpacity) ??
+    WAYPOINT_CONFIG.DEFAULT_OPACITY
 
   const labelCanvas = createCanvas(getLabelCanvasSize(), getLabelCanvasSize())
   drawCombinedOntoCanvas(labelCanvas, displayColor, options.label ?? '', '0m', visualScale)
@@ -98,7 +95,7 @@ export function createWaypointSprite (options: {
     transparent: true,
     opacity: 1,
     depthTest,
-    depthWrite: false,
+    depthWrite: false
   })
   const sprite = new THREE.Sprite(material)
   sprite.position.set(0, 0, 0)
@@ -122,11 +119,11 @@ export function createWaypointSprite (options: {
   const { x, y, z } = options.position
   group.position.set(x, y, z)
 
-  function refreshLabelTexture () {
+  function refreshLabelTexture() {
     labelTexture.needsUpdate = true
   }
 
-  function paintArrowOnCanvas () {
+  function paintArrowOnCanvas() {
     if (!arrowCanvas || !arrowCtx) return
     const size = arrowCanvas.width
     arrowCtx.clearRect(0, 0, size, size)
@@ -144,7 +141,7 @@ export function createWaypointSprite (options: {
     if (arrowTexture) arrowTexture.needsUpdate = true
   }
 
-  function setColor (newColor: number) {
+  function setColor(newColor: number) {
     displayColor = newColor
     lastDistanceText = '0m'
     lastDistanceBucket = 0
@@ -153,13 +150,13 @@ export function createWaypointSprite (options: {
     if (arrowSprite) paintArrowOnCanvas()
   }
 
-  function setLabel (newLabel?: string) {
+  function setLabel(newLabel?: string) {
     currentLabel = newLabel ?? ''
     drawCombinedOntoCanvas(labelCanvas, displayColor, currentLabel, lastDistanceText, visualScale)
     refreshLabelTexture()
   }
 
-  function updateDistanceText (label: string, distanceText: string) {
+  function updateDistanceText(label: string, distanceText: string) {
     if (distanceText === lastDistanceText) {
       return
     }
@@ -169,27 +166,22 @@ export function createWaypointSprite (options: {
     refreshLabelTexture()
   }
 
-  function setVisible (visible: boolean) {
+  function setVisible(visible: boolean) {
     sprite.visible = visible
   }
 
-  function setPosition (nx: number, ny: number, nz: number) {
+  function setPosition(nx: number, ny: number, nz: number) {
     group.position.set(nx, ny, nz)
   }
 
-  function updateScaleScreenPixels (
-    cameraPosition: THREE.Vector3,
-    cameraFov: number,
-    distance: number,
-    viewportHeightPx: number
-  ) {
-    const vFovRad = cameraFov * Math.PI / 180
+  function updateScaleScreenPixels(cameraPosition: THREE.Vector3, cameraFov: number, distance: number, viewportHeightPx: number) {
+    const vFovRad = (cameraFov * Math.PI) / 180
     const worldUnitsPerScreenHeightAtDist = Math.tan(vFovRad / 2) * 2 * distance
-    const scale = worldUnitsPerScreenHeightAtDist * (WAYPOINT_CONFIG.TARGET_SCREEN_PX * visualScale / viewportHeightPx)
+    const scale = worldUnitsPerScreenHeightAtDist * ((WAYPOINT_CONFIG.TARGET_SCREEN_PX * visualScale) / viewportHeightPx)
     sprite.scale.set(scale, scale, 1)
   }
 
-  function ensureArrow () {
+  function ensureArrow() {
     if (arrowSprite) return
     const size = 128
     arrowCanvas = createCanvas(size, size)
@@ -206,22 +198,18 @@ export function createWaypointSprite (options: {
     if (arrowParent) arrowParent.add(arrowSprite)
   }
 
-  function enableOffscreenArrow (enabled: boolean) {
+  function enableOffscreenArrow(enabled: boolean) {
     arrowEnabled = enabled
     if (!enabled && arrowSprite) arrowSprite.visible = false
   }
 
-  function setArrowParent (parent: THREE.Object3D | null) {
+  function setArrowParent(parent: THREE.Object3D | null) {
     if (arrowSprite?.parent) arrowSprite.parent.remove(arrowSprite)
     arrowParent = parent
     if (arrowSprite && parent) parent.add(arrowSprite)
   }
 
-  function updateOffscreenArrow (
-    camera: THREE.PerspectiveCamera,
-    viewportWidthPx: number,
-    viewportHeightPx: number
-  ): boolean {
+  function updateOffscreenArrow(camera: THREE.PerspectiveCamera, viewportWidthPx: number, viewportHeightPx: number): boolean {
     if (!arrowEnabled) return true
     ensureArrow()
     if (!arrowSprite) return true
@@ -246,7 +234,7 @@ export function createWaypointSprite (options: {
     const y = toWp.dot(upCam)
 
     const aspect = viewportWidthPx / viewportHeightPx
-    const vFovRad = camera.fov * Math.PI / 180
+    const vFovRad = (camera.fov * Math.PI) / 180
     const hFovRad = 2 * Math.atan(Math.tan(vFovRad / 2) * aspect)
 
     // Determine if waypoint is inside view frustum using angular checks
@@ -294,8 +282,8 @@ export function createWaypointSprite (options: {
 
     // Apply padding in pixel space by clamping
     const padding = WAYPOINT_CONFIG.ARROW.paddingPx
-    const pxX = ((ndcX + 1) * 0.5) * viewportWidthPx
-    const pxY = ((1 - ndcY) * 0.5) * viewportHeightPx
+    const pxX = (ndcX + 1) * 0.5 * viewportWidthPx
+    const pxY = (1 - ndcY) * 0.5 * viewportHeightPx
     const clampedPxX = Math.min(Math.max(pxX, padding), viewportWidthPx - padding)
     const clampedPxY = Math.min(Math.max(pxY, padding), viewportHeightPx - padding)
     ndcX = (clampedPxX / viewportWidthPx) * 2 - 1
@@ -305,7 +293,8 @@ export function createWaypointSprite (options: {
     const placeDist = Math.max(2, camera.near * 4)
     const halfPlaneHeight = Math.tan(vFovRad / 2) * placeDist
     const halfPlaneWidth = halfPlaneHeight * aspect
-    const pos = camPos.clone()
+    const pos = camPos
+      .clone()
       .add(forward.clone().multiplyScalar(placeDist))
       .add(right.clone().multiplyScalar(ndcX * halfPlaneWidth))
       .add(upCam.clone().multiplyScalar(ndcY * halfPlaneHeight))
@@ -320,21 +309,16 @@ export function createWaypointSprite (options: {
 
     // Constant pixel size for arrow (use fixed placement distance) with visual scale
     const worldUnitsPerScreenHeightAtDist = Math.tan(vFovRad / 2) * 2 * placeDist
-    const sPx = worldUnitsPerScreenHeightAtDist * (WAYPOINT_CONFIG.ARROW.pixelSize * visualScale / viewportHeightPx)
+    const sPx = worldUnitsPerScreenHeightAtDist * ((WAYPOINT_CONFIG.ARROW.pixelSize * visualScale) / viewportHeightPx)
     arrowSprite.scale.set(sPx, sPx, 1)
     return false
   }
 
-  function computeDistance (cameraPosition: THREE.Vector3): number {
+  function computeDistance(cameraPosition: THREE.Vector3): number {
     return cameraPosition.distanceTo(group.position)
   }
 
-  function updateForCamera (
-    cameraPosition: THREE.Vector3,
-    camera: THREE.PerspectiveCamera,
-    viewportWidthPx: number,
-    viewportHeightPx: number
-  ): boolean {
+  function updateForCamera(cameraPosition: THREE.Vector3, camera: THREE.PerspectiveCamera, viewportWidthPx: number, viewportHeightPx: number): boolean {
     const distance = computeDistance(cameraPosition)
     updateScaleScreenPixels(cameraPosition, camera.fov, distance, viewportHeightPx)
 
@@ -349,7 +333,7 @@ export function createWaypointSprite (options: {
     return onScreen
   }
 
-  function dispose () {
+  function dispose() {
     const mat = sprite.material
     mat.map?.dispose()
     mat.dispose()
@@ -378,28 +362,22 @@ export function createWaypointSprite (options: {
     updateDistanceText,
     setVisible,
     setPosition,
-    dispose,
+    dispose
   }
 }
 
 // Internal helpers
-function computeLabelCanvasLineScale (): number {
+function computeLabelCanvasLineScale(): number {
   const dpr = globalThis.devicePixelRatio || 1
   const effectiveDpr = Math.min(dpr, LABEL_CANVAS_MAX_DEVICE_PIXEL_RATIO)
   return WAYPOINT_CONFIG.CANVAS_SCALE * effectiveDpr
 }
 
-function getLabelCanvasSize (): number {
+function getLabelCanvasSize(): number {
   return Math.round(WAYPOINT_CONFIG.CANVAS_SIZE * computeLabelCanvasLineScale())
 }
 
-function drawCombinedOntoCanvas (
-  canvas: OffscreenCanvas,
-  color: number,
-  id: string,
-  distance: string,
-  visualScale: number
-): void {
+function drawCombinedOntoCanvas(canvas: OffscreenCanvas, color: number, id: string, distance: string, visualScale: number): void {
   const size = canvas.width
   const scale = computeLabelCanvasLineScale()
   const ctx = canvas.getContext('2d')!
@@ -443,17 +421,12 @@ function drawCombinedOntoCanvas (
 
 export const WaypointHelpers = {
   // World-scale constant size helper
-  computeWorldScale (distance: number, fixedReference = 10) {
+  computeWorldScale(distance: number, fixedReference = 10) {
     return Math.max(0.0001, distance / fixedReference)
   },
   // Screen-pixel constant size helper
-  computeScreenPixelScale (
-    camera: THREE.PerspectiveCamera,
-    distance: number,
-    pixelSize: number,
-    viewportHeightPx: number
-  ) {
-    const vFovRad = camera.fov * Math.PI / 180
+  computeScreenPixelScale(camera: THREE.PerspectiveCamera, distance: number, pixelSize: number, viewportHeightPx: number) {
+    const vFovRad = (camera.fov * Math.PI) / 180
     const worldUnitsPerScreenHeightAtDist = Math.tan(vFovRad / 2) * 2 * distance
     return worldUnitsPerScreenHeightAtDist * (pixelSize / viewportHeightPx)
   }

package/src/three/waypoints.ts

@@ -32,9 +32,7 @@ export class WaypointsRenderer {
   private lastUpdateTime = 0
   private readonly UPDATE_THROTTLE_MS = 16 // ~60fps max update rate
 
-  constructor(
-    private readonly worldRenderer: WorldRendererThree
-  ) {
+  constructor(private readonly worldRenderer: WorldRendererThree) {
     if (process.env.NODE_ENV !== 'production') {
       // this.addWaypoint('spawn', 0, 0, 0, { })
     }
@@ -60,8 +58,7 @@ export class WaypointsRenderer {
     for (const waypoint of this.waypoints.values()) {
       const waypointPos = new THREE.Vector3(waypoint.x, waypoint.y, waypoint.z)
       const distance = playerPos.distanceTo(waypointPos)
-      const visible = (!waypoint.minDistance || distance >= waypoint.minDistance) &&
-        (waypoint.maxDistance === Infinity || distance <= waypoint.maxDistance)
+      const visible = (!waypoint.minDistance || distance >= waypoint.minDistance) && (waypoint.maxDistance === Infinity || distance <= waypoint.maxDistance)
 
       waypoint.sprite.setVisible(visible)
 
@@ -90,17 +87,11 @@ export class WaypointsRenderer {
 
   // Removed sprite/label texture creation. Use utils/waypointSprite.ts
 
-  addWaypoint(
-    id: string,
-    x: number,
-    y: number,
-    z: number,
-    options: WaypointOptions = {}
-  ) {
+  addWaypoint(id: string, x: number, y: number, z: number, options: WaypointOptions = {}) {
     // Remove existing waypoint if it exists
     this.removeWaypoint(id)
 
-    const color = options.color ?? 0xFF_00_00
+    const color = options.color ?? 0xff_00_00
     const { label, metadata } = options
     const minDistance = options.minDistance ?? 0
     const maxDistance = options.maxDistance ?? Infinity
@@ -108,8 +99,8 @@ export class WaypointsRenderer {
     const sprite = createWaypointSprite({
       position: new THREE.Vector3(x, y, z),
       color,
-      label: (label || id),
-      metadata,
+      label: label || id,
+      metadata
     })
     sprite.enableOffscreenArrow(true)
     sprite.setArrowParent(this.waypointScene)
@@ -117,9 +108,15 @@ export class WaypointsRenderer {
     this.waypointScene.add(sprite.group)
 
     this.waypoints.set(id, {
-      id, x: x + 0.5, y: y + 0.5, z: z + 0.5, minDistance, maxDistance,
-      color, label,
-      sprite,
+      id,
+      x: x + 0.5,
+      y: y + 0.5,
+      z: z + 0.5,
+      minDistance,
+      maxDistance,
+      color,
+      label,
+      sprite
     })
   }
 
@@ -139,11 +136,11 @@ export class WaypointsRenderer {
   }
 
   testWaypoint() {
-    this.addWaypoint('Test Point', 0, 70, 0, { color: 0x00_FF_00, label: 'Test Point' })
-    this.addWaypoint('Spawn', 0, 64, 0, { color: 0xFF_FF_00, label: 'Spawn' })
-    this.addWaypoint('Far Point', 100, 70, 100, { color: 0x00_00_FF, label: 'Far Point' })
-    this.addWaypoint('Far Point 2', 180, 170, 100, { color: 0x00_00_FF, label: 'Far Point 2' })
-    this.addWaypoint('Far Point 3', 1000, 100, 1000, { color: 0x00_00_FF, label: 'Far Point 3' })
+    this.addWaypoint('Test Point', 0, 70, 0, { color: 0x00_ff_00, label: 'Test Point' })
+    this.addWaypoint('Spawn', 0, 64, 0, { color: 0xff_ff_00, label: 'Spawn' })
+    this.addWaypoint('Far Point', 100, 70, 100, { color: 0x00_00_ff, label: 'Far Point' })
+    this.addWaypoint('Far Point 2', 180, 170, 100, { color: 0x00_00_ff, label: 'Far Point 2' })
+    this.addWaypoint('Far Point 3', 1000, 100, 1000, { color: 0x00_00_ff, label: 'Far Point 3' })
   }
 
   getWaypoint(id: string): Waypoint | undefined {