4

我想编写一个游戏，并想为多个实体使用组件模式。

在具有接口/类型类/多重继承的语言中不会有问题。

我希望某些实体是可更新的但不可渲染的，而有些则两者兼而有之。

哈斯克尔：

class Updateable a where
    update :: Float -> a -> a

class Renderable a where
    render :: a -> Picture

class InputHandler a where
    handleInput :: Event -> a -> a

我可以创建一个可以更新的列表。

updateAll :: Updateable a => Float -> [a] -> [a]
updateAll delta objs = map (update delta) objs

在 Java/D/... 这可以通过接口实现

interface Updateable {
    void update(float delta);
}

// somewhere in a method
List<Updateable> objs = ...;
for (Updateable o : objs) {
    o.update(delta);
}

现在我想知道如何使用多种方法在 nim 中实现这一点。

拟合多方法的存在可以用类型表示吗？

var objs: seq[???] = @[]


编辑：添加了更多代码并修复了不正确的 Haskell 示例

4

3 回答 3

4

我不确定这是否能回答你的问题，但值得一提。

如果您要根据类型将游戏对象存储在单独的列表中，您仍然可以编写很多通用逻辑。由于预读和分支预测，按类型存储对象具有更好的性能。看这个讲座，由一个应该知道他在说什么的人讲：多处理器游戏循环：来自神秘海域 2 的教训：盗贼之间。

例如，如果您texture为某些对象类型定义了一个 proc，那么您可以编写一个draw(t: T) = magicRenderToScreen(texture(t))适用于所有对象类型的通用 proc。如果您正在实现资源池或任何类型的一般行为，这也很有用。

您确实必须以某种方式在渲染和更新循环中包含每个受影响的对象类型，但这在实践中通常不是什么大问题。你甚至可以使用一个简单的宏来减少冗长，所以你的渲染循环只包含类似的东西renderAll(players, enemies, sprites, tiles)

通用列表在编译语言中并不简单，并且 nim 会强制您查看它，这在您开发游戏时非常有用。要拥有通用列表，您通常要么必须使用指针和动态调度，要么使用某种联合类型。我似乎记得 nim 曾经能够从父对象 ref 分派到正确的多方法（这将使列表能够包含多种类型并在运行时动态分派）但老实说我不确定这是否仍然可以完毕...？

有更懂的人请告诉我们！

于 2016-03-21T12:11:22.300 回答
3

缺少明确的interface关键字是Nim 社区中的常见问题。采用 Araq 的答案并将其应用于基于您的 Java/D 代码段的假设案例，我们可以编写如下内容：

import strutils # For formatFloat

type
  IUpdateable =
    tuple[
      update: proc(v: float) {.closure.},
      show: proc(): string {.closure.}
      ]

  Rounded = ref object
    internalValue: float

  Real = ref object
    a_real_value: float

# Here goes our rounded type.
proc `$`(x: Rounded): string =
  result = "Rounded{" & $int(x.internalValue) & "}"

proc updateRounded(x: Rounded, delta: float) =
  x.internalValue += delta

proc getUpdateable(x: Rounded): IUpdateable =
  result = (
    update: proc(v: float) = x.updateRounded(v),
    show: proc(): string = `$`(x)
    )

converter toIUpdateable(x: Rounded): IUpdateable =
  result = x.getUpdateable

# Here goes our Real type.
proc `$`(x: Real): string =
  result = "Real{" &
    x.a_real_value.format_float(precision = 3) & "}"

proc update_real(x: Real, delta: float) =
  x.a_real_value += delta

proc getUpdateable(x: Real): IUpdateable =
  result = (
    update: proc(v: float) = x.update_real(v),
    show: proc(): string = `$`(x)
    )

# Here goes the usage
proc main() =
  var objs: seq[IUpdateable] = @[]
  var a = Rounded()
  var b = Real()
  a.internalValue = 3.5
  b.a_real_value = 3.5

  objs.add(a) # works because of toIUpdateable()
  objs.add(b.getUpdateable)

  for obj in objs:
    echo "Going through one loop iteration"
    echo "\t", obj.show()
    obj.update(0.4)
    echo "\t", obj.show()
    obj.update(0.4)
    echo "\t", obj.show()

main()
# -> Going through one loop iteration
# ->    Rounded{3}
# ->    Rounded{3}
# ->    Rounded{4}
# -> Going through one loop iteration
# ->    Real{3.50}
# ->    Real{3.90}
# ->    Real{4.30}

但是，正如您在该论坛主题中所读到的那样，取决于您需要什么接口，其他方法可能会更好。此外，未来的路可能是概念，但像往常一样，手册很枯燥，相关的单元测试也很神秘，所以我无法将前面的元组示例转换为概念。

如果您想了解概念，您应该直接在论坛中询问，但请注意，正如手册所说，概念仍在开发中。

于 2016-03-20T21:53:27.487 回答
0

Swift 也有同样的问题，他们在那里使用 Type Erasure，这与之前评论中提出的相同，但更加结构化。Nim 中的一般模式是这样的：

#-------------------------------------------------------------
# types
#-------------------------------------------------------------
type C = concept type C
    proc name(x: C, msg: string): string

type AnyC = object
    name: proc(msg: string): string # doesn't contain C

type A = object
type B = object

#-------------------------------------------------------------
# procs
#-------------------------------------------------------------
proc name(x: A, msg: string): string = "A" & msg
proc name(x: B, msg: string): string = "B" & msg
proc name(x: AnyC, msg: string): string = x.name(msg) # AnyC implements C

proc to_any(x: A): AnyC = AnyC(
    name: proc (msg: string): string = name(x, msg) # x captured by proc
)

proc to_any(x: B): AnyC = AnyC(
    name: proc (msg: string): string = name(x, msg) # x captured by proc
)

# actually use C
proc print_name(x: C, msg: string) = echo x.name(msg)

#-------------------------------------------------------------
# main
#-------------------------------------------------------------

let a = A()
let b = B()

let cs = [a.to_any(), b.to_any()] # the main goal of most erasure cases

for c in cs:
    c.print_name(" erased") # e.g. "A erased"

在这个例子中AnyC实现了C，A也B实现了，C但更重要的是可以转换为AnyC. 这些Any*类型通常包含闭包以有效地擦除类型，并concept通过简单的转发参数来实现自身。

我希望有一个宏或可以自动实现的Any*东西to_any。

于 2020-04-30T20:52:44.043 回答