围棋、一级函数和最佳实践

Question

在过去的几天里，我一直在为一级函数（将一个可调用的函数分配给某个变量）的问题，以及效率方面的最佳实践而犯难。

比方说，我正在编程一个Yugioh卡牌游戏，我希望每一张类型为卡牌的独立卡牌至少有这些属性。

type card struct {
    name string
    text string
}

我一直在思考在哪里（以及如何）为每张卡的单独功能编程。我目前确信，一级功能的最佳位置是在 type card struct 并像在Python中一样，将新属性创建为 "可调用"(去游乐场的链接).

package main

import "fmt"


type card struct {
    name string
    text string
    f interface{}
}

type monsterCard struct {
    card
    attack int
    defense int
}

type buff func(target *monsterCard) // Could be defined in a second file

type swap func(target *monsterCard, value int) // ditto

var increaseAttack buff = func(target *monsterCard)  { // ditto
    target.attack += 100
}

var swichStats swap = func(target *monsterCard, value int) { // ditto
    attack := target.attack
    target.attack = value
    target.defense = attack
}

func main()  {
    m1 := monsterCard{
        card:    card{
            name: "Celtic Guardian",
            f:    increaseAttack,
        },
        attack:  1400,
        defense: 1200,
    }
    m2 := monsterCard{
        card:    card{
            name:     "Dark Magician",
            f:         swichStats,
        },
        attack:  2500,
        defense: 2100,
    }
    var monsters = [2]monsterCard{m1, m2}
    for _, m := range monsters {
        fmt.Println(m)
        switch m.f.(type) {
        case buff:
            m.f.(buff)(&m)
        case swap:
            m.f.(swap)(&m, m.defense)
        default:
            fmt.Printf("%T", m.f)
        }
        fmt.Println(m)
    }
}

我并不擅长高效的代码，我完全理解我可能在这里进行了早期的优化；但是，我需要对数百个这样的卡进行编程，如果让这些可调用的卡存在于全局范围内，并且严重依赖类型断言，使程序变得很慢，那么我将在重组代码时遇到麻烦。

你能看出我的方法论有什么明显的问题吗？我对一级函数的处理是正确的，还是有什么明显的性能问题我看不出来？任何和所有的帮助都将非常感激!

Answer 1

你可以使用普通函数，在需要的地方使用闭包。

type card struct {
    name string
    text string
    fn   func(*monsterCard)
}

type monsterCard struct {
    card
    attack  int
    defense int
}

func (mc *monsterCard) call() {
    mc.fn(mc)
}

func increaseAttack(mc *monsterCard) {
    mc.attack += 100
}

func switchStats(mc *monsterCard) {
    mc.attack, mc.defense = mc.defense, mc.attack
}


func updateTextAndAttack(text string, attack int) func(mc *monsterCard) {
    return func(mc *monsterCard) {
        mc.text, mc.attack = text, attack
    }
}

https:/play.golang.compv_RbObnu7sN

你也可以在需要的地方使用普通方法和闭包。

type card struct {
    name string
    text string
}

type monsterCard struct {
    card
    attack  int
    defense int
}

func (mc *monsterCard) increaseAttack() {
    mc.attack += 100
}

func (mc *monsterCard) switchStats() {
    mc.attack, mc.defense = mc.defense, mc.attack
}

func (mc *monsterCard) updateTextAndAttack(text string, attack int) func() {
    return func() {
        mc.text, mc.attack = text, attack
    }
}

https:/play.golang.compEo1mm-seldA

Answer 2

感谢大家帮助我完成这个答案。看来我还是在用脚本语言的思维方式来尝试用编译语言解决问题。与其试图创建接口，最终导致代码更难读，我需要在自定义类型定义上更加严格，为每种类型的卡牌效果实现不同的函数类型。这样严格的执行也会让游戏中存在多种效果的卡牌。

package main

type card struct {
    name string
    text string
}

type monsterCard struct {
    card
    attack int
    defense int
}

type buffEffect struct {
    monsterCard
    fn buff
}

type setValueEffect struct {
    monsterCard
    fn swap
}

type buff func(target *monsterCard)

type swap func(target *monsterCard, value int)

var increaseAttack buff = func(target *monsterCard)  {
    target.attack += 100
}

var setAttackValue swap = func(target *monsterCard, value int) {
    target.attack = value
}

func main()  {
    m1 := buffEffect{
        monsterCard: monsterCard{
            card:    card{
                name: "Celtic Guardian",
            },
            attack:  1400,
            defense: 1200,
        },
        fn:          increaseAttack,
    }
    m2 := setValueEffect{
        monsterCard: monsterCard{
            card:    card{
                name: "Dark Magician",
            },
            attack:  2500,
            defense: 2100,
        },
        fn:          setAttackValue,
    }
    m1.fn(&m1.monsterCard)
    m2.fn(&m2.monsterCard, 100)
}