M9: navigeringslägen, linjenät och terminal

internal/nav med resources/data/network.json (76 stationer, 11 linjer,
Yamanote som ringlinje). Tåg bedöms från lineId + terminus mot banans
station/to: rätt, fel håll, för långt bort (fler än 12 stationer) eller
ingen trafik; correct räknas ut för nätkopplade banor, 1-4 rätta tåg.
Tågresan visar linjens riktiga stationer. Nya förlustorsaker "Fel håll"
och "För långt bort". Listläge (nästa tåg nere till vänster) och
skyltläge (+50 % poäng) växlas med N på bankartan och sparas; -mode.
Terminalen: biljettautomaten visar linjetavlan på nätbanor. Perronger
P p Q q R r. Bana 006 Ikebukuro med fyra perronger. Banorna 001-005
kopplade till nätet. Skript: waitover och pick calm; poängraden
radbryts; skärmdumpar uppdaterade.

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

internal/level/level_test.go

@@ -2,12 +2,12 @@ package level
 
 import (
 	"math"
-	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 	"testing"
 
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/nav"
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/res"
 )
 
@@ -122,11 +122,7 @@ func TestAllShippedLevels(t *testing.T) {
 	}
 	for _, f := range files {
 		t.Run(filepath.Base(f), func(t *testing.T) {
-			b, err := os.ReadFile(f)
-			if err != nil {
-				t.Fatal(err)
-			}
-			l, err := Parse(b)
+			l, err := LoadFile(f) // kopplar nätbanor till network.json (rätt tåg räknas ut där)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -146,6 +142,18 @@ func TestAllShippedLevels(t *testing.T) {
 				if tr.Track == "" {
 					t.Errorf("tåg %d saknar spårnummer", i)
 				}
+				if l.Networked() && tr.Verdict == nav.Unjudged {
+					t.Errorf("tåg %d är inte bedömt av nätet", i)
+				}
+			}
+			if l.Networked() && len(l.Trains) > 1 {
+				trap := false
+				for _, tr := range l.Trains {
+					trap = trap || !tr.Correct
+				}
+				if !trap {
+					t.Error("nätbanor med flera tåg ska ha minst ett fel tåg att undvika")
+				}
 			}
 			if l.Party > 1 && (len(l.Find(Toilet)) == 0 || len(l.Find(Kiosk)) == 0) {
 				t.Errorf("banor med sällskap behöver minst en toalett (W) och en kiosk (K)")
@@ -256,6 +264,112 @@ func TestPath(t *testing.T) {
 	}
 }
 
+// TestAnnotateWithNetwork: rätt/fel tåg räknas ut från linjenätet, inklusive
+// fel håll och för långt bort, och orimliga kopplingar ger fel.
+func TestAnnotateWithNetwork(t *testing.T) {
+	net, err := nav.Parse([]byte(`{"stations":[
+	  {"id":"a","name":{"ja":"あ"}},{"id":"b","name":{"ja":"い"}},{"id":"c","name":{"ja":"う"}},{"id":"d","name":{"ja":"え"}},{"id":"x","name":{"ja":"さ"}}],
+	  "lines":[{"id":"l1","name":{"ja":"一線"},"stations":["a","b","c","d"]},{"id":"l2","name":{"ja":"二線"},"stations":["x","b"]}]}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := `{"id":"net","name":{"sv":"x"},"difficulty":1,"destination":{"ja":"う"},"station":"b","to":"c",
+	  "grid":["#########","#S.GP.Gp#","#..GQ.Gq#","#########"],
+	  "trains":[
+	   {"platform":"P","track":"1","line":{"ja":"一線"},"destination":{"ja":"え"},"lineId":"l1","terminus":"d"},
+	   {"platform":"p","track":"2","line":{"ja":"一線"},"destination":{"ja":"あ"},"lineId":"l1","terminus":"a"},
+	   {"platform":"Q","track":"3","line":{"ja":"二線"},"destination":{"ja":"さ"},"lineId":"l2","terminus":"x"},
+	   {"platform":"q","track":"4","line":{"ja":"一線"},"destination":{"ja":"え"},"lineId":"l1","terminus":"d"}]}`
+	l, err := Parse([]byte(src))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !l.Networked() || l.Net != nil {
+		t.Fatal("nätbana före Annotate")
+	}
+	if err := l.Annotate(net); err != nil {
+		t.Fatal(err)
+	}
+	want := []nav.Verdict{nav.Direct, nav.WrongDirection, nav.NoService, nav.Direct}
+	for i, tr := range l.Trains {
+		if tr.Verdict != want[i] || tr.Correct != (want[i] == nav.Direct) {
+			t.Errorf("tåg %d: verdict=%v correct=%v, vill ha %v", i, tr.Verdict, tr.Correct, want[i])
+		}
+	}
+	if l.Net != net || !l.Solvable() || l.CorrectPlatform() != (Point{X: 4, Y: 1}) {
+		t.Fatal("kopplad bana ska vara lösbar via P")
+	}
+	// Fel: okänd linje, fel linjenamn, resmål som inte matchar, inget rätt tåg, nät saknas.
+	cases := map[string]string{
+		"okänd linje":     strings.Replace(src, `"lineId":"l1","terminus":"d"}`, `"lineId":"nope","terminus":"d"}`, 1),
+		"fel linjenamn":   strings.Replace(src, `"line":{"ja":"二線"}`, `"line":{"ja":"一線"}`, 1),
+		"fel resmålstext": strings.Replace(src, `"destination":{"ja":"う"},"station"`, `"destination":{"ja":"え"},"station"`, 1),
+		"inget rätt tåg":  strings.Replace(src, `"to":"c"`, `"to":"a"`, 1),
+		"obedömbart tåg":  strings.Replace(src, `"lineId":"l1","terminus":"a"}`, `"lineId":"l1","terminus":"b"}`, 1),
+	}
+	for name, c := range cases {
+		l, err := Parse([]byte(c))
+		if err != nil {
+			t.Fatalf("%s: %v", name, err)
+		}
+		if err := l.Annotate(net); err == nil {
+			t.Errorf("%s: skulle ha gett fel", name)
+		}
+	}
+	if err := l.Annotate(nil); err == nil {
+		t.Error("nätbana utan nät ska ge fel")
+	}
+	// Banor utan station/to påverkas inte.
+	plain, err := Parse([]byte(`{"id":"p","name":{"sv":"x"},"difficulty":1,"destination":{"ja":"う"},"grid":["#####","#S.P#","#####"],
+	  "trains":[{"platform":"P","track":"1","line":{"ja":"一線"},"destination":{"ja":"う"},"correct":true}]}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := plain.Annotate(net); err != nil || plain.Net != nil || plain.Trains[0].Verdict != nav.Unjudged || !plain.Trains[0].Correct {
+		t.Fatal("okopplad bana ska lämnas i fred")
+	}
+}
+
+func TestPlatformTilesAndShippedVerdicts(t *testing.T) {
+	for _, tl := range PlatformTiles {
+		if !tl.IsPlatform() || !knownTiles[tl] {
+			t.Errorf("%c ska vara en känd perrong", tl)
+		}
+	}
+	if Gate.IsPlatform() || Floor.IsPlatform() {
+		t.Fatal("spärr/golv är inte perronger")
+	}
+	dir, err := res.Path("data", "levels")
+	if err != nil {
+		t.Fatal(err)
+	}
+	l, err := LoadFile(filepath.Join(dir, "005-ueno.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tr := l.TrainAt(WrongPlatform); tr == nil || tr.Verdict != nav.WrongDirection {
+		t.Fatalf("005: Keihin-Tohoku mot Omiya ska vara fel håll, fick %v", tr)
+	}
+	l6, err := LoadFile(filepath.Join(dir, "006-ikebukuro.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := map[Tile]nav.Verdict{}
+	for _, tr := range l6.Trains {
+		got[Tile(tr.Platform[0])] = tr.Verdict
+	}
+	want := map[Tile]nav.Verdict{Platform: nav.Direct, Platform2: nav.Direct, WrongPlatform: nav.WrongDirection, Platform3: nav.TooFar}
+	for tl, v := range want {
+		if got[tl] != v {
+			t.Errorf("006 perrong %c: %v, vill ha %v", tl, got[tl], v)
+		}
+	}
+	all, err := LoadAll(dir)
+	if err != nil || len(all) < 7 {
+		t.Fatalf("LoadAll: %v (%d banor)", err, len(all))
+	}
+}
+
 func TestUngatedPlatforms(t *testing.T) {
 	// Perrong utan spärr framför -> rapporteras.
 	l := mustParse(t, sample)