Repository Public License
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