prompt the user to order its triggers

All TriggeredAction are passed in the wrapper action
DeclareTriggeredActionsAction to the controller of the triggers.
It is expected to receive an ordered list back from the user
again wrapped in a DeclareTriggeredActionsAction.
The triggered actions will be declared in from first to last.

1 files changed, 33 insertions, 1 deletions

diff --git a/go/game/action.go b/go/game/action.go
index 4f433845..a8b27314 100644
--- a/go/game/action.go
+++ b/go/game/action.go
@@ -2,6 +2,7 @@ package game
 
 import (
 	"fmt"
+	"log"
 )
 
 type (
@@ -12,6 +13,7 @@ type (
 
 type Action interface {
 	Source() interface{}
+	Controller() *Player
 	Targets() *Targets
 	Target() *Target // Shortcut for to select the first target
 
@@ -25,6 +27,7 @@ type Action interface {
 type PassPriority struct{ player *Player }
 
 func (a *PassPriority) Source() interface{}       { return a.player }
+func (a *PassPriority) Controller() *Player       { return a.player }
 func (*PassPriority) Targets() *Targets           { return nil }
 func (*PassPriority) Target() *Target             { return nil }
 func (*PassPriority) NeedsActionCostChoice() bool { return false }
@@ -40,6 +43,7 @@ type TargetSelection struct {
 }
 
 func (sel *TargetSelection) Source() interface{}         { return sel.player }
+func (sel *TargetSelection) Controller() *Player         { return sel.player }
 func (sel *TargetSelection) Targets() *Targets           { return sel.targets }
 func (sel *TargetSelection) Target() *Target             { return sel.targets.ts[0] }
 func (*TargetSelection) NeedsActionCostChoice() bool     { return false }
@@ -67,7 +71,20 @@ type ActionBase struct {
 	costFunc    ActionCostFunc
 }
 
-func (a *ActionBase) Source() interface{}    { return a.source }
+func (a *ActionBase) Source() interface{} { return a.source }
+func (a *ActionBase) Controller() *Player {
+	switch t := a.source.(type) {
+	case *Player:
+		return t
+	case Permanent:
+		return t.Controller()
+	default:
+		log.Panicf("Unhandled source type %v", t)
+		return nil
+	}
+
+	return nil
+}
 func (a *ActionBase) resolve(s *State)       { a.resolveFunc(s) }
 func (a *ActionBase) PayCosts(s *State) bool { return a.costFunc(s) }
 func (a *ActionBase) Targets() *Targets      { return a.targets }
@@ -102,6 +119,21 @@ func (a *TriggeredAction) String() string {
 	return fmt.Sprintf("%v ! %v", a.event, a.source)
 }
 
+// Wrapper action to pass all triggered actions through the PlayerControl
+type DeclareTriggeredActionsAction struct {
+	actions []*TriggeredAction
+}
+
+func (sel *DeclareTriggeredActionsAction) Source() interface{}         { return nil }
+func (sel *DeclareTriggeredActionsAction) Controller() *Player         { return nil }
+func (sel *DeclareTriggeredActionsAction) Targets() *Targets           { return nil }
+func (sel *DeclareTriggeredActionsAction) Target() *Target             { return nil }
+func (*DeclareTriggeredActionsAction) NeedsActionCostChoice() bool     { return false }
+func (sel *DeclareTriggeredActionsAction) CheckTargets(s *State) error { return nil }
+func (*DeclareTriggeredActionsAction) PayCosts(*State) bool            { return true }
+func (*DeclareTriggeredActionsAction) resolve(*State)                  {}
+func (*DeclareTriggeredActionsAction) String() string                  { return "declared triggered actions" }
+
 type PileDropAction struct {
 	ActionBase
 	pile []Permanent