Make event choices ruleset objects, with standard "uniques" field

android/assets/jsons/Civ V - Gods & Kings/Events.json

@@ -105,7 +105,7 @@
         "choices": [
             {
                 "text":"Got it",
-                "triggeredUniques": ["Mark tutorial [Meet another civilization] complete"],
+                "uniques": ["Mark tutorial [Meet another civilization] complete"],
             },
         ]
     },

core/src/com/unciv/models/ruleset/Event.kt

@@ -2,14 +2,8 @@ package com.unciv.models.ruleset
 
 import com.unciv.logic.civilization.Civilization
 import com.unciv.logic.map.mapunit.MapUnit
-import com.unciv.models.ruleset.unique.Conditionals
+import com.unciv.models.ruleset.unique.*
-import com.unciv.models.ruleset.unique.StateForConditionals
-import com.unciv.models.ruleset.unique.Unique
-import com.unciv.models.ruleset.unique.UniqueTarget
-import com.unciv.models.ruleset.unique.UniqueTriggerActivation
-import com.unciv.models.ruleset.unique.UniqueType
 import com.unciv.ui.components.input.KeyCharAndCode
-import com.unciv.ui.screens.civilopediascreen.FormattedLine
 import com.unciv.ui.screens.civilopediascreen.ICivilopediaText
 
 
@@ -39,27 +33,35 @@ class Event : RulesetObject() {
         getMatchingUniques(UniqueType.Unavailable, stateForConditionals).none()
 }
 
-class EventChoice : ICivilopediaText {
+class EventChoice : ICivilopediaText, RulesetObject() {
     var text = ""
-    override var civilopediaText = listOf<FormattedLine>()
+    override fun getUniqueTarget() = UniqueTarget.Event
     override fun makeLink() = ""
 
     /** Keyboard support - not user-rebindable, mod control only. Will be [parsed][KeyCharAndCode.parse], so Gdx key names will work. */
     val keyShortcut = ""
-
+    
     var triggeredUniques = ArrayList<String>()
     val triggeredUniqueObjects by lazy { triggeredUniques.map { Unique(it) } }
 
     var conditions = ArrayList<String>()
     val conditionObjects by lazy { conditions.map { Unique(it) } }
 
-    fun matchesConditions(stateForConditionals: StateForConditionals) =
+    fun matchesConditions(stateForConditionals: StateForConditionals): Boolean {
-        conditionObjects.all { Conditionals.conditionalApplies(null, it, stateForConditionals) }
+        if (conditionObjects.any { !Conditionals.conditionalApplies(null, it, stateForConditionals) })
+            return false
+        if (hasUnique(UniqueType.Unavailable, stateForConditionals)) return false
+        if (getMatchingUniques(UniqueType.OnlyAvailable, StateForConditionals.IgnoreConditionals)
+                .any { !it.conditionalsApply(stateForConditionals) })
+            return false
+        return true
+    }
 
     fun triggerChoice(civ: Civilization, unit: MapUnit? = null): Boolean {
         var success = false
         val stateForConditionals = StateForConditionals(civ, unit = unit)
-        for (unique in triggeredUniqueObjects.flatMap { it.getMultiplied(stateForConditionals) })
+        val triggerUniques = uniqueObjects.filter { it.isTriggerable } + triggeredUniqueObjects 
+        for (unique in triggerUniques.flatMap { it.getMultiplied(stateForConditionals) })
             if (UniqueTriggerActivation.triggerUnique(unique, civ, unit = unit)) success = true
         return success
     }

core/src/com/unciv/models/ruleset/Ruleset.kt

@@ -55,9 +55,7 @@ enum class RulesetFile(val filename: String,
     CityStateTypes("CityStateTypes.json", getUniques =
         { cityStateTypes.values.asSequence().flatMap { it.allyBonusUniqueMap.getAllUniques() + it.friendBonusUniqueMap.getAllUniques() } }),
     Personalities("Personalities.json", { personalities.values.asSequence() }),
-    Events("Events.json", {events.values.asSequence()},
+    Events("Events.json", {events.values.asSequence() + events.values.flatMap { it.choices }}),
-        { events.values.asSequence().flatMap { it.uniqueObjects } +
-                events.values.asSequence().flatMap { it.choices.flatMap { it.triggeredUniqueObjects } }}),
     GlobalUniques("GlobalUniques.json", { sequenceOf(globalUniques) }),
     ModOptions("ModOptions.json", getUniques = { modOptions.uniqueObjects.asSequence() }),
     Speeds("Speeds.json", { speeds.values.asSequence() }),

core/src/com/unciv/models/ruleset/unique/UniqueTarget.kt

@@ -59,6 +59,7 @@ enum class UniqueTarget(
     CityState(inheritsFrom = Global),
     ModOptions,
     Event,
+    EventChoice(inheritsFrom = Triggerable),
 
     // Modifiers
     Conditional("Modifiers that can be added to other uniques to limit when they will be active", modifierType = ModifierType.Conditional),

core/src/com/unciv/models/ruleset/validation/RulesetValidator.kt

@@ -238,8 +238,21 @@ class RulesetValidator(val ruleset: Ruleset) {
         // An Event is not a IHasUniques, so not suitable as sourceObject
         for (event in ruleset.events.values) {
             for (choice in event.choices) {
+                
                 for (unique in choice.conditionObjects + choice.triggeredUniqueObjects)
                     lines += uniqueValidator.checkUnique(unique, tryFixUnknownUniques, null, true)
+                
+                if (choice.conditions.isNotEmpty())
+                    lines.add("Event choice 'conditions' field is deprecated, " +
+                            "please replace with 'Only available' or 'Not availble' uniques in 'uniques' field", 
+                        errorSeverityToReport = RulesetErrorSeverity.WarningOptionsOnly, choice)
+                
+                if (choice.triggeredUniques.isNotEmpty())
+                    lines.add("Event choice 'triggered uniques' field is deprecated, " +
+                            "please place the triggers in the 'uniques' field",
+                        errorSeverityToReport = RulesetErrorSeverity.WarningOptionsOnly, choice)
+                
+                uniqueValidator.checkUniques(choice, lines, true, tryFixUnknownUniques)
             }
         }
     }