Revise paste brkout

// Package main implements Brkout - a classic Breakout game for Dreamcast.
// This is a port of the arcade classic using Go and KOS.
// Ported from https://3e8.org/hacks/brkout/
package main

import "kos"

// Screen dimensions
const (
	ScreenWidth  = 640
	ScreenHeight = 480
)

// Playing field configuration
const (
	FieldX      = 10
	FieldY      = 40
	FieldWidth  = 500
	FieldHeight = 420
)

// Brick grid configuration
const (
	BrickColumns = 20
	BrickRows    = 15
	BrickWidth   = 25
	BrickHeight  = 12
)

// Paddle configuration
const (
	PaddleWidth  = 70
	PaddleHeight = 10
	PaddleSpeed  = 6.0
	PaddleY      = FieldHeight - 30
)

// Ball configuration
const (
	BallRadius       = 6
	BallInitialSpeed = 3.0
	BallMaxSpeed     = 7.0
	BallSpeedStep    = 0.5
)

// Input configuration
const (
	JoystickDeadzone    = 15
	JoystickSensitivity = 18.0
)

// Game rules
const (
	InitialLives   = 3
	PointsPerBrick = 10
)

// Audio settings
const (
	SoundVolume = 160
	SoundCenter = 128
)

// Textures loaded from romdisk
var (
	titleTexture *kos.PlxTexture
	fontTexture  *kos.PlxTexture
	fieldTexture *kos.PlxTexture
)

// Sound effects
var (
	clickSound  kos.SfxHandle
	bounceSound kos.SfxHandle
	hitSound    kos.SfxHandle
	loseSound   kos.SfxHandle
	winSound    kos.SfxHandle
)

// Controller state
var (
	currentButtons  uint32
	previousButtons uint32
	joystickX       int32
)

// Game state
var (
	paddleX    float32
	ballX      float32
	ballY      float32
	ballSpeedX float32
	ballSpeedY float32
	bricks     [BrickColumns * BrickRows]int
	bricksLeft int
	lives      int
	score      int
	level      int
)

// Brick color palette
var brickColors []uint32

// ----------------------------------------------------------------------------
// Math helpers
// ----------------------------------------------------------------------------

func abs(x float32) float32 {
	if x < 0 {
		return -x
	}
	return x
}

// ----------------------------------------------------------------------------
// Input handling
// ----------------------------------------------------------------------------

func readController() {
	previousButtons = currentButtons

controller := kos.MapleEnumType(0, kos.MAPLE_FUNC_CONTROLLER)
	if controller == nil {
		currentButtons, joystickX = 0, 0
		return
	}

state := controller.ContState()
	if state == nil {
		currentButtons, joystickX = 0, 0
		return
	}

currentButtons = state.Buttons
	joystickX = state.Joyx
}

func buttonPressed(button uint32) bool {
	wasUp := (previousButtons & button) == 0
	isDown := (currentButtons & button) != 0
	return wasUp && isDown
}

func buttonHeld(button uint32) bool {
	return (currentButtons & button) != 0
}

func getJoystickMovement() float32 {
	if joystickX > -JoystickDeadzone && joystickX < JoystickDeadzone {
		return 0
	}
	return float32(joystickX) / JoystickSensitivity
}

// ----------------------------------------------------------------------------
// Drawing primitives (using Plx library like other examples)
// ----------------------------------------------------------------------------

func drawColoredQuad(x, y, width, height, z float32, color uint32) {
	kos.PlxVertInp(kos.PLX_VERT, x, y+height, z, color)
	kos.PlxVertInp(kos.PLX_VERT, x, y, z, color)
	kos.PlxVertInp(kos.PLX_VERT, x+width, y+height, z, color)
	kos.PlxVertInp(kos.PLX_VERT_EOS, x+width, y, z, color)
}

func drawTexturedQuad(x, y, width, height, z float32, color uint32, u1, v1, u2, v2 float32) {
	kos.PlxVertIfp(kos.PLX_VERT, x, y+height, z, color, u1, v2)
	kos.PlxVertIfp(kos.PLX_VERT, x, y, z, color, u1, v1)
	kos.PlxVertIfp(kos.PLX_VERT, x+width, y+height, z, color, u2, v2)
	kos.PlxVertIfp(kos.PLX_VERT_EOS, x+width, y, z, color, u2, v1)
}

func setupColoredContext(list uint32) {
	kos.PlxCxtInit()
	kos.PlxCxtTexture(nil)
	kos.PlxCxtCulling(kos.PLX_CULL_NONE)
	kos.PlxCxtSend(int32(list))
}

func setupTexturedContext(list uint32, texture *kos.PlxTexture) {
	kos.PlxCxtInit()
	kos.PlxCxtTexture(texture.Ptr())
	kos.PlxCxtCulling(kos.PLX_CULL_NONE)
	kos.PlxCxtSend(int32(list))
}

// ----------------------------------------------------------------------------
// Text rendering (bitmap font from texture)
// ----------------------------------------------------------------------------

const (
	CharWidth  = 12
	CharHeight = 24
	FontSize   = 256.0
)

func drawString(x, y, z float32, color uint32, text string) {
	for i, char := range text {
		if char < 32 {
			continue
		}
		column := int(char) % 16
		row := int(char) / 16
		u1 := float32(column*CharWidth) / FontSize
		v1 := float32(row*CharHeight) / FontSize
		u2 := u1 + CharWidth/FontSize
		v2 := v1 + CharHeight/FontSize
		drawTexturedQuad(x+float32(i*CharWidth), y, CharWidth, CharHeight, z, color, u1, v1, u2, v2)
	}
}

func drawInteger(x, y, z float32, color uint32, value int) {
	if value == 0 {
		drawString(x, y, z, color, "0")
		return
	}

text := ""
	for value > 0 {
		digit := byte(value % 10)
		text = string('0'+digit) + text
		value = value / 10
	}
	drawString(x, y, z, color, text)
}

// ----------------------------------------------------------------------------
// Asset loading
// ----------------------------------------------------------------------------

func loadAssets() {
	kos.PvrInitDefaults()

// Load textures from romdisk
	titleTexture = kos.PlxTxrLoad("/rd/brkout.png", false, 0)
	fontTexture = kos.PlxTxrLoad("/rd/font.png", true, 0)
	fieldTexture = kos.PlxTxrLoad("/rd/field.png", false, 0)

// Load sound effects
	kos.SndStreamInit()
	clickSound = kos.SndSfxLoad("/rd/click.wav")
	bounceSound = kos.SndSfxLoad("/rd/bounce.wav")
	hitSound = kos.SndSfxLoad("/rd/toggled.wav")
	loseSound = kos.SndSfxLoad("/rd/failure.wav")
	winSound = kos.SndSfxLoad("/rd/success.wav")

// Initialize brick color palette (rainbow gradient)
	brickColors = []uint32{
		kos.PlxPackColor(1, 1.0, 0.2, 0.2), // Red
		kos.PlxPackColor(1, 1.0, 0.6, 0.2), // Orange
		kos.PlxPackColor(1, 1.0, 1.0, 0.2), // Yellow
		kos.PlxPackColor(1, 0.2, 1.0, 0.2), // Green
		kos.PlxPackColor(1, 0.2, 1.0, 1.0), // Cyan
		kos.PlxPackColor(1, 0.2, 0.2, 1.0), // Blue
		kos.PlxPackColor(1, 0.8, 0.2, 1.0), // Purple
	}
}

// ----------------------------------------------------------------------------
// Colors (pre-computed for performance)
// ----------------------------------------------------------------------------

func colorWhite() uint32      { return kos.PlxPackColor(1, 1, 1, 1) }
func colorGray() uint32       { return kos.PlxPackColor(1, 0.5, 0.5, 0.5) }
func colorBackground() uint32 { return kos.PlxPackColor(1, 0.05, 0.05, 0.1) }
func colorWall() uint32       { return kos.PlxPackColor(1, 0.4, 0.4, 0.6) }
func colorPaddle() uint32     { return kos.PlxPackColor(1, 0.4, 0.4, 0.7) }
func colorShadow() uint32     { return kos.PlxPackColor(0.7, 0, 0, 0) }
func colorGameOverBg() uint32 { return kos.PlxPackColor(1, 0.1, 0.1, 0.15) }

// ----------------------------------------------------------------------------
// Title Menu
// ----------------------------------------------------------------------------

func showTitleMenu() bool {
	kos.PvrSetBgColor(0, 0, 0)
	selection := 0

for {
		readController()

// Navigate menu
		if buttonPressed(kos.CONT_DPAD_UP) || buttonPressed(kos.CONT_DPAD_DOWN) {
			selection = 1 - selection
			kos.SndSfxPlay(clickSound, SoundVolume, SoundCenter)
		}

// Confirm selection
		if buttonPressed(kos.CONT_A) || buttonPressed(kos.CONT_START) {
			kos.SndSfxPlay(hitSound, SoundVolume, SoundCenter)
			fadeOutMenu(selection)
			return selection == 1 // true = quit
		}

renderTitleMenu(selection, 1.0)
	}
}

func fadeOutMenu(selection int) {
	for frame := 30; frame >= 0; frame-- {
		alpha := float32(frame) / 30.0
		renderTitleMenu(selection, alpha)
	}
}

func renderTitleMenu(selection int, alpha float32) {
	kos.PvrWaitReady()
	kos.PvrSceneBegin()
	kos.PvrListBegin(kos.PVR_LIST_OP_POLY)

// Title screen background
	if titleTexture != nil {
		setupTexturedContext(kos.PVR_LIST_OP_POLY, titleTexture)
		tintColor := kos.PlxPackColor(1, alpha, alpha, alpha)
		drawTexturedQuad(0, 0, ScreenWidth, ScreenHeight, 100, tintColor,
			0, 0, 640.0/1024.0, 480.0/512.0)
	}
	kos.PvrListFinish()

// Menu cursor
	kos.PvrListBegin(kos.PVR_LIST_TR_POLY)
	setupColoredContext(kos.PVR_LIST_TR_POLY)
	cursorColor := kos.PlxPackColor(alpha, 1, 1, 1)
	cursorY := float32(314 + selection*50)
	drawColoredQuad(250, cursorY, 20, 20, 200, cursorColor)
	kos.PvrListFinish()

kos.PvrSceneFinish()
}

// ----------------------------------------------------------------------------
// Game Logic
// ----------------------------------------------------------------------------

func startNewGame() {
	lives = InitialLives
	score = 0
	level = 1
	setupLevel()
}

func setupLevel() {
	// Center paddle
	paddleX = float32(FieldWidth-PaddleWidth) / 2.0
	resetBall()

// Create brick grid (more rows at higher levels)
	rows := 3 + level
	if rows > BrickRows {
		rows = BrickRows
	}

bricksLeft = 0
	colorCount := len(brickColors)

for row := 0; row < BrickRows; row++ {
		for col := 0; col < BrickColumns; col++ {
			index := row*BrickColumns + col
			if row < rows {
				bricks[index] = (row % colorCount) + 1
				bricksLeft++
			} else {
				bricks[index] = 0
			}
		}
	}
}

func resetBall() {
	ballX = paddleX + float32(PaddleWidth)/2.0 - float32(BallRadius)
	ballY = float32(FieldHeight) - 50.0

speed := BallInitialSpeed + float32(level)*BallSpeedStep
	if speed > BallMaxSpeed {
		speed = BallMaxSpeed
	}
	ballSpeedX = speed * 0.6
	ballSpeedY = -speed
}

func runGameLoop() {
	kos.PvrSetBgColor(0.05, 0.05, 0.1)
	startNewGame()

for lives > 0 {
		readController()

// Exit to menu on START+B
		if buttonHeld(kos.CONT_START) && buttonHeld(kos.CONT_B) {
			return
		}

updatePaddle()
		updateBall()
		renderGameFrame()
	}
}

func updatePaddle() {
	// D-pad movement
	if buttonHeld(kos.CONT_DPAD_LEFT) {
		paddleX -= PaddleSpeed
	}
	if buttonHeld(kos.CONT_DPAD_RIGHT) {
		paddleX += PaddleSpeed
	}

// Analog stick movement
	paddleX += getJoystickMovement()

// Clamp to field bounds
	if paddleX < 0 {
		paddleX = 0
	}
	maxX := float32(FieldWidth - PaddleWidth)
	if paddleX > maxX {
		paddleX = maxX
	}
}

func updateBall() {
	ballX += ballSpeedX
	ballY += ballSpeedY

handleWallCollisions()
	handlePaddleCollision()
	handleBrickCollisions()
	handleBallLost()
	handleLevelComplete()
}

func handleWallCollisions() {
	// Left wall
	if ballX < 0 {
		ballX = 0
		ballSpeedX = -ballSpeedX
		kos.SndSfxPlay(bounceSound, 140, 64)
	}

// Right wall
	maxX := float32(FieldWidth - BallRadius*2)
	if ballX > maxX {
		ballX = maxX
		ballSpeedX = -ballSpeedX
		kos.SndSfxPlay(bounceSound, 140, 192)
	}

// Top wall
	if ballY < 0 {
		ballY = 0
		ballSpeedY = -ballSpeedY
		kos.SndSfxPlay(bounceSound, 140, SoundCenter)
	}
}

func handlePaddleCollision() {
	paddleTop := float32(PaddleY)
	ballBottom := ballY + float32(BallRadius*2)
	ballCenterX := ballX + float32(BallRadius)

// Check if ball is at paddle height
	if ballBottom < paddleTop || ballY >= paddleTop+float32(PaddleHeight) {
		return
	}

// Check if ball is horizontally aligned with paddle
	if ballCenterX < paddleX || ballCenterX >= paddleX+float32(PaddleWidth) {
		return
	}

// Bounce off paddle
	ballY = paddleTop - float32(BallRadius*2)
	ballSpeedY = -abs(ballSpeedY)

// Adjust horizontal speed based on hit position
	hitPosition := (ballCenterX - paddleX) / float32(PaddleWidth)
	ballSpeedX = (hitPosition - 0.5) * 8.0

kos.SndSfxPlay(bounceSound, SoundVolume, SoundCenter)
}

func handleBrickCollisions() {
	ballCenterX := ballX + float32(BallRadius)
	ballCenterY := ballY + float32(BallRadius)

// Convert ball position to brick grid coordinates
	brickCol := int(ballCenterX) / BrickWidth
	brickRow := int(ballCenterY) / BrickHeight

// Check bounds
	if brickCol < 0 || brickCol >= BrickColumns || brickRow < 0 || brickRow >= BrickRows {
		return
	}

index := brickRow*BrickColumns + brickCol
	if bricks[index] == 0 {
		return
	}

// Destroy brick
	bricks[index] = 0
	bricksLeft--
	score += PointsPerBrick * level

// Determine bounce direction
	brickCenterX := float32(brickCol*BrickWidth) + float32(BrickWidth)/2.0
	brickCenterY := float32(brickRow*BrickHeight) + float32(BrickHeight)/2.0

horizontalOverlap := abs(ballCenterX-brickCenterX) / float32(BrickWidth)
	verticalOverlap := abs(ballCenterY-brickCenterY) / float32(BrickHeight)

if horizontalOverlap > verticalOverlap {
		ballSpeedX = -ballSpeedX
	} else {
		ballSpeedY = -ballSpeedY
	}

kos.SndSfxPlay(hitSound, 150, SoundCenter)
}

func handleBallLost() {
	if ballY <= float32(FieldHeight) {
		return
	}

lives--
	kos.SndSfxPlay(loseSound, SoundVolume, SoundCenter)

if lives <= 0 {
		showGameOver()
		return
	}

resetBall()
	pauseFrames(60)
}

func handleLevelComplete() {
	if bricksLeft > 0 {
		return
	}

kos.SndSfxPlay(winSound, SoundVolume, SoundCenter)
	level++
	setupLevel()
	pauseFrames(60)
}

func pauseFrames(count int) {
	for i := 0; i < count; i++ {
		renderGameFrame()
	}
}

// ----------------------------------------------------------------------------
// Game Over Screen
// ----------------------------------------------------------------------------

func showGameOver() {
	for frame := 0; frame < 180; frame++ {
		kos.PvrWaitReady()
		kos.PvrSceneBegin()

// Background
		kos.PvrListBegin(kos.PVR_LIST_OP_POLY)
		setupColoredContext(kos.PVR_LIST_OP_POLY)
		drawColoredQuad(0, 0, ScreenWidth, ScreenHeight, 1, colorGameOverBg())
		kos.PvrListFinish()

// Text
		kos.PvrListBegin(kos.PVR_LIST_TR_POLY)
		if fontTexture != nil {
			setupTexturedContext(kos.PVR_LIST_TR_POLY, fontTexture)
			drawString(220, 180, 100, colorWhite(), "GAME OVER")
			drawString(220, 230, 100, colorGray(), "Score:")
			drawInteger(320, 230, 100, colorWhite(), score)
		}
		kos.PvrListFinish()

kos.PvrSceneFinish()

readController()
		if buttonPressed(kos.CONT_A) {
			return
		}
	}
}

// ----------------------------------------------------------------------------
// Game Rendering
// ----------------------------------------------------------------------------

func renderGameFrame() {
	kos.PvrWaitReady()
	kos.PvrSceneBegin()

// Opaque geometry
	kos.PvrListBegin(kos.PVR_LIST_OP_POLY)
	renderBackground()
	renderField()
	renderWalls()
	renderBricks()
	renderPaddle()
	renderBall()
	kos.PvrListFinish()

// Translucent geometry (HUD text)
	kos.PvrListBegin(kos.PVR_LIST_TR_POLY)
	renderHUD()
	kos.PvrListFinish()

kos.PvrSceneFinish()
}

func renderBackground() {
	setupColoredContext(kos.PVR_LIST_OP_POLY)
	drawColoredQuad(0, 0, ScreenWidth, ScreenHeight, 1, colorBackground())
}

func renderField() {
	if fieldTexture == nil {
		return
	}
	setupTexturedContext(kos.PVR_LIST_OP_POLY, fieldTexture)
	drawTexturedQuad(FieldX, FieldY, FieldWidth, FieldHeight, 50, colorWhite(),
		0, 0, float32(FieldWidth)/512.0, float32(FieldHeight)/512.0)
}

func renderWalls() {
	setupColoredContext(kos.PVR_LIST_OP_POLY)
	wall := colorWall()
	drawColoredQuad(FieldX-5, FieldY, 5, FieldHeight, 100, wall)          // Left
	drawColoredQuad(FieldX+FieldWidth, FieldY, 5, FieldHeight, 100, wall) // Right
	drawColoredQuad(FieldX-5, FieldY-5, FieldWidth+10, 5, 100, wall)      // Top
}

func renderBricks() {
	shadow := colorShadow()
	colorCount := len(brickColors)

for row := 0; row < BrickRows; row++ {
		for col := 0; col < BrickColumns; col++ {
			colorIndex := bricks[row*BrickColumns+col]
			if colorIndex == 0 {
				continue
			}

x := float32(FieldX + col*BrickWidth)
			y := float32(FieldY + row*BrickHeight)

// Shadow
			drawColoredQuad(x+2, y+2, BrickWidth-2, BrickHeight-2, 99, shadow)
			// Brick
			drawColoredQuad(x, y, BrickWidth-2, BrickHeight-2, 100,
				brickColors[(colorIndex-1)%colorCount])
		}
	}
}

func renderPaddle() {
	x := float32(FieldX) + paddleX
	y := float32(FieldY + PaddleY)

drawColoredQuad(x+3, y+3, PaddleWidth, PaddleHeight, 99, colorShadow())
	drawColoredQuad(x, y, PaddleWidth, PaddleHeight, 100, colorPaddle())
}

func renderBall() {
	x := float32(FieldX) + ballX
	y := float32(FieldY) + ballY
	drawColoredQuad(x, y, BallRadius*2, BallRadius*2, 100, colorWhite())
}

func renderHUD() {
	if fontTexture == nil {
		return
	}

setupTexturedContext(kos.PVR_LIST_TR_POLY, fontTexture)

hudX := float32(FieldX + FieldWidth + 15)
	white := colorWhite()
	gray := colorGray()

drawString(hudX, 50, 200, white, "BRKOUT")

drawString(hudX, 100, 200, gray, "Level")
	drawInteger(hudX, 125, 200, white, level)

drawString(hudX, 170, 200, gray, "Score")
	drawInteger(hudX, 195, 200, white, score)

drawString(hudX, 250, 200, gray, "Lives")
	drawInteger(hudX, 275, 200, white, lives)
}

// ----------------------------------------------------------------------------
// Main Entry Point
// ----------------------------------------------------------------------------

func main() {
	loadAssets()

for {
		if showTitleMenu() {
			return // User selected Quit
		}
		runGameLoop()
	}
}