f689ac7 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

f689ac7 — Peter John 2026-11-02T13:51:37+05:30

T6: KaM map viewer (P1)

Files changed (1) hide show

plum-game/kam/Main.plum +258 -0

plum-game/kam/Main.plum ADDED Viewed

@@ -0,0 +1,258 @@
+# A Knights and Merchants map viewer: terrain tiles and map objects drawn through
+# the game host, a camera that pans (arrows / WASD) and zooms about the mouse
+# (wheel), and a minimap in the bottom-right corner that centres the camera on click.
+module main
+import std/Str
+import std/Int
+import std/Float
+import std/Bool
+import std/Array
+import std/Grid
+import std/Vec2
+import std/Color
+import std/Game
+primitive View =
+  TileSize = 32.0       # world units per tile
+  MinScale = 0.25
+  MaxScale = 4.0
+  PanSpeed = 600.0      # screen pixels per second
+  MiniSize = 160.0      # minimap's longest side in screen pixels
+  MiniMargin = 8.0
+  MapPath = "Maps/A new Beginning/A new Beginning.map"
+# The inclusive tile columns and rows to draw.
+struct TileRange(x0: Int, y0: Int, x1: Int, y1: Int)
+# The minimap's placement on screen: top-left corner and pixels per tile.
+struct MiniRect(x: Float, y: Float, cell: Float)
+# World point (x, y) sits at the screen's top-left; one world unit is `scale` pixels.
+record Camera(x: Float, y: Float, scale: Float) =
+  fun screenToWorld(self, p: Vec2) -> Vec2 =
+    Vec2(x: self.x + p.x / self.scale, y: self.y + p.y / self.scale)
+  fun worldToScreen(self, p: Vec2) -> Vec2 =
+    Vec2(x: {p.x - self.x} * self.scale, y: {p.y - self.y} * self.scale)
+  # Keeps the view inside a `w` x `h` world on a `sw` x `sh` screen; an axis the
+  # world doesn't fill is centred.
+  fun clampTo(self, w: Float, h: Float, sw: Float, sh: Float) =
+    vw := sw / self.scale
+    vh := sh / self.scale
+    if vw >= w
+      self.x = {w - vw} / 2.0
+    else
+      self.x = self.x.max(0.0).min(w - vw)
+    if vh >= h
+      self.y = {h - vh} / 2.0
+    else
+      self.y = self.y.max(0.0).min(h - vh)
+  # Multiplies the zoom by `factor` (scale stays within MinScale..MaxScale) keeping the
+  # world point under `screen` fixed.
+  fun zoomAt(self, screen: Vec2, factor: Float) =
+    anchor := self.screenToWorld(screen)
+    self.scale = {self.scale * factor}.max(View.MinScale).min(View.MaxScale)
+    self.x = anchor.x - screen.x / self.scale
+    self.y = anchor.y - screen.y / self.scale
+  # Moves the view so world point `p` is at the screen's centre.
+  fun centerOn(self, p: Vec2, sw: Float, sh: Float) =
+    self.x = p.x - sw / self.scale / 2.0
+    self.y = p.y - sh / self.scale / 2.0
+  # Tiles touching the screen, including partial ones, clamped to a `mapW` x `mapH` map.
+  fun visibleTiles(self, mapW: Int, mapH: Int, sw: Float, sh: Float) -> TileRange =
+    left := self.x.max(0.0)
+    top := self.y.max(0.0)
+    right := {self.x + sw / self.scale}.max(0.0)
+    bottom := {self.y + sh / self.scale}.max(0.0)
+    TileRange(
+      x0: Int(left / View.TileSize).min(mapW - 1),
+      y0: Int(top / View.TileSize).min(mapH - 1),
+      x1: Int(right / View.TileSize).min(mapW - 1),
+      y1: Int(bottom / View.TileSize).min(mapH - 1))
+fun miniRect(sw: Float, sh: Float, mapW: Int, mapH: Int) -> MiniRect =
+  longest := Float(mapW.max(mapH))
+  cell := View.MiniSize / longest
+  MiniRect(
+    x: sw - View.MiniMargin - cell * Float(mapW),
+    y: sh - View.MiniMargin - cell * Float(mapH),
+    cell: cell)
+# World point under screen point `p` of the minimap, or null when `p` is outside it.
+fun miniToWorld(m: MiniRect, mapW: Int, mapH: Int, p: Vec2) -> Vec2? =
+  tx := {p.x - m.x} / m.cell
+  ty := {p.y - m.y} / m.cell
+  if tx < 0.0 || ty < 0.0 || tx >= Float(mapW) || ty >= Float(mapH)
+    return null
+  Vec2(x: tx * View.TileSize, y: ty * View.TileSize)
+record Viewer(
+  cam: Camera,
+  ok: Bool,
+  mapW: Int,
+  mapH: Int,
+  tileset: Int,
+  trees: Int,
+  terrain: Grid[Int],
+  rotation: Grid[Int],
+  objects: Grid[Int],
+  mini: Array[Color])
+export fun init() -> Viewer =
+  tileset := atlasLoad("Tileset")
+  trees := atlasLoad("Trees_a")
+  m := mapLoad(View.MapPath)
+  cam := Camera(x: 0.0, y: 0.0, scale: 1.0)
+  if tileset < 0 || trees < 0 || m < 0
+    return Viewer(
+      cam: cam, ok: false, mapW: 1, mapH: 1, tileset: tileset, trees: trees,
+      terrain: Grid.filled(1, 1, 0), rotation: Grid.filled(1, 1, 0),
+      objects: Grid.filled(1, 1, 0), mini: Array[Color]())
+  w := mapWidth(m)
+  h := mapHeight(m)
+  terrain := Grid.filled(w, h, 0)
+  rotation := Grid.filled(w, h, 0)
+  objects := Grid.filled(w, h, 0)
+  mini := Array[Color]()
+  for y := range h
+    for x := range w
+      t := mapTerrain(m, x, y)
+      terrain.set(x, y, t)
+      rotation.set(x, y, mapRotation(m, x, y))
+      objects.set(x, y, mapObject(m, x, y))
+      mini.push(spriteColor(tileset, t + 1))
+  Viewer(
+    cam: cam, ok: true, mapW: w, mapH: h, tileset: tileset, trees: trees,
+    terrain: terrain, rotation: rotation, objects: objects, mini: mini)
+fun worldW(v: Viewer) -> Float =
+  Float(v.mapW) * View.TileSize
+fun worldH(v: Viewer) -> Float =
+  Float(v.mapH) * View.TileSize
+export fun update(v: Viewer, dt: Float) =
+  if !v.ok
+    return
+  sw := screenWidth()
+  sh := screenHeight()
+  step := View.PanSpeed * dt / v.cam.scale
+  if isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
+    v.cam.x = v.cam.x - step
+  if isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
+    v.cam.x = v.cam.x + step
+  if isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
+    v.cam.y = v.cam.y - step
+  if isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
+    v.cam.y = v.cam.y + step
+  wheel := mouseWheel()
+  if wheel != 0.0
+    v.cam.zoomAt(mousePos(), Float(1.1).pow(wheel))
+  if isMouseDown(Mouse.Left)
+    target := miniToWorld(miniRect(sw, sh, v.mapW, v.mapH), v.mapW, v.mapH, mousePos())
+    if t := target
+      v.cam.centerOn(t, sw, sh)
+  v.cam.clampTo(worldW(v), worldH(v), sw, sh)
+export fun draw(v: Viewer) =
+  clear(Color.Black)
+  sw := screenWidth()
+  sh := screenHeight()
+  if !v.ok
+    drawText("assets not found", 20.0, 40.0, 24.0, Color.White)
+    return
+  setCamera(v.cam.x, v.cam.y, v.cam.scale)
+  r := v.cam.visibleTiles(v.mapW, v.mapH, sw, sh)
+  for y := range r.y1 - r.y0 + 1
+    for x := range r.x1 - r.x0 + 1
+      tx := r.x0 + x
+      ty := r.y0 + y
+      drawTile(v.tileset, v.terrain.get(tx, ty) + 1, Float(tx) * View.TileSize,
+        Float(ty) * View.TileSize, View.TileSize, v.rotation.get(tx, ty), Color.White)
+  for y := range r.y1 - r.y0 + 1
+    for x := range r.x1 - r.x0 + 1
+      tx := r.x0 + x
+      ty := r.y0 + y
+      o := v.objects.get(tx, ty)
+      if o != 0
+        drawSprite(v.trees, o, Float(tx) * View.TileSize, Float(ty) * View.TileSize,
+          false, Color.White)
+  resetCamera()
+  drawMinimap(v, sw, sh)
+  drawText("FPS {Int(1.0 / frameTime().max(0.0001))}", 8.0, 20.0, 20.0, Color.Yellow)
+fun drawMinimap(v: Viewer, sw: Float, sh: Float) =
+  m := miniRect(sw, sh, v.mapW, v.mapH)
+  for y := range v.mapH
+    for x := range v.mapW
+      drawRect(m.x + Float(x) * m.cell, m.y + Float(y) * m.cell, m.cell, m.cell,
+        v.mini.get(y * v.mapW + x))
+  vx := m.x + v.cam.x * m.cell / View.TileSize
+  vy := m.y + v.cam.y * m.cell / View.TileSize
+  vw := sw / v.cam.scale * m.cell / View.TileSize
+  vh := sh / v.cam.scale * m.cell / View.TileSize
+  drawLine(vx, vy, vx + vw, vy, 1.0, Color.White)
+  drawLine(vx + vw, vy, vx + vw, vy + vh, 1.0, Color.White)
+  drawLine(vx + vw, vy + vh, vx, vy + vh, 1.0, Color.White)
+  drawLine(vx, vy + vh, vx, vy, 1.0, Color.White)
+test "screenToWorld and worldToScreen are inverses"
+  c := Camera(x: 100.0, y: 50.0, scale: 2.0)
+  assert c.screenToWorld(Vec2(x: 20.0, y: 10.0)) == Vec2(x: 110.0, y: 55.0)
+  assert c.worldToScreen(Vec2(x: 110.0, y: 55.0)) == Vec2(x: 20.0, y: 10.0)
+test "zoomAt keeps the world point under the mouse fixed and clamps the scale"
+  c := Camera(x: 100.0, y: 50.0, scale: 2.0)
+  m := Vec2(x: 300.0, y: 200.0)
+  before := c.screenToWorld(m)
+  c.zoomAt(m, 1.5)
+  assert c.scale == 3.0
+  assert c.screenToWorld(m).distance(before) < 0.000001
+  c.zoomAt(m, 100.0)
+  assert c.scale == 4.0
+  c.zoomAt(m, 0.0001)
+  assert c.scale == 0.25
+test "visibleTiles covers the partial tile and clamps to the map"
+  c := Camera(x: 0.0, y: 0.0, scale: 1.0)
+  r := c.visibleTiles(64, 64, 800.0, 600.0)
+  assert r.x0 == 0
+  assert r.y0 == 0
+  assert r.x1 == 25
+  assert r.y1 == 18
+  small := c.visibleTiles(10, 8, 800.0, 600.0)
+  assert small.x1 == 9
+  assert small.y1 == 7
+  far := Camera(x: 3000.0, y: 3000.0, scale: 1.0).visibleTiles(64, 64, 800.0, 600.0)
+  assert far.x1 == 63
+  assert far.y1 == 63
+test "clampTo keeps the view in the map and centres a small map"
+  c := Camera(x: -50.0, y: 5000.0, scale: 1.0)
+  c.clampTo(2048.0, 2048.0, 800.0, 600.0)
+  assert c.x == 0.0
+  assert c.y == 1448.0
+  c.x = 5000.0
+  c.clampTo(2048.0, 2048.0, 800.0, 600.0)
+  assert c.x == 1248.0
+  s := Camera(x: 99.0, y: 99.0, scale: 1.0)
+  s.clampTo(320.0, 240.0, 800.0, 600.0)
+  assert s.x == -240.0
+  assert s.y == -180.0
+test "a minimap click centres the camera"
+  m := miniRect(800.0, 600.0, 64, 64)
+  assert m.cell == 2.5
+  assert m.x == 632.0
+  assert m.y == 432.0
+  w := miniToWorld(m, 64, 64, Vec2(x: 632.0 + 25.0, y: 432.0 + 50.0)) ?: Vec2.Zero
+  assert w == Vec2(x: 320.0, y: 640.0)
+  assert miniToWorld(m, 64, 64, Vec2(x: 10.0, y: 10.0)) == null
+  c := Camera(x: 0.0, y: 0.0, scale: 2.0)
+  c.centerOn(w, 800.0, 600.0)
+  assert c.screenToWorld(Vec2(x: 400.0, y: 300.0)) == w