Tool and grand exchange fixes (#1051)

* Fix map viewer zoom wobble #16

* Add map viewer coordinate setting #16

* Small render fixes

* Fix grand exchange instant sell giving cash back

Fix grand exchange ranges not syncing

Fix not being able to buy and sell items without trade limits

* Replace map dumper gouraud triangle renderer to fix tile rendering closes #710

Author: GregHib

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

@@ -42,7 +42,10 @@ class OpenOffers(
         }
     }
 
-    fun active(offer: ExchangeOffer): Boolean = (if (offer.sell) selling(offer.item) else buying(offer.item))[offer.price]?.any { it.id == offer.id } ?: false
+    fun active(offer: ExchangeOffer): Boolean {
+        val map = if (offer.sell) selling(offer.item) else buying(offer.item)
+        return map[offer.price]?.any { it.id == offer.id } ?: false
+    }
 
     fun add(offer: ExchangeOffer) {
         add(offer.id, offer.item, offer.price, offer.state.sell)

game/src/main/kotlin/content/social/trade/exchange/GrandExchange.kt

@@ -205,7 +205,7 @@ class GrandExchange(
                     val marketPrice = history.marketPrice(offer.item)
                     val instantPrice = marketPrice + (marketPrice * percent).toInt()
                     if (offer.price >= instantPrice) {
-                        exchange(offer, pending.account, instantPrice, mutableListOf(OpenOffer(remaining = offer.amount, lastActive = 0)))
+                        exchange(offer, pending.account, offer.price, mutableListOf(OpenOffer(remaining = offer.amount, lastActive = 0)))
                         break
                     }
                 }
@@ -240,6 +240,7 @@ class GrandExchange(
         } else {
             player.removeVarbit("grand_exchange_ranges", "slot_$index")
         }
+        player.sendVariable("grand_exchange_ranges")
         val itemDef = ItemDefinitions.get(offer.item)
         player.client?.grandExchange(index, offer.state.int, itemDef.id, offer.price, offer.amount, offer.completed, offer.coins)
     }
@@ -253,9 +254,12 @@ class GrandExchange(
         val required = offer.amount - offer.completed
         val available = open.remaining
         var traded = if (required >= available) available else required
-        traded = traded.coerceAtMost(limits.limit(if (offer.sell) open.account else account, offer.item))
-        if (traded <= 0) {
-            return false
+        val limit = limits.limit(if (offer.sell) open.account else account, offer.item)
+        if (limit != -1) {
+            traded = traded.coerceAtMost(limit)
+            if (traded <= 0) {
+                return false
+            }
         }
         // Update existing offer
         claim(offer.id, account, offer.item, traded, traderPrice, offer.price, offer.sell)

tools/src/main/kotlin/world/gregs/voidps/tools/map/render/draw/TileLevel.kt

@@ -257,7 +257,7 @@ class TileLevel(
         var ignore = false
         if (colours.size == 2 && vertexIndices1.size == 2 && (colours[0] == colours[1] || textures[0] != -1 && textures[0] == textures[1])) {
             ignore = true
-            for (i in 1..1) {
+            for (i in vertexIndices1.indices) {
                 val xOffset = xOffsets[vertexIndices1[i]]
                 val yOffset = yOffsets[vertexIndices1[i]]
                 if (xOffset != 0 && xOffset != tileUnits || yOffset != 0 && yOffset != tileUnits) {

tools/src/main/kotlin/world/gregs/voidps/tools/map/render/raster/Raster.kt

@@ -6,17 +6,13 @@ import java.awt.Point
 import java.awt.image.BufferedImage
 import java.io.File
 import javax.imageio.ImageIO
-import kotlin.math.abs
 import kotlin.math.max
 import kotlin.math.min
 
 class Raster(private val bi: BufferedImage) {
     val width: Int = bi.width
     val height: Int = bi.height
 
-    private var minX = 0
-    private var minY = 0
-
     fun get(x: Int, y: Int): Int = bi.getRGB(x, y)
 
     fun set(x: Int, y: Int, value: Int) {
@@ -33,110 +29,67 @@ class Raster(private val bi: BufferedImage) {
         val minY = min(y1, min(y2, y3))
         val maxY = max(y1, max(y2, y3))
 
-        val used = Array(maxX - minX + 1) { BooleanArray(maxY - minY + 1) }
-
-        this.minX = minX
-        this.minY = minY
-
-        bresenhamLine(used, x1, y1, x2, y2, colour1, colour2)
-        bresenhamLine(used, x1, y1, x3, y3, colour1, colour3)
-        bresenhamLine(used, x2, y2, x3, y3, colour2, colour3)
+        val area = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)
+        if (area == 0) {
+            return
+        }
 
-        // Find right point
-        for (y in minY until maxY) {
-            for (x in minX until maxX) {
-                if (used[x - this.minX][y - this.minY]) {
-                    val leftColour = get(x, y)
-                    for (rx in maxX downTo minX) {
-                        if (used[rx - this.minX][y - this.minY]) {
-                            bresenhamLine(used, x, y, rx, y, leftColour, get(rx, y))
-                            break
-                        }
+        val exclude = if (area > 0) -1 else 1
+        val bias1 = edgeBias(x2, y2, x3, y3, area, exclude)
+        val bias2 = edgeBias(x3, y3, x1, y1, area, exclude)
+        val bias3 = edgeBias(x1, y1, x2, y2, area, exclude)
+
+        val r1 = colour1 shr 16 and 0xff
+        val g1 = colour1 shr 8 and 0xff
+        val b1 = colour1 and 0xff
+        val r2 = colour2 shr 16 and 0xff
+        val g2 = colour2 shr 8 and 0xff
+        val b2 = colour2 and 0xff
+        val r3 = colour3 shr 16 and 0xff
+        val g3 = colour3 shr 8 and 0xff
+        val b3 = colour3 and 0xff
+
+        val areaF = area.toFloat()
+        for (y in minY..maxY) {
+            if (y !in 0..<height) {
+                continue
+            }
+            for (x in minX..maxX) {
+                if (x !in 0..<width) {
+                    continue
+                }
+                val e1 = (x3 - x2) * (y - y2) - (y3 - y2) * (x - x2)
+                val e2 = (x1 - x3) * (y - y3) - (y1 - y3) * (x - x3)
+                val e3 = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1)
+                if (area > 0) {
+                    if (e1 + bias1 < 0 || e2 + bias2 < 0 || e3 + bias3 < 0) {
+                        continue
+                    }
+                } else {
+                    if (e1 + bias1 > 0 || e2 + bias2 > 0 || e3 + bias3 > 0) {
+                        continue
                     }
-                    break
                 }
+               val w1 = e1 / areaF
+                val w2 = e2 / areaF
+                val w3 = 1f - w1 - w2
+                val r = (w1 * r1 + w2 * r2 + w3 * r3).toInt().coerceIn(0, 255)
+                val g = (w1 * g1 + w2 * g2 + w3 * g3).toInt().coerceIn(0, 255)
+                val b = (w1 * b1 + w2 * b2 + w3 * b3).toInt().coerceIn(0, 255)
+                set(x, y, -16777216 or (r shl 16) or (g shl 8) or b)
             }
         }
     }
 
-    private fun bresenhamLine(used: Array<BooleanArray>, x0: Int, y0: Int, x1: Int, y1: Int, colour1: Int, colour2: Int) {
-        var x0 = x0
-        var y0 = y0
-
-        val deltaWidth = x1 - x0
-        val deltaHeight = y1 - y0
-
-        var dx0 = 0
-        var dy0 = 0
-        var dx1 = 0
-        var dy1 = 0
-
-        if (deltaWidth < 0) {
-            dx0 = -1
-        } else if (deltaWidth > 0) {
-            dx0 = 1
-        }
-        if (deltaHeight < 0) {
-            dy0 = -1
-        } else if (deltaHeight > 0) {
-            dy0 = 1
-        }
-        if (deltaWidth < 0) {
-            dx1 = -1
-        } else if (deltaWidth > 0) {
-            dx1 = 1
-        }
-
-        var longest = abs(deltaWidth)
-        var shortest = abs(deltaHeight)
-
-        if (longest <= shortest) {
-            longest = abs(deltaHeight)
-            shortest = abs(deltaWidth)
-            if (deltaHeight < 0) {
-                dy1 = -1
-            } else if (deltaHeight > 0) {
-                dy1 = 1
-            }
-            dx1 = 0
-        }
-        var numerator = longest shr 1
-        val red1 = colour1 shr 16 and 0xff
-        val green1 = colour1 shr 8 and 0xff
-        val blue1 = colour1 and 0xff
-        val red2 = colour2 shr 16 and 0xff
-        val green2 = colour2 shr 8 and 0xff
-        val blue2 = colour2 and 0xff
-
-        val rStep = (red2 - red1).toFloat() / longest
-        val gStep = (green2 - green1).toFloat() / longest
-        val bStep = (blue2 - blue1).toFloat() / longest
-
-        for (i in 0..longest) {
-            // Colour computation
-            val r = (red1 + rStep * i).toDouble()
-            val g = (green1 + gStep * i).toDouble()
-            val b = (blue1 + bStep * i).toDouble()
-
-            // Pixel writing
-            if (y0 > -1 && x0 > -1 && y0 < height && x0 < width) {
-                val pixel = (abs(r).toInt() shl 16 or (abs(g).toInt() shl 8) or abs(b).toInt())
-                if (pixel > 0) {
-                    set(x0, y0, -16777216 or pixel)
-                }
-                used[x0 - minX][y0 - minY] = true
-            }
-
-            numerator += shortest
-            if (numerator >= longest) {
-                numerator -= longest
-                x0 += dx0
-                y0 += dy0
-            } else {
-                x0 += dx1
-                y0 += dy1
-            }
+    private fun edgeBias(ax: Int, ay: Int, bx: Int, by: Int, area: Int, exclude: Int): Int {
+        val dx = bx - ax
+        val dy = by - ay
+        val topLeft = if (area > 0) {
+            dy < 0 || (dy == 0 && dx < 0)
+        } else {
+            dy > 0 || (dy == 0 && dx > 0)
         }
+        return if (topLeft) 0 else exclude
     }
 
     companion object {

tools/src/main/kotlin/world/gregs/voidps/tools/map/view/draw/MapView.kt

@@ -40,8 +40,14 @@ class MapView : JPanel() {
     /*
         Offset from view 0, 0 to top left of world map
      */
-    var offsetX = 0
-    var offsetY = 0
+    private var offsetXd = 0.0
+    private var offsetYd = 0.0
+    var offsetX: Int
+        get() = offsetXd.toInt()
+        set(value) { offsetXd = value.toDouble() }
+    var offsetY: Int
+        get() = offsetYd.toInt()
+        set(value) { offsetYd = value.toDouble() }
     var level = 0
         private set
 
@@ -140,6 +146,10 @@ class MapView : JPanel() {
 
     fun viewToImageY(viewY: Int) = viewY - offsetY
 
+    fun viewToImageXd(viewX: Int): Double = viewX - offsetXd
+
+    fun viewToImageYd(viewY: Int): Double = viewY - offsetYd
+
     fun imageToViewX(imageX: Int) = imageX + offsetX
 
     fun imageToViewY(imageY: Int) = imageY + offsetY
@@ -204,6 +214,23 @@ class MapView : JPanel() {
         update()
     }
 
+    /**
+     * Aligns the viewport so that the map position currently under ([viewX], [viewY]) stays
+     * fixed after a scale change. [preZoomImageX]/[preZoomImageY] are the exact (fractional)
+     * image-space coordinates captured *before* the scale was updated (i.e. `viewX - offsetXd`).
+     *
+     * Uses doubles throughout to avoid the integer-division truncation that snaps the anchor
+     * to a tile corner and causes drift across multiple zoom steps.
+     *
+     * Also refreshes the hover overlay at ([viewX], [viewY]) after updating the offset, so
+     * the highlight doesn't bounce while the mouse is stationary.
+     */
+    fun alignToImage(viewX: Int, viewY: Int, preZoomImageX: Double, preZoomImageY: Double, oldScale: Int) {
+        offsetXd = viewX - preZoomImageX * scale / oldScale
+        offsetYd = viewY - preZoomImageY * scale / oldScale
+        update(viewX, viewY)
+    }
+
     fun offset(mapX: Int, mapY: Int, level: Int = 0) {
         offsetX += mapToImageX(mapX)
         offsetY += mapToImageY(mapY)

tools/src/main/kotlin/world/gregs/voidps/tools/map/view/interact/MouseZoom.kt

@@ -9,22 +9,29 @@ class MouseZoom(private val view: MapView, private val type: ZoomType) : MouseWh
         private set
 
     override fun mouseWheelMoved(e: MouseWheelEvent) {
-        val mapX = when (type) {
-            ZoomType.Centre -> view.viewToMapX(view.getCentreX())
-            ZoomType.Mouse -> view.viewToMapX(e.x)
+        val anchorViewX = when (type) {
+            ZoomType.Centre -> view.getCentreX()
+            ZoomType.Mouse -> e.x
         }
-        val mapY = when (type) {
-            ZoomType.Centre -> view.viewToMapY(view.getCentreY())
-            ZoomType.Mouse -> view.viewToMapY(e.y)
+        val anchorViewY = when (type) {
+            ZoomType.Centre -> view.getCentreY()
+            ZoomType.Mouse -> e.y
         }
+        val imageX = view.viewToImageXd(anchorViewX)
+        val imageY = view.viewToImageYd(anchorViewY)
+
         val offset = e.unitsToScroll.coerceIn(-1, 1)
         val previous = this.scale
         this.scale = (this.scale - offset).coerceIn(ZOOM_MIN, ZOOM_MAX)
         if (this.scale != previous) {
-            view.updateZoom(e.x, e.y)
             when (type) {
-                ZoomType.Centre -> view.centreOn(mapX, mapY)
-                ZoomType.Mouse -> view.align(e.x, e.y, mapX, mapY)
+                ZoomType.Centre -> {
+                    val mapX = (imageX / previous).toInt()
+                    val mapY = (imageY / previous).toInt()
+                    view.updateZoom(anchorViewX, anchorViewY)
+                    view.centreOn(mapX, mapY)
+                }
+                ZoomType.Mouse -> view.alignToImage(anchorViewX, anchorViewY, imageX, imageY, previous)
             }
         }
     }

tools/src/main/kotlin/world/gregs/voidps/tools/map/view/ui/OptionsPane.kt

@@ -10,11 +10,30 @@ class OptionsPane(private val view: MapView) : JPanel() {
     private val tileY = JTextField("16383")
     private val tileLevel = JTextField("4")
 
+    // Guard flag: true while we are programmatically updating fields from a camera move,
+    // so the ActionListeners don't fire and cause an infinite loop.
+    private var updatingFromCamera = false
+
     fun updatePosition(mapX: Int, mapY: Int, level: Int) {
-        tileX.text = mapX.toString()
-        tileY.text = mapY.toString()
-        tileLevel.text = level.toString()
-        region.text = Region.id(mapX / 64, mapY / 64).toString()
+        updatingFromCamera = true
+        try {
+            tileX.text = mapX.toString()
+            tileY.text = mapY.toString()
+            tileLevel.text = level.toString()
+            region.text = Region.id(mapX / 64, mapY / 64).toString()
+        } finally {
+            updatingFromCamera = false
+        }
+    }
+
+    private fun navigateToFields() {
+        if (updatingFromCamera) return
+        val x = tileX.text.toIntOrNull() ?: return
+        val y = tileY.text.toIntOrNull() ?: return
+        val lvl = tileLevel.text.toIntOrNull()?.coerceIn(0, 3) ?: return
+        view.centreOn(x, view.flipMapY(y), lvl)
+        view.updateLevel(lvl)
+        region.text = Region.id(x / 64, y / 64).toString()
     }
 
     init {
@@ -28,6 +47,10 @@ class OptionsPane(private val view: MapView) : JPanel() {
         }
         add(region)
 
+        tileX.addActionListener { navigateToFields() }
+        tileY.addActionListener { navigateToFields() }
+        tileLevel.addActionListener { navigateToFields() }
+
         val coordinates = JPanel().apply {
             layout = BoxLayout(this, BoxLayout.X_AXIS)
             add(tileX)