Advanced OO & Functional Programming

open class Monster(val name: String)
class FireMonster(name: String) : Monster(name)

fun main() {
    val pyron = FireMonster("Pyron")
    println(pyron.name)
}

Pyron

open class Monster {
    open fun sound(): String = "Monster sound"
    fun category(): String = "Creature" // final by default
}
class FireMonster : Monster() {
    override fun sound(): String = "Roar"
}
fun main() {
    println(FireMonster().sound())
    println(FireMonster().category())
}

Roar
Creature

abstract class Monster(val name: String) {
    abstract val element: String
    fun describe(): String = "$name is $element"
}
class FireMonster(name: String) : Monster(name) {
    override val element = "FIRE"
}
fun main() = println(FireMonster("Pyron").describe())

Pyron is FIRE

open class Monster(val name: String) {
    open fun describe(): String = "Monster: $name"
}
class FireMonster(name: String) : Monster(name) {
    override fun describe(): String = "${super.describe()} (FIRE)"
}
fun main() = println(FireMonster("Pyron").describe())

Monster: Pyron (FIRE)

fun damage(attack: Int): Int = maxOf(1, attack)
fun damage(attack: Int, defense: Int): Int = maxOf(1, attack - defense)

fun main() {
    println(damage(30))
    println(damage(30, 12))
}

30
18

abstract class Monster(val name: String) {
    abstract fun element(): String
}
class FireMonster(name: String) : Monster(name) {
    override fun element() = "FIRE"
}
class WaterMonster(name: String) : Monster(name) {
    override fun element() = "WATER"
}
fun main() {
    val monsters: List<Monster> = listOf(FireMonster("Pyron"), WaterMonster("Aquara"))
    monsters.forEach { println("${it.name}: ${it.element()}") }
}

Pyron: FIRE
Aquara: WATER

open class Monster(val name: String)
class FireMonster(name: String) : Monster(name)

fun announce(monster: Monster) = println("Entering: ${monster.name}")
fun main() = announce(FireMonster("Pyron"))

Entering: Pyron

data class Stats(val attack: Int)
open class Monster(val name: String, val stats: Stats)
class FireMonster(name: String, stats: Stats) : Monster(name, stats)

fun main() {
    val pyron = FireMonster("Pyron", Stats(30))
    println("${pyron.name}: ${pyron.stats.attack} ATK")
}

Pyron: 30 ATK

class DamageCalculator {
    fun calculate(attack: Int, defense: Int) = maxOf(1, attack - defense)
}
class BattleService(private val calculator: DamageCalculator) {
    fun attack() = calculator.calculate(30, 12)
}
fun main() = println(BattleService(DamageCalculator()).attack())

18

interface DamageRule {
    fun calculate(attack: Int, defense: Int): Int
}
class NormalDamage : DamageRule {
    override fun calculate(attack: Int, defense: Int) = maxOf(1, attack - defense)
}
class BattleDamage(rule: DamageRule) : DamageRule by rule

fun main() = println(BattleDamage(NormalDamage()).calculate(30, 12))

18

class Monster(val name: String)
class BattleService {
    fun versus(first: Monster, second: Monster): String =
        "${first.name} vs ${second.name}"
}
fun main() = println(BattleService().versus(Monster("Pyron"), Monster("Aquara")))

Pyron vs Aquara

class Monster(val name: String)
class MonsterTeam(val members: List<Monster>)

fun main() {
    val pyron = Monster("Pyron")
    val team = MonsterTeam(listOf(pyron))
    println(team.members.first().name)
    println(pyron.name) // Exists independently of the team
}

Pyron
Pyron

data class BattleEvent(val text: String)
class BattleResult {
    private val events = mutableListOf<BattleEvent>()
    fun record(text: String) { events += BattleEvent(text) }
    fun log(): List<BattleEvent> = events.toList()
}
fun main() {
    val result = BattleResult()
    result.record("Pyron attacks")
    println(result.log().single().text)
}

Pyron attacks

class DamageCalculator {
    fun normal(attack: Int, defense: Int): Int = maxOf(1, attack - defense)
    fun critical(attack: Int, defense: Int): Int = normal(attack, defense) * 2
}
fun main() = println(DamageCalculator().normal(30, 12))

18

interface DamageCalculator {
    fun calculate(attack: Int, defense: Int): Int
}
class NormalDamage : DamageCalculator {
    override fun calculate(attack: Int, defense: Int) = maxOf(1, attack - defense)
}
class BattleService(private val calculator: DamageCalculator) {
    fun hit() = calculator.calculate(30, 12)
}
fun main() = println(BattleService(NormalDamage()).hit())

18

// Small, focused contract used by battle logic.
fun interface DamageRule {
    fun calculate(attack: Int, defense: Int): Int
}
fun main() {
    val normal = DamageRule { attack, defense -> maxOf(1, attack - defense) }
    println(normal.calculate(30, 12))
}

18

class DamageCalculator {
    fun calculate(attack: Int, defense: Int) = maxOf(1, attack - defense)
}
fun formatHit(name: String, damage: Int) = "$name deals $damage damage"
fun main() {
    val amount = DamageCalculator().calculate(30, 12)
    println(formatHit("Pyron", amount))
}

Pyron deals 18 damage

fun interface DamageRule {
    fun calculate(attack: Int, defense: Int): Int
}
class BattleService(private val rule: DamageRule) {
    fun hit() = rule.calculate(30, 12)
}
fun main() {
    val normal = DamageRule { a, d -> maxOf(1, a - d) }
    println(BattleService(normal).hit())
}

18

abstract class Monster(val name: String) {
    abstract fun isAlive(): Boolean
}
class FireMonster(name: String, private val hp: Int) : Monster(name) {
    override fun isAlive() = hp > 0
}
fun status(monster: Monster) = "${monster.name} alive: ${monster.isAlive()}"
fun main() = println(status(FireMonster("Pyron", 100)))

Pyron alive: true

interface Attacker { fun attackPower(): Int }
interface Damageable { fun takeDamage(amount: Int) }
class FireMonster : Attacker {
    override fun attackPower() = 30
}
fun main() {
    val attacker: Attacker = FireMonster()
    println(attacker.attackPower())
}

30

interface DamageRule { fun hit(): Int }
class NormalDamage : DamageRule { override fun hit() = 18 }
class BattleService(private val rule: DamageRule) {
    fun run() = "Damage: ${rule.hit()}"
}
fun main() = println(BattleService(NormalDamage()).run())

Damage: 18

fun calculateDamage(attack: Int, defense: Int): Int = maxOf(1, attack - defense)
fun main() {
    println(calculateDamage(30, 12))
    println(calculateDamage(25, 10))
}

18
15

fun calculateDamage(attack: Int, defense: Int): Int = maxOf(1, attack - defense)
fun main() {
    println(calculateDamage(30, 12))
    println(calculateDamage(30, 12))
}

18
18

class Monster(var hp: Int) {
    fun takeDamage(amount: Int) { hp = (hp - amount).coerceAtLeast(0) }
}
fun main() {
    val aquara = Monster(110)
    aquara.takeDamage(18) // Changes object state
    println(aquara.hp)
}

92

fun main() {
    val calculate: (Int, Int) -> Int = { attack, defense ->
        maxOf(1, attack - defense)
    }
    println(calculate(30, 12))
}

18

fun main() {
    val hit = { attack: Int, defense: Int -> maxOf(1, attack - defense) }
    println(hit(30, 12))
}

18

fun resolveHit(attack: Int, defense: Int, rule: (Int, Int) -> Int): Int =
    rule(attack, defense)

fun main() {
    println(resolveHit(30, 12) { a, d -> maxOf(1, a - d) })
}

18

fun hit(attack: Int, rule: (Int) -> Int): Int = rule(attack)
fun main() {
    val damage = hit(30) { attack -> attack - 12 }
    println(damage)
}

18

fun main() {
    val attacks = listOf(30, 25, 20)
    val boosted = attacks.map { it + 5 }
    println(boosted)
}

[35, 30, 25]

fun main() {
    val attacks = listOf(30, -1, 25)
    val valid = attacks.map {
        if (it < 0) return@map 0
        it // Last expression becomes the result
    }
    println(valid)
}

[30, 0, 25]

fun calculateDamage(attack: Int, defense: Int) = maxOf(1, attack - defense)
fun resolve(rule: (Int, Int) -> Int) = rule(30, 12)
fun main() = println(resolve(::calculateDamage))

18

class Monster(val name: String, val attack: Int)
fun describe(monster: Monster, block: Monster.() -> String): String = monster.block()
fun main() {
    val pyron = Monster("Pyron", 30)
    println(describe(pyron) { "$name has $attack ATK" })
}

Pyron has 30 ATK

data class BattleResult(val winner: String, val rounds: Int, val remainingHp: Int)
fun main() {
    val result = BattleResult("Pyron", 7, 10)
    println("${result.winner} wins in ${result.rounds} rounds")
    println("Remaining HP: ${result.remainingHp}")
}

Pyron wins in 7 rounds
Remaining HP: 10

data class Stats(val attack: Int, val defense: Int, val speed: Int)
class Monster(val name: String, val stats: Stats, var hp: Int)

class BattleService {
    fun fight(a: Monster, b: Monster): String {
        val first = if (a.stats.speed >= b.stats.speed) a else b
        val second = if (first === a) b else a
        while (a.hp > 0 && b.hp > 0) {
            second.hp = (second.hp - maxOf(1, first.stats.attack - second.stats.defense))
                .coerceAtLeast(0)
            if (second.hp == 0) break
            first.hp = (first.hp - maxOf(1, second.stats.attack - first.stats.defense))
                .coerceAtLeast(0)
        }
        return if (a.hp > 0) a.name else b.name
    }
}
fun main() {
    val pyron = Monster("Pyron", Stats(30, 10, 110), 100)
    val aquara = Monster("Aquara", Stats(25, 12, 95), 110)
    println("Winner: ${BattleService().fight(pyron, aquara)}")
    println("Pyron HP: ${pyron.hp}")
}

Winner: Pyron
Pyron HP: 10

data class BattleEvent(val attacker: String, val damage: Int, val remainingHp: Int)
fun main() {
    val log = mutableListOf<BattleEvent>()
    log += BattleEvent("Pyron", 18, 92)
    log += BattleEvent("Aquara", 15, 85)
    log.forEach { println("${it.attacker}: ${it.damage} damage, target ${it.remainingHp} HP") }
}

Pyron: 18 damage, target 92 HP
Aquara: 15 damage, target 85 HP

import kotlin.test.Test
import kotlin.test.assertEquals

fun calculateDamage(attack: Int, defense: Int) = maxOf(1, attack - defense)

class DamageCalculatorTest {
    @Test
    fun `normal damage uses attack minus defense`() {
        assertEquals(18, calculateDamage(30, 12))
    }

    @Test
    fun `damage is always at least one`() {
        assertEquals(1, calculateDamage(5, 20))
    }
}

Verwacht: 2 geslaagde tests (via ./kotlin test)