M9a: stationer i flera våningar med trappor

- level: Point har Z; banor kan ha floors (lika stora rutnät med namn),
  gamla grid-banor läses som en våning; trappor U/D på samma x,y en våning
  upp/ner valideras parvis; Neighbors ger grannar över våningar så att
  Path, lösbarhet, spärregel och Unreachable fungerar; skyltar har z
- sim: att kliva på en trappa flyttar spelaren till andra änden
  (FloorChanges); dimman är per våning och avslöjar trappans andra ände;
  tåg hörs/syns bara på egen våning
- game: bara spelarens våning ritas (följare på andra våningar döljs),
  HUD och minikarta visar våningens namn, trappgrafik i genart och färg på
  minikartan
- bana 004 Tokyo (svårighet 3, tre i sällskapet): start under mark på B1,
  trappa upp till 1F med perronger; generatorn gör våningar med trappor
  som flaskhalsar; ordboken utökad
- testbotar och tools/shots förstår trappor; två våningsbilder
- docs/README/wiki uppdaterade

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/sim/fog.go

@@ -9,23 +9,24 @@ const FogRadius = 3
 // Fog håller reda på vilka rutor spelaren har sett i den här omgången.
 // Minikartan ritar bara sedda rutor plus riktmärken som alltid syns.
 type Fog struct {
-	w, h           int
+	w, h, floors   int
 	seen           []bool
 	Radius         int
 	count          int
 	ExtraLandmarks bool // toaletter, kiosker och automater syns alltid (skillen Lokalkännedom)
 }
 
-// NewFog skapar en tom dimma för banan.
+// NewFog skapar en tom dimma för banan (alla våningar).
 func NewFog(l *level.Level, radius int) *Fog {
-	return &Fog{w: l.Width(), h: l.Height(), seen: make([]bool, l.Width()*l.Height()), Radius: radius}
+	n := max(1, l.NumFloors())
+	return &Fog{w: l.Width(), h: l.Height(), floors: n, seen: make([]bool, l.Width()*l.Height()*n), Radius: radius}
 }
 
 func (f *Fog) idx(p level.Point) (int, bool) {
-	if p.X < 0 || p.Y < 0 || p.X >= f.w || p.Y >= f.h {
+	if p.X < 0 || p.Y < 0 || p.Z < 0 || p.X >= f.w || p.Y >= f.h || p.Z >= f.floors {
 		return 0, false
 	}
-	return p.Y*f.w + p.X, true
+	return (p.Z*f.h+p.Y)*f.w + p.X, true
 }
 
 // Seen rapporterar om rutan har setts.
@@ -41,8 +42,9 @@ func (f *Fog) mark(p level.Point) {
 	}
 }
 
-// Reveal avslöjar allt inom Radius steg från from via passerbara rutor,
-// samt väggarna som gränsar till dem (så att gångarnas form syns).
+// Reveal avslöjar allt inom Radius steg från from via passerbara rutor på
+// samma våning, samt väggarna som gränsar till dem (så att gångarnas form
+// syns). Trappans andra ände avslöjas också.
 func (f *Fog) Reveal(l *level.Level, from level.Point) {
 	dist := map[level.Point]int{from: 0}
 	queue := []level.Point{from}
@@ -50,10 +52,16 @@ func (f *Fog) Reveal(l *level.Level, from level.Point) {
 		p := queue[0]
 		queue = queue[1:]
 		f.mark(p)
+		switch l.At(p) {
+		case level.StairsUp:
+			f.mark(p.Up())
+		case level.StairsDown:
+			f.mark(p.Down())
+		}
 		for dx := -1; dx <= 1; dx++ {
 			for dy := -1; dy <= 1; dy++ {
-				n := level.Point{X: p.X + dx, Y: p.Y + dy}
-				if !l.At(n.X, n.Y).Passable() {
+				n := level.Point{X: p.X + dx, Y: p.Y + dy, Z: p.Z}
+				if !l.At(n).Passable() {
 					f.mark(n) // gränsande vägg
 				}
 			}
@@ -62,8 +70,8 @@ func (f *Fog) Reveal(l *level.Level, from level.Point) {
 			continue
 		}
 		for _, d := range [...]level.Point{{X: 1}, {X: -1}, {Y: 1}, {Y: -1}} {
-			n := level.Point{X: p.X + d.X, Y: p.Y + d.Y}
-			if _, ok := dist[n]; ok || !l.At(n.X, n.Y).Passable() {
+			n := level.Point{X: p.X + d.X, Y: p.Y + d.Y, Z: p.Z}
+			if _, ok := dist[n]; ok || !l.At(n).Passable() {
 				continue
 			}
 			dist[n] = dist[p] + 1
@@ -75,8 +83,8 @@ func (f *Fog) Reveal(l *level.Level, from level.Point) {
 // Landmark är rutor som alltid syns på minikartan: perrongerna (avgångarna),
 // starten och spärrarna – det man orienterar sig efter.
 func Landmark(l *level.Level, p level.Point) bool {
-	switch l.At(p.X, p.Y) {
-	case level.Platform, level.WrongPlatform, level.Spawn, level.Gate:
+	switch l.At(p) {
+	case level.Platform, level.WrongPlatform, level.Spawn, level.Gate, level.StairsUp, level.StairsDown:
 		return true
 	}
 	return false
@@ -88,7 +96,7 @@ func (f *Fog) Visible(l *level.Level, p level.Point) bool {
 		return true
 	}
 	if f.ExtraLandmarks {
-		switch l.At(p.X, p.Y) {
+		switch l.At(p) {
 		case level.Toilet, level.Kiosk, level.TicketMachine:
 			return true
 		}
@@ -98,9 +106,11 @@ func (f *Fog) Visible(l *level.Level, p level.Point) bool {
 
 // RevealAll avslöjar hela banan (kartan köpt som item).
 func (f *Fog) RevealAll(l *level.Level) {
-	for y := 0; y < l.Height(); y++ {
-		for x := 0; x < l.Width(); x++ {
-			f.mark(level.Point{X: x, Y: y})
+	for z := 0; z < l.NumFloors(); z++ {
+		for y := 0; y < l.Height(); y++ {
+			for x := 0; x < l.Width(); x++ {
+				f.mark(level.Point{X: x, Y: y, Z: z})
+			}
 		}
 	}
 }
@@ -111,14 +121,17 @@ func (f *Fog) Count() int { return f.count }
 // Explored är andelen passerbara rutor som setts, 0..1.
 func (f *Fog) Explored(l *level.Level) float64 {
 	total, seen := 0, 0
-	for y := 0; y < l.Height(); y++ {
-		for x := 0; x < l.Width(); x++ {
-			if !l.At(x, y).Passable() {
-				continue
-			}
-			total++
-			if f.Seen(level.Point{X: x, Y: y}) {
-				seen++
+	for z := 0; z < l.NumFloors(); z++ {
+		for y := 0; y < l.Height(); y++ {
+			for x := 0; x < l.Width(); x++ {
+				p := level.Point{X: x, Y: y, Z: z}
+				if !l.At(p).Passable() {
+					continue
+				}
+				total++
+				if f.Seen(p) {
+					seen++
+				}
 			}
 		}
 	}