M10c: vem betalar i kiosken och spärrar utan återvändo

Björns tillägg 2026-10-24. Med egna kort och fler i sällskapet frågar
kiosken vem som betalar (minigame.Payer: kontant, spelarens kort eller en
följares kort; den som inte har råd nekas, Esc avbryter). Avgiften dras
nu när man passerar spärren in i det betalda området (level.InsideGates),
inte på spärrrutan. Banflaggan oneWayGates: incheckad släpps inte ut igen
förrän man åkt; Enter vid spärren kallar på personal (10 s) som låser upp
korten; ny inpassering kostar igen. På i 005, 007/007b och 008/008b.
Skriptkommandon urge och push. Docs, wiki och skärmdumpar uppdaterade.

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

internal/sim/gates_test.go

@@ -0,0 +1,141 @@
+package sim
+
+import (
+	"testing"
+
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/level"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/minigame"
+	"gitea.brasse-pc.eu/brasse/metro-puzzle-jp/internal/rng"
+)
+
+// pathTo är testbotens väg till goal: som PathCanEnter, men andra perronger
+// används inte som genvägar (på spärrar utan återvändo skulle man fastna).
+func pathTo(r *Run, goal level.Point) []level.Point {
+	return r.Level.Path(r.Player.Tile, goal, func(p level.Point) bool {
+		return r.PathCanEnter(p) && (!r.Level.At(p).IsPlatform() || p == goal)
+	})
+}
+
+// stepUntilStill tar ett steg i riktningen och låter rörelsen bli klar.
+func stepUntilStill(r *Run, d Dir) {
+	r.Step(frame, d, false)
+	for i := 0; i < 120 && r.Player.Moving(); i++ {
+		r.Step(frame, None, false)
+	}
+}
+
+// TestKioskAsksWhoPays: med egna kort och fler i sällskapet frågar kiosken
+// vem som betalar; den valda följarens kort dras, inte spelarens.
+func TestKioskAsksWhoPays(t *testing.T) {
+	l := loadLevel(t, "007-akihabara")
+	if !l.IndividualCards || l.Party < 3 {
+		t.Fatal("007 ska ha egna kort och sällskap")
+	}
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(7)})
+	r.NPCs = nil
+	r.Party.nextEventAt = 1e9
+	ville := r.Party.Members[2]
+	ville.Meters.Drink, ville.Urge = 5, Thirsty
+	walk(t, r, pathTo(r, l.Find(level.Kiosk)[0]))
+	card, villeCard := r.Wallet.Card, ville.Card
+	r.Step(frame, None, true)
+	g, ok := r.Mini.(*minigame.Payer)
+	if !ok || r.MiniKind != MiniPayer || len(g.Options) != r.Party.Size()+1 || g.Price != KioskPriceYen {
+		t.Fatalf("kiosken ska fråga vem som betalar: kind=%v", r.MiniKind)
+	}
+	if !g.Options[0].Cash || g.Options[1].Member != 0 || g.Options[3].Name != ville.Name {
+		t.Fatalf("källorna: %+v", g.Options)
+	}
+	for g.Cursor != 3 {
+		r.StepMini(frame, minigame.Input{MoveX: 1})
+	}
+	r.StepMini(frame, minigame.Input{Confirm: true})
+	if r.Mini != nil || ville.Card != villeCard-KioskPriceYen || r.Wallet.Card != card || ville.Meters.Drink != 100 || r.Served != 1 {
+		t.Fatalf("Villes kort ska betala: ville=%d (var %d) kort=%d served=%d", ville.Card, villeCard, r.Wallet.Card, r.Served)
+	}
+	// Ingen som behöver något: ingen fråga. Avbrutet köp: inget dras.
+	r.Step(frame, None, true)
+	if r.Mini != nil {
+		t.Fatal("utan behov ska kiosken inte fråga")
+	}
+	anna := r.Party.Members[1]
+	anna.Meters.Food, anna.Urge, anna.Card = 5, Hungry, 0
+	r.Step(frame, None, true)
+	g = r.Mini.(*minigame.Payer)
+	for g.Cursor != 2 { // Anna, utan pengar
+		r.StepMini(frame, minigame.Input{MoveX: 1})
+	}
+	r.StepMini(frame, minigame.Input{Confirm: true})
+	if r.Mini == nil || !g.Refused {
+		t.Fatal("den som inte har råd nekas")
+	}
+	r.StepMini(frame, minigame.Input{Cancel: true})
+	if r.Mini != nil || anna.Meters.Food > 10 || r.Served != 1 {
+		t.Fatal("avbrutet köp ska inte dra något")
+	}
+	// Kontant betalar.
+	cash := r.Wallet.Cash
+	r.Step(frame, None, true)
+	r.StepMini(frame, minigame.Input{Confirm: true}) // markören står på kontant (Anna har inte råd, kontant står först)
+	if r.Wallet.Cash != cash-KioskPriceYen || anna.Meters.Food != 100 {
+		t.Fatalf("kontant: cash=%d (var %d) food=%.0f", r.Wallet.Cash, cash, anna.Meters.Food)
+	}
+}
+
+// TestOneWayGatesNeedStaff: i Ueno släpper spärren inte ut en som checkat
+// in; Enter vid spärren kallar på personal, sedan får man gå ut, och går man
+// in igen dras avgiften igen.
+func TestOneWayGatesNeedStaff(t *testing.T) {
+	l := loadLevel(t, "005-ueno")
+	if !l.OneWayGates {
+		t.Fatal("005 ska ha spärrar utan återvändo")
+	}
+	r := NewRun(l, RunOptions{Seed: rng.FromInt(5)})
+	r.NPCs = nil
+	r.Party.nextEventAt = 1e9
+	plat := l.CorrectPlatform()
+	start := r.Wallet.Card
+	walk(t, r, pathTo(r, plat))
+	if !r.CheckedIn() || !r.NeedsStaff() || r.GatePasses != 1 || r.Wallet.Card != start-l.FareYen {
+		t.Fatalf("på perrongen ska man vara incheckad och ha betalat en gång: checkedIn=%v passes=%d card=%d", r.CheckedIn(), r.GatePasses, r.Wallet.Card)
+	}
+	card := r.Wallet.Card
+	stepUntilStill(r, Left) // tillbaka på spärren: kostar inget
+	if !r.inGate() || r.GatePasses != 1 || r.Wallet.Card != card {
+		t.Fatalf("spärren igen: inGate=%v passes=%d card=%d", r.inGate(), r.GatePasses, r.Wallet.Card)
+	}
+	gate := r.Player.Tile
+	stepUntilStill(r, Left) // ut? nej
+	if r.Player.Tile != gate || r.NoExitAt < 0 {
+		t.Fatalf("spärren ska inte släppa ut: tile=%v noExitAt=%.1f", r.Player.Tile, r.NoExitAt)
+	}
+	r.Step(frame, None, true) // kalla på personal
+	if !r.Staff.Active {
+		t.Fatal("Enter vid spärren ska kalla på personal")
+	}
+	for i := 0; i < int(StaffSec*60)+5 && r.Staff.Active; i++ {
+		r.Step(frame, None, false)
+	}
+	if r.Staff.Active || !r.StaffUnlocked || r.StaffCalls != 1 || r.FlashKey != FlashStaff {
+		t.Fatalf("personalen ska ha låst upp: active=%v unlocked=%v calls=%d", r.Staff.Active, r.StaffUnlocked, r.StaffCalls)
+	}
+	stepUntilStill(r, Left)
+	if r.Player.Tile == gate || r.CheckedIn() || r.StaffUnlocked {
+		t.Fatalf("ute igen: tile=%v checkedIn=%v unlocked=%v", r.Player.Tile, r.CheckedIn(), r.StaffUnlocked)
+	}
+	stepUntilStill(r, Right) // på spärren utifrån: inget dras än
+	if !r.inGate() || r.CheckedIn() || r.GatePasses != 1 {
+		t.Fatalf("spärren utifrån: inGate=%v checkedIn=%v passes=%d", r.inGate(), r.CheckedIn(), r.GatePasses)
+	}
+	stepUntilStill(r, Right) // in igen: kostar igen
+	if r.Player.Tile != plat || !r.CheckedIn() || r.GatePasses != 2 || r.Wallet.Card != card-l.FareYen {
+		t.Fatalf("ny inpassering: tile=%v checkedIn=%v passes=%d card=%d (var %d)", r.Player.Tile, r.CheckedIn(), r.GatePasses, r.Wallet.Card, card)
+	}
+	// Utan flaggan är det fritt fram.
+	l1 := loadLevel(t, "001-flygplatsen")
+	r1 := NewRun(l1, RunOptions{Seed: rng.FromInt(1)})
+	walk(t, r1, l1.Path(r1.Player.Tile, l1.CorrectPlatform(), r1.PathCanEnter))
+	if r1.CheckedIn() || r1.NeedsStaff() {
+		t.Fatal("utan oneWayGates ska ingen vara incheckad")
+	}
+}

internal/sim/nav_test.go

@@ -17,7 +17,7 @@ func boardAt(t *testing.T, r *Run, tile level.Tile) *level.Train {
 	r.NPCs = nil // folket ska inte stå i vägen för testboten
 	r.Party.nextEventAt = 1e9
 	l := r.Level
-	path := l.Path(r.Player.Tile, l.Find(tile)[0], r.PathCanEnter)
+	path := pathTo(r, l.Find(tile)[0])
 	if path == nil {
 		t.Fatalf("ingen väg till perrong %c", tile)
 	}

internal/sim/run.go

@@ -47,6 +47,16 @@ type Run struct {
 	timeLimit   int // resans tidsgräns (första delbanans), 0 = ingen
 	maxMissed   int // resans gräns för missade tåg (första delbanans)
 
+	// Spärrar utan återvändo (level.OneWayGates): incheckad släpps inte ut
+	// förrän personalen låst upp korten.
+	inside        map[level.Point]bool // rutorna innanför spärrarna
+	checkedIn     bool
+	gateFromIn    bool // spärrrutan man står på nåddes inifrån (på väg ut)
+	StaffUnlocked bool
+	Staff         StaffState
+	StaffCalls    int
+	NoExitAt      float64 // när spärren senast vägrade släppa ut (< 0 = aldrig)
+
 	// Språk: ordboken, spelarens kunskap (delas mellan banor) och hjälpen.
 	Dict      *lang.Dictionary
 	Know      *lang.Knowledge
@@ -129,6 +139,7 @@ const (
 const (
 	FlashWomenOnly = "hud.women_only"
 	FlashTransfer  = "hud.transfer_done"
+	FlashStaff     = "hud.staff_unlocked"
 	FlashEarly     = "hud.early_board"
 	FlashBump      = "hud.bump"
 )
@@ -177,6 +188,7 @@ const (
 	MiniCrowd
 	MiniRide
 	MiniCarPick
+	MiniPayer
 )
 
 // Förlustorsaker (textnycklar).
@@ -208,6 +220,18 @@ type FacilityState struct {
 	Count     int
 }
 
+// StaffState är ett pågående personalanrop vid spärren (tar tid, avbryts
+// om man går).
+type StaffState struct {
+	Active    bool
+	At        level.Point
+	Remaining float64
+	Total     float64
+}
+
+// StaffSec är hur länge man väntar på personalen vid spärren.
+const StaffSec = 10.0
+
 // RunOptions styr en banomgång.
 type RunOptions struct {
 	Speed   float64          // rutor per sekund (0 = DefaultSpeed)
@@ -280,6 +304,8 @@ func NewRun(l *level.Level, o RunOptions) *Run {
 		timeLimit:     l.TimeLimitSec,
 		maxMissed:     l.MaxMissedTrains,
 		TransferAt:    -1,
+		inside:        l.InsideGates(),
+		NoExitAt:      -1,
 		Party:         NewParty(l.Party, l.SpawnPoint(), o.Seed.Derive("party")),
 		baseSpeed:     o.Speed,
 		NoticeAt:      -1,
@@ -375,6 +401,8 @@ func (r *Run) startLeg(l *level.Level) {
 	r.Mini, r.MiniKind, r.PendingTrain, r.CarChosen = nil, MiniNone, nil, nil
 	r.Help, r.Facility = HelpState{}, FacilityState{}
 	r.DeniedAt, r.BumpedAt, r.WrongLane = -1, -1, false
+	r.inside = l.InsideGates()
+	r.checkedIn, r.StaffUnlocked, r.gateFromIn, r.Staff = false, false, false, StaffState{}
 	r.parSec += parFor(l)
 	r.TransferAt = r.Time
 	r.flash(FlashTransfer)
@@ -418,6 +446,10 @@ func (r *Run) CanEnter(p level.Point) bool {
 		r.DeniedAt = r.Time
 		return false
 	}
+	if r.NeedsStaff() && r.inGate() && r.gateFromIn && t != level.Gate && !r.inside[p] {
+		r.NoExitAt = r.Time // incheckad: spärren släpper inte ut en
+		return false
+	}
 	for _, n := range r.NPCs {
 		if n.Occupies(p) {
 			r.BumpedAt = r.Time
@@ -427,6 +459,48 @@ func (r *Run) CanEnter(p level.Point) bool {
 	return true
 }
 
+// NeedsStaff rapporterar om man är incheckad i en spärr utan återvändo och
+// behöver personalen för att komma ut.
+func (r *Run) NeedsStaff() bool { return r.Level.OneWayGates && r.checkedIn && !r.StaffUnlocked }
+
+// CheckedIn rapporterar om spelaren har checkat in i spärren (och inte åkt).
+func (r *Run) CheckedIn() bool { return r.checkedIn }
+
+// callStaff trycker på knappen vid spärren: efter StaffSec låser personalen
+// upp korten så att man får gå ut.
+func (r *Run) callStaff() {
+	if !r.NeedsStaff() || r.Staff.Active {
+		return
+	}
+	r.Staff = StaffState{Active: true, At: r.Player.Tile, Remaining: StaffSec, Total: StaffSec}
+}
+
+func (r *Run) stepStaff(dt float64) {
+	if !r.Staff.Active {
+		return
+	}
+	if r.Player.Moving() || r.Player.Tile != r.Staff.At {
+		r.Staff = StaffState{}
+		return
+	}
+	r.Staff.Remaining -= dt
+	if r.Staff.Remaining > 0 {
+		return
+	}
+	r.Staff = StaffState{}
+	r.StaffUnlocked = true
+	r.StaffCalls++
+	r.flash(FlashStaff)
+}
+
+// StaffProgress är 0..1 för ett pågående personalanrop.
+func (r *Run) StaffProgress() float64 {
+	if !r.Staff.Active || r.Staff.Total <= 0 {
+		return 0
+	}
+	return 1 - r.Staff.Remaining/r.Staff.Total
+}
+
 func (r *Run) canPassGate() bool {
 	if r.opts.FreeGates {
 		return true // JR Pass: genväg genom alla spärrar
@@ -538,11 +612,21 @@ func (r *Run) Step(dt float64, want Dir, board bool) {
 	}
 	r.stepHelp(dt)
 	r.stepFacility(dt)
+	r.stepStaff(dt)
 	r.stepReading()
 	r.stepNPCs(dt)
 	r.checkLimits()
 	if r.Player.Tile != before && r.inGate() && !wasGate {
+		r.gateFromIn = r.inside[before] // på väg ut (eller bara på genomresa utifrån)
+	}
+	// Avgiften dras när man passerar spärren in i det betalda området, inte
+	// när man står på spärrrutan: spärrar som ligger i en gång kan passeras
+	// utifrån utan att det kostar.
+	if r.Player.Tile != before && r.inside[r.Player.Tile] && !r.inside[before] {
 		r.GatePasses++
+		if r.Level.OneWayGates {
+			r.checkedIn = true // incheckad: spärren släpper inte ut en förrän man åkt
+		}
 		if !r.Level.TicketRequired && !r.opts.FreeGates {
 			r.Wallet.PayCard(r.Level.FareYen)
 			if r.Level.IndividualCards {
@@ -558,8 +642,13 @@ func (r *Run) Step(dt float64, want Dir, board bool) {
 			}
 		}
 	}
+	if r.Level.OneWayGates && r.Player.Tile != before && wasGate && r.gateFromIn && !r.inside[r.Player.Tile] && !r.inGate() {
+		r.checkedIn, r.StaffUnlocked = false, false // ute igen (efter personalens upplåsning); ny inpassering kostar igen
+	}
 	if board && !r.Player.Moving() {
 		switch r.Level.At(r.Player.Tile) {
+		case level.Gate:
+			r.callStaff()
 		case level.Toilet:
 			r.useToilet()
 		case level.Kiosk:
@@ -791,6 +880,10 @@ func (r *Run) StepMini(dt float64, in minigame.Input) {
 			r.Party.Members[g.Member].Card += g.Amount
 			r.TopUps++
 		}
+	case *minigame.Payer:
+		if g.Success() && g.Chosen != nil {
+			r.purchaseAtKiosk(r.payFrom(*g.Chosen))
+		}
 	case *minigame.Ticket:
 		if !g.Success() || g.Chosen == nil {
 			break
@@ -882,10 +975,58 @@ func (r *Run) stepFacility(dt float64) {
 	r.Facility = FacilityState{}
 }
 
-// buyAtKiosk köper mat och dryck åt alla som behöver, betalat med kortet.
-// Med liten seedad otur blir maten dålig: matförgiftning efter banan.
+// buyAtKiosk köper mat och dryck åt alla som behöver. Med egna kort och
+// fler i sällskapet frågar kiosken först vem som betalar (minigame.Payer),
+// annars dras det från spelarens kort.
 func (r *Run) buyAtKiosk() {
-	n := r.Party.BuyAtKiosk(r.Wallet.PayCard)
+	needs := r.Party.NeedsKiosk()
+	if len(needs) == 0 {
+		return
+	}
+	if r.Level.IndividualCards && r.Party.Size() > 1 {
+		r.Mini, r.MiniKind = minigame.NewPayer(KioskPriceYen*len(needs), r.payOptions()), MiniPayer
+		return
+	}
+	r.purchaseAtKiosk(r.Wallet.PayCard)
+}
+
+// payOptions är källorna man kan betala kiosken med: kontant, spelarens
+// kort och varje följares kort.
+func (r *Run) payOptions() []minigame.PayOption {
+	card := r.Wallet.Card
+	if !r.Wallet.CardUsable() {
+		card = 0
+	}
+	opts := []minigame.PayOption{{Cash: true, Yen: r.Wallet.Cash}, {Name: r.Party.Members[0].Name, Member: 0, Yen: card}}
+	for i, m := range r.Party.Followers() {
+		opts = append(opts, minigame.PayOption{Name: m.Name, Member: i + 1, Yen: m.Card})
+	}
+	return opts
+}
+
+// payFrom ger betalfunktionen för en vald källa.
+func (r *Run) payFrom(o minigame.PayOption) func(int) bool {
+	switch {
+	case o.Cash:
+		return r.Wallet.PayCash
+	case o.Member == 0:
+		return r.Wallet.PayCard
+	}
+	m := r.Party.Members[o.Member]
+	return func(yen int) bool {
+		if m.Card < yen {
+			return false
+		}
+		m.Card -= yen
+		r.Wallet.Spent += yen
+		return true
+	}
+}
+
+// purchaseAtKiosk genomför köpet med en betalfunktion. Med liten seedad
+// otur blir maten dålig: matförgiftning efter banan.
+func (r *Run) purchaseAtKiosk(pay func(int) bool) {
+	n := r.Party.BuyAtKiosk(pay)
 	if n == 0 {
 		return
 	}

internal/sim/run_test.go

@@ -155,6 +155,25 @@ func walk(t *testing.T, r *Run, path []level.Point) {
 	}
 }
 
+// throughGate kapar en väg vid första rutan innanför spärrarna – där dras
+// avgiften (inte på spärrrutan).
+func throughGate(l *level.Level, path []level.Point) []level.Point {
+	in := l.InsideGates()
+	for i, p := range path {
+		if in[p] {
+			return path[:i+1]
+		}
+	}
+	if len(path) > 0 { // vägen slutar på spärren: kliv in på rutan innanför
+		for _, n := range l.Neighbors(path[len(path)-1]) {
+			if in[n] {
+				return append(path, n)
+			}
+		}
+	}
+	return path
+}
+
 // waitForTrain står still tills tåget vid perrongen är inne.
 func waitForTrain(t *testing.T, r *Run) *level.Train {
 	t.Helper()
@@ -698,12 +717,7 @@ func TestPhoneSpeedRescanAndBattery(t *testing.T) {
 		}
 		gate := l.Find(level.Gate)[0]
 		path := l.Path(r.Player.Tile, gate, r.PathCanEnter)
-		for i, p := range path { // stanna på den första spärrutan – där sker skanningen
-			if l.At(p) == level.Gate {
-				path = path[:i+1]
-				break
-			}
-		}
+		path = throughGate(l, path) // in i det betalda området: där dras avgiften och sker skanningen
 		walk(t, r, path)
 		rescans[r.Rescans]++
 		if r.Rescans == 1 {
@@ -873,12 +887,7 @@ func TestIndividualCardsAtGateAndMachine(t *testing.T) {
 	// Spärren drar från allas kort.
 	before := r.Wallet.Spent
 	path := l1.Path(r.Player.Tile, gate, r.PathCanEnter)
-	for i, p := range path {
-		if l1.At(p) == level.Gate {
-			path = path[:i+1]
-			break
-		}
-	}
+	path = throughGate(l1, path) // in i det betalda området: där dras avgiften och sker skanningen
 	walk(t, r, path)
 	if anna.Card != 1000-l1.FareYen || r.Wallet.Card != StartCardYen-l1.FareYen || r.Wallet.Spent != before+2*l1.FareYen {
 		t.Fatalf("efter spärren: anna=%d egen=%d spent=%d", anna.Card, r.Wallet.Card, r.Wallet.Spent)
@@ -1039,12 +1048,7 @@ func TestRunOptionsFromProgression(t *testing.T) {
 		r.Step(frame, None, false)
 	}
 	path := l.Path(r.Player.Tile, gate, r.PathCanEnter)
-	for i, p := range path {
-		if l.At(p) == level.Gate {
-			path = path[:i+1]
-			break
-		}
-	}
+	path = throughGate(l, path) // in i det betalda området: där dras avgiften och sker skanningen
 	walk(t, r, path)
 	if r.Wallet.Spent != 0 || r.GatePasses != 1 {
 		t.Fatalf("gratis spärr: spent=%d passes=%d", r.Wallet.Spent, r.GatePasses)