Inlärning (framsteg, stjärnor, ordlista) och M4: lämmeltåget

Inlärning enligt Björns regler: - lang.Knowledge: framsteg per ord (3 läsningar = känt), språkpoäng, köp av valfria ord (kostnad = tier), Award per stjärna - sim.Run: RunOptions med seed; stjärnor 1–3 mot par (parSec eller kortaste vägen × 0,5 s + 20 s); ≥2 stjärnor lär resmålets ord; att stanna på skylt/perrong ger seedad 35 % chans till framsteg per okänt ord - game: ordlista (L) med kända ord, framsteg och kostnad; stjärnor, poäng och inlärt resmål på resultatskärmen; framstegsnotis; flaggor -points/-seed M4 lämmeltåget: - sim.Party: medlemmar med mat/dryck/toa-mätare, behov under tröskel, seedade händelser var 45 s / antal (toa, törst, hunger, distraktion), fartstraff, toalett (W, 3 s/person) och kiosk (K, 150 ¥/person), följare på ledarens spår - level: rutor W och K, party och parSec i bandatan; banor med sällskap måste ha toalett och kiosk (testas); 001 har 2, 002 har 3 i sällskapet - game: följare med färgton, behovsmarkering över huvudet, mätarpanel, facilitetsrutor med förlopp; genart ritar toalett och kiosk - skriptläget: move stannar exakt på målrutan även när farten inte är bildruteexakt (sällskapets fartstraff), stall-skydd mot väggar - docs/README/wiki/spelbeskrivning uppdaterade Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-10-23 21:29:09 +02:00
parent b67493fddb
commit daa2089eda
38 changed files with 1436 additions and 115 deletions
--- a/internal/game/assets.go
+++ b/internal/game/assets.go
@@ -24,8 +24,12 @@ const LineH = 12
 // Ordningen på rutorna i resources/sprites/tiles.png (måste matcha tools/genart).
 var tileOrder = []level.Tile{
 	level.Wall, level.Floor, level.Spawn, level.Platform, level.Gate, level.TicketMachine, level.Sign,
+	level.Wall, // plats 7 = tågvagnen (laddas separat som Train)
+	level.Toilet, level.Kiosk,
 }

+const trainIndex = 7
+
 // Assets är allt som laddats från resources/.
 type Assets struct {
 	ResDir    string
@@ -55,14 +59,17 @@ func LoadAssets() (*Assets, error) {
 	sub := func(i int) *ebiten.Image {
 		return tiles.SubImage(image.Rect(i*TileSize, 0, (i+1)*TileSize, TileSize)).(*ebiten.Image)
 	}
-	if w, need := tiles.Bounds().Dx(), TileSize*(len(tileOrder)+1); w < need {
+	if w, need := tiles.Bounds().Dx(), TileSize*len(tileOrder); w < need {
 		return nil, fmt.Errorf("tiles.png är %d px bred, behöver minst %d", w, need)
 	}
 	for i, t := range tileOrder {
+		if i == trainIndex {
+			continue
+		}
 		a.Tiles[t] = sub(i)
 	}
 	a.Tiles[level.WrongPlatform] = a.Tiles[level.Platform] // samma utseende; tåget avgör
-	a.Train = sub(len(tileOrder))
+	a.Train = sub(trainIndex)

 	player, err := loadImage("sprites", "player.png")
 	if err != nil {
--- a/internal/game/game.go
+++ b/internal/game/game.go
@@ -8,6 +8,7 @@ import (
 	"github.com/hajimehoshi/ebiten/v2"

 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/lang"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
 )

 // Intern upplösning. Allt ritas i denna storlek och skalas sedan upp med
@@ -29,6 +30,7 @@ type Scene interface {
 type Game struct {
 	Assets    *Assets
 	Know      *lang.Knowledge // spelarens japanska – följer med mellan banor (sparas i M8)
+	fixedSeed uint64          // >0: alla banor startar med denna seed (tester/skärmdumpar)
 	scene     Scene
 	next      Scene
 	smokeLeft int // >0: avsluta automatiskt efter så många uppdateringar
@@ -42,6 +44,8 @@ type Options struct {
 	SmokeFrames int      // >0 avslutar efter N uppdateringar (smoke-test)
 	Script      string   // skriptade steg för skärmdumpar/tester, se script.go
 	KnownWords  []string // ord spelaren kan från start (för tester/skärmdumpar)
+	Points      int      // språkpoäng från start (för tester/skärmdumpar)
+	Seed        uint64   // >0: fast seed för banorna (för tester/skärmdumpar)
 }

 // New laddar resurser och bygger spelet.
@@ -54,13 +58,15 @@ func New(opt Options) (*Game, error) {
 	for _, w := range opt.KnownWords {
 		g.Know.Learn(w)
 	}
+	g.Know.Points = opt.Points
+	g.fixedSeed = opt.Seed
 	if opt.Script != "" {
 		if g.script, err = parseScript(opt.Script); err != nil {
 			return nil, err
 		}
 	}
 	if opt.LevelID != "" {
-		s, err := NewLevelScene(a, opt.LevelID, g.Know)
+		s, err := NewLevelScene(a, opt.LevelID, g.Know, g.seed())
 		if err != nil {
 			return nil, err
 		}
@@ -104,3 +110,11 @@ func (g *Game) Draw(screen *ebiten.Image) {

 // Layout talar om för Ebitengine vilken intern upplösning vi ritar i.
 func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) { return ScreenW, ScreenH }
+
+// seed ger seeden för en ny banomgång: fast om -seed angetts, annars färsk.
+func (g *Game) seed() rng.Seed {
+	if g.fixedSeed > 0 {
+		return rng.FromInt(g.fixedSeed)
+	}
+	return rng.NewSeed()
+}
--- a/internal/game/input.go
+++ b/internal/game/input.go
@@ -76,6 +76,11 @@ func helpJustPressed() bool {
 	return virtual.pressed["h"] || inpututil.IsKeyJustPressed(ebiten.KeyH) || gamepadJustPressed(ebiten.StandardGamepadButtonRightTop)
 }

+// wordsJustPressed: L = ordlistan/språkträdet.
+func wordsJustPressed() bool {
+	return virtual.pressed["l"] || inpututil.IsKeyJustPressed(ebiten.KeyL) || gamepadJustPressed(ebiten.StandardGamepadButtonLeftRight)
+}
+
 // menuMove returnerar -1/+1 när användaren just tryckte upp/ner i en meny.
 func menuMove() int {
 	switch {
--- a/internal/game/scene_level.go
+++ b/internal/game/scene_level.go
@@ -5,22 +5,22 @@ import (
 	"image/color"
 	"math"
 	"path/filepath"
+	"strings"

 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/vector"

 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/lang"
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/level"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/sim"
 )

-// Spelarens grundfart i rutor per sekund (blir en stat i M7).
-const playerSpeed = 6.0
-
 // Hur länge tillfälliga meddelanden visas.
 const (
-	deniedShowSec  = 2.0
-	learnedShowSec = 3.0
+	deniedShowSec     = 2.0
+	learnedShowSec    = 3.0
+	progressedShowSec = 2.5
 )

 // LevelScene är själva spelandet av en bana. All spellogik ligger i sim.Run;
@@ -33,15 +33,15 @@ type LevelScene struct {
 }

 // NewLevelScene laddar banan och ställer spelaren på startrutan. know är
-// spelarens japanska, som delas mellan banor.
-func NewLevelScene(a *Assets, id string, know *lang.Knowledge) (*LevelScene, error) {
+// spelarens japanska, som delas mellan banor; seed styr omgångens slump.
+func NewLevelScene(a *Assets, id string, know *lang.Knowledge, seed rng.Seed) (*LevelScene, error) {
 	lvl, err := level.LoadFile(filepath.Join(a.LevelsDir, id+".json"))
 	if err != nil {
 		return nil, err
 	}
 	s := &LevelScene{
 		id:  id,
-		run: sim.NewRun(lvl, playerSpeed, a.Dict, know),
+		run: sim.NewRun(lvl, sim.RunOptions{Dict: a.Dict, Know: know, Seed: seed}),
 		cam: sim.NewCamera(ScreenW, ScreenH, float64(lvl.Width()*TileSize), float64(lvl.Height()*TileSize)),
 	}
 	s.followPlayer()
@@ -51,6 +51,9 @@ func NewLevelScene(a *Assets, id string, know *lang.Knowledge) (*LevelScene, err
 // PlayerTile returnerar rutan spelaren står på/lämnar (används av skriptläget).
 func (s *LevelScene) PlayerTile() level.Point { return s.run.Player.Tile }

+// PlayerMoving rapporterar om spelaren är mellan två rutor (skriptläget).
+func (s *LevelScene) PlayerMoving() bool { return s.run.Player.Moving() }
+
 // TrainHere rapporterar om spelaren står på en perrong vars tåg är inne (skriptläget).
 func (s *LevelScene) TrainHere() bool {
 	tr, at, _ := s.run.PlatformHere()
@@ -131,14 +134,73 @@ func (s *LevelScene) Draw(g *Game, screen *ebiten.Image) {
 		}
 	}

-	px, py := s.run.Player.WorldPos(TileSize)
+	// Följarna ritas bakifrån så att ledaren hamnar överst.
+	leader := s.run.Player
+	followers := s.run.Party.Followers()
+	for i := len(followers); i >= 1; i-- {
+		from, to := s.run.Party.FollowerTiles(i)
+		fx := float64(from.X*TileSize) + float64((to.X-from.X)*TileSize)*leader.Progress
+		fy := float64(from.Y*TileSize) + float64((to.Y-from.Y)*TileSize)*leader.Progress
+		facing := sim.Down
+		switch {
+		case to.X > from.X:
+			facing = sim.Right
+		case to.X < from.X:
+			facing = sim.Left
+		case to.Y < from.Y:
+			facing = sim.Up
+		}
+		op.GeoM.Reset()
+		op.GeoM.Translate(ox+math.Round(fx), oy+math.Round(fy))
+		op.ColorScale.Reset()
+		t := memberTints[i%len(memberTints)]
+		op.ColorScale.Scale(t[0], t[1], t[2], 1)
+		screen.DrawImage(g.Assets.PlayerFrame(facing, leader.Moving() && from != to, s.animT), &op)
+		op.ColorScale.Reset()
+		s.drawUrge(g, screen, followers[i-1], int(ox+math.Round(fx)), int(oy+math.Round(fy)))
+	}
+
+	px, py := leader.WorldPos(TileSize)
 	op.GeoM.Reset()
 	op.GeoM.Translate(ox+math.Round(px), oy+math.Round(py))
-	screen.DrawImage(g.Assets.PlayerFrame(s.run.Player.Facing, s.run.Player.Moving(), s.animT), &op)
+	screen.DrawImage(g.Assets.PlayerFrame(leader.Facing, leader.Moving(), s.animT), &op)
+	s.drawUrge(g, screen, s.run.Party.Members[0], int(ox+math.Round(px)), int(oy+math.Round(py)))

 	s.drawHUD(g, screen)
 }

+// memberTints färgar följarnas sprites tills de har egna.
+var memberTints = [][3]float32{{1, 1, 1}, {1, 0.75, 0.55}, {0.7, 0.95, 0.75}, {0.8, 0.7, 1}, {1, 0.95, 0.55}}
+
+// urgeMark är tecknet som visas över huvudet på någon med ett behov.
+func urgeMark(u sim.Urge) (string, color.Color) {
+	switch u {
+	case sim.NeedToilet:
+		return "WC", colBad
+	case sim.Thirsty:
+		return "飲", colEnglish
+	case sim.Hungry:
+		return "食", colWarn
+	case sim.Distracted:
+		return "?", colDim
+	}
+	return "", nil
+}
+
+func (s *LevelScene) drawUrge(g *Game, screen *ebiten.Image, m *sim.Member, x, y int) {
+	mark, col := urgeMark(m.Urge)
+	if mark == "" {
+		if m.Meters.Min() <= 0 {
+			mark, col = "!!", colBad
+		} else {
+			return
+		}
+	}
+	w := g.Assets.Width(mark)
+	vector.DrawFilledRect(screen, float32(x+8-w/2-1), float32(y-11), float32(w+2), 11, colPanel, false)
+	g.Assets.Draw(screen, mark, x+8-w/2, y-12, col)
+}
+
 // drawHUD ritar den övre raden (bana, resmål, tid, kort, japanska-nivå) och
 // inforutan (perrong, skylt, nekad spärr, nytt ord).
 func (s *LevelScene) drawHUD(g *Game, screen *ebiten.Image) {
@@ -152,9 +214,9 @@ func (s *LevelScene) drawHUD(g *Game, screen *ebiten.Image) {
 	}
 	a.Draw(screen, r.Level.Name.Get(UILang), 4, 0, colText)
 	a.Draw(screen, a.T("hud.destination")+": "+dest, 4+a.Width(r.Level.Name.Get(UILang))+12, 0, colKnown)
-	a.Draw(screen, fmt.Sprintf("%s %3.0fs  %s %d  %s %d¥  %s Lv%d·%d  %s", a.T("hud.time"), r.Time,
-		a.T("hud.steps"), r.Steps, a.T("hud.card"), r.Card.Balance, a.T("hud.japanese"), r.Know.Level(), r.Know.Count(),
-		a.T("hud.controls")), 4, LineH, colDim)
+	a.Draw(screen, fmt.Sprintf("%s %3.0fs  %s %d  %s %d¥  %s Lv%d·%d", a.T("hud.time"), r.Time,
+		a.T("hud.steps"), r.Steps, a.T("hud.card"), r.Card.Balance, a.T("hud.japanese"), r.Know.Level(), r.Know.Count()), 4, LineH, colDim)
+	s.drawMeters(g, screen)

 	if r.Outcome != sim.Ongoing {
 		return
@@ -164,6 +226,16 @@ func (s *LevelScene) drawHUD(g *Game, screen *ebiten.Image) {
 		lines = append(lines, plainLine(fmt.Sprintf("%s: %s = %s (%s)", a.T("hud.learned"), r.Learned,
 			entry.Translation(UILang), entry.Romaji), colKnown))
 	}
+	if len(r.Progressed) > 0 && r.Time-r.ProgressedAt < progressedShowSec {
+		lines = append(lines, a.wrapLine(plainLine(a.T("hud.progress")+": "+strings.Join(r.Progressed, ", "), colWarn), ScreenW-8)...)
+	}
+	if urges := r.Party.Urges(); len(urges) > 0 {
+		var parts []string
+		for _, m := range urges {
+			parts = append(parts, m.Name+": "+a.T("urge."+m.Urge.String()))
+		}
+		lines = append(lines, a.wrapLine(plainLine(strings.Join(parts, "   "), colWarn), ScreenW-8)...)
+	}
 	if len(lines) == 0 {
 		return
 	}
@@ -182,9 +254,13 @@ func (s *LevelScene) drawHUD(g *Game, screen *ebiten.Image) {
 	vector.DrawFilledRect(screen, 0, float32(y), ScreenW, 2, accent, false)
 	a.drawLines(screen, lines, 4, y+4)
 	if bar {
+		p := r.HelpProgress()
+		if r.Facility.Active {
+			p = r.FacilityProgress()
+		}
 		by := float32(y + h - 7)
 		vector.DrawFilledRect(screen, 4, by, ScreenW-8, 4, colBar, false)
-		vector.DrawFilledRect(screen, 4, by, float32((ScreenW-8)*r.HelpProgress()), 4, colKnown, false)
+		vector.DrawFilledRect(screen, 4, by, float32((ScreenW-8)*p), 4, colKnown, false)
 	}
 }

@@ -199,8 +275,7 @@ func (s *LevelScene) infoLines(a *Assets) (lines []line, accent color.Color, bar

 	if tr, at, secs := r.PlatformHere(); tr != nil {
 		// Avgångstavlan är en skylt som alla andra: japanska, sedd genom kunskapen.
-		ja := fmt.Sprintf("%s%s %s %s%s", tr.Track, a.T("hud.track_suffix_ja"), tr.Line.Get("ja"), tr.Destination.Get("ja"), a.T("hud.for_ja"))
-		rd := lang.Render(a.Dict, r.Know, ja, UILang)
+		rd := lang.Render(a.Dict, r.Know, tr.BoardText(), UILang)
 		lines = append(lines, a.wrapLine(shownLine(rd.Original, colText, r.Know.ShowsReadings()), maxW)...)
 		lines = append(lines, a.wrapLine(shownLine(rd.Partial, colText, false), maxW)...)
 		if english {
@@ -240,8 +315,46 @@ func (s *LevelScene) infoLines(a *Assets) (lines []line, accent color.Color, bar
 		return lines, accent, bar
 	}

+	switch lvl.At(tile.X, tile.Y) {
+	case level.Toilet:
+		if r.Facility.Active {
+			return []line{plainLine(a.T("hud.toilet_busy"), colDim)}, colGood, true
+		}
+		if n := len(r.Party.NeedsToilet()); n > 0 {
+			return []line{plainLine(fmt.Sprintf(a.T("hud.toilet_prompt"), n, sim.ToiletSecPerMember*float64(n)), colGood)}, colGood, false
+		}
+		return []line{plainLine(a.T("hud.toilet_none"), colDim)}, accent, false
+	case level.Kiosk:
+		if n := len(r.Party.NeedsKiosk()); n > 0 {
+			return []line{plainLine(fmt.Sprintf(a.T("hud.kiosk_prompt"), n, sim.KioskPriceYen*n), colGood)}, colGood, false
+		}
+		return []line{plainLine(a.T("hud.kiosk_none"), colDim)}, accent, false
+	}
 	if r.DeniedAt >= 0 && r.Time-r.DeniedAt < deniedShowSec {
 		return []line{plainLine(a.T("hud.gate_denied"), colBad)}, colBad, false
 	}
 	return nil, accent, false
 }
+
+// drawMeters ritar sällskapets mat/dryck/toa-mätare uppe till höger.
+func (s *LevelScene) drawMeters(g *Game, screen *ebiten.Image) {
+	members := s.run.Party.Members
+	const w, gap = 14, 4
+	x0 := ScreenW - 4 - len(members)*(w+gap)
+	for i, m := range members {
+		x := float32(x0 + i*(w+gap))
+		g.Assets.Draw(screen, string([]rune(m.Name)[:1]), int(x)+3, 0, colDim)
+		for j, v := range []struct {
+			val float64
+			col color.Color
+		}{{m.Meters.Food, colWarn}, {m.Meters.Drink, colEnglish}, {m.Meters.Toilet, colGood}} {
+			y := float32(13 + j*3)
+			vector.DrawFilledRect(screen, x, y, w, 2, colBar, false)
+			c := v.col
+			if v.val < sim.UrgeThreshold {
+				c = colBad
+			}
+			vector.DrawFilledRect(screen, x, y, float32(w*v.val/100), 2, c, false)
+		}
+	}
+}
--- a/internal/game/scene_menu.go
+++ b/internal/game/scene_menu.go
@@ -54,10 +54,14 @@ func (m *MenuScene) Update(g *Game) error {
 	if backJustPressed() {
 		return ebiten.Termination
 	}
+	if wordsJustPressed() {
+		g.SetScene(NewWordsScene(g.Assets, m))
+		return nil
+	}
 	if n := len(m.entries); n > 0 {
 		m.sel = (m.sel + menuMove() + n) % n
 		if confirmJustPressed() {
-			s, err := NewLevelScene(g.Assets, m.entries[m.sel].id, g.Know)
+			s, err := NewLevelScene(g.Assets, m.entries[m.sel].id, g.Know, g.seed())
 			if err != nil {
 				m.err = err
 				return nil
@@ -87,7 +91,8 @@ func (m *MenuScene) Draw(g *Game, screen *ebiten.Image) {
 	if m.err != nil {
 		a.Draw(screen, "FEL: "+m.err.Error(), 8, ScreenH-40, colBad)
 	}
-	a.Draw(screen, fmt.Sprintf("%s  Lv%d  %d %s", a.T("hud.japanese"), g.Know.Level(), g.Know.Count(), a.T("hud.words")), 8, ScreenH-38, colDim)
+	a.Draw(screen, fmt.Sprintf("%s  Lv%d  %d %s  %s %d", a.T("hud.japanese"), g.Know.Level(), g.Know.Count(), a.T("hud.words"),
+		a.T("words.points"), g.Know.Points), 8, ScreenH-38, colDim)
 	a.Draw(screen, a.T("menu.hint"), 8, ScreenH-26, colDim)
 	a.Draw(screen, fmt.Sprintf("%s (%s)", buildinfo.Version, buildinfo.Mode), 8, ScreenH-13, colDim)
 }
--- a/internal/game/scene_result.go
+++ b/internal/game/scene_result.go
@@ -2,6 +2,7 @@ package game

 import (
 	"fmt"
+	"strings"

 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/vector"
@@ -19,8 +20,10 @@ func NewResultScene(from *LevelScene) *ResultScene { return &ResultScene{from: f

 func (r *ResultScene) Update(g *Game) error {
 	switch {
+	case wordsJustPressed():
+		g.SetScene(NewWordsScene(g.Assets, r))
 	case inpututil_R():
-		s, err := NewLevelScene(g.Assets, r.from.id, g.Know)
+		s, err := NewLevelScene(g.Assets, r.from.id, g.Know, g.seed())
 		if err != nil {
 			return err
 		}
@@ -47,6 +50,10 @@ func (r *ResultScene) Draw(g *Game, screen *ebiten.Image) {
 	}
 	vector.DrawFilledRect(screen, 20, 36, ScreenW-40, 3, accent, false)
 	a.DrawBig(screen, headline, 28, 44, accent)
+	if run.Outcome == sim.Won {
+		stars := strings.Repeat("★", run.Stars) + strings.Repeat("☆", 3-run.Stars)
+		a.DrawBig(screen, stars, ScreenW-28-a.Width(stars)-8, 44, colWarn)
+	}

 	y := 62
 	if tr := run.Boarded; tr != nil {
@@ -64,10 +71,18 @@ func (r *ResultScene) Draw(g *Game, screen *ebiten.Image) {
 		}
 	}
 	y += 4
-	a.Draw(screen, fmt.Sprintf("%s %.1fs  %s %d  %s %d  %s %d¥", a.T("hud.time"), run.Time,
+	a.Draw(screen, fmt.Sprintf("%s %.1fs (%s %.0fs)  %s %d  %s %d  %s %d¥", a.T("hud.time"), run.Time, a.T("result.par"), run.ParSec(),
 		a.T("hud.steps"), run.Steps, a.T("result.gates"), run.GatePasses, a.T("result.card"), run.Card.Balance), 28, y, colText)
 	y += LineH
-	a.Draw(screen, fmt.Sprintf("%s Lv%d  %d %s  (%d %s)", a.T("hud.japanese"), run.Know.Level(), run.Know.Count(),
-		a.T("hud.words"), run.Know.Helps, a.T("result.helps")), 28, y, colDim)
+	if run.Outcome == sim.Won {
+		msg := fmt.Sprintf("+%d %s", run.PointsEarned, a.T("words.points"))
+		if len(run.LearnedDest) > 0 {
+			msg += "   " + a.T("hud.learned") + ": " + strings.Join(run.LearnedDest, " ") + " (" + a.T("result.destination") + ")"
+		}
+		a.Draw(screen, msg, 28, y, colKnown)
+		y += LineH
+	}
+	a.Draw(screen, fmt.Sprintf("%s Lv%d  %d %s  %s %d  (%d %s)", a.T("hud.japanese"), run.Know.Level(), run.Know.Count(),
+		a.T("hud.words"), a.T("words.points"), run.Know.Points, run.Know.Helps, a.T("result.helps")), 28, y, colDim)
 	a.Draw(screen, a.T("result.hint"), 28, 130, colDim)
 }
--- a/internal/game/scene_words.go
+++ b/internal/game/scene_words.go
@@ -0,0 +1,112 @@
+package game
+
+import (
+	"fmt"
+	"image/color"
+	"sort"
+	"strings"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/lang"
+)
+
+// WordsScene är ordlistan/språkträdet: alla ord i ordboken, vad spelaren
+// kan, framsteg på resten, och möjligheten att lägga språkpoäng på valfria
+// ord. Blir ett riktigt träd med skills i M8.
+type WordsScene struct {
+	back    Scene
+	entries []*lang.Entry
+	sel     int
+	top     int
+	msg     string
+}
+
+const wordsRows = 9
+
+// NewWordsScene listar ordboken sorterad på tier och ord.
+func NewWordsScene(a *Assets, back Scene) *WordsScene {
+	var es []*lang.Entry
+	for _, w := range a.Dict.Words() {
+		es = append(es, a.Dict.Lookup(w))
+	}
+	sort.Slice(es, func(i, j int) bool {
+		if es[i].Tier != es[j].Tier {
+			return es[i].Tier < es[j].Tier
+		}
+		return es[i].Word < es[j].Word
+	})
+	return &WordsScene{back: back, entries: es}
+}
+
+func (w *WordsScene) Update(g *Game) error {
+	if backJustPressed() || wordsJustPressed() {
+		g.SetScene(w.back)
+		return nil
+	}
+	if n := len(w.entries); n > 0 {
+		w.sel = (w.sel + menuMove() + n) % n
+		if w.sel < w.top {
+			w.top = w.sel
+		}
+		if w.sel >= w.top+wordsRows {
+			w.top = w.sel - wordsRows + 1
+		}
+		if confirmJustPressed() {
+			e := w.entries[w.sel]
+			switch {
+			case g.Know.Knows(e.Word):
+				w.msg = g.Assets.T("words.already")
+			case g.Know.Buy(e):
+				w.msg = fmt.Sprintf(g.Assets.T("words.bought"), e.Word, e.Translation(UILang))
+			default:
+				w.msg = fmt.Sprintf(g.Assets.T("words.too_expensive"), lang.WordCost(e))
+			}
+		}
+	}
+	return nil
+}
+
+func (w *WordsScene) Draw(g *Game, screen *ebiten.Image) {
+	a := g.Assets
+	k := g.Know
+	screen.Fill(color.RGBA{24, 20, 37, 255})
+	vector.DrawFilledRect(screen, 0, 0, ScreenW, 22, color.RGBA{38, 43, 68, 255}, false)
+	a.DrawBig(screen, a.T("words.title"), 8, 5, colText)
+	hdr := fmt.Sprintf("%s %d   %s Lv%d  %d/%d %s", a.T("words.points"), k.Points, a.T("hud.japanese"),
+		k.Level(), k.Count(), len(w.entries), a.T("hud.words"))
+	a.Draw(screen, hdr, ScreenW-8-a.Width(hdr), 6, colKnown)
+
+	y0 := 30
+	for i := w.top; i < len(w.entries) && i < w.top+wordsRows; i++ {
+		e := w.entries[i]
+		y := y0 + (i-w.top)*LineH
+		if i == w.sel {
+			vector.DrawFilledRect(screen, 4, float32(y-1), ScreenW-8, LineH, colBar, false)
+		}
+		status, scol := strings.Repeat("●", lang.WordCost(e)), colDim
+		if k.CanBuy(e) {
+			scol = colKnown
+		}
+		wcol := colText
+		switch {
+		case k.Knows(e.Word):
+			status, scol, wcol = "✓", colGood, colKnown
+		case k.ProgressOf(e.Word) > 0:
+			status, scol = fmt.Sprintf("%d/%d", k.ProgressOf(e.Word), lang.ProgressToLearn), colWarn
+		}
+		a.Draw(screen, e.Word, 8, y, wcol)
+		a.Draw(screen, e.Romaji, 92, y, colDim)
+		a.Draw(screen, e.Translation(UILang), 180, y, colText)
+		a.Draw(screen, status, ScreenW-8-a.Width(status), y, scol)
+	}
+	// rullningsindikator
+	if len(w.entries) > wordsRows {
+		a.Draw(screen, fmt.Sprintf("%d-%d / %d", w.top+1, min(len(w.entries), w.top+wordsRows), len(w.entries)), 8, ScreenH-38, colDim)
+	}
+	if w.msg != "" {
+		a.Draw(screen, w.msg, 8, ScreenH-26, colKnown)
+	}
+	a.Draw(screen, a.T("words.hint"), 8, ScreenH-13, colDim)
+}
--- a/internal/game/script.go
+++ b/internal/game/script.go
@@ -20,8 +20,8 @@ import (
 //
 //	wait N          vänta N bildrutor
 //	waittrain       vänta tills tåget vid perrongen spelaren står på är inne
-//	press KEY       tryck enter | esc | r | up | down en bildruta
-//	move DIR N      gå N rutor åt up | down | left | right (släpper när rutorna är avklarade)
+//	press KEY       tryck enter | esc | r | h | l | up | down en bildruta
+//	move DIR N      gå N rutor åt up | down | left | right (stannar exakt där)
 //	shot PATH       spara aktuell bild som PNG (intern upplösning × shotScale)
 //	quit            avsluta spelet
 //
@@ -29,18 +29,22 @@ import (

 const shotScale = 3

+// moveStallFrames: så många bildrutor utan ny ruta räknas som "vägg" och
+// avslutar ett move-steg (annars skulle skriptet hänga för evigt).
+const moveStallFrames = 120
+
 type scriptStep struct {
-	cmd  string
-	arg  string
-	n    int
-	dir  sim.Dir
-	done bool
+	cmd string
+	arg string
+	n   int
+	dir sim.Dir
 }

 type script struct {
 	steps   []scriptStep
 	i       int
 	counter int
+	stall   int
 	lastPos level.Point
 	havePos bool
 }
@@ -108,7 +112,10 @@ func parseDir(s string) sim.Dir {
 }

 // playerTiler implementeras av scener som har en spelare i rutnätet.
-type playerTiler interface{ PlayerTile() level.Point }
+type playerTiler interface {
+	PlayerTile() level.Point
+	PlayerMoving() bool
+}

 // trainWaiter implementeras av scener där man kan vänta på ett tåg.
 type trainWaiter interface{ TrainHere() bool }
@@ -139,26 +146,39 @@ func (s *script) tick(g *Game, frame *ebiten.Image) error {
 		}
 		cur := pt.PlayerTile()
 		if !s.havePos {
-			s.lastPos, s.havePos = cur, true
+			s.lastPos, s.havePos, s.stall = cur, true, 0
 		}
 		if cur != s.lastPos {
 			s.lastPos = cur
 			s.counter++
+			s.stall = 0
+		} else {
+			s.stall++
 		}
-		if s.counter >= st.n {
+		if s.counter >= st.n && !pt.PlayerMoving() {
 			s.advance()
 			return nil
 		}
-		virtual.held = st.dir
+		if s.stall > moveStallFrames { // blockerad av vägg: ge upp steget
+			s.advance()
+			return nil
+		}
+		// Håll riktningen tills sista rutan har påbörjats; släpp sedan så att
+		// figuren stannar exakt där. Hålls tangenten kvar i ankomstbildrutan
+		// fortsätter figuren annars en ruta till när farten (t.ex. med
+		// sällskapets fartstraff) inte är bildruteexakt.
+		if s.counter < st.n-1 || (s.counter == st.n-1 && !pt.PlayerMoving()) {
+			virtual.held = st.dir
+		}
+	case "waittrain":
+		if tw, ok := g.scene.(trainWaiter); !ok || tw.TrainHere() {
+			s.advance()
+		}
 	case "shot":
 		if err := saveShot(frame, st.arg); err != nil {
 			return err
 		}
 		s.advance()
-	case "waittrain":
-		if tw, ok := g.scene.(trainWaiter); !ok || tw.TrainHere() {
-			s.advance()
-		}
 	case "quit":
 		return ebiten.Termination
 	}
@@ -168,6 +188,7 @@ func (s *script) tick(g *Game, frame *ebiten.Image) error {
 func (s *script) advance() {
 	s.i++
 	s.counter = 0
+	s.stall = 0
 	s.havePos = false
 }

--- a/internal/lang/knowledge.go
+++ b/internal/lang/knowledge.go
@@ -4,9 +4,11 @@ import "math"

 // Knowledge är vad spelaren kan: ord ur ordboken och om hen kan läsa kana.
 type Knowledge struct {
-	Words map[string]bool `json:"words"`
-	Kana  bool            `json:"kana"`
-	Helps int             `json:"helps"` // antal gånger spelaren frågat om hjälp
+	Words    map[string]bool `json:"words"`
+	Progress map[string]int  `json:"progress"` // framsteg på ord som ännu inte är kända
+	Points   int             `json:"points"`   // språkpoäng att lägga på valfria ord
+	Kana     bool            `json:"kana"`
+	Helps    int             `json:"helps"` // antal gånger spelaren frågat om hjälp
 }

 // KanaUnlockWords: när så här många kända ord innehåller kana "lossnar"
@@ -20,7 +22,9 @@ const (
 )

 // NewKnowledge börjar från noll.
-func NewKnowledge() *Knowledge { return &Knowledge{Words: map[string]bool{}} }
+func NewKnowledge() *Knowledge {
+	return &Knowledge{Words: map[string]bool{}, Progress: map[string]int{}}
+}

 // Knows rapporterar om ordet är känt.
 func (k *Knowledge) Knows(word string) bool { return k.Words[word] }
@@ -115,3 +119,69 @@ func ShowEnglish(levelID string, x, y, difficulty int) bool {
 	}
 	return float64(h%1000)/1000 < share
 }
+
+// Inlärning utöver hjälp (Björns regler 2026-10-23):
+//   - bra resultat på en bana lär ut resmålets ord (StarsToLearnDestination),
+//   - varje läst okänt ord har chansen ReadChance att ge +1 framsteg; vid
+//     ProgressToLearn framsteg kan man ordet,
+//   - språkpoäng (Points) tjänas på banor och läggs på valfria ord i ordlistan.
+const (
+	ReadChance              = 0.35
+	ProgressToLearn         = 3
+	StarsToLearnDestination = 2
+	PointsPerStar           = 1
+)
+
+// ProgressOf är hur många framsteg ordet har (0 om känt eller aldrig läst).
+func (k *Knowledge) ProgressOf(word string) int {
+	if k.Progress == nil {
+		return 0
+	}
+	return k.Progress[word]
+}
+
+// AddProgress ger ett framsteg på ett okänt ord. Returnerar true om ordet
+// därmed blev känt.
+func (k *Knowledge) AddProgress(word string) bool {
+	if k.Knows(word) {
+		return false
+	}
+	if k.Progress == nil {
+		k.Progress = map[string]int{}
+	}
+	k.Progress[word]++
+	if k.Progress[word] >= ProgressToLearn {
+		delete(k.Progress, word)
+		k.Learn(word)
+		return true
+	}
+	return false
+}
+
+// WordCost är vad ett ord kostar i språkpoäng: dess tier (minst 1).
+func WordCost(e *Entry) int { return max(1, e.Tier) }
+
+// CanBuy rapporterar om ordet går att köpa för poängen.
+func (k *Knowledge) CanBuy(e *Entry) bool {
+	return e != nil && !k.Knows(e.Word) && k.Points >= WordCost(e)
+}
+
+// Buy lär in ordet mot språkpoäng. Returnerar false om det inte går.
+func (k *Knowledge) Buy(e *Entry) bool {
+	if !k.CanBuy(e) {
+		return false
+	}
+	k.Points -= WordCost(e)
+	if k.Progress != nil {
+		delete(k.Progress, e.Word)
+	}
+	k.Learn(e.Word)
+	return true
+}
+
+// Award ger språkpoäng för stjärnor på en klarad bana.
+func (k *Knowledge) Award(stars int) int {
+	p := max(0, stars) * PointsPerStar
+	k.Points += p
+	return p
+}
--- a/internal/lang/lang_test.go
+++ b/internal/lang/lang_test.go
@@ -208,3 +208,43 @@ func TestCharClasses(t *testing.T) {
 		t.Fatal("HasKana/IsJapanese")
 	}
 }
+
+func TestProgressLearnsAfterEnoughReads(t *testing.T) {
+	k := NewKnowledge()
+	for i := 1; i < ProgressToLearn; i++ {
+		if k.AddProgress("改札") || k.ProgressOf("改札") != i || k.Knows("改札") {
+			t.Fatalf("efter %d framsteg: progress=%d known=%v", i, k.ProgressOf("改札"), k.Knows("改札"))
+		}
+	}
+	if !k.AddProgress("改札") || !k.Knows("改札") || k.ProgressOf("改札") != 0 {
+		t.Fatal("tredje framsteget ska lära ordet och nollställa framstegen")
+	}
+	if k.AddProgress("改札") {
+		t.Fatal("kända ord får inga framsteg")
+	}
+}
+
+func TestBuyWordsWithPoints(t *testing.T) {
+	d := testDict()
+	k := NewKnowledge()
+	e1, e3 := d.Lookup("改札"), d.Lookup("新宿駅") // tier 1 resp. 3
+	if WordCost(e1) != 1 || WordCost(e3) != 3 {
+		t.Fatal("kostnad = tier")
+	}
+	if k.CanBuy(e1) || k.Buy(e1) {
+		t.Fatal("utan poäng ska inget gå att köpa")
+	}
+	if got := k.Award(3); got != 3*PointsPerStar || k.Points != got {
+		t.Fatalf("Award = %d, points=%d", got, k.Points)
+	}
+	k.Progress["新宿駅"] = 2
+	if !k.Buy(e3) || !k.Knows("新宿駅") || k.Points != 0 || k.ProgressOf("新宿駅") != 0 {
+		t.Fatalf("köp misslyckades: points=%d known=%v", k.Points, k.Knows("新宿駅"))
+	}
+	if k.CanBuy(e3) {
+		t.Fatal("redan känt ord ska inte gå att köpa")
+	}
+	if k.Award(-2) != 0 || k.Points != 0 {
+		t.Fatal("negativa stjärnor ger inget")
+	}
+}
--- a/internal/level/level.go
+++ b/internal/level/level.go
@@ -29,11 +29,13 @@ const (
 	Gate          Tile = 'G' // spärr (kräver kort/biljett)
 	TicketMachine Tile = 'T' // biljett-/påfyllningsautomat
 	Sign          Tile = 'i' // skylt
+	Toilet        Tile = 'W' // toalett (sällskapets toamätare)
+	Kiosk         Tile = 'K' // kiosk/automat för mat och dryck
 )

 var knownTiles = map[Tile]bool{
 	Wall: true, Floor: true, Spawn: true, Platform: true, WrongPlatform: true,
-	Gate: true, TicketMachine: true, Sign: true,
+	Gate: true, TicketMachine: true, Sign: true, Toilet: true, Kiosk: true,
 }

 // Passable rapporterar om en ruta går att gå på (utan hänsyn till spärrar).
@@ -69,6 +71,7 @@ const (
 	DefaultIntervalSec = 30.0
 	DefaultDwellSec    = 10.0
 	DefaultFareYen     = 200
+	MaxParty           = 5
 )

 // Status returnerar om tåget står vid perrongen vid tiden t, och hur många
@@ -108,6 +111,8 @@ type Level struct {
 	Difficulty   int        `json:"difficulty"`   // 1 (lätt) … 5 (svår)
 	Destination  Text       `json:"destination"`  // dit spelaren ska
 	TimeLimitSec int        `json:"timeLimitSec"` // 0 = ingen tidsgräns
+	ParSec       int        `json:"parSec"`       // "bra tid" för tre stjärnor (0 = räknas ut från kortaste vägen)
+	Party        int        `json:"party"`        // antal i sällskapet inkl. spelaren (0 = 1)
 	FareYen      int        `json:"fareYen"`      // vad spärren drar från kortet (0 = standard)
 	Grid         []string   `json:"grid"`
 	Trains       []Train    `json:"trains"`
@@ -229,8 +234,14 @@ func (l *Level) Validate() error {
 	if l.FareYen == 0 {
 		l.FareYen = DefaultFareYen
 	}
-	if l.FareYen < 0 {
-		return fmt.Errorf("level %s: negativ avgift", l.ID)
+	if l.FareYen < 0 || l.ParSec < 0 || l.Party < 0 {
+		return fmt.Errorf("level %s: negativ avgift/partid/sällskap", l.ID)
+	}
+	if l.Party == 0 {
+		l.Party = 1
+	}
+	if l.Party > MaxParty {
+		return fmt.Errorf("level %s: sällskapet får vara högst %d", l.ID, MaxParty)
 	}
 	// Skyltar: varje post måste stå på en 'i'-ruta och varje 'i'-ruta ha text.
 	seen := map[Point]bool{}
@@ -369,7 +380,7 @@ func (l *Level) UngatedPlatforms() []Point {
 func (l *Level) Unreachable() []Point {
 	reach := l.Reachable()
 	var out []Point
-	for _, t := range []Tile{Platform, WrongPlatform, TicketMachine, Sign, Gate} {
+	for _, t := range []Tile{Platform, WrongPlatform, TicketMachine, Sign, Gate, Toilet, Kiosk} {
 		for _, p := range l.Find(t) {
 			if !reach[p] {
 				out = append(out, p)
@@ -379,6 +390,24 @@ func (l *Level) Unreachable() []Point {
 	return out
 }

+// BoardText är avgångstavlans text på japanska, t.ex. "2番線 成田エクスプレス 新宿方面".
+func (tr *Train) BoardText() string {
+	return tr.Track + "番線 " + tr.Line.Get("ja") + " " + tr.Destination.Get("ja") + "方面"
+}
+
+// CorrectPlatform returnerar en perrongruta med rätt tåg (valideringen
+// garanterar att det finns minst ett rätt tåg vid en befintlig perrong).
+func (l *Level) CorrectPlatform() Point {
+	for _, tr := range l.Trains {
+		if tr.Correct {
+			if pts := l.Find(Tile(tr.Platform[0])); len(pts) > 0 {
+				return pts[0]
+			}
+		}
+	}
+	return l.SpawnPoint()
+}
+
 // CanEnter rapporterar om rutan går att gå in på (för sim.Mover).
 func (l *Level) CanEnter(p Point) bool { return l.At(p.X, p.Y).Passable() }

--- a/internal/level/level_test.go
+++ b/internal/level/level_test.go
@@ -147,6 +147,9 @@ func TestAllShippedLevels(t *testing.T) {
 					t.Errorf("tåg %d saknar spårnummer", i)
 				}
 			}
+			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)")
+			}
 			for _, sg := range l.Signs {
 				if sg.Text["sv"] == "" || sg.Text["en"] == "" {
 					t.Errorf("skylt (%d,%d) saknar sv/en-text", sg.X, sg.Y)
@@ -265,3 +268,23 @@ func TestUngatedPlatforms(t *testing.T) {
 		t.Fatal("banan ska vara lösbar med spärren passerbar")
 	}
 }
+
+func TestPartyAndParDefaults(t *testing.T) {
+	l := mustParse(t, sample)
+	if l.Party != 1 || l.ParSec != 0 {
+		t.Fatalf("party=%d par=%d", l.Party, l.ParSec)
+	}
+	if _, err := Parse([]byte(strings.Replace(sample, `"difficulty": 1`, `"difficulty": 1, "party": 9`, 1))); err == nil {
+		t.Fatal("för stort sällskap ska ge fel")
+	}
+	if l.CorrectPlatform() != (Point{5, 1}) {
+		t.Fatalf("CorrectPlatform = %v", l.CorrectPlatform())
+	}
+	if got := l.Trains[0].BoardText(); got != "番線 A B方面" {
+		t.Fatalf("BoardText = %q", got)
+	}
+	l2 := mustParse(t, strings.Replace(sample, `"#S..#P#"`, `"#SW.KP#"`, 1))
+	if l2.At(2, 1) != Toilet || l2.At(4, 1) != Kiosk || !l2.Solvable() {
+		t.Fatal("W och K ska vara passerbara rutor")
+	}
+}
--- a/internal/sim/party.go
+++ b/internal/sim/party.go
@@ -0,0 +1,265 @@
+package sim
+
+import (
+	"fmt"
+	"math/rand/v2"
+
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/level"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
+)
+
+// Urge är ett behov som en i sällskapet kan få.
+type Urge int
+
+// Behov.
+const (
+	NoUrge     Urge = iota
+	NeedToilet      // måste på toa -> toalettruta (W)
+	Thirsty         // törstig -> kiosk (K)
+	Hungry          // hungrig -> kiosk (K)
+	Distracted      // distraherad av något – går över av sig självt
+)
+
+func (u Urge) String() string {
+	return [...]string{"", "toilet", "thirsty", "hungry", "distracted"}[u]
+}
+
+// Meters är mat, dryck och toa: 100 = allt väl, 0 = akut.
+type Meters struct{ Food, Drink, Toilet float64 }
+
+// Min är den lägsta mätaren.
+func (m Meters) Min() float64 { return min(m.Food, m.Drink, m.Toilet) }
+
+// Lowest returnerar behovet som hör till den lägsta mätaren.
+func (m Meters) Lowest() (Urge, float64) {
+	u, v := Hungry, m.Food
+	if m.Drink < v {
+		u, v = Thirsty, m.Drink
+	}
+	if m.Toilet < v {
+		u, v = NeedToilet, m.Toilet
+	}
+	return u, v
+}
+
+// Member är en i sällskapet. Members[0] är spelaren själv.
+type Member struct {
+	Name   string
+	Meters Meters
+	Urge   Urge
+	UrgeAt float64 // när behovet uppstod
+}
+
+// PartyNames är namnen i den ordning de följer med.
+var PartyNames = []string{"Du", "Anna", "Ville", "Sara", "Omar"}
+
+// Takter och trösklar. Mätarna går från 100 till 0 på ungefär 10/7/8 minuter.
+const (
+	FoodPerSec            = 100.0 / 600
+	DrinkPerSec           = 100.0 / 420
+	ToiletPerSec          = 100.0 / 480
+	UrgeThreshold         = 25.0 // under detta uppstår ett behov av sig självt
+	BaseEventSec          = 45.0 // händelseintervall för en ensam resenär; delas med antalet i sällskapet
+	DistractionSec        = 4.0
+	UrgeSpeedFactor       = 0.8 // någon har ett behov
+	DistractedSpeedFactor = 0.5
+	EmptySpeedFactor      = 0.5 // någon mätare har nått 0
+	KioskPriceYen         = 150
+	ToiletSecPerMember    = 3.0
+	RestoreBelow          = 50.0 // kiosk/toalett hjälper alla under den här nivån
+)
+
+// Party är sällskapet – lämmeltåget – med mätare, behov och följarnas spår.
+type Party struct {
+	Members     []*Member
+	trail       []level.Point // ledarens rutor, senaste sist
+	rand        *rand.Rand
+	nextEventAt float64
+	Events      int      // antal händelser som inträffat
+	Log         []string // händelselogg (tester/HUD)
+}
+
+// NewParty skapar n medlemmar (minst 1) på startrutan. All slump i
+// sällskapet kommer från seed.
+func NewParty(n int, start level.Point, seed rng.Seed) *Party {
+	n = max(1, min(n, len(PartyNames)))
+	p := &Party{rand: seed.New()}
+	for i := 0; i < n; i++ {
+		p.Members = append(p.Members, &Member{Name: PartyNames[i], Meters: Meters{100, 100, 100}})
+	}
+	p.trail = []level.Point{start}
+	p.nextEventAt = p.interval() * (0.5 + p.rand.Float64())
+	return p
+}
+
+// Size är antalet i sällskapet inkl. spelaren.
+func (p *Party) Size() int { return len(p.Members) }
+
+// Followers är alla utom spelaren.
+func (p *Party) Followers() []*Member { return p.Members[1:] }
+
+// interval är tiden mellan händelser: fler i sällskapet = oftare.
+func (p *Party) interval() float64 { return BaseEventSec / float64(p.Size()) }
+
+// Advance sänker mätarna, låter behov uppstå och kör de slumpade
+// händelserna. t är omgångens klocka.
+func (p *Party) Advance(dt, t float64) {
+	for _, m := range p.Members {
+		m.Meters.Food = max(0, m.Meters.Food-FoodPerSec*dt)
+		m.Meters.Drink = max(0, m.Meters.Drink-DrinkPerSec*dt)
+		m.Meters.Toilet = max(0, m.Meters.Toilet-ToiletPerSec*dt)
+		if m.Urge == Distracted && t-m.UrgeAt >= DistractionSec {
+			m.Urge = NoUrge
+		}
+		if m.Urge == NoUrge {
+			if u, v := m.Meters.Lowest(); v < UrgeThreshold {
+				m.setUrge(u, t)
+				p.log(t, m, "behovet uppstod av sig självt")
+			}
+		}
+	}
+	if t >= p.nextEventAt {
+		p.event(t)
+		p.nextEventAt = t + p.interval()*(0.7+0.6*p.rand.Float64())
+	}
+}
+
+// event: en slumpad i sällskapet får ett behov – oftast det som mätaren
+// står lägst i, ibland bara en distraktion.
+func (p *Party) event(t float64) {
+	p.Events++
+	m := p.Members[p.rand.IntN(len(p.Members))]
+	if m.Urge != NoUrge {
+		p.log(t, m, "händelse utan effekt (hade redan ett behov)")
+		return
+	}
+	if p.rand.Float64() < 0.25 {
+		m.setUrge(Distracted, t)
+		p.log(t, m, "blev distraherad")
+		return
+	}
+	u, _ := m.Meters.Lowest()
+	m.setUrge(u, t)
+	// Behovet är på riktigt: dra ned mätaren till tröskeln.
+	switch u {
+	case NeedToilet:
+		m.Meters.Toilet = min(m.Meters.Toilet, UrgeThreshold)
+	case Thirsty:
+		m.Meters.Drink = min(m.Meters.Drink, UrgeThreshold)
+	case Hungry:
+		m.Meters.Food = min(m.Meters.Food, UrgeThreshold)
+	}
+	p.log(t, m, "fick behovet "+u.String())
+}
+
+func (m *Member) setUrge(u Urge, t float64) { m.Urge, m.UrgeAt = u, t }
+
+func (p *Party) log(t float64, m *Member, what string) {
+	p.Log = append(p.Log, fmt.Sprintf("%.1fs %s: %s", t, m.Name, what))
+}
+
+// Urges returnerar de som har ett aktivt behov.
+func (p *Party) Urges() []*Member {
+	var out []*Member
+	for _, m := range p.Members {
+		if m.Urge != NoUrge {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+// SpeedFactor är hur mycket sällskapet saktar ned ledaren.
+func (p *Party) SpeedFactor() float64 {
+	f := 1.0
+	for _, m := range p.Members {
+		switch {
+		case m.Meters.Min() <= 0:
+			f = min(f, EmptySpeedFactor)
+		case m.Urge == Distracted:
+			f = min(f, DistractedSpeedFactor)
+		case m.Urge != NoUrge:
+			f = min(f, UrgeSpeedFactor)
+		}
+	}
+	return f
+}
+
+// NeedsToilet är de som har nytta av en toalett just nu.
+func (p *Party) NeedsToilet() []*Member {
+	var out []*Member
+	for _, m := range p.Members {
+		if m.Urge == NeedToilet || m.Meters.Toilet < RestoreBelow {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+// NeedsKiosk är de som har nytta av mat eller dryck just nu.
+func (p *Party) NeedsKiosk() []*Member {
+	var out []*Member
+	for _, m := range p.Members {
+		if m.Urge == Thirsty || m.Urge == Hungry || m.Meters.Drink < RestoreBelow || m.Meters.Food < RestoreBelow {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+// UseToilet fyller toamätaren för alla som behövde och tar bort behovet.
+// Returnerar antalet som gick.
+func (p *Party) UseToilet() int {
+	n := 0
+	for _, m := range p.NeedsToilet() {
+		m.Meters.Toilet = 100
+		if m.Urge == NeedToilet {
+			m.Urge = NoUrge
+		}
+		n++
+	}
+	return n
+}
+
+// BuyAtKiosk köper mat/dryck åt alla som behöver, en betalning per person
+// via pay (returnerar false när pengarna är slut). Returnerar antalet
+// försörjda.
+func (p *Party) BuyAtKiosk(pay func(yen int) bool) int {
+	n := 0
+	for _, m := range p.NeedsKiosk() {
+		if !pay(KioskPriceYen) {
+			break
+		}
+		m.Meters.Food, m.Meters.Drink = 100, 100
+		if m.Urge == Thirsty || m.Urge == Hungry {
+			m.Urge = NoUrge
+		}
+		n++
+	}
+	return n
+}
+
+// OnLeaderArrived registrerar att ledaren nått en ny ruta; följarna följer
+// spåret bakom.
+func (p *Party) OnLeaderArrived(tile level.Point) {
+	if p.trail[len(p.trail)-1] == tile {
+		return
+	}
+	p.trail = append(p.trail, tile)
+	if keep := p.Size() + 1; len(p.trail) > keep {
+		p.trail = p.trail[len(p.trail)-keep:]
+	}
+}
+
+// FollowerTiles returnerar var följare i (1 = närmast ledaren) står och vart
+// hen är på väg; följaren interpoleras med samma framsteg som ledaren.
+func (p *Party) FollowerTiles(i int) (from, to level.Point) {
+	at := func(k int) level.Point {
+		if k < 0 {
+			return p.trail[0]
+		}
+		return p.trail[k]
+	}
+	n := len(p.trail)
+	return at(n - 1 - i), at(n - i)
+}
--- a/internal/sim/party_test.go
+++ b/internal/sim/party_test.go
@@ -0,0 +1,143 @@
+package sim
+
+import (
+	"strings"
+	"testing"
+
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/level"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
+)
+
+func TestMetersDecayAtRates(t *testing.T) {
+	p := NewParty(2, pt(1, 1), rng.FromInt(1))
+	for i := 0; i < 60*60; i++ { // 60 s
+		p.Advance(frame, float64(i)*frame)
+	}
+	m := p.Members[1].Meters
+	for _, c := range []struct {
+		name string
+		got  float64
+		rate float64
+	}{{"mat", m.Food, FoodPerSec}, {"dryck", m.Drink, DrinkPerSec}, {"toa", m.Toilet, ToiletPerSec}} {
+		if want := 100 - c.rate*60; c.got > want+0.5 || c.got < want-0.5 {
+			t.Errorf("%s = %.1f, vill ha ~%.1f", c.name, c.got, want)
+		}
+	}
+}
+
+// TestMoreMembersMoreEvents: fler i lämmeltåget ger fler händelser.
+func TestMoreMembersMoreEvents(t *testing.T) {
+	count := func(n int) int {
+		p := NewParty(n, pt(1, 1), rng.FromInt(3))
+		for i := 0; i < 60*600; i++ { // 10 min
+			p.Advance(frame, float64(i)*frame)
+		}
+		return p.Events
+	}
+	one, four := count(1), count(4)
+	if one < 8 || one > 20 {
+		t.Fatalf("ensam: %d händelser på 10 min (väntat ~13)", one)
+	}
+	if four < 3*one {
+		t.Fatalf("fyra i sällskapet (%d) ska ge klart fler händelser än en (%d)", four, one)
+	}
+}
+
+func TestEventsAreSeeded(t *testing.T) {
+	run := func(seed uint64) []string {
+		p := NewParty(3, pt(1, 1), rng.FromInt(seed))
+		for i := 0; i < 60*300; i++ {
+			p.Advance(frame, float64(i)*frame)
+		}
+		return p.Log
+	}
+	a, b := run(9), run(9)
+	if strings.Join(a, "|") != strings.Join(b, "|") {
+		t.Fatal("samma seed ska ge samma händelser")
+	}
+	if strings.Join(a, "|") == strings.Join(run(10), "|") {
+		t.Fatal("olika seeds ska ge olika händelser")
+	}
+	if len(a) == 0 {
+		t.Fatal("inga händelser på fem minuter")
+	}
+}
+
+func TestUrgesSlowAndFacilitiesRestore(t *testing.T) {
+	p := NewParty(3, pt(1, 1), rng.FromInt(1))
+	if p.SpeedFactor() != 1 {
+		t.Fatal("utan behov full fart")
+	}
+	anna, ville := p.Members[1], p.Members[2]
+	anna.setUrge(NeedToilet, 0)
+	anna.Meters.Toilet = 10
+	if p.SpeedFactor() != UrgeSpeedFactor || len(p.NeedsToilet()) != 1 {
+		t.Fatalf("toabehov: fart=%.2f behöver=%d", p.SpeedFactor(), len(p.NeedsToilet()))
+	}
+	if n := p.UseToilet(); n != 1 || anna.Urge != NoUrge || anna.Meters.Toilet != 100 || p.SpeedFactor() != 1 {
+		t.Fatalf("toaletten: n=%d urge=%v toa=%.0f", n, anna.Urge, anna.Meters.Toilet)
+	}
+
+	ville.setUrge(Thirsty, 0)
+	ville.Meters.Drink = 5
+	anna.Meters.Food = 40 // under RestoreBelow men utan behov – kiosken hjälper ändå
+	paid := 0
+	pay := func(yen int) bool { paid += yen; return true }
+	if n := p.BuyAtKiosk(pay); n != 2 || paid != 2*KioskPriceYen || ville.Urge != NoUrge || ville.Meters.Drink != 100 || anna.Meters.Food != 100 {
+		t.Fatalf("kiosken: n=%d betalt=%d", n, paid)
+	}
+	// Slut på pengar: ingen försörjs.
+	ville.Meters.Drink = 5
+	if n := p.BuyAtKiosk(func(int) bool { return false }); n != 0 || ville.Meters.Drink != 5 {
+		t.Fatal("utan pengar ska ingen få något")
+	}
+
+	ville.Meters.Drink = 100 // annars uppstår törsten igen när distraktionen går över
+	p.nextEventAt = 1e9      // inga slumphändelser i resten av testet
+	ville.setUrge(Distracted, 100)
+	if p.SpeedFactor() != DistractedSpeedFactor {
+		t.Fatal("distraktion halverar farten")
+	}
+	p.Advance(frame, 100+DistractionSec)
+	if ville.Urge != NoUrge {
+		t.Fatal("distraktionen ska gå över av sig själv")
+	}
+	ville.Meters.Food = 0
+	if p.SpeedFactor() != EmptySpeedFactor {
+		t.Fatal("tom mätare ger stor fartstraff")
+	}
+}
+
+func TestUrgeArisesBelowThreshold(t *testing.T) {
+	p := NewParty(1, pt(1, 1), rng.FromInt(1))
+	p.Members[0].Meters.Drink = UrgeThreshold - 1
+	p.Advance(frame, 0)
+	if p.Members[0].Urge != Thirsty {
+		t.Fatalf("urge=%v", p.Members[0].Urge)
+	}
+}
+
+func TestFollowersTrailLeader(t *testing.T) {
+	p := NewParty(3, pt(1, 1), rng.FromInt(1))
+	for _, tile := range []level.Point{pt(2, 1), pt(3, 1), pt(3, 2)} {
+		p.OnLeaderArrived(tile)
+	}
+	p.OnLeaderArrived(pt(3, 2)) // samma ruta igen: ingen dubblett
+	if from, to := p.FollowerTiles(1); from != pt(3, 1) || to != pt(3, 2) {
+		t.Fatalf("följare 1: %v -> %v", from, to)
+	}
+	if from, to := p.FollowerTiles(2); from != pt(2, 1) || to != pt(3, 1) {
+		t.Fatalf("följare 2: %v -> %v", from, to)
+	}
+	// Vid start står alla på startrutan.
+	q := NewParty(3, pt(5, 5), rng.FromInt(1))
+	if from, to := q.FollowerTiles(2); from != pt(5, 5) || to != pt(5, 5) {
+		t.Fatalf("start: %v -> %v", from, to)
+	}
+}
+
+func TestPartySizeIsClamped(t *testing.T) {
+	if NewParty(0, pt(0, 0), rng.FromInt(1)).Size() != 1 || NewParty(99, pt(0, 0), rng.FromInt(1)).Size() != len(PartyNames) {
+		t.Fatal("storleken ska klampas")
+	}
+}
--- a/internal/sim/run.go
+++ b/internal/sim/run.go
@@ -1,8 +1,11 @@
 package sim

 import (
+	"fmt"
+
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/lang"
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/level"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
 )

 // Outcome är hur en banomgång står sig.
@@ -53,8 +56,56 @@ type Run struct {
 	Revealed  map[level.Point]bool // skyltar som översatts helt via hjälp
 	Learned   string               // senast inlärda ord (för HUD-notis)
 	LearnedAt float64              // när det lärdes in; < 0 = aldrig
+
+	// Slump och inlärning genom läsning.
+	Seed         rng.Seed            // all slump i omgången härleds härifrån
+	Visits       map[level.Point]int // hur många gånger spelaren stannat på en skylt/perrong
+	lastTile     level.Point
+	Progressed   []string // ord som fick framsteg vid senaste läsningen, "ord n/3"
+	ProgressedAt float64  // < 0 = aldrig
+
+	// Resultat när banan vunnits.
+	Stars        int      // 1–3 efter tid mot par
+	PointsEarned int      // språkpoäng
+	LearnedDest  []string // resmålets ord som lärdes in tack vare bra resultat
+	parSec       float64
+
+	// Sällskapet (lämmeltåget) och pågående toalettbesök.
+	Party     *Party
+	Facility  FacilityState
+	baseSpeed float64
+	Served    int     // personer som fått mat/dryck/toa (statistik)
+	Notice    string  // senaste meddelande från sällskapet (HUD)
+	NoticeAt  float64 // < 0 = aldrig
 }

+// FacilityState är ett pågående toalettbesök (tar tid, avbryts om man går).
+type FacilityState struct {
+	Active    bool
+	At        level.Point
+	Remaining float64
+	Total     float64
+	Count     int
+}
+
+// RunOptions styr en banomgång.
+type RunOptions struct {
+	Speed float64          // rutor per sekund (0 = DefaultSpeed)
+	Dict  *lang.Dictionary // nil = tom ordbok
+	Know  *lang.Knowledge  // nil = ny kunskap
+	Seed  rng.Seed         // omgångens seed (sparas med spelet)
+}
+
+// DefaultSpeed är spelarens grundfart i rutor per sekund.
+const DefaultSpeed = 6.0
+
+// Par: utan parSec i bandatan räknas "bra tid" som kortaste vägen i rutor ×
+// ParSecPerTile + ParSlackSec. Tre stjärnor under par, två under 1,5 × par.
+const (
+	ParSecPerTile = 0.5
+	ParSlackSec   = 20.0
+)
+
 // HelpState är en pågående "fråga någon om hjälp".
 type HelpState struct {
 	Active    bool
@@ -63,24 +114,54 @@ type HelpState struct {
 	Total     float64
 }

-// NewRun startar banan med spelaren på startrutan. dict och know får vara
-// nil (tom ordbok respektive ny kunskap).
-func NewRun(l *level.Level, speed float64, dict *lang.Dictionary, know *lang.Knowledge) *Run {
-	if dict == nil {
-		dict = lang.NewDictionary()
+// NewRun startar banan med spelaren på startrutan.
+func NewRun(l *level.Level, o RunOptions) *Run {
+	if o.Dict == nil {
+		o.Dict = lang.NewDictionary()
 	}
-	if know == nil {
-		know = lang.NewKnowledge()
+	if o.Know == nil {
+		o.Know = lang.NewKnowledge()
 	}
-	return &Run{
-		Level:     l,
-		Player:    NewMover(l.SpawnPoint(), speed),
-		Card:      Card{Balance: StartBalanceYen},
-		DeniedAt:  -1,
-		Dict:      dict,
-		Know:      know,
-		Revealed:  map[level.Point]bool{},
-		LearnedAt: -1,
+	if o.Speed <= 0 {
+		o.Speed = DefaultSpeed
+	}
+	r := &Run{
+		Level:        l,
+		Player:       NewMover(l.SpawnPoint(), o.Speed),
+		Card:         Card{Balance: StartBalanceYen},
+		DeniedAt:     -1,
+		Dict:         o.Dict,
+		Know:         o.Know,
+		Revealed:     map[level.Point]bool{},
+		LearnedAt:    -1,
+		Seed:         o.Seed,
+		Visits:       map[level.Point]int{},
+		lastTile:     l.SpawnPoint(),
+		ProgressedAt: -1,
+		parSec:       float64(l.ParSec),
+		Party:        NewParty(l.Party, l.SpawnPoint(), o.Seed.Derive("party")),
+		baseSpeed:    o.Speed,
+		NoticeAt:     -1,
+	}
+	if r.parSec <= 0 {
+		n := len(l.Path(l.SpawnPoint(), l.CorrectPlatform(), l.CanEnter))
+		r.parSec = float64(max(0, n-1))*ParSecPerTile + ParSlackSec
+	}
+	return r
+}
+
+// ParSec är tiden för tre stjärnor.
+func (r *Run) ParSec() float64 { return r.parSec }
+
+// StarsFor ger 3 stjärnor under par, 2 under 1,5 × par, annars 1.
+func (r *Run) StarsFor(t float64) int {
+	switch {
+	case t <= r.parSec:
+		return 3
+	case t <= 1.5*r.parSec:
+		return 2
+	default:
+		return 1
 	}
 }

@@ -111,19 +192,79 @@ func (r *Run) Step(dt float64, want Dir, board bool) {
 	r.Time += dt
 	before := r.Player.Tile
 	wasGate := r.inGate()
+	r.Player.Speed = r.baseSpeed * r.Party.SpeedFactor()
 	r.Steps += r.Player.Step(dt, want, r.CanEnter)
+	if r.Player.Tile != before {
+		r.Party.OnLeaderArrived(r.Player.Tile)
+	}
+	logged := len(r.Party.Log)
+	r.Party.Advance(dt, r.Time)
+	if len(r.Party.Log) > logged {
+		r.Notice, r.NoticeAt = r.Party.Log[len(r.Party.Log)-1], r.Time
+	}
 	r.stepHelp(dt)
+	r.stepFacility(dt)
+	r.stepReading()
 	if r.Player.Tile != before && r.inGate() && !wasGate {
 		r.Card.Pay(r.Level.FareYen)
 		r.GatePasses++
 	}
 	if board && !r.Player.Moving() {
-		if tr, at, _ := r.PlatformHere(); tr != nil && at {
-			r.Board(tr)
+		switch r.Level.At(r.Player.Tile.X, r.Player.Tile.Y) {
+		case level.Toilet:
+			r.useToilet()
+		case level.Kiosk:
+			r.buyAtKiosk()
+		default:
+			if tr, at, _ := r.PlatformHere(); tr != nil && at {
+				r.Board(tr)
+			}
 		}
 	}
 }

+// useToilet startar ett toalettbesök för alla som behöver (tar tid).
+func (r *Run) useToilet() {
+	if r.Facility.Active {
+		return
+	}
+	n := len(r.Party.NeedsToilet())
+	if n == 0 {
+		return
+	}
+	secs := ToiletSecPerMember * float64(n)
+	r.Facility = FacilityState{Active: true, At: r.Player.Tile, Remaining: secs, Total: secs, Count: n}
+}
+
+func (r *Run) stepFacility(dt float64) {
+	if !r.Facility.Active {
+		return
+	}
+	if r.Player.Moving() || r.Player.Tile != r.Facility.At {
+		r.Facility = FacilityState{}
+		return
+	}
+	r.Facility.Remaining -= dt
+	if r.Facility.Remaining > 0 {
+		return
+	}
+	r.Served += r.Party.UseToilet()
+	r.Facility = FacilityState{}
+}
+
+// buyAtKiosk köper mat och dryck åt alla som behöver, betalat med kortet.
+func (r *Run) buyAtKiosk() {
+	r.Served += r.Party.BuyAtKiosk(r.Card.Pay)
+}
+
+// FacilityProgress är 0..1 för ett pågående toalettbesök.
+func (r *Run) FacilityProgress() float64 {
+	if !r.Facility.Active || r.Facility.Total <= 0 {
+		return 0
+	}
+	return 1 - r.Facility.Remaining/r.Facility.Total
+}
+
 // PlatformHere returnerar tåget vid perrongen spelaren står på (nil om
 // spelaren inte står på en perrong), om det är inne, och sekunder kvar
 // till avgång respektive ankomst.
@@ -148,13 +289,63 @@ func (r *Run) SignHere() *level.SignText {
 	return r.Level.SignAt(r.Player.Tile)
 }

-// Board kliver på ett tåg och avgör banan.
+// Board kliver på ett tåg och avgör banan. En vinst ger stjärnor efter tid,
+// språkpoäng, och vid tillräckligt bra resultat lär man sig resmålets ord.
 func (r *Run) Board(tr *level.Train) {
 	r.Boarded = tr
-	if tr.Correct {
-		r.Outcome = Won
-	} else {
+	if !tr.Correct {
 		r.Outcome = Lost
+		return
+	}
+	r.Outcome = Won
+	r.Stars = r.StarsFor(r.Time)
+	r.PointsEarned = r.Know.Award(r.Stars)
+	if r.Stars >= lang.StarsToLearnDestination {
+		for _, w := range r.Dict.WordsIn(r.Level.Destination.Get("ja")) {
+			if r.Know.Learn(w) {
+				r.LearnedDest = append(r.LearnedDest, w)
+			}
+		}
+	}
+}
+
+// stepReading: när spelaren stannar på en skylt eller perrong "läser" hen
+// texten – varje okänt ord har chansen lang.ReadChance att ge ett framsteg,
+// slumpat deterministiskt från seeden, skyltens position och besöksnumret.
+func (r *Run) stepReading() {
+	if r.Player.Moving() || r.Player.Tile == r.lastTile {
+		return
+	}
+	r.lastTile = r.Player.Tile
+	text := ""
+	if sg := r.Level.SignAt(r.Player.Tile); sg != nil {
+		text = sg.Text.Get("ja")
+	} else if tr, _, _ := r.PlatformHere(); tr != nil {
+		text = tr.BoardText()
+	}
+	if text == "" {
+		return
+	}
+	r.Visits[r.Player.Tile]++
+	roll := r.Seed.Derive(fmt.Sprintf("read:%d,%d:%d", r.Player.Tile.X, r.Player.Tile.Y, r.Visits[r.Player.Tile])).New()
+	seen := map[string]bool{}
+	var progressed []string
+	for _, w := range r.Dict.WordsIn(text) {
+		if seen[w] || r.Know.Knows(w) {
+			continue
+		}
+		seen[w] = true
+		if roll.Float64() >= lang.ReadChance {
+			continue
+		}
+		if r.Know.AddProgress(w) {
+			r.Learned, r.LearnedAt = w, r.Time
+		} else {
+			progressed = append(progressed, fmt.Sprintf("%s %d/%d", w, r.Know.ProgressOf(w), lang.ProgressToLearn))
+		}
+	}
+	if len(progressed) > 0 {
+		r.Progressed, r.ProgressedAt = progressed, r.Time
 	}
 }

--- a/internal/sim/run_test.go
+++ b/internal/sim/run_test.go
@@ -8,6 +8,7 @@ import (
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/lang"
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/level"
 	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/res"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
 )

 func loadDict(t *testing.T) *lang.Dictionary {
@@ -90,7 +91,7 @@ func waitForTrain(t *testing.T, r *Run) *level.Train {
 // och kliver på – helt utan fönster.
 func TestBotWinsLevel001(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, nil, nil)
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
 	goal := l.Find(level.Platform)[0]
 	path := l.Path(r.Player.Tile, goal, r.CanEnter)
 	if path == nil {
@@ -116,6 +117,9 @@ func TestBotWinsLevel001(t *testing.T) {
 	if r.Steps != len(path)-1 {
 		t.Fatalf("steg=%d, vägen är %d rutor", r.Steps, len(path)-1)
 	}
+	if r.Stars != 3 || r.PointsEarned != 3*lang.PointsPerStar || r.Know.Points != r.PointsEarned {
+		t.Fatalf("snabb vinst ska ge 3 stjärnor: stars=%d points=%d", r.Stars, r.PointsEarned)
+	}
 	// Efter utfall händer inget mer.
 	before := r.Time
 	r.Step(frame, Right, true)
@@ -126,7 +130,7 @@ func TestBotWinsLevel001(t *testing.T) {

 func TestBotLosesOnWrongTrain(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, nil, nil)
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
 	goal := l.Find(level.WrongPlatform)[0]
 	walk(t, r, l.Path(r.Player.Tile, goal, r.CanEnter))
 	tr := waitForTrain(t, r)
@@ -138,7 +142,7 @@ func TestBotLosesOnWrongTrain(t *testing.T) {

 func TestGateNeedsCardBalance(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, nil, nil)
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
 	gate := l.Find(level.Gate)[0]
 	r.Card.Balance = 0
 	if r.CanEnter(gate) {
@@ -165,7 +169,7 @@ func TestGateNeedsCardBalance(t *testing.T) {

 func TestBoardOnlyWhenTrainPresent(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, nil, nil)
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
 	goal := l.Find(level.Platform)[0]
 	walk(t, r, l.Path(r.Player.Tile, goal, r.CanEnter))
 	// Spola fram till en tidpunkt då tåget är borta.
@@ -184,7 +188,7 @@ func TestBoardOnlyWhenTrainPresent(t *testing.T) {

 func TestSignHereOnlyWhenStill(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, nil, nil)
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
 	sign := l.Find(level.Sign)[0]
 	walk(t, r, l.Path(r.Player.Tile, sign, r.CanEnter))
 	if sg := r.SignHere(); sg == nil || sg.Text.Get("sv") == "" {
@@ -201,7 +205,7 @@ func TestSignHereOnlyWhenStill(t *testing.T) {
 func TestAskHelpRevealsSignAndTeachesWord(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
 	know := lang.NewKnowledge()
-	r := NewRun(l, 6, loadDict(t), know)
+	r := NewRun(l, RunOptions{Dict: loadDict(t), Know: know, Seed: rng.FromInt(1)})
 	sign := l.Find(level.Sign)[1]
 	walk(t, r, l.Path(r.Player.Tile, sign, r.CanEnter))

@@ -241,7 +245,7 @@ func TestAskHelpRevealsSignAndTeachesWord(t *testing.T) {

 func TestHelpIsCancelledByWalkingAway(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, loadDict(t), nil)
+	r := NewRun(l, RunOptions{Dict: loadDict(t), Seed: rng.FromInt(1)})
 	sign := l.Find(level.Sign)[1]
 	walk(t, r, l.Path(r.Player.Tile, sign, r.CanEnter))
 	r.AskHelp()
@@ -256,8 +260,155 @@ func TestHelpIsCancelledByWalkingAway(t *testing.T) {

 func TestNoHelpOffSign(t *testing.T) {
 	l := loadLevel(t, "001-flygplatsen")
-	r := NewRun(l, 6, loadDict(t), nil)
+	r := NewRun(l, RunOptions{Dict: loadDict(t), Seed: rng.FromInt(1)})
 	if r.AskHelp() {
 		t.Fatal("ingen skylt på startrutan")
 	}
 }
+
+func TestStarsFromParTime(t *testing.T) {
+	l := loadLevel(t, "001-flygplatsen")
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
+	par := r.ParSec()
+	n := len(l.Path(l.SpawnPoint(), l.CorrectPlatform(), l.CanEnter)) - 1
+	if want := float64(n)*ParSecPerTile + ParSlackSec; par != want {
+		t.Fatalf("par=%.1f, vill ha %.1f (%d rutor)", par, want, n)
+	}
+	if r.StarsFor(par) != 3 || r.StarsFor(par*1.5) != 2 || r.StarsFor(par*1.51) != 1 {
+		t.Fatal("stjärntrösklarna")
+	}
+	l.ParSec = 40
+	if NewRun(l, RunOptions{}).ParSec() != 40 {
+		t.Fatal("parSec i bandatan ska vinna")
+	}
+}
+
+// TestGoodResultTeachesDestination: tre stjärnor lär ut resmålets ord (新宿),
+// en långsam vinst gör det inte men ger ändå en poäng.
+func TestGoodResultTeachesDestination(t *testing.T) {
+	l := loadLevel(t, "001-flygplatsen")
+	for _, tc := range []struct {
+		name     string
+		slow     bool
+		stars    int
+		knowsDst bool
+	}{{"snabb", false, 3, true}, {"långsam", true, 1, false}} {
+		know := lang.NewKnowledge()
+		r := NewRun(l, RunOptions{Dict: loadDict(t), Know: know, Seed: rng.FromInt(2)})
+		walk(t, r, l.Path(r.Player.Tile, l.CorrectPlatform(), r.CanEnter))
+		waitForTrain(t, r)
+		if tc.slow {
+			r.Time = 10 * r.ParSec()
+			waitForTrain(t, r)
+		}
+		r.Step(frame, None, true)
+		if r.Outcome != Won || r.Stars != tc.stars {
+			t.Fatalf("%s: outcome=%v stars=%d", tc.name, r.Outcome, r.Stars)
+		}
+		if know.Knows("新宿") != tc.knowsDst || (tc.knowsDst && (len(r.LearnedDest) != 1 || r.LearnedDest[0] != "新宿")) {
+			t.Fatalf("%s: knows 新宿=%v learnedDest=%v", tc.name, know.Knows("新宿"), r.LearnedDest)
+		}
+		if know.Points != tc.stars*lang.PointsPerStar {
+			t.Fatalf("%s: poäng=%d", tc.name, know.Points)
+		}
+	}
+}
+
+// TestReadingGivesSeededProgress: att stanna på en skylt ger okända ord en
+// chans till framsteg; samma seed ger exakt samma utfall, och efter många
+// besök har något ord lossnat.
+func TestReadingGivesSeededProgress(t *testing.T) {
+	l := loadLevel(t, "001-flygplatsen")
+	sign := l.Find(level.Sign)[1]
+	left := level.Point{X: sign.X - 1, Y: sign.Y}
+	play := func(seed uint64) *lang.Knowledge {
+		know := lang.NewKnowledge()
+		r := NewRun(l, RunOptions{Dict: loadDict(t), Know: know, Seed: rng.FromInt(seed)})
+		walk(t, r, l.Path(r.Player.Tile, sign, r.CanEnter))
+		for i := 0; i < 15; i++ { // gå av och på skylten = nya besök
+			walk(t, r, []level.Point{sign, left})
+			walk(t, r, []level.Point{left, sign})
+		}
+		if r.Visits[sign] != 16 {
+			t.Fatalf("besök=%d", r.Visits[sign])
+		}
+		return know
+	}
+	a, b := play(5), play(5)
+	if a.Count() != b.Count() || len(a.Progress) != len(b.Progress) {
+		t.Fatalf("samma seed ska ge samma inlärning: %v/%v vs %v/%v", a.Words, a.Progress, b.Words, b.Progress)
+	}
+	for w, n := range a.Progress {
+		if b.Progress[w] != n {
+			t.Fatalf("framsteg skiljer sig för %s", w)
+		}
+	}
+	if a.Count() == 0 {
+		t.Fatalf("efter 16 läsningar borde minst ett ord ha lossnat: progress=%v", a.Progress)
+	}
+	for w := range a.Words {
+		if a.ProgressOf(w) != 0 {
+			t.Fatalf("känt ord %s ska inte ha framsteg kvar", w)
+		}
+	}
+}
+
+func TestToiletAndKioskInRun(t *testing.T) {
+	l := loadLevel(t, "001-flygplatsen")
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
+	if r.Party.Size() != l.Party || r.Party.Size() < 2 {
+		t.Fatalf("sällskap=%d, banan säger %d", r.Party.Size(), l.Party)
+	}
+	anna := r.Party.Members[1]
+	r.Party.nextEventAt = 1e9 // inga slumphändelser som stör testet
+
+	// Toalett: tar ToiletSecPerMember per person, avbryts om man går.
+	toilet := l.Find(level.Toilet)[0]
+	walk(t, r, l.Path(r.Player.Tile, toilet, r.CanEnter))
+	anna.Meters.Toilet = 10
+	anna.Urge = NeedToilet
+	r.Step(frame, None, true)
+	if !r.Facility.Active || r.Facility.Count != 1 || r.Facility.Total != ToiletSecPerMember {
+		t.Fatalf("toalettbesök: %+v", r.Facility)
+	}
+	r.Step(frame, Right, false)
+	if r.Facility.Active {
+		t.Fatal("att gå avbryter besöket")
+	}
+	for r.Player.Moving() { // gå klart rutan innan vi vänder tillbaka
+		r.Step(frame, None, false)
+	}
+	walk(t, r, l.Path(r.Player.Tile, toilet, r.CanEnter))
+	r.Step(frame, None, true)
+	if !r.Facility.Active {
+		t.Fatal("besöket ska starta igen")
+	}
+	for i := 0; i < int(ToiletSecPerMember/frame)+2 && r.Facility.Active; i++ {
+		r.Step(frame, None, false)
+	}
+	if r.Facility.Active || anna.Meters.Toilet != 100 || anna.Urge != NoUrge || r.Served != 1 {
+		t.Fatalf("efter besöket: active=%v toa=%.0f urge=%v served=%d", r.Facility.Active, anna.Meters.Toilet, anna.Urge, r.Served)
+	}
+
+	// Kiosk: direkt, kostar KioskPriceYen per person från kortet.
+	kiosk := l.Find(level.Kiosk)[0]
+	walk(t, r, l.Path(r.Player.Tile, kiosk, r.CanEnter))
+	anna.Meters.Drink = 5
+	anna.Urge = Thirsty
+	before := r.Card.Balance
+	r.Step(frame, None, true)
+	if anna.Meters.Drink != 100 || anna.Urge != NoUrge || r.Card.Balance != before-KioskPriceYen || r.Served != 2 {
+		t.Fatalf("kiosken: dryck=%.0f urge=%v saldo=%d->%d served=%d", anna.Meters.Drink, anna.Urge, before, r.Card.Balance, r.Served)
+	}
+}
+
+func TestPartySlowsLeader(t *testing.T) {
+	l := loadLevel(t, "001-flygplatsen")
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(1)})
+	r.Party.Members[1].Urge = Distracted
+	r.Party.Members[1].UrgeAt = 1000 // går inte över under testet
+	r.Step(frame, Right, false)
+	if r.Player.Speed != DefaultSpeed*DistractedSpeedFactor {
+		t.Fatalf("fart=%.2f", r.Player.Speed)
+	}
+}