From 3eacf89dded0121d2a50fb01dec5d8ccbfbbe4ee Mon Sep 17 00:00:00 2001
From: ewy <ewy0@protonmail.com>
Date: Tue, 22 Sep 2026 15:05:51 +0200
Subject: naive auth

---
 engine/card.go   | 20 ++++++++++++++++++++
 engine/game.go   | 45 +++++++++++++++++++++++++++++++++++++--------
 engine/player.go | 16 +++++++++++++++-
 engine/stack.go  |  6 +++++-
 4 files changed, 77 insertions(+), 10 deletions(-)

(limited to 'engine')

diff --git a/engine/card.go b/engine/card.go
index 3eb6a8f..fce1af0 100644
--- a/engine/card.go
+++ b/engine/card.go
@@ -1,5 +1,7 @@
 package engine
 
+import "slices"
+
 type Card struct {
 	Name   string
 	AllOut bool
@@ -19,3 +21,21 @@ type IsCard interface {
 	Base() *Card
 	CanPlay(g *Game) bool
 }
+
+type CardInstance struct {
+	*Card
+	Visible bool
+}
+
+var secretCardStruct = &Card{
+	Name: "?",
+}
+
+var SecretCard = &CardInstance{
+	Card:    secretCardStruct,
+	Visible: false,
+}
+
+func Secrets(size int) Stack {
+	return slices.Repeat([]IsCard{SecretCard}, size)
+}
diff --git a/engine/game.go b/engine/game.go
index 8365869..0735958 100644
--- a/engine/game.go
+++ b/engine/game.go
@@ -5,22 +5,24 @@ import (
 )
 
 type Turn struct {
-	Player *Player
+	Player      *Player `json:"-"`
+	PlayerSlot  string  `json:"Player"`
 	ActionTaken bool
-	Actions []Action
+	Actions     []Action
 }
 
 type Game struct {
 	Shadow   *pool.Pool
 	Distance *pool.Pool
-	Yin      *Player
-	Yang     *Player
+	Yin      *Player `json:"PlayerYin"`
+	Yang     *Player `json:"PlayerYang"`
 
 	Stack []IsCard
 
 	Actions []Action
 
-	CurrentPlayer *Player
+	CurrentPlayer     *Player `json:"-"`
+	CurrentPlayerSlot string  `json:"CurrentPlayer"`
 
 	History []Turn
 }
@@ -59,18 +61,45 @@ func (g *Game) Winner() *Player {
 func (g *Game) NextTurn() {
 	current := g.CurrentPlayer.Opponent(g)
 	g.CurrentPlayer = current
+	playerRef := "UNKNOWN"
+	switch current {
+	case g.Yin:
+		playerRef = "YIN"
+	case g.Yang:
+		playerRef = "YANG"
+	}
 	g.History = append(g.History, Turn{
-		Player: current,
+		Player:      current,
 		ActionTaken: false,
+		PlayerSlot:  playerRef,
 	})
-	g.Actions = Interactions(ShuffleDeckAction(g),DrawCardAction(g)),
+	g.CurrentPlayerSlot = playerRef
+	g.Actions = Interactions(ShuffleDeckAction(g), DrawCardAction(g))
 }
 
 func (g *Game) CurrentTurn() Turn {
-	return g.History[len(g.History) - 1]
+	return g.History[len(g.History)-1]
 }
 
 func (g *Game) ActionToHistory(a Action) {
 	thisTurn := g.History[len(g.History)-1]
 	thisTurn.Actions = append(thisTurn.Actions, a)
 }
+
+func (g *Game) Present(p *Player) Game {
+	localGame := *g
+	switch p {
+	case g.Yin:
+		localGame.Yang.Hide()
+	case g.Yang:
+		localGame.Yin.Hide()
+	}
+	var acs []Action
+	for _, a := range g.Actions {
+		if a.Actor(g) == p {
+			acs = append(acs, a)
+		}
+	}
+	localGame.Actions = acs
+	return localGame
+}
diff --git a/engine/player.go b/engine/player.go
index eb7ac49..a4f7c35 100644
--- a/engine/player.go
+++ b/engine/player.go
@@ -13,7 +13,15 @@ type Player struct {
 	Hand       Stack
 	MasterDeck Stack
 	DrawPile   Stack
-	Ultimates  []*Card
+	Ultimates  []IsCard
+	Character  *Character
+	Cookie     string
+}
+
+func (p *Player) SetCharacter(c *Character) {
+	p.Character = c
+	p.MasterDeck = c.Cards
+	p.Ultimates = c.Ultimates
 }
 
 func (p *Player) Opponent(g *Game) *Player {
@@ -41,3 +49,9 @@ func NewPlayer(g *Game) *Player {
 	p.propagate(g)
 	return p
 }
+
+func (p *Player) Hide() {
+	p.MasterDeck = p.MasterDeck.Hidden()
+	p.Hand = p.Hand.Hidden()
+	p.DrawPile = p.DrawPile.Hidden()
+}
diff --git a/engine/stack.go b/engine/stack.go
index 8bcff6f..dd10dd6 100644
--- a/engine/stack.go
+++ b/engine/stack.go
@@ -1,6 +1,6 @@
 package engine
 
-type Stack []*Card
+type Stack []IsCard
 
 func (s Stack) Contains(predicate func(c IsCard) bool) bool {
 	for _, c := range s {
@@ -30,3 +30,7 @@ func (s Stack) Pop() IsCard {
 		return c
 	}
 }
+
+func (s Stack) Hidden() Stack {
+	return Secrets(len(s))
+}
-- 
cgit v1.3.1