add more events

4 files changed, 132 insertions, 88 deletions

diff --git a/go/game/events.go b/go/game/events.go
new file mode 100644
index 00000000..efe5cdb5
--- /dev/null
+++ b/go/game/events.go
@@ -0,0 +1,125 @@
+package game
+
+import (
+	"fmt"
+
+	"muhq.space/muhqs-game/go/log"
+	"muhq.space/muhqs-game/go/utils"
+)
+
+type eventType int
+
+const (
+	destruction eventType = iota
+	eot
+	sacrifice
+	play
+	target
+	etb
+	damageDealt
+	shuffle
+	declaredAction
+	resolvedAction
+)
+
+var EventTypes = struct {
+	Destruction    eventType
+	Eot            eventType
+	Sacrifice      eventType
+	Play           eventType
+	Target         eventType
+	Etb            eventType
+	DamageDealt    eventType
+	Shuffle        eventType
+	DeclaredAction eventType
+	ResolvedAction eventType
+}{
+	Destruction:    destruction,
+	Eot:            eot,
+	Sacrifice:      sacrifice,
+	Play:           play,
+	Target:         target,
+	Etb:            etb,
+	DamageDealt:    damageDealt,
+	Shuffle:        shuffle,
+	DeclaredAction: declaredAction,
+	ResolvedAction: resolvedAction,
+}
+
+func (e eventType) String() string {
+	switch e {
+	case destruction:
+		return "destruction"
+	case eot:
+		return "eot"
+	case sacrifice:
+		return "sacrifice"
+	case play:
+		return "play"
+	case target:
+		return "target"
+	case etb:
+		return "etb"
+	case damageDealt:
+		return "damageDealt"
+	case shuffle:
+		return "shuffle"
+	case declaredAction:
+		return "declaredAction"
+	case resolvedAction:
+		return "resolvedAction"
+	}
+
+	log.Panicf("Unknown eventType: %d", e)
+	return ""
+}
+
+type Event struct {
+	eventType eventType
+	sources   []any
+	affected  []any
+}
+
+func (e Event) String() string {
+	if len(e.sources) == 0 {
+		return e.eventType.String()
+	}
+
+	return fmt.Sprintf("%v:%v", e.sources, e.eventType)
+}
+
+func newEotEvent() Event {
+	return Event{eventType: eot}
+}
+
+func newTargetEvent(source any, targets *Targets) Event {
+	affected := make([]any, 0, len(targets.ts))
+	for _, t := range targets.ts {
+		affected = append(affected, t.sel...)
+	}
+	return Event{eventType: target, sources: []any{source}, affected: affected}
+}
+
+func newShuffleEvent(p *Player, affected []PileOfCards) Event {
+	return Event{
+		eventType: shuffle,
+		sources:   []any{p},
+		affected:  utils.TypedSliceToInterfaceSlice(affected),
+	}
+}
+
+func newDeclaredActionEvent(action Action) Event {
+	return Event{eventType: declaredAction, sources: []any{action}}
+}
+
+func newResolvedActionEvent(action Action, err error) Event {
+	return Event{
+		eventType: resolvedAction,
+		affected:  []any{action, err},
+	}
+}
+
+func (s *LocalState) fireEvent(e Event) {
+	log.Game(e)
+	s.events = append(s.events, e)
+}
diff --git a/go/game/stack.go b/go/game/stack.go
index 1ab4ccf8..4d2a056e 100644
--- a/go/game/stack.go
+++ b/go/game/stack.go
@@ -35,7 +35,8 @@ func (s *Stack) pop() {
 		s.gameState.ResolveAction(a)
 	}
 
-	log.Println("Resolved", a, err)
+	resolvedActionEvent := newResolvedActionEvent(a, err)
+	s.gameState.fireEvent(resolvedActionEvent)
 	s.gameState.broadcastNotification(newResolvedActionNotification(a, err))
 
 	// Some action may be reused like full actions of permanents.
diff --git a/go/game/state.go b/go/game/state.go
index 0d8066c0..c0b3ed37 100644
--- a/go/game/state.go
+++ b/go/game/state.go
@@ -168,7 +168,9 @@ func (s *LocalState) Loop() []*Player {
 			p.Turn++
 
 			if p.Deck.IsEmpty() {
-				log.Printf("Shuffle %s pile into the deck\n", p.Name)
+				e := newShuffleEvent(p, []PileOfCards{p.DiscardPile})
+				s.fireEvent(e)
+
 				p.DiscardPile.MoveInto(p.Deck)
 				p.Deck.Shuffle(s.Rand)
 			}
@@ -464,6 +466,7 @@ func (s *LocalState) declareAction(a Action) {
 
 	if err == nil {
 		s.pushAction(a)
+		s.fireEvent(newDeclaredActionEvent(a))
 	}
 
 	s.broadcastNotification(newDeclaredActionNotification(a, err))
diff --git a/go/game/trigger.go b/go/game/trigger.go
index b061ea78..93b155c6 100644
--- a/go/game/trigger.go
+++ b/go/game/trigger.go
@@ -1,97 +1,12 @@
 package game
 
 import (
-	"fmt"
-	"log"
-
 	"golang.org/x/exp/slices"
 
+	"muhq.space/muhqs-game/go/log"
 	"muhq.space/muhqs-game/go/utils"
 )
 
-type eventType int
-
-const (
-	destruction eventType = iota
-	eot
-	sacrifice
-	play
-	target
-	etb
-	damageDealt
-)
-
-var EventTypes = struct {
-	Destruction eventType
-	Eot         eventType
-	Sacrifice   eventType
-	Play        eventType
-	Target      eventType
-	Etb         eventType
-	DamageDealt eventType
-}{
-	Destruction: destruction,
-	Eot:         eot,
-	Sacrifice:   sacrifice,
-	Play:        play,
-	Target:      target,
-	Etb:         etb,
-	DamageDealt: damageDealt,
-}
-
-func (e eventType) String() string {
-	switch e {
-	case destruction:
-		return "destruction"
-	case eot:
-		return "eot"
-	case sacrifice:
-		return "sacrifice"
-	case play:
-		return "play"
-	case target:
-		return "target"
-	case etb:
-		return "etb"
-	case damageDealt:
-		return "damageDealt"
-	}
-
-	log.Panicf("Unknown evenType: %d", e)
-	return ""
-}
-
-type Event struct {
-	eventType eventType
-	sources   []any
-	affected  []any
-}
-
-func (e Event) String() string {
-	if len(e.sources) == 0 {
-		return e.eventType.String()
-	}
-
-	return fmt.Sprintf("%v:%v", e.sources, e.eventType)
-}
-
-func newEotEvent() Event {
-	return Event{eventType: eot}
-}
-
-func newTargetEvent(source any, targets *Targets) Event {
-	affected := make([]any, 0, len(targets.ts))
-	for _, t := range targets.ts {
-		affected = append(affected, t.sel...)
-	}
-	return Event{eventType: target, sources: []any{source}, affected: affected}
-}
-
-func (s *LocalState) fireEvent(e Event) {
-	log.Println("fire event:", e)
-	s.events = append(s.events, e)
-}
-
 type Trigger interface {
 	Source() any
 	String() string