diff --git a/src/net/torvald/terrarum/GameCrashHandler.kt b/src/net/torvald/terrarum/GameCrashHandler.kt
index a32c6d580..4e6b72b8a 100644
--- a/src/net/torvald/terrarum/GameCrashHandler.kt
+++ b/src/net/torvald/terrarum/GameCrashHandler.kt
@@ -121,6 +121,46 @@ emph {
val uptime = App.getTIME_T() - App.startupTime
+
+
+ // print out the error
+ printStream.println("The Error Info
")
+ System.err.println("== The Error Info ==")
+
+ printStream.println("")
+ e.printStackTrace(printStream)
+ printStream.println("")
+ e.printStackTrace(System.err)
+
+
+
+ printStream.println("Module Info
")
+ printStream.println("Load Order
")
+ printStream.println("${ModMgr.loadOrder.joinToString(separator = "") { "- " +
+ "$it (" +
+ "${moduleMetaToText(ModMgr.moduleInfo[it] ?: ModMgr.moduleInfoErrored[it])}" +
+ ")
" }
+ }
")
+
+
+
+ // print out loaded modules
+ ModMgr.errorLogs.let {
+ if (it.size > 0) {
+ printStream.println("Module Errors
")
+ System.err.println("== Module Errors ==")
+ it.forEach {
+ printStream.println("From Module ${it.moduleName} (${it.type.toHTML()}):
")
+ printStream.println("")
+ it.cause?.printStackTrace(printStream)
+ printStream.println("")
+ it.cause?.printStackTrace(System.err)
+ }
+ }
+ }
+
+
+
// print out device info
printStream.println("System Info
")
printStream.println("")
- it.cause?.printStackTrace(printStream)
- printStream.println("")
- it.cause?.printStackTrace(System.err)
- }
- }
- }
-
- printStream.println("The Error Info
")
- System.err.println("== The Error Info ==")
-
- printStream.println("")
- e.printStackTrace(printStream)
- printStream.println("")
- e.printStackTrace(System.err)
-
-
-
textArea.text = "$htmlSB"
}
diff --git a/src/net/torvald/terrarum/IngameInstance.kt b/src/net/torvald/terrarum/IngameInstance.kt
index c40ad3480..b0ea0e1d6 100644
--- a/src/net/torvald/terrarum/IngameInstance.kt
+++ b/src/net/torvald/terrarum/IngameInstance.kt
@@ -8,6 +8,7 @@ import net.torvald.terrarum.gameactors.ActorID
import net.torvald.terrarum.gameactors.ActorWithBody
import net.torvald.terrarum.gameactors.ActorWithBody.Companion.PHYS_EPSILON_DIST
import net.torvald.terrarum.gameactors.BlockMarkerActor
+import net.torvald.terrarum.gameactors.WorldUpdater
import net.torvald.terrarum.gamecontroller.KeyToggler
import net.torvald.terrarum.gamecontroller.TerrarumKeyboardEvent
import net.torvald.terrarum.gameitems.ItemID
@@ -147,6 +148,13 @@ open class IngameInstance(val batch: FlippingSpriteBatch, val isMultiplayer: Boo
val actorAdditionQueue = ArrayList Unit>>() // actor, stacktrace object, onSpawn
val actorRemovalQueue = ArrayList Unit>>() // actor, stacktrace object, onDespawn
+ /**
+ * Registry of actors that implement [WorldUpdater].
+ * World simulation (fluids, wires, tile updates) is active around these actors.
+ * Automatically maintained when actors are added/removed.
+ */
+ val worldUpdaters: MutableSet = HashSet()
+
/**
* ## BIG NOTE: Calculated actor distance is the **Euclidean distance SQUARED**
*
@@ -378,6 +386,10 @@ open class IngameInstance(val batch: FlippingSpriteBatch, val isMultiplayer: Boo
actorContainer.removeAt(indexToDelete)
}
}
+ // Unregister from worldUpdaters if applicable
+ if (actor is WorldUpdater && actor is ActorWithBody) {
+ worldUpdaters.remove(actor)
+ }
}
protected open fun forceAddActor(actor: Actor?, caller: Throwable = StackTraceRecorder()) {
@@ -388,6 +400,10 @@ open class IngameInstance(val batch: FlippingSpriteBatch, val isMultiplayer: Boo
}
else {
actorContainerActive.add(actor)
+ // Register to worldUpdaters if applicable
+ if (actor is WorldUpdater && actor is ActorWithBody) {
+ worldUpdaters.add(actor)
+ }
}
}
diff --git a/src/net/torvald/terrarum/gameactors/WorldUpdateAnchor.kt b/src/net/torvald/terrarum/gameactors/WorldUpdateAnchor.kt
new file mode 100644
index 000000000..0db3ed48d
--- /dev/null
+++ b/src/net/torvald/terrarum/gameactors/WorldUpdateAnchor.kt
@@ -0,0 +1,47 @@
+package net.torvald.terrarum.gameactors
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+
+/**
+ * Minimal anchor actor for world updates.
+ *
+ * This actor has no visible representation and does not participate in physics.
+ * It serves purely as a point around which world simulation (fluids, wires, tile updates)
+ * remains active.
+ *
+ * Created by minjaesong on 2026-01-19.
+ */
+class WorldUpdateAnchor : ActorWithBody, WorldUpdater, NoSerialise {
+
+ constructor() : super(RenderOrder.MIDDLE, PhysProperties.IMMOBILE()) {
+ isVisible = false
+ chunkAnchoring = true
+ setHitboxDimension(1, 1, 0, 0)
+ }
+
+ constructor(id: ActorID) : super(RenderOrder.MIDDLE, PhysProperties.IMMOBILE(), id) {
+ isVisible = false
+ chunkAnchoring = true
+ setHitboxDimension(1, 1, 0, 0)
+ }
+
+ override fun updateImpl(delta: Float) {
+ // No-op; this actor exists solely as a world update anchor
+ }
+
+ override fun drawBody(frameDelta: Float, batch: SpriteBatch) {
+ // No-op; this actor is invisible
+ }
+
+ override fun drawGlow(frameDelta: Float, batch: SpriteBatch) {
+ // No-op; this actor is invisible
+ }
+
+ override fun drawEmissive(frameDelta: Float, batch: SpriteBatch) {
+ // No-op; this actor is invisible
+ }
+
+ override fun dispose() {
+ // Nothing to dispose
+ }
+}
diff --git a/src/net/torvald/terrarum/gameactors/WorldUpdater.kt b/src/net/torvald/terrarum/gameactors/WorldUpdater.kt
new file mode 100644
index 000000000..e332c72e9
--- /dev/null
+++ b/src/net/torvald/terrarum/gameactors/WorldUpdater.kt
@@ -0,0 +1,13 @@
+package net.torvald.terrarum.gameactors
+
+/**
+ * Marker interface for actors that serve as "world update anchors".
+ *
+ * Actors implementing this interface cause world simulation (fluids, wires, tile updates)
+ * to be active in their vicinity, regardless of camera position.
+ *
+ * All implementations must also extend [ActorWithBody].
+ *
+ * Created by minjaesong on 2026-01-19.
+ */
+interface WorldUpdater
diff --git a/src/net/torvald/terrarum/modulebasegame/TerrarumIngame.kt b/src/net/torvald/terrarum/modulebasegame/TerrarumIngame.kt
index a97bb9667..25cff4004 100644
--- a/src/net/torvald/terrarum/modulebasegame/TerrarumIngame.kt
+++ b/src/net/torvald/terrarum/modulebasegame/TerrarumIngame.kt
@@ -150,8 +150,23 @@ open class TerrarumIngame(batch: FlippingSpriteBatch) : IngameInstance(batch) {
(a.hitbox.centeredY - WorldCamera.yCentre).sqr()
)
- /** whether the actor is within update range */
- fun ActorWithBody.inUpdateRange(world: GameWorld) = distToCameraSqr(world, this) <= ACTOR_UPDATE_RANGE.sqr()
+ /**
+ * Returns the minimum squared distance from the actor to any living WorldUpdater.
+ * Falls back to camera distance if no WorldUpdaters exist.
+ */
+ fun distToNearestUpdaterSqr(world: GameWorld, actor: ActorWithBody): Double {
+ val worldUpdaters = Terrarum.ingame?.worldUpdaters
+ if (worldUpdaters.isNullOrEmpty()) {
+ return distToCameraSqr(world, actor)
+ }
+ return worldUpdaters.minOf { updater ->
+ if (updater.flagDespawn || updater.despawned) Double.MAX_VALUE
+ else distToActorSqr(world, actor, updater)
+ }
+ }
+
+ /** whether the actor is within update range of any WorldUpdater */
+ fun ActorWithBody.inUpdateRange(world: GameWorld) = distToNearestUpdaterSqr(world, this) <= ACTOR_UPDATE_RANGE.sqr()
/** whether the actor is within screen */
fun ActorWithBody.inScreen(world: GameWorld) =
diff --git a/src/net/torvald/terrarum/modulebasegame/WorldSimulator.kt b/src/net/torvald/terrarum/modulebasegame/WorldSimulator.kt
index da18c7250..29d8a34b8 100644
--- a/src/net/torvald/terrarum/modulebasegame/WorldSimulator.kt
+++ b/src/net/torvald/terrarum/modulebasegame/WorldSimulator.kt
@@ -23,6 +23,7 @@ import net.torvald.terrarum.realestate.LandUtil.CHUNK_H
import net.torvald.terrarum.realestate.LandUtil.CHUNK_W
import org.dyn4j.geometry.Vector2
import kotlin.math.cosh
+import kotlin.math.max
import kotlin.math.min
import kotlin.math.pow
import kotlin.math.roundToInt
@@ -50,6 +51,9 @@ object WorldSimulator {
private val fluidNewMap = Array(DOUBLE_RADIUS) { FloatArray(DOUBLE_RADIUS) }
private val fluidNewTypeMap = Array(DOUBLE_RADIUS) { Array(DOUBLE_RADIUS) { Fluid.NULL } }
+ // Mask to track tiles that have already been fluid-simulated this frame (for overlap deduplication)
+ private val processedFluidTiles = HashSet()
+
const val FLUID_MAX_MASS = 1f // The normal, un-pressurized mass of a full water cell
const val FLUID_MAX_COMP = 0.01f // How much excess water a cell can store, compared to the cell above it. A tile of fluid can contain more than MaxMass water.
// const val FLUID_MIN_MASS = net.torvald.terrarum.gameworld.FLUID_MIN_MASS //Ignore cells that are almost dry (smaller than epsilon of float16)
@@ -66,6 +70,97 @@ object WorldSimulator {
/** Bottom-right point */
var updateYTo = 0
+ /**
+ * Represents a rectangular region for world updates.
+ */
+ data class UpdateRegion(val xFrom: Int, val yFrom: Int, val xTo: Int, val yTo: Int) {
+ fun overlaps(other: UpdateRegion): Boolean {
+ return xFrom <= other.xTo && xTo >= other.xFrom &&
+ yFrom <= other.yTo && yTo >= other.yFrom
+ }
+
+ fun merge(other: UpdateRegion): UpdateRegion {
+ return UpdateRegion(
+ min(xFrom, other.xFrom),
+ min(yFrom, other.yFrom),
+ max(xTo, other.xTo),
+ max(yTo, other.yTo)
+ )
+ }
+
+ val width get() = xTo - xFrom
+ val height get() = yTo - yFrom
+ }
+
+ /**
+ * Merges overlapping regions into non-overlapping ones.
+ * Uses iterative merging until no more merges are possible.
+ */
+ private fun mergeOverlappingRegions(regions: List): List {
+ if (regions.size <= 1) return regions
+
+ val result = regions.toMutableList()
+ var merged = true
+ while (merged) {
+ merged = false
+ outer@ for (i in result.indices) {
+ for (j in i + 1 until result.size) {
+ if (result[i].overlaps(result[j])) {
+ val mergedRegion = result[i].merge(result[j])
+ result.removeAt(j)
+ result[i] = mergedRegion
+ merged = true
+ break@outer
+ }
+ }
+ }
+ }
+ return result
+ }
+
+ /**
+ * Computes update regions from all living WorldUpdaters.
+ * Returns a list of non-overlapping merged regions.
+ */
+ private fun computeUpdateRegions(): List {
+ val worldUpdaters = ingame.worldUpdaters.filter { !it.flagDespawn && !it.despawned }
+ if (worldUpdaters.isEmpty()) return emptyList()
+
+ val regions = worldUpdaters.map { updater ->
+ val cx = updater.hitbox.centeredX.div(TILE_SIZE).roundToInt()
+ val cy = updater.hitbox.centeredY.div(TILE_SIZE).roundToInt()
+ UpdateRegion(
+ cx - FLUID_UPDATING_SQUARE_RADIUS,
+ cy - FLUID_UPDATING_SQUARE_RADIUS,
+ cx + FLUID_UPDATING_SQUARE_RADIUS,
+ cy + FLUID_UPDATING_SQUARE_RADIUS
+ )
+ }
+
+ return mergeOverlappingRegions(regions)
+ }
+
+ /**
+ * Computes individual (unmerged) fluid regions for each WorldUpdater.
+ * Each region is exactly DOUBLE_RADIUS × DOUBLE_RADIUS to fit the fixed fluid arrays.
+ * Overlap deduplication is handled by processedFluidTiles mask during fluidmapToWorld().
+ */
+ private fun computeIndividualFluidRegions(): List {
+ val worldUpdaters = ingame.worldUpdaters.filter { !it.flagDespawn && !it.despawned }
+ if (worldUpdaters.isEmpty()) return emptyList()
+
+ return worldUpdaters.map { updater ->
+ val cx = updater.hitbox.centeredX.div(TILE_SIZE).roundToInt()
+ val cy = updater.hitbox.centeredY.div(TILE_SIZE).roundToInt()
+ UpdateRegion(
+ cx - FLUID_UPDATING_SQUARE_RADIUS,
+ cy - FLUID_UPDATING_SQUARE_RADIUS,
+ cx + FLUID_UPDATING_SQUARE_RADIUS,
+ cy + FLUID_UPDATING_SQUARE_RADIUS
+ )
+ }
+ }
+
private val ingame: TerrarumIngame
get() = Terrarum.ingame!! as TerrarumIngame
private val world: GameWorld
@@ -82,21 +177,66 @@ object WorldSimulator {
//printdbg(this, "============================")
- if (player != null) {
- updateXFrom = player.hitbox.centeredX.div(TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundToInt()
- updateYFrom = player.hitbox.centeredY.div(TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundToInt()
- updateXTo = updateXFrom + DOUBLE_RADIUS
- updateYTo = updateYFrom + DOUBLE_RADIUS
+ // Compute non-overlapping merged regions for general simulations
+ val mergedRegions = computeUpdateRegions()
+
+ // Compute individual (unmerged) regions for fluid simulation
+ // Each WorldUpdater gets its own fluid region; overlap is handled by processedFluidTiles mask
+ val fluidRegions = computeIndividualFluidRegions()
+
+ // Fallback to player-based region if no WorldUpdaters exist
+ val regionsToProcess = if (mergedRegions.isNotEmpty()) {
+ mergedRegions
+ } else if (player != null) {
+ val px = player.hitbox.centeredX.div(TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundToInt()
+ val py = player.hitbox.centeredY.div(TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundToInt()
+ listOf(UpdateRegion(px, py, px + DOUBLE_RADIUS, py + DOUBLE_RADIUS))
+ } else {
+ emptyList()
}
- if (ingame.terrainChangeQueue.isNotEmpty()) { App.measureDebugTime("WorldSimulator.degrass") { buryGrassImmediately() } }
- App.measureDebugTime("WorldSimulator.growGrass") { growOrKillGrass() }
- App.measureDebugTime("WorldSimulator.fluids") { moveFluids(delta) }
- App.measureDebugTime("WorldSimulator.fallables") { displaceFallables(delta) }
- App.measureDebugTime("WorldSimulator.wires") { simulateWires(delta) }
- App.measureDebugTime("WorldSimulator.collisionDroppedItem") { collideDroppedItems() }
- App.measureDebugTime("WorldSimulator.dropTreeLeaves") { dropTreeLeaves() }
+ val fluidRegionsToProcess = if (fluidRegions.isNotEmpty()) {
+ fluidRegions
+ } else if (player != null) {
+ val px = player.hitbox.centeredX.div(TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundToInt()
+ val py = player.hitbox.centeredY.div(TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundToInt()
+ listOf(UpdateRegion(px, py, px + DOUBLE_RADIUS, py + DOUBLE_RADIUS))
+ } else {
+ emptyList()
+ }
+ // buryGrassImmediately doesn't depend on update region
+ if (ingame.terrainChangeQueue.isNotEmpty()) {
+ App.measureDebugTime("WorldSimulator.degrass") { buryGrassImmediately() }
+ }
+
+ // Process fluids for each WorldUpdater individually, using mask for overlap deduplication
+ processedFluidTiles.clear()
+ App.measureDebugTime("WorldSimulator.fluids") {
+ for (region in fluidRegionsToProcess) {
+ updateXFrom = region.xFrom
+ updateYFrom = region.yFrom
+ updateXTo = region.xTo
+ updateYTo = region.yTo
+ moveFluids(delta)
+ }
+ }
+
+ // Process other simulations using merged non-overlapping regions
+ for (region in regionsToProcess) {
+ updateXFrom = region.xFrom
+ updateYFrom = region.yFrom
+ updateXTo = region.xTo
+ updateYTo = region.yTo
+
+ App.measureDebugTime("WorldSimulator.growGrass") { growOrKillGrass() }
+ App.measureDebugTime("WorldSimulator.fallables") { displaceFallables(delta) }
+ App.measureDebugTime("WorldSimulator.wires") { simulateWires(delta) }
+ App.measureDebugTime("WorldSimulator.dropTreeLeaves") { dropTreeLeaves() }
+ }
+
+ // collideDroppedItems doesn't depend on update region (uses actor list)
+ App.measureDebugTime("WorldSimulator.collisionDroppedItem") { collideDroppedItems() }
//printdbg(this, "============================")
}
@@ -502,10 +642,21 @@ object WorldSimulator {
}
}
+ /** Packs world coordinates into a single Long for use as a HashSet key */
+ private fun packFluidCoords(worldX: Int, worldY: Int): Long =
+ (worldX.toLong() shl 32) or (worldY.toLong() and 0xFFFFFFFFL)
+
private fun fluidmapToWorld() {
for (y in fluidMap.indices) {
for (x in fluidMap[0].indices) {
- world.setFluid(x + updateXFrom, y + updateYFrom, fluidNewTypeMap[y][x], fluidNewMap[y][x])
+ val worldX = x + updateXFrom
+ val worldY = y + updateYFrom
+ val key = packFluidCoords(worldX, worldY)
+ // Only write if this tile hasn't been processed yet (deduplication for overlapping regions)
+ if (key !in processedFluidTiles) {
+ world.setFluid(worldX, worldY, fluidNewTypeMap[y][x], fluidNewMap[y][x])
+ processedFluidTiles.add(key)
+ }
}
}
}
diff --git a/src/net/torvald/terrarum/modulebasegame/gameactors/IngamePlayer.kt b/src/net/torvald/terrarum/modulebasegame/gameactors/IngamePlayer.kt
index e5a180d0c..c90ababaa 100644
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/IngamePlayer.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/IngamePlayer.kt
@@ -7,6 +7,7 @@ import net.torvald.terrarum.App
import net.torvald.terrarum.Terrarum
import net.torvald.terrarum.gameactors.AVKey
import net.torvald.terrarum.gameactors.NoSerialise
+import net.torvald.terrarum.gameactors.WorldUpdater
import net.torvald.terrarum.itemproperties.ItemRemapTable
import net.torvald.terrarum.itemproperties.ItemTable
import net.torvald.terrarum.spriteassembler.ADProperties
@@ -20,7 +21,7 @@ import java.util.*
* Created by minjaesong on 2015-12-31.
*/
-class IngamePlayer : ActorHumanoid, HasAssembledSprite, NoSerialise {
+class IngamePlayer : ActorHumanoid, HasAssembledSprite, NoSerialise, WorldUpdater {
val creationTime = App.getTIME_T()
var lastPlayTime = App.getTIME_T() // cumulative value for the savegame