Jam

export const Jam: GameBuilder<JamState, JamSettings> = {
  id: "jam",
  init: (world) => ({
    id: "jam",
    netcode: "rollback",
    renderer: "three",
    settings: {
      blockColor: "white",
      showControls: true,
      showCrosshair: true,
      showNametags: true
    },
    state: {
      doubleJumped: []
    },
    systems: [
      JamSystem,
      SpawnSystem({ spawner: Bob, pos: { x: 0, y: 0, z: 3 } }),
      BlockPhysicsSystem("global"),
      BlockPhysicsSystem("local"),
      ThreeCameraSystem({ height: 0.5, distance: 1 }),
      JamBoundsSystem,
      HUDSystem(controls),
      ThreeNametagSystem,
      BlockMeshSystem({ 
        counts: { 
          grass: 4000, 
          leaf: 0, 
          oak: 0, 
          spruce: 0, 
          marble: 4000 
        } 
      }),
      ThreeSystem,
      InventorySystem
    ],
    entities: [
      Crosshair(),
      EscapeMenu(world),
      HtmlChat(),
      HtmlLagText(),
      HtmlFpsText(),
      Sun({ getDayness: () => 0 }),  // Always night
      Sky({ getDayness: () => 0 }),
      HtmlFpsText()
    ]
  })
}

export type JamState = {
  doubleJumped: string[]  // Players who used double jump
}

export type JamSettings = {
  blockColor: BlockColor
  showControls: boolean
  showCrosshair: boolean
  showNametags: boolean
}

const JamSystem = SystemBuilder({
  id: "JamSystem",
  init: (world) => {
    // Load the nightclub map
    world.blocks.loadMap(JamMap)
    world.blocks.coloring = JamMapColoring

    return {
      id: "JamSystem",
      query: [],
      priority: 1
    }
  }
})

const JamBoundsSystem = SystemBuilder({
  id: "JamBoundsSystem",
  init: (world) => ({
    id: "JamBoundsSystem",
    query: ["position"],
    priority: 6,
    onTick: (entities: Entity[]) => {
      const state = world.state<JamState>()

      for (const entity of entities) {
        if (!entity.id.startsWith("jammer-")) continue

        const { position } = entity.components
        if (!position) continue

        // Reset double jump on landing
        if (position.data.standing) {
          state.doubleJumped = state.doubleJumped.filter((id) => id !== entity.id)
        }

        // Respawn if fell off
        if (position.data.z < -8) {
          position.setPosition({ x: 0, y: 0, z: 4 })
          position.setVelocity({ x: 0, y: 0, z: 0 })
        }
      }
    }
  })
})

export const JamDancer = (player: Player): Character => {
  return Character({
    id: `jammer-${player.id}`,
    components: {
      position: Position({
        x: 0, y: 0, z: 3,
        friction: true,
        gravity: 0.003
      }),
      // Dancing animations
      // Rhythm input
      // Music synchronization
    }
  })
}

export const JamMap: XYZ[] = [
  // Dance floor
  // Stage
  // Bar area
  // Walls
  // Lighting positions
]

export const JamMapColoring: Record<string, BlockColor> = {
  // Colorful blocks for nightclub aesthetic
  // Dance floor = bright colors
  // Walls = dark
}

export const HtmlJamMusic = (): Entity => Entity({
  id: "jam-music",
  components: {
    html: HtmlDiv({
      style: {
        position: "fixed",
        bottom: "20px",
        left: "50%",
        transform: "translateX(-50%)",
        padding: "10px",
        backgroundColor: "rgba(0, 0, 0, 0.8)",
        borderRadius: "10px"
      }
    }),
    npc: NPC({
      behavior: (entity, world) => {
        // Music player controls
        // Track selection
        // Volume control
        // Sync with gameplay
      }
    })
  }
})

export const JamAudioStore = {
  tracks: [
    { id: "track1", name: "Dance Beat 1", bpm: 128 },
    { id: "track2", name: "House Mix", bpm: 124 },
    { id: "track3", name: "Electronic Vibe", bpm: 130 }
  ],
  
  currentTrack: null as string | null,
  
  play: (trackId: string) => {
    // Load and play track
    // Update beat tracking
  },
  
  stop: () => {
    // Stop playback
  },
  
  getBeat: () => {
    // Return current beat number
    // For rhythm synchronization
  }
}

export type DanceMove = "idle" | "jump" | "spin" | "slide" | "wave"

export type JamDanceState = {
  currentMove: DanceMove
  beatAccuracy: number     // 0-100%
  combo: number            // Consecutive hits
  score: number            // Total points
}

export const updateDanceState = (state: JamDanceState, input: Input, beat: number) => {
  // Check if input matches beat
  // Update combo
  // Award points
  // Trigger animations
}

Sun({ getDayness: () => 0 })  // Always night
Sky({ getDayness: () => 0 })  // Dark sky

const controls: HUDSystemProps = {
  clusters: [
    {
      label: "move",
      buttons: [["A", "S", "D"], ["W"]]
    },
    {
      label: "jump",
      buttons: [["spacebar"]]
    },
    {
      label: "menu",
      buttons: [["esc"]]
    }
  ]
}

ThreeCameraSystem({ height: 0.5, distance: 1 })

BlockMeshSystem({ 
  counts: { 
    grass: 4000,   // Not used
    leaf: 0,
    oak: 0,
    spruce: 0,
    marble: 4000   // Nightclub blocks
  } 
})

netcode: "rollback"

Sun({ getDayness: () => 0 })  // Always 0 = night
Sky({ getDayness: () => 0 })

export const JamMap: XYZ[] = [
  // Main dance floor (center)
  // Stage area (elevated)
  // Bar/lounge (side)
  // Walls (boundaries)
  // Platforms (multi-level)
]