SPB Git

Repository Public License

DigToCoreTests.swift 28.0 KB 580 lines swift

1// ORIX Arcade2// File: Tests/DigToCoreTests.swift3// Description: Dig to Core logic tests — seeded generation, guaranteed route, collisions, collection, hazards, upgrades, banking, save/load, economy balance and bounded memory.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import XCTest8@testable import ORIXArcade910@MainActor11final class DigToCoreTests: XCTestCase {12    private let centre = Double(DigConfig.cols) / 21314    /// A run whose starting shaft has been replaced by a hand-made layout, for exact rule tests.15    private func sandbox(levels: [String: Int] = [:], rows: Int = 40, fill: DigTile = .ground, _ edits: [(Int, Int, DigTile)] = []) -> DigRun {16        let run = DigRun(seed: 99, stats: DigStats(levels: levels))17        for r in 0..<rows { for c in 0..<DigConfig.cols { run.world.set(col: c, row: r, fill) } }18        for (c, r, tile) in edits { run.world.set(col: c, row: r, tile) }19        return run20    }2122    @discardableResult23    private func advance(_ run: DigRun, seconds: Double, targetX: Double? = nil, until: ((DigRun) -> Bool)? = nil) -> [DigEvent] {24        var events: [DigEvent] = []25        var elapsed = 0.026        while elapsed < seconds, run.ended == nil {27            run.step(dt: 1.0 / 60, targetX: targetX ?? run.x)28            events += run.drainEvents()29            elapsed += 1.0 / 6030            if let until, until(run) { break }31        }32        return events33    }3435    // MARK: Generation3637    func testSameSeedGivesIdenticalChunks() {38        for index in [0, 1, 7, 20, 41] {39            XCTAssertEqual(DigGenerator.chunk(seed: 1234, index: index), DigGenerator.chunk(seed: 1234, index: index))40        }41        XCTAssertNotEqual(DigGenerator.chunk(seed: 1234, index: 3).tiles, DigGenerator.chunk(seed: 1235, index: 3).tiles)42    }4344    func testChunksAreIndependentOfGenerationOrder() {45        let forward = (0..<6).map { DigGenerator.chunk(seed: 77, index: $0) }46        let backward = (0..<6).reversed().map { DigGenerator.chunk(seed: 77, index: $0) }.reversed()47        XCTAssertEqual(forward, Array(backward))48    }4950    func testEveryChunkHasATraversableRouteWithoutRepair() {51        let lastChunk = DigConfig.coreRow / DigConfig.chunkRows52        for seed in UInt64(1)...60 {53            for index in 0...lastChunk {54                let chunk = DigGenerator.chunk(seed: seed, index: index)55                XCTAssertFalse(chunk.repaired, "seed \(seed) chunk \(index) needed a repair")56                XCTAssertTrue(DigGenerator.isTraversable(chunk, seed: seed), "seed \(seed) chunk \(index)")57                for i in chunk.tiles.indices where chunk.route[i] {58                    XCTAssertFalse(chunk.tiles[i].blocksRoute, "hazard on the route, seed \(seed) chunk \(index)")59                }60            }61        }62    }6364    func testRouteIsContinuousAcrossChunkBoundaries() {65        for seed in UInt64(1)...20 {66            for index in 0..<12 {67                let upper = DigGenerator.chunk(seed: seed, index: index), lower = DigGenerator.chunk(seed: seed, index: index + 1)68                let column = DigGenerator.boundaryColumn(seed: seed, boundary: index + 1)69                XCTAssertTrue(upper.route[(DigConfig.chunkRows - 1) * DigConfig.cols + column])70                XCTAssertTrue(lower.route[column])71            }72        }73    }7475    func testSpawnAreaIsSafeAndHasTutorialOre() {76        for seed in UInt64(1)...40 {77            let chunk = DigGenerator.chunk(seed: seed, index: 0)78            for r in 0..<8 {79                for c in 0..<DigConfig.cols {80                    let tile = chunk.tile(col: c, localRow: r)81                    XCTAssertFalse(tile.isHazard || tile.isUnbreakable || tile == .hardRock, "seed \(seed) row \(r)")82                }83            }84            XCTAssertEqual(chunk.tile(col: DigConfig.cols / 2, localRow: 3), .coal)85            XCTAssertTrue(chunk.tiles.contains(.fuelCell), "the first chunk always offers fuel")86        }87    }8889    func testHazardsAreFairlyPlaced() {90        var lavaInLoam = 0, lavaInMagma = 0, gasInLoam = 091        for seed in UInt64(1)...30 {92            for index in 0...40 {93                let chunk = DigGenerator.chunk(seed: seed, index: index)94                var boulderRowAbove = false95                for r in 0..<DigConfig.chunkRows {96                    let row = (0..<DigConfig.cols).map { chunk.tile(col: $0, localRow: r) }97                    let blockers = row.filter(\.blocksRoute).count98                    XCTAssertLessThanOrEqual(blockers, DigConfig.cols - 5, "row nearly sealed, seed \(seed) chunk \(index)")99                    let hasBoulder = row.contains(.boulder)100                    XCTAssertFalse(hasBoulder && boulderRowAbove, "boulders on consecutive rows can trap the drill")101                    boulderRowAbove = hasBoulder102                    let biome = DigBiome.at(row: chunk.firstRow + r)103                    if biome == .loam { lavaInLoam += row.filter { $0 == .lava }.count; gasInLoam += row.filter { $0 == .gas }.count }104                    if biome == .magma { lavaInMagma += row.filter { $0 == .lava }.count }105                }106            }107        }108        XCTAssertEqual(lavaInLoam, 0, "lava is introduced later")109        XCTAssertEqual(gasInLoam, 0, "gas is introduced later")110        XCTAssertGreaterThan(lavaInMagma, 100)111    }112113    func testBiomesAndCoreDepths() {114        XCTAssertEqual(DigBiome.allCases.count, 5)115        XCTAssertEqual(DigBiome.at(row: 0), .loam)116        XCTAssertEqual(DigBiome.at(row: 119), .loam)117        XCTAssertEqual(DigBiome.at(row: 120), .crystal)118        XCTAssertEqual(DigBiome.at(row: 999), .mantle)119        let world = DigWorld(seed: 5)120        XCTAssertEqual(world.tile(col: 3, row: DigConfig.coreRow), .core)121        XCTAssertNotEqual(world.tile(col: 3, row: DigConfig.coreRow - 1), .core)122        XCTAssertEqual(world.tile(col: -1, row: 10), .boulder, "outside the shaft is solid wall")123        XCTAssertEqual(world.tile(col: 3, row: -2), .air)124        XCTAssertEqual(Set(DigBiome.allCases.map(\.backHex)).count, 5, "each biome has its own palette")125    }126127    func testEveryBiomeOffersOre() {128        for biome in DigBiome.allCases {129            var found = Set<DigTile>()130            for seed in UInt64(1)...6 {131                let chunk = DigGenerator.chunk(seed: seed, index: biome.startRow / DigConfig.chunkRows + 1)132                found.formUnion(chunk.tiles.filter(\.isOre))133            }134            XCTAssertGreaterThanOrEqual(found.count, 2, "\(biome)")135        }136    }137138    // MARK: Movement and collisions139140    func testDrillDescendsAutomaticallyAndCarvesATunnel() {141        let run = sandbox()142        advance(run, seconds: 2)143        XCTAssertGreaterThan(run.depth, 5)144        for r in 0..<run.depth { XCTAssertEqual(run.world.tile(col: DigConfig.cols / 2, row: r), .air) }145        XCTAssertEqual(run.world.tile(col: 0, row: 2), .ground, "only the drill's path is carved")146    }147148    func testHarderMaterialIsSlower() {149        let soft = sandbox(), hard = sandbox(fill: .hardRock)150        advance(soft, seconds: 2)151        advance(hard, seconds: 2)152        XCTAssertGreaterThan(soft.y, hard.y * 1.8)153        let air = sandbox(fill: .air)154        advance(air, seconds: 1)155        XCTAssertGreaterThan(air.y, 6, "open caves are fast")156    }157158    func testBoulderBlocksDescentUntilSteeredAround() {159        let c = DigConfig.cols / 2160        let run = sandbox([(c, 6, .boulder)])161        let events = advance(run, seconds: 3)162        XCTAssertLessThan(run.y, 6)163        XCTAssertTrue(run.isBlocked)164        XCTAssertTrue(events.contains(.blocked))165        XCTAssertEqual(run.world.tile(col: c, row: 6), .boulder, "boulders are never destroyed")166        advance(run, seconds: 2, targetX: Double(c) + 1.5)167        XCTAssertGreaterThan(run.y, 8, "steering aside frees the drill")168    }169170    func testClippingABoulderCornerSlidesTheDrillClear() {171        let c = DigConfig.cols / 2172        let run = sandbox([(c + 1, 6, .boulder)])173        // Start off-centre so the drill overlaps the boulder's column by a sliver.174        advance(run, seconds: 0.3, targetX: Double(c) + 0.72)175        advance(run, seconds: 3)176        XCTAssertGreaterThan(run.y, 8, "a corner clip must not stall the run")177        XCTAssertEqual(run.world.tile(col: c + 1, row: 6), .boulder)178    }179180    func testDrillCannotMoveSidewaysThroughBoulderOrWalls() {181        let c = DigConfig.cols / 2182        let run = sandbox(fill: .air, (0..<30).map { (c + 2, $0, DigTile.boulder) })183        advance(run, seconds: 0.5)184        advance(run, seconds: 1.5, targetX: Double(DigConfig.cols))185        XCTAssertLessThanOrEqual(run.x + DigConfig.halfWidth, Double(c + 2))186        let free = sandbox(fill: .air)187        advance(free, seconds: 2, targetX: -50)188        XCTAssertEqual(free.x, DigConfig.halfWidth, accuracy: 0.001)189        advance(free, seconds: 3, targetX: 500)190        XCTAssertEqual(free.x, Double(DigConfig.cols) - DigConfig.halfWidth, accuracy: 0.001)191    }192193    func testSteeringReachesTheRequestedColumn() {194        let run = sandbox()195        advance(run, seconds: 1.5, targetX: 2.5)196        XCTAssertEqual(run.x, 2.5, accuracy: 0.05)197        XCTAssertGreaterThan(run.lateralTravel, 2.5)198    }199200    // MARK: Collection and hazards201202    func testOreIsCollectedOnceAndValued() {203        let c = DigConfig.cols / 2204        let run = sandbox([(c, 3, .gold), (c, 5, .coal)])205        let events = advance(run, seconds: 2)206        XCTAssertEqual(run.cargo, [.gold, .coal])207        XCTAssertEqual(events.filter { if case .collected = $0 { true } else { false } }.count, 2)208        XCTAssertEqual(run.cargoValue, 18)209        XCTAssertEqual(run.world.tile(col: c, row: 3), .air)210    }211212    func testFullHoldKeepsTheMostValuableOre() {213        let c = DigConfig.cols / 2214        var edits: [(Int, Int, DigTile)] = (0..<10).map { (c, $0, DigTile.coal) }215        edits += [(c, 10, .diamond), (c, 11, .coal)]216        let run = sandbox(edits)217        XCTAssertEqual(run.stats.cargoCap, 10)218        let events = advance(run, seconds: 4)219        XCTAssertEqual(run.cargo.count, 10)220        XCTAssertEqual(run.cargo.filter { $0 == .diamond }.count, 1)221        XCTAssertTrue(events.contains(.swapped(tile: .diamond, col: c, row: 10)))222        XCTAssertTrue(events.contains(.cargoFull(col: c, row: 11)))223    }224225    func testLavaDamagesHullOnceAndHeatShieldReducesIt() {226        let c = DigConfig.cols / 2227        let plain = sandbox([(c, 4, .lava)])228        advance(plain, seconds: 2)229        XCTAssertEqual(plain.hull, 100 - 22, accuracy: 0.001)230        let shielded = sandbox(levels: ["cooling": 5], [(c, 4, .lava)])231        advance(shielded, seconds: 2)232        XCTAssertEqual(shielded.hull, 100 - 22 * 0.3, accuracy: 0.001)233    }234235    func testLavaBesideTheDrillIsForgiven() {236        let c = DigConfig.cols / 2237        let run = sandbox((0..<12).map { (c + 1, $0, DigTile.lava) })238        advance(run, seconds: 2)239        XCTAssertEqual(run.hull, run.stats.hullMax, "a centred drill does not touch lava in the next column")240    }241242    func testGasExplosionClearsChainsAndHurtsOnce() {243        let c = DigConfig.cols / 2244        let run = sandbox([(c, 5, .gas), (c + 1, 6, .gas), (c - 1, 5, .ruby), (c + 2, 7, .boulder)])245        let events = advance(run, seconds: 1.4, until: { $0.hull < 100 })246        XCTAssertEqual(run.hull, 100 - 16, accuracy: 0.001, "a chain hurts only once")247        XCTAssertEqual(events.filter { if case .gas = $0 { true } else { false } }.count, 2)248        XCTAssertEqual(run.world.tile(col: c + 1, row: 6), .air)249        XCTAssertEqual(run.world.tile(col: c + 2, row: 7), .boulder)250        XCTAssertTrue(run.cargo.contains(.ruby), "blasted ore is still collected")251    }252253    func testPickupsRefuelRepairAndPay() {254        let c = DigConfig.cols / 2255        let run = sandbox([(c, 2, .lava), (c, 12, .repairKit), (c, 14, .fuelCell), (c, 16, .chest), (c, 18, .fossil)])256        advance(run, seconds: 10, until: { $0.depth >= 13 })257        XCTAssertEqual(run.hull, 100, accuracy: 0.001, "repair restores hull (capped at max)")258        let before = run.fuel259        let events = advance(run, seconds: 10, until: { $0.depth >= 20 })260        XCTAssertTrue(events.contains(.fuelCell(col: c, row: 14)))261        XCTAssertGreaterThan(run.fuel + 2, before, "fuel cell outweighs the fuel burned meanwhile")262        XCTAssertEqual(run.chests, 1)263        XCTAssertEqual(run.fossils, 1)264        XCTAssertEqual(run.findCoins, 30 + 16 / 10 + DigConfig.fossilValue)265    }266267    func testMilestonesRewardFuelAndCoins() {268        let run = sandbox(levels: ["tank": 5, "drill": 5, "economy": 5], rows: 230, fill: .air)269        let events = advance(run, seconds: 40, until: { $0.depth >= 205 })270        XCTAssertTrue(events.contains(.milestone(depth: 100, bonus: 15)))271        XCTAssertTrue(events.contains(.milestone(depth: 200, bonus: 20)))272        XCTAssertTrue(events.contains(.biome(.crystal)))273        XCTAssertEqual(run.findCoins, 35)274    }275276    // MARK: Run endings and banking277278    func testRunEndsWhenFuelRunsOutAndBanksEverything() {279        let c = DigConfig.cols / 2280        let run = sandbox(rows: 90, fill: .hardRock, [(c, 3, .gold)])281        let events = advance(run, seconds: 60)282        XCTAssertEqual(run.ended, .outOfFuel)283        XCTAssertTrue(events.contains(.ended(.outOfFuel)))284        XCTAssertEqual(run.time, run.stats.fuelMax, accuracy: 0.05, "the base tank burns one unit per second")285        let result = run.result286        XCTAssertEqual(result.keptFraction, 1)287        XCTAssertEqual(result.oreCoins, 16)288        XCTAssertEqual(result.depthCoins, result.depth / 5)289        XCTAssertEqual(result.total, result.oreCoins + result.findCoins + result.depthCoins)290        let depth = run.depth291        run.step(dt: 1, targetX: 0)292        XCTAssertEqual(run.depth, depth, "an ended run no longer moves")293    }294295    func testWreckLosesHalfTheOreAndWinchSavesMore() {296        let c = DigConfig.cols / 2297        let edits: [(Int, Int, DigTile)] = [(c, 1, .ruby), (c, 2, .ruby)] + (3..<9).map { (c, $0, DigTile.lava) }298        let run = sandbox(edits)299        advance(run, seconds: 10)300        XCTAssertEqual(run.ended, .wrecked)301        XCTAssertEqual(run.result.oreValue, 72)302        XCTAssertEqual(run.result.oreCoins, 36)303        XCTAssertEqual(run.result.lostCoins, 36)304        let rescued = sandbox(levels: ["winch": 5], edits)305        advance(rescued, seconds: 10)306        XCTAssertEqual(rescued.result.oreCoins, 72)307    }308309    func testSurfacingEndsTheRunWithFullCargo() {310        let c = DigConfig.cols / 2311        let run = sandbox([(c, 2, .iron)])312        advance(run, seconds: 1.5)313        run.surface()314        XCTAssertEqual(run.ended, .surfaced)315        XCTAssertEqual(run.result.oreCoins, 7)316        run.surface()317        XCTAssertEqual(run.drainEvents().filter { $0 == .ended(.surfaced) }.count, 1)318    }319320    func testReachingTheCoreWinsTheRun() {321        let run = DigRun(seed: 3, stats: DigStats(levels: Dictionary(uniqueKeysWithValues: DigUpgrade.all.map { ($0.id, $0.maxLevel) })))322        for r in 0..<DigConfig.coreRow { for c in 0..<DigConfig.cols { run.world.set(col: c, row: r, .air) } }323        // Chunks far below are generated lazily; keep clearing ahead while falling.324        var events: [DigEvent] = []325        while run.ended == nil, run.time < 200 {326            for r in run.depth...(run.depth + 30) where r < DigConfig.coreRow {327                for c in 0..<DigConfig.cols where run.world.tile(col: c, row: r) != .air { run.world.set(col: c, row: r, .air) }328            }329            run.step(dt: 1.0 / 60, targetX: run.x)330            events += run.drainEvents()331        }332        XCTAssertEqual(run.ended, .core)333        XCTAssertEqual(run.result.depth, DigConfig.coreRow)334        XCTAssertEqual(run.result.coreCoins, DigConfig.coreBonus)335        XCTAssertTrue(events.contains(.biome(.mantle)))336    }337338    func testBankingUpdatesSaveRecordsAndSkins() {339        var save = DigSave()340        let result = DigRunResult(reason: .outOfFuel, depth: 130, biome: .crystal, oreCount: 4, oreValue: 60, keptFraction: 1, oreCoins: 60, findCoins: 15,341                                  depthCoins: 26, coreCoins: 0, fossils: 5, chests: 1, duration: 30)342        let outcome = DigEconomy.bank(result, into: &save)343        XCTAssertTrue(outcome.isRecord)344        XCTAssertEqual(save.bank, 101)345        XCTAssertEqual(save.totalBanked, 101)346        XCTAssertEqual(save.bestDepth, 130)347        XCTAssertEqual(save.runs, 1)348        XCTAssertTrue(save.tutorialDone)349        XCTAssertEqual(Set(outcome.newSkins.map(\.id)), ["copperhead", "bonehunter"])350        XCTAssertTrue(save.skins.contains("copperhead"))351        let again = DigEconomy.bank(result, into: &save)352        XCTAssertFalse(again.isRecord)353        XCTAssertTrue(again.newSkins.isEmpty, "skins unlock once")354        XCTAssertEqual(save.bank, 202)355    }356357    // MARK: Upgrades358359    func testThereAreAtLeastTenUpgradesAndEachOneChangesTheDrill() {360        XCTAssertGreaterThanOrEqual(DigUpgrade.all.count, 10)361        XCTAssertEqual(Set(DigUpgrade.all.map(\.id)).count, DigUpgrade.all.count)362        let base = DigStats()363        for upgrade in DigUpgrade.all {364            var previous = base365            for level in 1...upgrade.maxLevel {366                let stats = DigStats(levels: [upgrade.id: level])367                XCTAssertNotEqual(stats, previous, "\(upgrade.id) level \(level) has no effect")368                XCTAssertNotEqual(upgrade.effectLabel(level: level), upgrade.effectLabel(level: level - 1))369                previous = stats370            }371            XCTAssertEqual(DigStats(levels: [upgrade.id: 99]), previous, "levels are capped")372        }373        let maxed = DigStats(levels: Dictionary(uniqueKeysWithValues: DigUpgrade.all.map { ($0.id, $0.maxLevel) }))374        XCTAssertGreaterThan(maxed.drillPower, base.drillPower)375        XCTAssertGreaterThan(maxed.lateralSpeed, base.lateralSpeed)376        XCTAssertGreaterThan(maxed.fuelMax, base.fuelMax)377        XCTAssertLessThan(maxed.fuelDrain, base.fuelDrain)378        XCTAssertGreaterThan(maxed.fuelDrain, 0)379        XCTAssertGreaterThan(maxed.hullMax, base.hullMax)380        XCTAssertLessThan(maxed.lavaDamage, base.lavaDamage)381        XCTAssertGreaterThan(maxed.lavaDamage, 0)382        XCTAssertLessThan(maxed.gasDamage, base.gasDamage)383        XCTAssertGreaterThan(maxed.cargoCap, base.cargoCap)384        XCTAssertGreaterThan(maxed.scannerRows, base.scannerRows)385        XCTAssertGreaterThan(maxed.magnetRange, base.magnetRange)386        XCTAssertGreaterThan(maxed.valueMultiplier, base.valueMultiplier)387        XCTAssertEqual(maxed.wreckKeep, 1, accuracy: 0.0001)388    }389390    func testUpgradeEffectsInPlay() {391        let c = DigConfig.cols / 2392        let slow = sandbox(), fast = sandbox(levels: ["drill": 5])393        advance(slow, seconds: 2)394        advance(fast, seconds: 2)395        XCTAssertGreaterThan(fast.y, slow.y * 1.5, "drill bit digs faster")396397        let floor = (0..<DigConfig.cols).map { ($0, 5, DigTile.boulder) }398        let thirsty = sandbox(fill: .air, floor), frugal = sandbox(levels: ["economy": 5, "tank": 5], fill: .air, floor)399        advance(thirsty, seconds: 200)400        advance(frugal, seconds: 200)401        XCTAssertGreaterThan(frugal.time, thirsty.time * 2.5, "tank and economy extend the dive")402403        let magnet = sandbox(levels: ["magnet": 2], [(c + 2, 4, .gold), (c - 1, 5, .gold), (c + 4, 6, .gold)])404        advance(magnet, seconds: 2)405        XCTAssertEqual(magnet.cargo.count, 2, "magnet reaches two columns, not four")406407        let refined = sandbox(levels: ["refinery": 5], [(c, 2, .gold)])408        advance(refined, seconds: 1.5)409        XCTAssertEqual(refined.cargoValue, 24)410411        let big = sandbox(levels: ["cargo": 5], (0..<30).map { (c, $0, DigTile.coal) })412        advance(big, seconds: 8)413        XCTAssertEqual(big.cargo.count, 30)414415        let armoured = sandbox(levels: ["hull": 5, "dampers": 3], [(c, 4, .gas)])416        advance(armoured, seconds: 2)417        XCTAssertEqual(armoured.hull, 225 - 16 * 0.4, accuracy: 0.001)418419        let agile = sandbox(levels: ["engine": 5], fill: .air), sluggish = sandbox(fill: .air)420        advance(agile, seconds: 0.4, targetX: 10)421        advance(sluggish, seconds: 0.4, targetX: 10)422        XCTAssertGreaterThan(agile.x, sluggish.x + 0.5)423    }424425    func testBuyingUpgradesSpendsCreditsAndStopsAtMax() {426        var save = DigSave()427        XCTAssertFalse(DigEconomy.buy(.drill, save: &save), "cannot buy without credits")428        save.bank = 100_000429        var spent = 0430        for level in 0..<DigUpgrade.magnet.maxLevel {431            let cost = DigUpgrade.magnet.cost(atLevel: level)!432            XCTAssertTrue(DigEconomy.buy(.magnet, save: &save))433            spent += cost434            if level > 0 { XCTAssertGreaterThan(cost, DigUpgrade.magnet.cost(atLevel: level - 1)!) }435        }436        XCTAssertEqual(save.bank, 100_000 - spent)437        XCTAssertEqual(save.level(.magnet), 3)438        XCTAssertNil(DigUpgrade.magnet.cost(atLevel: 3))439        XCTAssertFalse(DigEconomy.buy(.magnet, save: &save), "maxed upgrades cannot be bought again")440        XCTAssertEqual(save.totalUpgradeLevels, 3)441    }442443    // MARK: Save / load444445    func testSaveRoundTripAndTolerantDecoding() throws {446        var save = DigSave()447        save.bank = 321448        save.totalBanked = 900449        save.bestDepth = 412450        save.upgrades = ["drill": 3, "magnet": 1]451        save.skins = ["rookie", "copperhead"]452        save.selectedSkin = "copperhead"453        save.fossils = 2454        save.seenHints = ["lava"]455        save.tutorialDone = true456        let decoded = try JSONDecoder().decode(DigSave.self, from: JSONEncoder().encode(save))457        XCTAssertEqual(decoded, save)458459        let sparse = try JSONDecoder().decode(DigSave.self, from: Data(#"{"bank":50}"#.utf8))460        XCTAssertEqual(sparse.bank, 50)461        XCTAssertEqual(sparse.skins, ["rookie"])462        XCTAssertEqual(sparse.selectedSkin, "rookie")463464        let hostile = try JSONDecoder().decode(DigSave.self, from: Data(465            #"{"bank":-5,"upgrades":{"drill":99,"bogus":3,"tank":-2},"skins":["ghost"],"selectedSkin":"ghost","bestDepth":-9}"#.utf8))466        XCTAssertEqual(hostile.bank, 0)467        XCTAssertEqual(hostile.upgrades, ["drill": 5], "unknown upgrades are dropped and levels clamped")468        XCTAssertEqual(hostile.skins, ["rookie"])469        XCTAssertEqual(hostile.selectedSkin, "rookie")470        XCTAssertEqual(hostile.bestDepth, 0)471472        var whole = SaveData()473        whole.dig = save474        XCTAssertEqual(try SaveCodec.decode(SaveCodec.encode(whole)).dig, save)475    }476477    func testProgressPersistsThroughTheStore() {478        let dir = FileManager.default.temporaryDirectory.appendingPathComponent("orix-dig-\(UUID().uuidString)")479        let services = ArcadeServices.preview(directory: dir)480        services.store.update { data in481            data.dig.bank = 500482            _ = DigEconomy.buy(.tank, save: &data.dig)483            data.dig.bestDepth = 222484        }485        services.store.flush()486        let reloaded = SaveStore(name: "test", directory: dir)487        XCTAssertEqual(reloaded.data.dig.level(.tank), 1)488        XCTAssertEqual(reloaded.data.dig.bank, 500 - DigUpgrade.tank.cost(atLevel: 0)!)489        XCTAssertEqual(reloaded.data.dig.bestDepth, 222)490    }491492    // MARK: Economy, balance and long runs493494    func testBotRunsAreReproducible() {495        XCTAssertEqual(DigBot.play(seed: 42, stats: DigStats()), DigBot.play(seed: 42, stats: DigStats()))496    }497498    func testFirstRunsAreFunAndFundAnUpgrade() {499        let cheapest = DigUpgrade.all.compactMap { $0.cost(atLevel: 0) }.min()!500        var depths: [Int] = [], totals: [Int] = []501        for seed in UInt64(1)...30 {502            let result = DigBot.play(seed: seed, stats: DigStats())503            depths.append(result.depth)504            totals.append(result.total)505            XCTAssertGreaterThanOrEqual(result.depth, 60, "seed \(seed): a first dive must get somewhere")506            XCTAssertGreaterThanOrEqual(result.total, cheapest, "seed \(seed): the first dive pays for an upgrade")507            XCTAssertGreaterThan(result.duration, 20, "seed \(seed): the first dive lasts long enough to enjoy")508        }509        let averageDepth = depths.reduce(0, +) / depths.count, averageTotal = totals.reduce(0, +) / totals.count510        print("DIG first run: avg depth \(averageDepth) m (\(depths.min()!)–\(depths.max()!)), avg credits \(averageTotal) (\(totals.min()!)–\(totals.max()!))")511        XCTAssertLessThan(averageDepth, 400, "the first dive should not exhaust the game")512        let starterSet = [DigUpgrade.drill, .tank, .cargo].compactMap { $0.cost(atLevel: 0) }.reduce(0, +)513        XCTAssertLessThanOrEqual(starterSet, averageTotal * 3, "three starter upgrades within about three average dives")514    }515516    func testGreedyProgressionReachesDeeperBiomesAndEventuallyTheCore() {517        var save = DigSave()518        var bestByRun: [Int] = []519        var coreRun: Int?520        var firstReached: [String] = []521        for runIndex in 0..<70 {522            let result = DigBot.play(seed: UInt64(1000 + runIndex), stats: DigStats(save: save))523            DigEconomy.bank(result, into: &save)524            bestByRun.append(save.bestDepth)525            if firstReached.count < save.deepestBiome.rawValue { firstReached.append("\(save.deepestBiome) run \(runIndex + 1)") }526            if runIndex < 8 || runIndex % 10 == 0 { print("DIG run \(runIndex + 1): \(result.depth) m, \(result.total) cr (ore \(result.oreCoins) finds \(result.findCoins)), \(Int(result.duration)) s, \(result.reason), levels \(save.totalUpgradeLevels)") }527            if result.reason == .core, coreRun == nil { coreRun = runIndex + 1 }528            // Spend like a player: always the cheapest available upgrade.529            while let pick = DigUpgrade.all.filter({ $0.cost(atLevel: save.level($0)) != nil })530                .min(by: { $0.cost(atLevel: save.level($0))! < $1.cost(atLevel: save.level($1))! }), DigEconomy.buy(pick, save: &save) {}531        }532        print("DIG progression: best after 5/10/20/40/70 runs = \(bestByRun[4])/\(bestByRun[9])/\(bestByRun[19])/\(bestByRun[39])/\(bestByRun[69]) m, levels \(save.totalUpgradeLevels), core on run \(coreRun.map(String.init) ?? "never"), bank \(save.bank), biomes \(firstReached)")533        XCTAssertGreaterThanOrEqual(bestByRun[9], DigBiome.crystal.startRow, "the second biome within ten dives")534        XCTAssertGreaterThan(bestByRun[19], bestByRun[4], "upgrades keep pushing the record")535        XCTAssertGreaterThanOrEqual(bestByRun[39], DigBiome.shale.startRow)536        XCTAssertGreaterThan(save.totalUpgradeLevels, 25)537        XCTAssertNotNil(coreRun, "a fully geared drill can reach the core")538        XCTAssertGreaterThan(coreRun ?? 0, 12, "the core is a long-term goal, not a first-session one")539    }540541    func testLongRunKeepsMemoryBoundedAndGeneratesEachChunkOnce() {542        let levels = Dictionary(uniqueKeysWithValues: DigUpgrade.all.map { ($0.id, $0.maxLevel) })543        let run = DigRun(seed: 9, stats: DigStats(levels: levels))544        var peak = 0, steps = 0545        var aim = run.x546        while run.ended == nil, run.time < 600 {547            if steps % 6 == 0 { aim = DigBot.target(for: run) }548            run.step(dt: 1.0 / 60, targetX: aim)549            _ = run.drainEvents()550            peak = max(peak, run.world.loadedChunkCount)551            steps += 1552        }553        XCTAssertGreaterThan(run.depth, 300)554        XCTAssertLessThanOrEqual(peak, 6, "only the chunks around the drill stay loaded")555        XCTAssertLessThanOrEqual(run.world.generatedCount, run.depth / DigConfig.chunkRows + 5, "chunks are not regenerated while descending")556    }557558    func testGenerationIsFastEnoughForChunkTransitions() {559        measure {560            for index in 0..<200 { _ = DigGenerator.chunk(seed: 31, index: index % 42) }561        }562    }563564    // MARK: Catalogue565566    func testDescriptorAndAchievements() {567        let descriptor = DigToCoreGame.descriptor568        XCTAssertEqual(descriptor.id, .digToCore)569        XCTAssertNil(descriptor.bestLabel(SaveData()))570        var data = SaveData()571        data.dig.bestDepth = 140572        data.dig.runs = 1573        XCTAssertEqual(descriptor.bestLabel(data), "BEST 140 M")574        XCTAssertNotNil(descriptor.progress(data))575        XCTAssertTrue((4...6).contains(DigToCoreGame.achievements.count))576        XCTAssertTrue(DigToCoreGame.achievements.allSatisfy { $0.id.hasPrefix("dig.") && $0.game == .digToCore })577        XCTAssertEqual(DigSkin.all.filter { $0.isEarned(by: DigSave()) }.map(\.id), ["rookie"], "other skins are earned through play")578    }579}580
Files main
Menu

Theme