Replace enum and struct definitions with object & fix flakey GE test

engine/src/main/kotlin/world/gregs/voidps/engine/EngineModules.kt

@@ -33,7 +33,7 @@ fun engineModule(files: ConfigFiles) = module {
     single {
         SaveQueue(get(), SafeStorage(File(Settings["storage.players.errors"])))
     }
-    single { AccountManager(get(), get(), get(), get(), AppearanceOverrides(get(), get())) }
+    single { AccountManager(get(), get(), get(), get(), AppearanceOverrides()) }
     // IO
     single { PlayerAccountLoader(get(), get(), get(), get(), get(), Contexts.Game) }
     // Map

engine/src/main/kotlin/world/gregs/voidps/engine/client/instruction/InterfaceHandler.kt

@@ -12,7 +12,6 @@ import world.gregs.voidps.engine.inv.equipment
 
 class InterfaceHandler(
     private val inventoryDefinitions: InventoryDefinitions,
-    private val enumDefinitions: EnumDefinitions,
 ) {
 
     fun getInterfaceItem(player: Player, interfaceId: Int, componentId: Int, itemId: Int, itemSlot: Int): InterfaceData? {
@@ -25,7 +24,7 @@ class InterfaceHandler(
                 id.startsWith("summoning_") && id.endsWith("_creation") -> item = Item(ItemDefinitions.get(itemId).stringId)
                 id == "summoning_trade_in" -> item = Item(ItemDefinitions.get(itemId).stringId)
                 id == "exchange_item_sets" -> {
-                    val expected = enumDefinitions.get("exchange_item_sets").getInt(itemSlot + 1)
+                    val expected = EnumDefinitions.get("exchange_item_sets").getInt(itemSlot + 1)
                     if (expected != itemId) {
                         logger.info { "Exchange item sets don't match [$player, expected=$expected, actual=$itemId]" }
                         return null

engine/src/main/kotlin/world/gregs/voidps/engine/client/ui/Interfaces.kt

@@ -281,9 +281,8 @@ fun Player.closeInterfaces(): Boolean {
 }
 
 fun Player.playTrack(trackIndex: Int) {
-    val enums: EnumDefinitions = get()
-    playMusicTrack(enums.get("music_tracks").getInt(trackIndex))
-    val name = enums.get("music_track_names").getString(trackIndex)
+    playMusicTrack(EnumDefinitions.get("music_tracks").getInt(trackIndex))
+    val name = EnumDefinitions.get("music_track_names").getString(trackIndex)
     interfaces.sendText("music_player", "currently_playing", name)
     this["playing_song"] = true
     this["current_track"] = trackIndex

engine/src/main/kotlin/world/gregs/voidps/engine/data/definition/EnumDefinitions.kt

@@ -3,36 +3,56 @@ package world.gregs.voidps.engine.data.definition
 import it.unimi.dsi.fastutil.Hash
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap
+import org.jetbrains.annotations.TestOnly
 import world.gregs.config.Config
 import world.gregs.voidps.cache.definition.data.EnumDefinition
+import world.gregs.voidps.engine.data.definition.ItemDefinitions.loaded
 import world.gregs.voidps.engine.timedLoad
 
 /**
  * Also known as DataMap in cs2 or tables
  */
-class EnumDefinitions(
-    override var definitions: Array<EnumDefinition>,
-    private val structs: StructDefinitions,
-) : DefinitionsDecoder<EnumDefinition> {
+object EnumDefinitions : DefinitionsDecoder<EnumDefinition> {
 
-    override lateinit var ids: Map<String, Int>
+    override var definitions: Array<EnumDefinition> = emptyArray()
+
+    override var ids: Map<String, Int> = emptyMap()
+
+    fun init(definitions: Array<EnumDefinition>): EnumDefinitions {
+        this.definitions = definitions
+        loaded = true
+        return this
+    }
+
+    @TestOnly
+    fun set(definitions: Array<EnumDefinition>, ids: Map<String, Int>) {
+        this.definitions = definitions
+        this.ids = ids
+        loaded = true
+    }
+
+    fun clear() {
+        this.definitions = emptyArray()
+        this.ids = emptyMap()
+        loaded = false
+    }
 
     fun <T : Any> getStruct(id: String, index: Int, param: String): T {
         val enum = get(id)
         val struct = enum.getInt(index)
-        return structs.get(struct)[param]
+        return StructDefinitions.get(struct)[param]
     }
 
     fun <T : Any?> getStructOrNull(id: String, index: Int, param: String): T? {
         val enum = get(id)
         val struct = enum.getInt(index)
-        return structs.getOrNull(struct)?.getOrNull(param)
+        return StructDefinitions.getOrNull(struct)?.getOrNull(param)
     }
 
     fun <T : Any> getStruct(id: String, index: Int, param: String, default: T): T {
         val enum = get(id)
         val struct = enum.getInt(index)
-        return structs.get(struct)[param, default]
+        return StructDefinitions.get(struct)[param, default]
     }
 
     fun load(path: String): EnumDefinitions {

engine/src/main/kotlin/world/gregs/voidps/engine/data/definition/StructDefinitions.kt

@@ -2,18 +2,40 @@ package world.gregs.voidps.engine.data.definition
 
 import it.unimi.dsi.fastutil.Hash
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
+import org.jetbrains.annotations.TestOnly
 import world.gregs.config.Config
 import world.gregs.voidps.cache.config.data.StructDefinition
+import world.gregs.voidps.cache.definition.data.ItemDefinition
+import world.gregs.voidps.engine.data.definition.ItemDefinitions.loaded
 import world.gregs.voidps.engine.timedLoad
 
 /**
  * Also known as AttributeMaps in cs2 or rows
  */
-class StructDefinitions(
-    override var definitions: Array<StructDefinition> = emptyArray(),
-) : DefinitionsDecoder<StructDefinition> {
+object StructDefinitions : DefinitionsDecoder<StructDefinition> {
 
-    override lateinit var ids: Map<String, Int>
+    override var definitions: Array<StructDefinition> = emptyArray()
+
+    override var ids: Map<String, Int> = emptyMap()
+
+    fun init(definitions: Array<StructDefinition>): StructDefinitions {
+        this.definitions = definitions
+        loaded = true
+        return this
+    }
+
+    @TestOnly
+    fun set(definitions: Array<StructDefinition>, ids: Map<String, Int>) {
+        this.definitions = definitions
+        this.ids = ids
+        loaded = true
+    }
+
+    fun clear() {
+        this.definitions = emptyArray()
+        this.ids = emptyMap()
+        loaded = false
+    }
 
     override fun empty() = StructDefinition.EMPTY
 

engine/src/main/kotlin/world/gregs/voidps/engine/data/exchange/OpenOffers.kt

@@ -1,5 +1,6 @@
 package world.gregs.voidps.engine.data.exchange
 
+import world.gregs.voidps.engine.timer.epochMilliseconds
 import java.util.*
 import java.util.concurrent.TimeUnit
 import kotlin.math.absoluteValue
@@ -17,7 +18,7 @@ class OpenOffers(
     var counter: Int = 0,
 ) {
 
-    data class Activity(val item: String, val price: Int, val id: Int, var lastActive: Long = System.currentTimeMillis())
+    data class Activity(val item: String, val price: Int, val id: Int, var lastActive: Long = epochMilliseconds())
 
     fun id(): Int = ++counter
 
@@ -28,7 +29,7 @@ class OpenOffers(
         if (days <= 0) {
             return
         }
-        val now = System.currentTimeMillis()
+        val now = epochMilliseconds()
         val it = activity.iterator()
         while (it.hasNext()) {
             val activity = it.next()

engine/src/main/kotlin/world/gregs/voidps/engine/entity/character/mode/combat/CombatApi.kt

@@ -159,11 +159,11 @@ interface CombatApi {
         }
 
         fun impact(npc: NPC, target: Character, id: String): Boolean {
-            return npcImpact[id]?.invoke(npc, target) ?: return true
+            return npcImpact[id]?.invoke(npc, target) ?: true
         }
 
         fun condition(npc: NPC, target: Character, condition: String): Boolean {
-            return npcCondition[condition]?.invoke(npc, target) ?: return true
+            return npcCondition[condition]?.invoke(npc, target) ?: true
         }
 
         fun attack(npc: NPC, attack: CombatAttack) {

engine/src/main/kotlin/world/gregs/voidps/engine/entity/character/player/equip/AppearanceOverrides.kt

@@ -5,11 +5,7 @@ import world.gregs.voidps.cache.definition.data.EnumDefinition
 import world.gregs.voidps.engine.data.definition.EnumDefinitions
 import world.gregs.voidps.engine.data.definition.StructDefinitions
 
-class AppearanceOverrides() {
-
-    constructor(enums: EnumDefinitions, structs: StructDefinitions) : this() {
-        load(enums, structs)
-    }
+class AppearanceOverrides {
 
     private val maleMid: MutableMap<Int, Int> = Int2IntOpenHashMap(32)
     private val femaleMid: MutableMap<Int, Int> = Int2IntOpenHashMap(48)
@@ -24,17 +20,17 @@ class AppearanceOverrides() {
         femaleLow.getOrDefault(current, 243)
     } + 0x100
 
-    private fun load(enums: EnumDefinitions, structs: StructDefinitions) {
-        load(maleMid, enums.get("look_hair_male"), structs, "body_look_flat_mid")
-        load(femaleMid, enums.get("look_hair_female"), structs, "body_look_flat_mid")
-        load(maleLow, enums.get("look_hair_male"), structs, "body_look_flat_low")
-        load(femaleLow, enums.get("look_hair_female"), structs, "body_look_flat_low")
+    private fun load() {
+        load(maleMid, EnumDefinitions.get("look_hair_male"), "body_look_flat_mid")
+        load(femaleMid, EnumDefinitions.get("look_hair_female"), "body_look_flat_mid")
+        load(maleLow, EnumDefinitions.get("look_hair_male"), "body_look_flat_low")
+        load(femaleLow, EnumDefinitions.get("look_hair_female"), "body_look_flat_low")
     }
 
-    private fun load(map: MutableMap<Int, Int>, enum: EnumDefinition, structs: StructDefinitions, key: String) {
+    private fun load(map: MutableMap<Int, Int>, enum: EnumDefinition, key: String) {
         for (value in enum.map?.values ?: return) {
             val structId = value as Int
-            val struct = structs.getOrNull(structId) ?: continue
+            val struct = StructDefinitions.getOrNull(structId) ?: continue
             val index: Int = struct.getOrNull("body_look_index") ?: continue
             val replacement: Int = struct.getOrNull(key) ?: continue
             map[index] = replacement

game/src/main/kotlin/GameModules.kt

@@ -25,7 +25,7 @@ fun gameModule(files: ConfigFiles) = module {
     single(createdAtStart = true) { MusicTracks().load(files.find(Settings["map.music"])) }
     single(createdAtStart = true) { FairyRingCodes().load(files.find(Settings["definitions.fairyCodes"])) }
     single(createdAtStart = true) { CharterShips().load(files.find(Settings["map.ships.prices"])) }
-    single { InstructionHandlers(InterfaceHandler(get(), get())) }
+    single { InstructionHandlers(InterfaceHandler(get())) }
     single(createdAtStart = true) {
         get<Storage>().offers(Settings["grandExchange.offers.activeDays", 0])
     }

game/src/main/kotlin/Main.kt

@@ -124,14 +124,14 @@ object Main {
             single(createdAtStart = true) { NPCDefinitions.init(NPCDecoder(members, get<ParameterDefinitions>()).load(cache)).load(files.list(Settings["definitions.npcs"]), get()) }
             single(createdAtStart = true) { ItemDefinitions.init(ItemDecoder(get<ParameterDefinitions>()).load(cache)).load(files.list(Settings["definitions.items"])) }
             single(createdAtStart = true) { AnimationDefinitions(AnimationDecoder().load(cache)).load(files.list(Settings["definitions.animations"])) }
-            single(createdAtStart = true) { EnumDefinitions(EnumDecoder().load(cache), get()).load(files.find(Settings["definitions.enums"])) }
+            single(createdAtStart = true) { EnumDefinitions.init(EnumDecoder().load(cache)).load(files.find(Settings["definitions.enums"])) }
             single(createdAtStart = true) { GraphicDefinitions(GraphicDecoder().load(cache)).load(files.list(Settings["definitions.graphics"])) }
             single(createdAtStart = true) { InterfaceDefinitions.init(InterfaceDecoder().load(cache)).load(files.list(Settings["definitions.interfaces"]), files.find(Settings["definitions.interfaces.types"])) }
             single(createdAtStart = true) {
                 get<ItemDefinitions>()
                 InventoryDefinitions.init(InventoryDecoder().load(cache)).load(files.list(Settings["definitions.inventories"]), files.list(Settings["definitions.shops"]))
             }
-            single(createdAtStart = true) { StructDefinitions(StructDecoder(get<ParameterDefinitions>()).load(cache)).load(files.find(Settings["definitions.structs"])) }
+            single(createdAtStart = true) { StructDefinitions.init(StructDecoder(get<ParameterDefinitions>()).load(cache)).load(files.find(Settings["definitions.structs"])) }
             single(createdAtStart = true) { QuickChatPhraseDefinitions(QuickChatPhraseDecoder().load(cache)).load() }
             single(createdAtStart = true) { WeaponStyleDefinitions().load(files.find(Settings["definitions.weapons.styles"])) }
             single(createdAtStart = true) { WeaponAnimationDefinitions().load(files.find(Settings["definitions.weapons.animations"])) }

game/src/main/kotlin/content/achievement/TaskList.kt

@@ -10,7 +10,6 @@ import world.gregs.voidps.engine.entity.character.player.Player
 
 class TaskList(
     val variables: VariableDefinitions,
-    val enumDefinitions: EnumDefinitions,
 ) : Script {
 
     init {
@@ -79,7 +78,7 @@ class TaskList(
         interfaceOption("Hint", "task_list:hint_*") {
             val selected = get("task_slot_selected", 0)
             val index = indexOfSlot(this, selected) ?: return@interfaceOption
-            val tile: Int = enumDefinitions.getStructOrNull("task_structs", index, it.component.replace("hint_", "task_hint_tile_")) ?: return@interfaceOption
+            val tile: Int = EnumDefinitions.getStructOrNull("task_structs", index, it.component.replace("hint_", "task_hint_tile_")) ?: return@interfaceOption
             // TODO I expect the functionality is actually minimap highlights not world map
             set("world_map_marker_1", tile)
             set("world_map_marker_text_1", "")

game/src/main/kotlin/content/achievement/TaskSystem.kt

@@ -16,8 +16,6 @@ import world.gregs.voidps.engine.event.AuditLog
 
 class TaskSystem(
     val variables: VariableDefinitions,
-    val enumDefinitions: EnumDefinitions,
-    val structDefinitions: StructDefinitions,
 ) : Script {
 
     init {
@@ -111,7 +109,7 @@ class TaskSystem(
         interfaceOption("Hint", "task_system:hint_*") {
             val selected = get("task_slot_selected", 0)
             val index = indexOfSlot(this, selected) ?: return@interfaceOption
-            val tile: Int = enumDefinitions.getStructOrNull("task_structs", index, it.component.replace("hint_", "task_hint_tile_")) ?: return@interfaceOption
+            val tile: Int = EnumDefinitions.getStructOrNull("task_structs", index, it.component.replace("hint_", "task_hint_tile_")) ?: return@interfaceOption
             // TODO I expect the functionality is actually minimap highlights not world map
             set("world_map_marker_1", tile)
             set("world_map_marker_text_1", "")
@@ -202,14 +200,14 @@ class TaskSystem(
         Task completion
      */
     fun completeTask(player: Player, id: String) {
-        val definition = structDefinitions.get(id)
+        val definition = StructDefinitions.get(id)
         AuditLog.event(player, "task_completed", id)
         val index = definition["task_index", -1]
         player["task_popup"] = index
         val difficulty = definition["task_difficulty", 0]
         val area = definition["task_area", 61]
-        val areaName = enumDefinitions.get("task_area_names").getString(area)
-        val difficultyName = enumDefinitions.get("task_difficulties").getString(difficulty)
+        val areaName = EnumDefinitions.get("task_area_names").getString(area)
+        val difficultyName = EnumDefinitions.get("task_difficulties").getString(difficulty)
         if (areaName.isNotBlank() && difficultyName.isNotBlank()) {
             player.message("You have completed the Task '${definition["task_name", ""]}' in the $difficultyName $areaName set!")
         } else {

game/src/main/kotlin/content/achievement/Tasks.kt

@@ -37,14 +37,12 @@ object Tasks {
     }
 
     fun <R> forEach(areaId: Int, block: TaskIterator.() -> R?): R? {
-        val enumDefinitions: EnumDefinitions = get()
-        val structDefinitions: StructDefinitions = get()
-        var next = enumDefinitions.get("task_area_start_indices").getInt(areaId)
-        val structs = enumDefinitions.get("task_structs")
+        var next = EnumDefinitions.get("task_area_start_indices").getInt(areaId)
+        val structs = EnumDefinitions.get("task_structs")
         val iterator = TaskIterator()
         while (next != 4091 && next != 450 && next != 4094) {
             val struct = structs.getInt(next)
-            iterator.definition = structDefinitions.getOrNull(struct) ?: break
+            iterator.definition = StructDefinitions.getOrNull(struct) ?: break
             iterator.index = next
             iterator.skip = false
             val result = block.invoke(iterator)

game/src/main/kotlin/content/area/asgarnia/falador/Hairdresser.kt

@@ -16,9 +16,7 @@ import world.gregs.voidps.network.login.protocol.visual.update.player.BodyColour
 import world.gregs.voidps.network.login.protocol.visual.update.player.BodyPart
 import world.gregs.voidps.network.login.protocol.visual.update.player.EquipSlot
 
-class Hairdresser(
-    val enums: EnumDefinitions,
-) : Script {
+class Hairdresser : Script {
 
     init {
         npcOperate("Talk-to", "hairdresser") {
@@ -40,8 +38,8 @@ class Hairdresser(
 
         interfaceOpened("hairdressers_salon") { id ->
             interfaces.sendText(id, "confirm_text", "Change")
-            val styles = enums.get("style_hair_$sex")
-            val colours = enums.get("colour_hair")
+            val styles = EnumDefinitions.get("style_hair_$sex")
+            val colours = EnumDefinitions.get("colour_hair")
             interfaceOptions.unlockAll(id, "styles", 0 until styles.length * 2)
             interfaceOptions.unlockAll(id, "colours", 0 until colours.length * 2)
             set("makeover_hair", body.getLook(BodyPart.Hair))
@@ -58,15 +56,15 @@ class Hairdresser(
             val type = if (beard) "beard" else "hair"
             val key = "look_${type}_$sex"
             val value = if (beard) {
-                enums.get(key).getInt(itemSlot / 2)
+                EnumDefinitions.get(key).getInt(itemSlot / 2)
             } else {
-                enums.getStruct(key, itemSlot / 2, "body_look_id")
+                EnumDefinitions.getStruct(key, itemSlot / 2, "body_look_id")
             }
             set("makeover_$type", value)
         }
 
         interfaceOption(id = "hairdressers_salon:colours") { (_, itemSlot) ->
-            set("makeover_colour_hair", enums.get("colour_hair").getInt(itemSlot / 2))
+            set("makeover_colour_hair", EnumDefinitions.get("colour_hair").getInt(itemSlot / 2))
         }
 
         interfaceClosed("hairdressers_salon") {