Android Studio: Build a 2D Side-Scroller

val playerName = "Hero"   // val = cannot be reassigned (prefer this by default)
var health = 100          // var = can change — use only when it actually will

health = 90                  // fine, health is a var
// playerName = "Villain"    // ERROR — playerName is a val

var name: String = "Hero"       // cannot be null — compiler enforces it
var nickname: String? = null   // CAN be null — the ? says so explicitly

// nickname.length          // ERROR — might be null, compiler won't allow direct access
nickname?.length              // safe call — returns null instead of crashing if nickname is null
nickname ?: "no nickname"       // elvis operator — provide a fallback if null

fun takeDamage(amount: Int): Int {
    return health - amount
}

// single-expression shorthand for simple functions
fun isAlive(hp: Int): Boolean = hp > 0

class Player(var x: Float, var y: Float) {
    var health = 100
    fun moveRight(amount: Float) { x += amount }
}

// data class — auto-generates equals(), toString(), copy() — great for simple data holders
data class Vector2(val x: Float, val y: Float)

val player = Player(0f, 0f)
player.moveRight(10f)

val enemies = mutableListOf("Goomba", "Koopa")
enemies.add("Piranha")

for (enemy in enemies) {
    println("Enemy: $enemy")   // string templates with $variable
}

when (health) {                  // Kotlin's switch, but more powerful
    in 0..20  -> println("Critical!")
    in 21..99 -> println("Hurt")
    else       -> println("Full health")
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)  // connects to the XML layout
    }
}

<activity
    android:name=".MainActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Score: 0"
        android:id="@+id/scoreText" />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Game"
        android:id="@+id/startButton" />
</LinearLayout>

class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        binding.startButton.setOnClickListener {
            binding.scoreText.text = "Game Started!"
        }
    }
}

class GameView(context: Context) : View(context) {

    private val playerPaint = Paint().apply {
        color = Color.RED
        style = Paint.Style.FILL
    }

    private var playerX = 100f
    private var playerY = 300f

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        canvas.drawColor(Color.CYAN)  // clear/fill background each frame
        canvas.drawRect(playerX, playerY, playerX + 80f, playerY + 80f, playerPaint)
    }
}

class GameView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {

    private var gameThread: GameThread? = null

    init {
        holder.addCallback(this)
    }

    override fun surfaceCreated(holder: SurfaceHolder) {
        gameThread = GameThread(holder, this)
        gameThread?.running = true
        gameThread?.start()
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {
        gameThread?.running = false
        gameThread?.join()  // wait for the thread to actually finish before continuing
    }

    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {}

    fun update() { // game logic goes here — Module 8+ builds this out }

    fun render(canvas: Canvas) {
        canvas.drawColor(Color.CYAN)
        // draw game objects here — Module 7 covers real sprites
    }
}

class GameThread(
    private val surfaceHolder: SurfaceHolder,
    private val gameView: GameView
) : Thread() {

    var running = false

    override fun run() {
        while (running) {
            val canvas = surfaceHolder.lockCanvas() ?: continue
            try {
                gameView.update()
                gameView.render(canvas)
            } finally {
                surfaceHolder.unlockCanvasAndPost(canvas)  // ALWAYS release the canvas, even if render() throws
            }
        }
    }
}

override fun run() {
    val targetFrameTimeMs = 1000L / 60  // ~16.6ms per frame for 60 FPS
    while (running) {
        val startTime = System.currentTimeMillis()
        val canvas = surfaceHolder.lockCanvas() ?: continue
        try {
            gameView.update()
            gameView.render(canvas)
        } finally {
            surfaceHolder.unlockCanvasAndPost(canvas)
        }
        val frameTime = System.currentTimeMillis() - startTime
        val sleepTime = targetFrameTimeMs - frameTime
        if (sleepTime > 0) sleep(sleepTime)
    }
}

override fun onPause() {
    super.onPause()
    gameView.pause()  // stop the thread — from Module 3, don't let it run invisibly
}

override fun onResume() {
    super.onResume()
    gameView.resume()  // restart it
}

val playerBitmap = BitmapFactory.decodeResource(resources, R.drawable.player)

// in render():
canvas.drawBitmap(playerBitmap, playerX, playerY, null)

val frameWidth = 64
val frameHeight = 64
var currentFrame = 0

fun drawPlayer(canvas: Canvas) {
    val srcRect = Rect(
        currentFrame * frameWidth, 0,
        (currentFrame + 1) * frameWidth, frameHeight
    )
    val dstRect = Rect(
        playerX.toInt(), playerY.toInt(),
        playerX.toInt() + frameWidth, playerY.toInt() + frameHeight
    )
    canvas.drawBitmap(playerSheet, srcRect, dstRect, null)
}

private var frameTimer = 0L
private val frameDurationMs = 120L  // ~8 frames per second walk cycle
private val totalFrames = 4

fun update(deltaTime: Long) {
    frameTimer += deltaTime
    if (frameTimer >= frameDurationMs) {
        frameTimer = 0
        currentFrame = (currentFrame + 1) % totalFrames  // loop back to 0 after the last frame
    }
}

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.action) {
        MotionEvent.ACTION_DOWN -> {
            // finger just touched the screen
            handleJump()
        }
        MotionEvent.ACTION_MOVE -> {
            // finger is dragging — event.x, event.y give current position
        }
        MotionEvent.ACTION_UP -> {
            // finger lifted
        }
    }
    return true  // tells Android you consumed the event
}

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.action) {
        MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE -> {
            if (event.x < width / 2) {
                moveDirection = -1  // left half — move left
            } else {
                moveDirection = 1   // right half — move right
            }
        }
        MotionEvent.ACTION_UP -> moveDirection = 0
    }
    return true
}

private var isJumping = false

fun handleJump() {
    if (!isJumping) {
        velocityY = jumpVelocity  // only apply jump force once per press
        isJumping = true
    }
}
// isJumping is reset to false only once the player lands — Module 9 covers that check

private var velocityY = 0f
private val gravity = 1.5f       // tune this — higher feels "heavier"
private val jumpVelocity = -28f  // negative = upward in screen coordinates

fun update() {
    velocityY += gravity
    playerY += velocityY

    if (playerY >= groundY) {   // hit the ground
        playerY = groundY
        velocityY = 0f
        isJumping = false       // from Module 8 — allows jumping again
    }
}

fun isColliding(a: RectF, b: RectF): Boolean {
    return a.left < b.right &&
           a.right > b.left &&
           a.top < b.bottom &&
           a.bottom > b.top
}

// Android's RectF has this built in:
val colliding = playerRect.intersects(enemyRect.left, enemyRect.top, enemyRect.right, enemyRect.bottom)

fun resolvePlatformCollision(player: RectF, prevPlayerBottom: Float, platform: RectF) {
    if (player.intersects(platform.left, platform.top, platform.right, platform.bottom)) {
        val wasAbove = prevPlayerBottom <= platform.top
        if (wasAbove && velocityY >= 0f) {
            // falling AND was above the platform last frame → land on top
            playerY = platform.top - playerHeight
            velocityY = 0f
            isJumping = false
        }
        // side/bottom collisions handled separately if the game needs them (e.g. head-bump blocks)
    }
}

private var cameraX = 0f

fun update() {
    // keep the camera centered on the player, but never let it go negative
    cameraX = (player.x - screenWidth / 2).coerceAtLeast(0f)
}

fun render(canvas: Canvas) {
    val playerScreenX = player.x - cameraX  // world position minus camera = screen position
    canvas.drawBitmap(playerBitmap, playerScreenX, player.y, null)

    for (enemy in enemies) {
        val enemyScreenX = enemy.x - cameraX
        canvas.drawBitmap(enemyBitmap, enemyScreenX, enemy.y, null)
    }
}

data class ParallaxLayer(val bitmap: Bitmap, val scrollSpeed: Float)

fun renderBackground(canvas: Canvas, layers: List<ParallaxLayer>) {
    for (layer in layers) {
        val offsetX = -(cameraX * layer.scrollSpeed) % layer.bitmap.width
        canvas.drawBitmap(layer.bitmap, offsetX, 0f, null)
        // draw a second copy right after the first, so there's no gap when it wraps
        canvas.drawBitmap(layer.bitmap, offsetX + layer.bitmap.width, 0f, null)
    }
}

// 0 = empty, 1 = ground, 2 = platform
val level = arrayOf(
    intArrayOf(0,0,0,0,2,2,0,0,0,0),
    intArrayOf(0,0,0,0,0,0,0,2,2,0),
    intArrayOf(1,1,1,1,1,1,1,1,1,1)
)
const val TILE_SIZE = 64

fun renderLevel(canvas: Canvas) {
    for (row in level.indices) {
        for (col in level[row].indices) {
            val tile = level[row][col]
            if (tile == 0) continue  // skip empty cells

            val worldX = col * TILE_SIZE
            val screenX = worldX - cameraX  // Module 9's camera pattern

            // skip tiles fully off-screen — cheap and meaningfully faster on big levels
            if (screenX < -TILE_SIZE || screenX > screenWidth) continue

            val bitmap = if (tile == 1) groundBitmap else platformBitmap
            canvas.drawBitmap(bitmap, screenX, (row * TILE_SIZE).toFloat(), null)
        }
    }
}

fun isSolidAt(worldX: Float, worldY: Float): Boolean {
    val col = (worldX / TILE_SIZE).toInt()
    val row = (worldY / TILE_SIZE).toInt()
    if (row !in level.indices || col !in level[0].indices) return false
    return level[row][col] != 0
}

val soundPool = SoundPool.Builder().setMaxStreams(5).build()
val jumpSoundId = soundPool.load(context, R.raw.jump, 1)  // load once, keep the ID

// later, inside handleJump():
soundPool.play(jumpSoundId, 1f, 1f, 0, 0, 1f)
// params: soundId, leftVolume, rightVolume, priority, loop, playbackRate

var musicPlayer: MediaPlayer? = null

fun startMusic() {
    musicPlayer = MediaPlayer.create(context, R.raw.background_music)
    musicPlayer?.isLooping = true
    musicPlayer?.start()
}

fun stopMusic() {
    musicPlayer?.stop()
    musicPlayer?.release()  // always release — it holds real system resources
    musicPlayer = null
}

override fun onPause() {
    super.onPause()
    gameView.pause()
    musicPlayer?.pause()
}

override fun onDestroy() {
    super.onDestroy()
    soundPool.release()
    musicPlayer?.release()
}

enum class GameState { MENU, PLAYING, PAUSED, GAME_OVER }

class GameView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
    private var state = GameState.MENU

    fun update() {
        when (state) {
            GameState.MENU      -> { /* waiting for tap to start */ }
            GameState.PLAYING   -> updateGameplay()
            GameState.PAUSED    -> { /* frozen — no updates */ }
            GameState.GAME_OVER -> { /* waiting for tap to restart */ }
        }
    }

    fun render(canvas: Canvas) {
        when (state) {
            GameState.MENU      -> renderMenu(canvas)
            GameState.PLAYING,
            GameState.PAUSED    -> renderGameplay(canvas)  // paused still shows the frozen world
            GameState.GAME_OVER -> renderGameOver(canvas)
        }
    }
}

private var score = 0

fun onCoinCollected() {
    score += 10
}

// in render(), drawn every frame regardless of camera position — this is UI, not world space
canvas.drawText("Score: $score", 20f, 60f, scoreTextPaint)

fun onPlayerDied() {
    state = GameState.GAME_OVER
}

fun restartGame() {
    player = Player(startX, startY)   // fresh player state
    cameraX = 0f
    score = 0
    enemies.clear()
    enemies.addAll(loadLevelEnemies())
    state = GameState.PLAYING
}

class MainActivity : AppCompatActivity() {
    private lateinit var gameView: GameView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        gameView = GameView(this)
        setContentView(gameView)   // the whole screen IS the game — no XML layout needed here
    }

    override fun onPause() { super.onPause(); gameView.pause() }
    override fun onResume() { super.onResume(); gameView.resume() }
}

enum class GameState { MENU, PLAYING, GAME_OVER }

class GameView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {

    private var thread: GameThread? = null
    private var state = GameState.MENU

    private val player = Player(x = 100f, groundY = 600f)
    private var cameraX = 0f
    private var score = 0

    // level as a tile grid — Module 11. 0=empty, 1=ground, 2=platform
    private val level = arrayOf(
        intArrayOf(0,0,0,2,2,0,0,2,2,2,0,0,0,2,2),
        intArrayOf(1,1,1,1,1,1,0,0,1,1,1,1,1,1,1)  // note the 2-tile gap = a pit
    )
    private val tileSize = 64

    private data class Enemy(var x: Float, val y: Float, var alive: Boolean = true)
    private data class Coin(val x: Float, val y: Float, var collected: Boolean = false)
    private val enemies = mutableListOf(Enemy(700f, 536f), Enemy(1100f, 536f))
    private val coins = mutableListOf(Coin(300f, 450f), Coin(500f, 450f), Coin(900f, 450f))

    init { holder.addCallback(this) }

    override fun surfaceCreated(holder: SurfaceHolder) {
        thread = GameThread(holder, this).apply { running = true; start() }
    }
    override fun surfaceDestroyed(holder: SurfaceHolder) {
        thread?.running = false
        thread?.join()
    }
    override fun surfaceChanged(h: SurfaceHolder, f: Int, w: Int, ht: Int) {}

    fun pause() { thread?.running = false }
    fun resume() { thread?.running = true }
}

class Player(var x: Float, val groundY: Float) {
    var y = groundY
    var velocityY = 0f
    var isJumping = false
    val width = 48f
    val height = 64f
    private val gravity = 1.6f
    private val jumpVelocity = -28f
    val runSpeed = 4f  // auto-runner — always moving right

    fun jump() {
        if (!isJumping) { velocityY = jumpVelocity; isJumping = true }
    }

    fun update() {
        x += runSpeed
        velocityY += gravity
        y += velocityY
        if (y >= groundY) { y = groundY; velocityY = 0f; isJumping = false }
    }

    fun bounds() = RectF(x, y, x + width, y + height)
    fun isFalling() = velocityY > 15f  // used for "fell into a pit" death check
}

class GameThread(private val holder: SurfaceHolder, private val view: GameView) : Thread() {
    var running = false
    override fun run() {
        val targetMs = 1000L / 60
        while (running) {
            val start = System.currentTimeMillis()
            val canvas = holder.lockCanvas() ?: continue
            try { view.update(); view.render(canvas) }
            finally { holder.unlockCanvasAndPost(canvas) }
            val sleepTime = targetMs - (System.currentTimeMillis() - start)
            if (sleepTime > 0) sleep(sleepTime)
        }
    }
}

fun update() {
    if (state != GameState.PLAYING) return

    player.update()
    cameraX = player.x - 200f

    // Module 9 AABB checks against enemies
    val pBounds = player.bounds()
    for (enemy in enemies) {
        if (!enemy.alive) continue
        val eBounds = RectF(enemy.x, enemy.y, enemy.x + 48f, enemy.y + 48f)
        if (pBounds.intersects(eBounds.left, eBounds.top, eBounds.right, eBounds.bottom)) {
            if (player.isFalling() && pBounds.bottom < eBounds.top + 16f) {
                enemy.alive = false  // stomped from above — classic platformer rule
                score += 50
            } else {
                state = GameState.GAME_OVER
            }
        }
    }

    // coin collection
    for (coin in coins) {
        if (coin.collected) continue
        val cBounds = RectF(coin.x, coin.y, coin.x + 24f, coin.y + 24f)
        if (pBounds.intersects(cBounds.left, cBounds.top, cBounds.right, cBounds.bottom)) {
            coin.collected = true
            score += 10
        }
    }

    // fell into a pit — Module 11's grid lookup at the player's feet
    val col = (player.x / tileSize).toInt()
    if (player.y > 700f) state = GameState.GAME_OVER
}

fun render(canvas: Canvas) {
    canvas.drawColor(Color.rgb(135,206,235))  // sky

    when (state) {
        GameState.MENU -> {
            canvas.drawText("TAP TO START", width / 2f - 150f, height / 2f, hudPaint)
        }
        GameState.PLAYING -> {
            renderLevel(canvas)   // Module 11, offset by cameraX (Module 9)
            for (coin in coins) if (!coin.collected)
                canvas.drawCircle(coin.x - cameraX, coin.y, 12f, coinPaint)
            for (enemy in enemies) if (enemy.alive)
                canvas.drawRect(enemy.x - cameraX, enemy.y, enemy.x - cameraX + 48f, enemy.y + 48f, enemyPaint)
            canvas.drawRect(player.x - cameraX, player.y, player.x - cameraX + player.width, player.y + player.height, playerPaint)
            canvas.drawText("Score: $score", 20f, 60f, hudPaint)  // screen space — no camera offset
        }
        GameState.GAME_OVER -> {
            canvas.drawText("GAME OVER — Score: $score", width / 2f - 220f, height / 2f, hudPaint)
            canvas.drawText("Tap to restart", width / 2f - 140f, height / 2f + 60f, hudPaint)
        }
    }
}

override fun onTouchEvent(event: MotionEvent): Boolean {
    if (event.action != MotionEvent.ACTION_DOWN) return true
    when (state) {
        GameState.MENU      -> state = GameState.PLAYING
        GameState.PLAYING   -> player.jump()
        GameState.GAME_OVER -> restartGame()
    }
    return true
}

private fun restartGame() {
    player.x = 100f; player.y = player.groundY; player.velocityY = 0f
    cameraX = 0f; score = 0
    enemies.forEach { it.alive = true }
    coins.forEach { it.collected = false }
    state = GameState.PLAYING
}