components

func RegisterMultiplayerHost()

{
	initial := multiplayerState{Players: make(map[string]multiplayerPlayer)}
	srv := netcode.NewServer(multiplayerChannel, initial, applyMultiplayerCommand)
	host.Register(srv.HostComponent())

	ticker := time.NewTicker(multiplayerTick)
	go func() {
		defer ticker.Stop()
		var tick int64
		for range ticker.C {
			tick += int64(multiplayerTick / time.Millisecond)
			srv.Update(func(state *multiplayerState) {
				stepMultiplayer(state, multiplayerTick.Seconds())
			})
			srv.Broadcast(tick)
		}
	}()
}

func applyMultiplayerCommand(state *multiplayerState, cmd any)

{
	payload, ok := cmd.(map[string]any)
	if !ok {
		return
	}
	session, _ := payload["session"].(string)
	if session == "" {
		return
	}
	if state.Players == nil {
		state.Players = make(map[string]multiplayerPlayer)
	}

	action, _ := payload["type"].(string)
	switch action {
	case "join":
		ensurePlayer(state, session)
		state.Winner = ""
		return
	}

	player := ensurePlayer(state, session)
	if !player.Alive {
		state.Players[session] = player
		return
	}

	dx := floatFrom(payload["dx"])
	dy := floatFrom(payload["dy"])
	mag := math.Hypot(dx, dy)
	if mag > 1 {
		dx /= mag
		dy /= mag
		mag = 1
	}
	player.VX = dx * playerSpeed
	player.VY = dy * playerSpeed

	aimX := floatFrom(payload["aimX"])
	aimY := floatFrom(payload["aimY"])
	if aimLen := math.Hypot(aimX, aimY); aimLen > 0 {
		player.AimX = aimX / aimLen
		player.AimY = aimY / aimLen
	} else if mag > 0 {
		norm := math.Hypot(dx, dy)
		if norm > 0 {
			player.AimX = dx / norm
			player.AimY = dy / norm
		}
	}

	shoot := boolFrom(payload["shoot"])
	if shoot && player.Cooldown <= 0 && player.Alive {
		ax, ay := player.AimX, player.AimY
		if math.Hypot(ax, ay) == 0 {
			ax, ay = 0, -1
			player.AimX, player.AimY = ax, ay
		}
		bullet := multiplayerBullet{
			X:     player.X + ax*(playerRadius+bulletRadius),
			Y:     player.Y + ay*(playerRadius+bulletRadius),
			VX:    ax * bulletSpeed,
			VY:    ay * bulletSpeed,
			Owner: session,
		}
		state.Bullets = append(state.Bullets, bullet)
		player.Cooldown = shootCooldownSeconds
	}

	state.Players[session] = player
}

func stepMultiplayer(state *multiplayerState, dt float64)

{
	if state.Players == nil {
		state.Players = make(map[string]multiplayerPlayer)
	}

	for id, player := range state.Players {
		if player.Cooldown > 0 {
			player.Cooldown -= dt
			if player.Cooldown < 0 {
				player.Cooldown = 0
			}
		}
		if player.Alive {
			player.X += player.VX * dt
			player.Y += player.VY * dt
			if player.X < playerRadius {
				player.X = playerRadius
			}
			if player.X > arenaWidth-playerRadius {
				player.X = arenaWidth - playerRadius
			}
			if player.Y < playerRadius {
				player.Y = playerRadius
			}
			if player.Y > arenaHeight-playerRadius {
				player.Y = arenaHeight - playerRadius
			}
		}
		state.Players[id] = player
	}

	newBullets := make([]multiplayerBullet, 0, len(state.Bullets))
	for _, bullet := range state.Bullets {
		bullet.X += bullet.VX * dt
		bullet.Y += bullet.VY * dt
		bullet.Life += dt
		if bullet.Life > bulletLifetime {
			continue
		}
		if bullet.X < 0 || bullet.X > arenaWidth || bullet.Y < 0 || bullet.Y > arenaHeight {
			continue
		}

		hit := false
		for id, player := range state.Players {
			if !player.Alive || id == bullet.Owner {
				continue
			}
			if overlaps(bullet.X, bullet.Y, player.X, player.Y, playerRadius+bulletRadius) {
				player.Lives--
				if player.Lives < 0 {
					player.Lives = 0
				}
				if player.Lives <= 0 {
					player.Alive = false
					player.VX, player.VY = 0, 0
				}
				state.Players[id] = player
				hit = true
				break
			}
		}
		if !hit {
			newBullets = append(newBullets, bullet)
		}
	}
	state.Bullets = newBullets

	aliveCount := 0
	lastAlive := ""
	for id, player := range state.Players {
		if player.Alive {
			aliveCount++
			lastAlive = id
		}
	}
	if aliveCount == 1 {
		state.Winner = lastAlive
	} else if aliveCount == 0 {
		state.Winner = ""
	} else {
		state.Winner = ""
	}
}

func ensurePlayer(state *multiplayerState, session string) multiplayerPlayer

{
	if player, ok := state.Players[session]; ok {
		return player
	}
	spawnX := playerRadius + rand.Float64()*(arenaWidth-2*playerRadius)
	spawnY := playerRadius + rand.Float64()*(arenaHeight-2*playerRadius)
	player := multiplayerPlayer{
		ID:    session,
		X:     spawnX,
		Y:     spawnY,
		AimX:  0,
		AimY:  -1,
		Color: pickColor(state),
		Lives: maxLives,
		Alive: true,
	}
	state.Players[session] = player
	return player
}

func pickColor(state *multiplayerState) string

{
	used := make(map[string]bool, len(state.Players))
	for _, player := range state.Players {
		used[player.Color] = true
	}
	for _, color := range colorPalette {
		if !used[color] {
			return color
		}
	}
	return colorPalette[rand.Intn(len(colorPalette))]
}

func floatFrom(v any) float64

{
	switch val := v.(type) {
	case float64:
		return val
	case float32:
		return float64(val)
	case int:
		return float64(val)
	case int64:
		return float64(val)
	}
	return 0
}

func boolFrom(v any) bool

{
	switch val := v.(type) {
	case bool:
		return val
	case float64:
		return val != 0
	case int:
		return val != 0
	}
	return false
}

func RegisterNetcodeHost()

{
	srv := netcode.NewServer("NetcodeHost", ncState{}, func(s *ncState, cmd any) {
		if m, ok := cmd.(map[string]any); ok {
			if dx, ok := m["dx"].(float64); ok {
				s.X += dx
			}
		}
	})
	host.Register(srv.HostComponent())
	go func() {
		ticker := time.NewTicker(50 * time.Millisecond)
		var tick int64
		for range ticker.C {
			tick += 50
			srv.Broadcast(tick)
		}
	}()
}

func RegisterSSCHost()

{
	var counter int
	host.Register(host.NewHostComponent("SSCHost", func(_ map[string]any) any {
		return map[string]any{"value": counter}
	}))
	go func() {
		ticker := time.NewTicker(5 * time.Second)
		for range ticker.C {
			counter++
			host.Broadcast("SSCHost", map[string]any{"value": counter})
		}
	}()
}