Error when I use my CUBEDs Societies mod

BennieCUBED commented 12 months ago

Platform: Android Version: 4.8.2 (Build 910) Rulesets: [Modern Civilizations, CUBEDs Societies, =GeneCiv=, Enlightenment, Brave New World, Tech Stopper WW1, Historica, Community Maps, WWII Expansion, LM DLC War or Peace, DeCiv Redux, Bamboo Deciv Expans, CUBEDs Minecraft Mod, 3rd and 4th Unique Component, Extra Buildings, World Of Gensokyo Touhou Mod, LOTR Unciv, Warfare Expanded Lite, Geographic Civs, Z2, Community Civs, Civilization II Music, Unciv Terrine Warfare, Capture The Flag, Only Mod Civilizations, Yet Another Music Pack, Unciv WWII, Son Of War Mod, Unciv Vanilla Music Pack, Civ V - Vanilla, Civ style set by Bucketeer, CUBEDs Tribal Mod, Civ6 mod, Civ Army Color Style Sheet, Civ6 Tileset, WW1 Nations, Ukraine Mod, Expanded Warfare, Civ V - Gods & Kings, JJs Basic Unciv, Unciv The New Order The Great World War, Closer Cities Distance of 1, The Great Unciv Rework, Mapping Tools for Unciv, Logicians] Last Screen: com.unciv.ui.screens.civilopediascreen.CivilopediaScreen

Device Model: moto e32 API Level: 30

Message:

java.lang.OutOfMemoryError: Failed to allocate a 280364296 byte allocation with 50331648 free bytes and 267MB until OOM, target footprint 307199648, growth limit 536870912
    at java.util.Arrays.copyOf(Arrays.java:3136)
    at java.util.Arrays.copyOf(Arrays.java:3106)
    at java.util.ArrayList.grow(ArrayList.java:275)
    at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:249)
    at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:241)
    at java.util.ArrayList.add(ArrayList.java:467)
    at com.unciv.logic.map.mapunit.UnitUpgradeManager.getUpgradePath(UnitUpgradeManager.kt:20)
    at com.unciv.logic.map.mapunit.UnitUpgradeManager.getUnitToUpgradeTo(UnitUpgradeManager.kt:30)
    at com.unciv.logic.automation.unit.UnitAutomation.tryUpgradeUnit$core(UnitAutomation.kt:135)
    at com.unciv.logic.automation.civilization.BarbarianAutomation.automateUnitOnEncampment(BarbarianAutomation.kt:41)
    at com.unciv.logic.automation.civilization.BarbarianAutomation.automateUnit(BarbarianAutomation.kt:22)
    at com.unciv.logic.automation.civilization.BarbarianAutomation.automate(BarbarianAutomation.kt:13)
    at com.unciv.logic.automation.civilization.NextTurnAutomation.automateCivMoves(NextTurnAutomation.kt:59)
    at com.unciv.logic.civilization.managers.TurnManager.automateTurn(TurnManager.kt:326)
    at com.unciv.logic.GameInfo.nextTurn(GameInfo.kt:375)
    at com.unciv.ui.screens.worldscreen.WorldScreen$nextTurn$1.invokeSuspend(WorldScreen.kt:596)
    at com.unciv.ui.screens.worldscreen.WorldScreen$nextTurn$1.invoke(Unknown Source:8)
    at com.unciv.ui.screens.worldscreen.WorldScreen$nextTurn$1.invoke(Unknown Source:4)
    at com.unciv.utils.ConcurrencyKt$launchCrashHandling$1.invokeSuspend(Concurrency.kt:87)
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
    at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
    at com.unciv.utils.CrashHandlingDispatcher$dispatch$1.invoke(Concurrency.kt:173)
    at com.unciv.utils.CrashHandlingDispatcher$dispatch$1.invoke(Concurrency.kt:173)
    at com.unciv.ui.crashhandling.CrashHandlingExtensionsKt$wrapCrashHandling$1.invoke(CrashHandlingExtensions.kt:17)
    at com.unciv.ui.crashhandling.CrashHandlingExtensionsKt$wrapCrashHandlingUnit$1.invoke(CrashHandlingExtensions.kt:33)
    at com.unciv.ui.crashhandling.CrashHandlingExtensionsKt$wrapCrashHandlingUnit$1.invoke(CrashHandlingExtensions.kt:33)
    at com.unciv.utils.CrashHandlingDispatcher.dispatch$lambda$0(Concurrency.kt:173)
    at com.unciv.utils.CrashHandlingDispatcher.$r8$lambda$GFMOlD6QMgmLfgwAvPAW33Ob6HE(Unknown Source:0)
    at com.unciv.utils.CrashHandlingDispatcher$$ExternalSyntheticLambda0.run(Unknown Source:2)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)
    at java.lang.Thread.run(Thread.java:923)

Save Mods:

[CUBEDs Societies]

Save Data:

Show Saved Game

``` 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 ```

SomeTroglodyte commented 12 months ago

        "name": "Cannon",
        "unitType": "Siege",
        "upgradesTo": "Artillery",

        "name": "Artillery",
        "unitType": "Siege",
        "replaces": "Cannon",

How do you expect that to work?

SomeTroglodyte commented 12 months ago

So, the only bug here is that RulesetValidator does not flag this. Regrettably, adapting getUpgradePath to catch this is easy, but using it from RulesetValidator is not - it would have to instantiate mock civs to satisfy the getEquivalentUnit call...

SomeTroglodyte commented 12 months ago

So, this patch:

```patch Index: core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>UTF-8 =================================================================== diff --git a/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt b/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt --- a/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt (revision 6f9476d5646677f16b25d73f0971016c6ad34b89) +++ b/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt (date 1694374638794) @@ -1,5 +1,7 @@ package com.unciv.logic.map.mapunit +import com.unciv.logic.UncivShowableException +import com.unciv.logic.civilization.Civilization import com.unciv.models.ruleset.RejectionReasonType import com.unciv.models.ruleset.unique.StateForConditionals import com.unciv.models.ruleset.unique.UniqueType @@ -7,20 +9,12 @@ import com.unciv.ui.components.extensions.toPercent import kotlin.math.pow -class UnitUpgradeManager(val unit:MapUnit) { +class UnitUpgradeManager(val unit: MapUnit) { /** Returns FULL upgrade path, without checking what we can or cannot build currently. - * Does not contain current baseunit, so will be empty if no upgrades. */ - private fun getUpgradePath(): List{ - var currentUnit = unit.baseUnit - val upgradeList = arrayListOf() - while (currentUnit.upgradesTo != null){ - val nextUpgrade = unit.civ.getEquivalentUnit(currentUnit.upgradesTo!!) - currentUnit = nextUpgrade - upgradeList.add(currentUnit) - } - return upgradeList - } + * Does not contain current baseunit, so will be empty if no upgrades. + * @throws UncivShowableException if any step yields a unit already in the path */ + private fun getUpgradePath() = getUpgradePathForBaseUnit(unit.baseUnit, unit.civ) /** Get the base unit this map unit could upgrade to, respecting researched tech and nation uniques only. * Note that if the unit can't upgrade, the current BaseUnit is returned. @@ -38,7 +32,7 @@ return false } - for (baseUnit in upgradePath.reversed()){ + for (baseUnit in upgradePath.reversed()) { if (isInvalidUpgradeDestination(baseUnit)) continue return baseUnit } @@ -114,5 +108,18 @@ return goldCostOfUpgrade } - + companion object { + fun getUpgradePathForBaseUnit(unit: BaseUnit, civ: Civilization): Iterable { + var currentUnit = unit + val upgradeList = linkedSetOf() + while (currentUnit.upgradesTo != null) { + val nextUpgrade = civ.getEquivalentUnit(currentUnit.upgradesTo!!) + if (nextUpgrade in upgradeList) + throw UncivShowableException("Circular or self-referencing upgrade path for ${currentUnit.name}") + currentUnit = nextUpgrade + upgradeList.add(currentUnit) + } + return upgradeList + } + } } ```

would make the crash immediate and read like this:

**Platform:** Desktop **Version:** 4.8.3 (Build 911) **Rulesets:** [Higher quality builtin sounds, CUBEDs Societies, Great Farmer, Community Maps, DeCiv Redux, Thin Bubbly Borders, Extra Buildings, Wikia Leader Portraits, Barbarian xp farm, Extra Units, Deciv Redux Leader Portraits, Higher Quality City Ambience Sounds, Additional Music Movies, Great Community Maps, More Fauna And Flora, Aggtelek, Unciv Vanilla Music Pack, Civ V - Vanilla, Additional Music Ambient, Tintin Victory Illustrations, Resource Recyclers, UnitTypeIcons, Extra Chinese, Modern Joke Religions, Civ V Leader portraits, Epic of Fantasy, Civ V Soundtrack, Extra Wonders, Civ VI Soundtrack, Aliens have crashed on Earth, Civ V - Gods & Kings, Pauline Anna Strom, Additional Music Various, 5Hex Tileset, Civ 5 Icons, Extra Promotions, The Barbarians] **Last Screen:** `com.unciv.ui.screens.worldscreen.WorldScreen` -------------------------------- OS: Linux (amd64, 6.2.0-32-generic) Linux Mint 21.2 Java: JetBrains s.r.o. 17.0.6+0-17.0.6b829.9-10027231 Max Memory: 4096 MB System default encoding: UTF-8 -------------------------------- **Message:** ``` com.unciv.logic.UncivShowableException: Circular or self-referencing upgrade path for Cannon at com.unciv.logic.map.mapunit.UnitUpgradeManager$Companion.getUpgradePathForBaseUnit(UnitUpgradeManager.kt:118) at com.unciv.logic.map.mapunit.UnitUpgradeManager.getUpgradePath(UnitUpgradeManager.kt:17) at com.unciv.logic.map.mapunit.UnitUpgradeManager.getUnitToUpgradeTo(UnitUpgradeManager.kt:24) at com.unciv.logic.automation.unit.UnitAutomation.tryUpgradeUnit$core(UnitAutomation.kt:135) at com.unciv.logic.automation.civilization.BarbarianAutomation.automateUnitOnEncampment(BarbarianAutomation.kt:41) at com.unciv.logic.automation.civilization.BarbarianAutomation.automateUnit(BarbarianAutomation.kt:22) at com.unciv.logic.automation.civilization.BarbarianAutomation.automate(BarbarianAutomation.kt:13) at com.unciv.logic.automation.civilization.NextTurnAutomation.automateCivMoves(NextTurnAutomation.kt:59) at com.unciv.logic.civilization.managers.TurnManager.automateTurn(TurnManager.kt:326) at com.unciv.logic.GameInfo.nextTurn(GameInfo.kt:375) at com.unciv.ui.screens.worldscreen.WorldScreen$nextTurn$1.invokeSuspend(WorldScreen.kt:596) at com.unciv.ui.screens.worldscreen.WorldScreen$nextTurn$1.invoke(WorldScreen.kt) at com.unciv.ui.screens.worldscreen.WorldScreen$nextTurn$1.invoke(WorldScreen.kt) at com.unciv.utils.ConcurrencyKt$launchCrashHandling$1.invokeSuspend(Concurrency.kt:87) at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33) at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106) at com.unciv.utils.CrashHandlingDispatcher$dispatch$1.invoke(Concurrency.kt:173) at com.unciv.utils.CrashHandlingDispatcher$dispatch$1.invoke(Concurrency.kt:173) at com.unciv.ui.crashhandling.CrashHandlingExtensionsKt$wrapCrashHandling$1.invoke(CrashHandlingExtensions.kt:17) at com.unciv.ui.crashhandling.CrashHandlingExtensionsKt$wrapCrashHandlingUnit$1.invoke(CrashHandlingExtensions.kt:33) at com.unciv.ui.crashhandling.CrashHandlingExtensionsKt$wrapCrashHandlingUnit$1.invoke(CrashHandlingExtensions.kt:33) at com.unciv.utils.CrashHandlingDispatcher.dispatch$lambda$0(Concurrency.kt:173) at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136) at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635) at java.base/java.lang.Thread.run(Thread.java:833) ``` **Save Mods:** ``` [CUBEDs Societies] ```

... but still needs something for RulesetValidator ...

BennieCUBED commented 12 months ago

LOL

SomeTroglodyte commented 12 months ago

Hey I wasn't done with this - I assume the mod is by now fixed? Will it be sufficient to go back to dfa7a12 2 days ago to reproduce? .... Yes.

SomeTroglodyte commented 12 months ago

Getting closer:

yairm210 / Unciv

Error when I use my CUBEDs Societies mod #10092