#Build Games Where Everyone Has A Part

import Plot from '@plot.game/sdk'

// The host updates Game State; every player can read it.
// Subscribe once; changes, late joins, and reloads stay in sync.
type GameState = { roundEndsAt?: number }
const gameState = Plot.gameState.as<GameState>()
gameState.subscribe((state) => {
  renderGame(state)
})

// Player Data gives each player one object only they can write.
// Every screen can read every object: ideal for choices and scores.
type PlayerData = { ready?: boolean }
const playerData = Plot.playerData.as<PlayerData>()
playerData.subscribe((data) => {
  renderReadiness(data.objects)
})

// Typed channels carry moments happening now.
// Target one player or broadcast; Plot handles delivery and recovery.
type Buzz = { pressedAt: number }
const buzzes = Plot.realtime.channels.channel<Buzz>('round.buzz')
buzzes.subscribe((message) => {
  showBuzz(message.fromPlayerId, message.payload.pressedAt)
})

// One call activates a fully synchronized player.
// Connection and recovery stay inside Plot.
await Plot.ready()

// Party provides full player objects and stable IDs.
// Subscribe once for live presence and profile updates.
const party = Plot.party.get()
const self = party.self
const host = party.host
Plot.party.subscribe((updatedParty) => {
  renderParty(updatedParty.players)
})

// Each player writes only their object; all players see the update.
await playerData.setSelf({ ready: true })

// Plot.time is a synchronized clock with a shared epoch.
// Use it to schedule events, run countdowns, and timestamp actions.
async function startRound() {
  if (self.playerId !== host.playerId) return
  await gameState.set({
    roundEndsAt: Plot.time.now() + 30_000,
  })
}

function buzzIn() {
  buzzes.sendTo(host.playerId, { pressedAt: Plot.time.now() })
}