path: root/go/game/card.go

package game

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"path"
	"strconv"
	"strings"

	"golang.org/x/exp/slices"
	"gopkg.in/yaml.v3"
)

type CardType int

const (
	undefinedCardType CardType = iota
	unitType
	spellType
	artifactType
	equipmentType
	potionType
	intentionType
)

func (ct CardType) String() string {
	switch ct {
	case undefinedCardType:
		return "undefined"
	case unitType:
		return "unit"
	case spellType:
		return "spell"
	case artifactType:
		return "artifact"
	case equipmentType:
		return "equipment"
	case potionType:
		return "potion"
	case intentionType:
		return "intention"
	}
	log.Panicf("Switch not exhausting %d", ct)
	return ""
}

var CardTypes = struct {
	Unit      CardType
	Spell     CardType
	Artifact  CardType
	Equipment CardType
	Potion    CardType
	Intention CardType
}{
	Unit:      unitType,
	Spell:     spellType,
	Artifact:  artifactType,
	Equipment: equipmentType,
	Potion:    potionType,
	Intention: intentionType,
}

var CardTypeNames = map[string]CardType{
	"unit":      unitType,
	"spell":     spellType,
	"artifact":  artifactType,
	"equipment": equipmentType,
	"potion":    potionType,
	"intention": intentionType,
}

type cardImplementation interface {
	spawnTiles(*State, *Player) []*Tile
	fullActionPrototypes(*Unit) []*FullActionPrototype
	freeActionPrototypes(Permanent) []*FreeActionPrototype
}

// Default implementation of the cardImplementation interface.
//
// Card Implementations should embed this struct to "inherit" the
// default behavior.
type cardImplementationBase struct{}

func (impl *cardImplementationBase) spawnTiles(*State, *Player) []*Tile {
	return nil
}

func (impl *cardImplementationBase) fullActionPrototypes(*Unit) []*FullActionPrototype {
	return nil
}

func (impl *cardImplementationBase) freeActionPrototypes(Permanent) []*FreeActionPrototype {
	return nil
}

// Map of all card implementations
var cardImplementations map[string]cardImplementation

func getCardImplementation(c *Card) cardImplementation {
	if impl, found := cardImplementations[c.Path()]; found {
		return impl
	}

	impl := newParsedCardImplementation(c)
	cardImplementations[c.Path()] = impl
	return impl
}

const (
	CARD_DATA_URL string = "data/cards"
	NOT_BUYABLE   int    = -1 // Maybe this needs to be changed some day to allow more design space
)

type Card struct {
	Name    string
	Set     SetIdentifier
	Type    CardType
	BuyCost int
	Values  map[string]interface{}
	Impl    cardImplementation
}

var cardDefinitions = map[string]map[string][]byte{}

func getCardDefinition(set, cardName string) []byte {
	cardDefinition, found := cardDefinitions[set][cardName]
	if !found {
		cardDefinition = retrieveCardDefinition(path.Join(set, cardName))
		if cardDefinitions[set] == nil {
			cardDefinitions[set] = map[string][]byte{}
		}
		cardDefinitions[set][cardName] = cardDefinition
	}
	return cardDefinition
}

func retrieveCardDefinition(cardPath string) []byte {
	url := PROTOCOL + path.Join(BASE_URL, CARD_DATA_URL, cardPath+".yml")
	log.Printf("loading %s\n", url)
	resp, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}

	defer resp.Body.Close()
	data, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	return data
}

func (card *Card) parseDefinition(definition []byte) {
	data := make(map[interface{}]interface{})
	err := yaml.Unmarshal(definition, &data)
	if err != nil {
		log.Fatalf("parsing %s failed with: %v\n", definition, err)
	}

	name, found := data["name"]
	if !found {
		log.Fatalf("no name in card yaml %s\n", definition)
	}
	delete(data, "name")

	switch nameYml := name.(type) {
	case string:
		card.Name = nameYml
	case map[string]interface{}:
		cardName := nameYml["en"]
		card.Name = cardName.(string)
	default:
		log.Fatalf("Unexpected type %T of yml card field 'Name'\n", name)
	}

	t, found := data["type"]
	if !found {
		log.Fatalf("no type in card yaml %s\n", definition)
	}
	delete(data, "type")

	card.Type = CardTypeNames[t.(string)]

	bc, found := data["buy"]
	if found {
		card.BuyCost = bc.(int)
	} else {
		card.BuyCost = NOT_BUYABLE
	}
	delete(data, "buy")

	for k, v := range data {
		card.Values[k.(string)] = v
	}

	card.Impl = getCardImplementation(card)
}

func (card *Card) getCanonicalValues(key string) []string {
	var values []string
	untypedValues, found := card.Values[key]
	if !found {
		return []string{}
	}

	switch typedValues := untypedValues.(type) {
	case map[string]interface{}:
		enValues := typedValues["en"]
		switch typedEnValues := enValues.(type) {
		case string:
			values = []string{typedEnValues}
		case []string:
			values = typedEnValues
		case []interface{}:
			values = []string{}
			for _, v := range typedEnValues {
				values = append(values, v.(string))
			}
		}
	case string:
		values = []string{typedValues}
	case int:
		values = []string{strconv.Itoa(typedValues)}
	case []string:
		values = typedValues
	}

	for i, value := range values {
		values[i] = strings.ToLower(value)
	}

	return values
}

func (card *Card) getEffects() []string {
	return card.getCanonicalValues("effect")
}

func (card *Card) hasEffect(effect string) bool {
	return slices.Contains(card.getEffects(), effect)
}

func (card *Card) getXEffect(effect string) (int, error) {
	for _, e := range card.getEffects() {
		if !strings.Contains(e, effect) {
			continue
		}

		tokens := strings.SplitN(e, " ", 2)
		return strconv.Atoi(tokens[1])
	}
	return 0, fmt.Errorf("Crad %s has no effect %s", card.Name, effect)
}

func (card *Card) hasPlacementConstrain(effect string) bool {
	if slices.Contains(card.getEffects(), effect) {
		return true
	} else if card.Type != CardTypes.Unit {
		return false
	}

	movementDesc := card.getCanonicalValues("movement")[0]
	return strings.Contains(movementDesc, effect)
}

func (card *Card) getAI() string {
	aiDesc := card.getCanonicalValues("ai")
	if len(aiDesc) == 0 {
		return ""
	}
	return strings.Split(aiDesc[0], " ")[0]
}

func NewCard(cardPath string) *Card {
	cardName := path.Base(cardPath)
	set := path.Dir(cardPath)

	cardDefinition := getCardDefinition(set, cardName)

	c := Card{
		Name:    "",
		Set:     SetIdentifierNames[set],
		Type:    undefinedCardType,
		BuyCost: NOT_BUYABLE,
		Values:  map[string]interface{}{},
	}
	c.parseDefinition(cardDefinition)
	return &c
}

func (c *Card) Path() string {
	fileName := strings.ReplaceAll(strings.ToLower(c.Name), " ", "_")
	return path.Join(c.Set.String(), fileName)
}

func (c *Card) IsPermanent() bool {
	return c.Type == CardTypes.Unit ||
		c.Type != CardTypes.Artifact ||
		c.Type != CardTypes.Equipment ||
		c.Type != CardTypes.Potion
}

func (c *Card) IsBuyable() bool {
	return c.BuyCost != NOT_BUYABLE
}

func (c *Card) PlayCosts() int {
	switch c.Type {
	case CardTypes.Unit:
		return c.Values["upkeep"].(int)
	default:
		return c.Values["play"].(int)
	}
}