From 09fdf1994874ddcae898b142361cfff787bd0e0d Mon Sep 17 00:00:00 2001 From: Kistaro Windrider Date: Sat, 1 Apr 2023 22:09:05 -0700 Subject: [PATCH] CardOption.Enable Make it possible for a card to display an option but not actually allow it to be selected. It's up to the UI layer to decide how to display options that are not enabled. The option text should probably contiain a note on why the option cannot be selected... --- cardsim/card.go | 28 +++++++++++++++++++++++++--- cardsim/player.go | 31 ++++++++++++++++++++++--------- 2 files changed, 47 insertions(+), 12 deletions(-) diff --git a/cardsim/card.go b/cardsim/card.go index cd51389..5d3cc55 100644 --- a/cardsim/card.go +++ b/cardsim/card.go @@ -52,6 +52,9 @@ type CardOption[C StatsCollection] interface { // After an option is enacted, the card is deleted. If a card should be // repeatable, Enact must return it to the deck (on every option). Enact(p *Player[C]) (Message, error) + + // Enabled returns whether this option can curently be enacted. + Enabled(p *Player[C]) bool } // A BasicCard is a Card with fixed title, text, options, and optional @@ -64,22 +67,27 @@ type BasicCard[C StatsCollection] struct { AfterOption func(p *Player[C], option CardOption[C]) error } -func (b *BasicCard[C]) Title(p *Player[C]) (Message, error) { +// Title implements Card. +func (b *BasicCard[C]) Title(_ *Player[C]) (Message, error) { return b.CardTitle, nil } +// Urgent implements Card. func (b *BasicCard[C]) Urgent(_ *Player[C]) bool { return b.IsUrgent } -func (b *BasicCard[C]) EventText(p *Player[C]) (Message, error) { +// EventText implements Card. +func (b *BasicCard[C]) EventText(_ *Player[C]) (Message, error) { return b.CardText, nil } +// Options implements Card. func (b *BasicCard[C]) Options(_ *Player[C]) ([]CardOption[C], error) { return b.CardOptions, nil } +// Then implements Card. func (b *BasicCard[C]) Then(p *Player[C], option CardOption[C]) error { if b.AfterOption == nil { return nil @@ -87,11 +95,13 @@ func (b *BasicCard[C]) Then(p *Player[C], option CardOption[C]) error { return b.AfterOption(p, option) } -func (b *BasicCard[C]) Drawn(p *Player[C]) bool { +// Drawn implements Card. +func (b *BasicCard[C]) Drawn(_ *Player[C]) bool { return true } // A BasicOption is a CardOption with fixed text, effects, and output. +// It's always enabled. type BasicOption[C StatsCollection] struct { Text Message Effect func(*Player[C]) error @@ -108,6 +118,11 @@ func (b *BasicOption[C]) Enact(p *Player[C]) (Message, error) { return b.Output, b.Effect(p) } +// Enabled implements CardOption. +func (b *BasicOption[C]) Enabled(p *Player[C]) bool { + return true +} + // OptionFunc attaches a fixed prompt to an Enact-like function. Unlike // BasicOption, the enactment function provided to OptionFunc returns // the text that should be output as a result of the action, so it is @@ -121,10 +136,17 @@ type optionFunc[C StatsCollection] struct { f func(*Player[C]) (Message, error) } +// OptionText implements CardOption. func (o *optionFunc[C]) OptionText(p *Player[C]) (Message, error) { return o.text, nil } +// Enact implements CardOption. func (o *optionFunc[C]) Enact(p *Player[C]) (Message, error) { return o.f(p) } + +// Enabled implements CardOption. +func (o *optionFunc[C]) Enabled(p *Player[C]) bool { + return true +} diff --git a/cardsim/player.go b/cardsim/player.go index 2758ec8..a0eeaac 100644 --- a/cardsim/player.go +++ b/cardsim/player.go @@ -277,9 +277,10 @@ func (p *Player[C]) HasUrgentCards() bool { // EnactCardUnchecked executes a card choice, removes it from the hand, and // decrements the ActionsRemaining. It does not check for conflicting Urgent // cards or already being out of actions. If no such card or card choice -// exists, this returns nil and ErrInvalidCard/ErrInvalidChoice. Otherwise, this returns -// the result of enacting the card. If enacting the card causes an error, -// the State becomes GameCrashed. +// exists, or the specified choice is not enabled, this returns nil and +// ErrInvalidCard/ErrInvalidChoice without changing anything. Otherwise, this +// returns the result of enacting the card. If enacting the card causes a +// serious error, the State becomes GameCrashed. func (p *Player[C]) EnactCardUnchecked(cardIdx, choiceIdx int) (Message, error) { if cardIdx < 0 || cardIdx >= len(p.Hand) { return nil, fmt.Errorf("%w: no card #%d when %d cards in hand", ErrInvalidCard, cardIdx, len(p.Hand)) @@ -293,7 +294,13 @@ func (p *Player[C]) EnactCardUnchecked(cardIdx, choiceIdx int) (Message, error) } errs.Add(err) if choiceIdx < 0 || choiceIdx > len(options) { - errs.Add(fmt.Errorf("%w: no option #%d on card #%d with %d options", ErrInvalidCard, choiceIdx, cardIdx, len(options))) + errs.Add(fmt.Errorf("%w: no option #%d on card #%d with %d options", ErrInvalidChoice, choiceIdx, cardIdx, len(options))) + return nil, errs.Emit() + } + + chosen := options[choiceIdx] + if !chosen.Enabled(p) { + errs.Add(fmt.Errorf("%w: option %d on card %d was not enabled", ErrInvalidChoice, choiceIdx, cardIdx)) return nil, errs.Emit() } @@ -335,9 +342,10 @@ func (p *Player[C]) EnactCard(cardIdx, choiceIdx int) (Message, error) { // EnactPermanentActionUnchecked executes a permanently-available action and // decrements the ActionsRemaining. It does not check for conflicting Urgent // cards or already being out of actions. If no such action or card option -// exists, this returns nil and ErrInvalidCard/ErrInvalidChoice. Otherwise, this returns -// the result of enacting the permanent action. If enacting the card causes an error, -// the State becomes GameCrashed. +// exists, or the option is not enabled, this returns nil and ErrInvalidCard +// or ErrInvalidChoice without changing anything. Otherwise, this returns the +// result of enacting the permanent action. If enacting the card causes a +// serious error, the State becomes GameCrashed. func (p *Player[C]) EnactPermanentActionUnchecked(actionIdx, choiceIdx int) (Message, error) { if actionIdx < 0 || actionIdx >= len(p.PermanentActions) { return nil, fmt.Errorf("%w: no action #%d when %d permanent actions exist", ErrInvalidCard, actionIdx, len(p.PermanentActions)) @@ -354,17 +362,22 @@ func (p *Player[C]) EnactPermanentActionUnchecked(actionIdx, choiceIdx int) (Mes errs.Add(fmt.Errorf("%w: no option #%d on permanent action #%d with %d options", ErrInvalidChoice, choiceIdx, actionIdx, len(options))) return nil, errs.Emit() } + chosen := options[choiceIdx] + if !chosen.Enabled(p) { + errs.Add(fmt.Errorf("%w: option #%d on permanent action #%d is not enabled", ErrInvalidChoice, choiceIdx, actionIdx)) + return nil, errs.Emit() + } p.ActionsRemaining-- - ret, err := options[choiceIdx].Enact(p) + ret, err := chosen.Enact(p) errs.Add(err) if IsSeriousError(err) { p.State = GameCrashed return ret, errs.Emit() } - err = card.Then(p, options[choiceIdx]) + err = card.Then(p, chosen) errs.Add(err) if IsSeriousError(err) { p.State = GameCrashed