Go gamedev patterns

Transcript

1. Go gamedev patterns @quasilyte for Golang United, 2022 1
2. Prerequisite ✅ Go 1.18 (we need generics) ✅ Ebitengine ✅ Legendary tolerance for my English Please ⭐ both Ebitengine and Godot projects :3 2
3. About $username • Compiler engineer during the day • Game developer during the night • I also stream random indie games from itch io • Played video games since ~2000 I worked with Game Maker, Godot and Ebiten. I also tried Defold and Phaser. 3
4. My Ebitengine games 4
15. My published games • Autotanks • Retrowave City • Decipherism (GameOff 2022 game jam submission) 15
16. Go gamedev overview 16
17. Ebitengine vs Godot impressions Cons: 17
18. Ebitengine vs Godot impressions Cons: • It’s much harder to become productive 18
19. Ebitengine vs Godot impressions Cons: • It’s much harder to become productive • Much smaller community 19
20. Ebitengine vs Godot impressions Cons: • It’s much harder to become productive • Much smaller community • Ebiten provides no “framework” to shape your game 20
21. Ebitengine vs Godot impressions Cons: • It’s much harder to become productive • Much smaller community • Ebiten provides no “framework” to shape your game • The ecosystem is not mature enough 21
22. Ebitengine vs Godot impressions Pros: 22
23. Ebitengine vs Godot impressions Pros: • Go as a first-class language 23
24. Ebitengine vs Godot impressions Pros: • Go as a first-class language • Full go toolchain benefits: tests, benchmarks, profiling 24
25. Ebitengine vs Godot impressions Pros: • Go as a first-class language • Full go toolchain benefits: tests, benchmarks, profiling • You can help the ecosystem to get better 25
26. Ebitengine game development guide 26
27. You need more than just Ebitengine Ebitengine Input Nodes/ECS Res. manager Math utils Collisions Slots/signals UI Layers Camera Tiles Scripting Prem ium content! $$$ 27
28. Some core ideas • Port the code and ideas from Godot (C++ -> Go) 28
29. Some core ideas • Port the code and ideas from Godot (C++ -> Go) • Start from the simpler, small games 29
30. Some core ideas • Port the code and ideas from Godot (C++ -> Go) • Start from the simpler, small games • Browse awesome-ebiten for packages and inspiration 30
31. Why many Go gamedev libs are not mature? In my opinion: • They’re created to solve a specific task at the moment of the game creation • Most lib authors are interested in creating games, not libraries 31
32. Some other issues • Libraries don’t play well together • It’s hard to become the #1 library 32
33. Some other issues • Libraries don’t play well together • It’s hard to become the #1 library 33
34. Vectors & Math 34
35. Vec2 use cases • Velocity, force and other vector-like units 35
36. Vec2 use cases • Velocity, force and other vector-like units • Simple positions, points in space (X, Y) 36
37. Vec2 use cases • Velocity, force and other vector-like units • Simple positions, points in space (X, Y) • Normalized (unit) vectors for directions 37
38. type Vec2 struct { X float64 Y float64 } 38
39. Why float64 • Float literals in Go imply float64 type • Go math library works with float64 • Most ebiten APIs work with float64 Only GPU-related things may require float32 39
40. Why float64 • Float literals in Go imply float64 type • Go math library works with float64 • Most ebiten APIs work with float64 Only GPU-related things may require float32 40
41. Why float64 • Float literals in Go imply float64 type • Go math library works with float64 • Most ebiten APIs work with float64 Only GPU-related things may require float32 41
42. Vec2 representation kvartborg/vector uses slices to represent vectors. This is not efficient because most vectors in 2D game have exactly 2 components. Godot is open-source, you can roll the implementation based on its source code. 42
43. Vec2 representation kvartborg/vector uses slices to represent vectors. This is not efficient because most vectors in 2D game have exactly 2 components. Godot is open-source, you can roll the implementation based on its source code. 43
44. gmath library github.com/quasilyte/gmath Vec2, radians and other gamedev math helpers. Inspired by Godot math library. 44
45. Positions / data binding 45
46. type Button struct { Pos Vec2 } type Container struct { Pos Vec2 } How about simple vectors for UI elements position? 46
47. Offset relative to another element Container Button1 Button1 47
48. type Tank struct { Pos Vec2 } type Turret struct { Pos Vec2 } And for the other game objects as well... 48
49. The turret follows its hull: their positions are related 49
50. Position requirements • Small size • Can express a position with offset • Can automatically follow other position (parent) Some positions are still going to be Vec2 50
51. Position requirements • Small size • Can express a position with offset • Can automatically follow other position (parent) Some positions are still going to be Vec2 51
52. Position requirements • Small size • Can express a position with offset • Can automatically follow other position (parent) Some positions are still going to be Vec2 52
53. Pointers for the (one-sided) data binding • Data source: a value owner, read+write • Pointer to data: read-only We can combine both to get a more flexible concept. 53
54. type Pos struct { Base *Vec2 // The position origin or (0, 0) if nil Offset Vec2 // The offset in relation to the origin } func (p Pos) Resolve() Vec2 { if p.Base == nil { return p.Offset } return p.Base.Add(p.Offset) } 54
55. type Pos struct { Base *Vec2 // The position origin or (0, 0) if nil Offset Vec2 // The offset in relation to the origin } func (p Pos) Resolve() Vec2 { if p.Base == nil { return p.Offset } return p.Base.Add(p.Offset) } 55
56. type Tank struct { Pos Vec2 } type Turret struct { - Pos Vec2 + Pos Pos } 56
57. Connected position turret.Pos.Base = &tank.Pos 57
58. Absolute pos container.Pos.Offset = Vec2{X: x, Y: y} 58
59. Pos with offset button1.Pos = container.Pos.WithOffset(ox, oy) button2.Pos = button1.Pos.WithOffset(ox, 0) 59
60. func (p Pos) WithOffset(ox, oy float64) Pos { ox += p.Offset.X oy += p.Offset.Y return Pos{ Base: p.Base, Offset: Vec2{X: ox, Y: oy}, } } 60
61. Signals & Slots 61
62. Why signals & slots? • Reduces objects coupling 62
63. Why signals & slots? • Reduces objects coupling • An elegant event listener solution for Go 63
64. Why signals & slots? • Reduces objects coupling • An elegant event listener solution for Go • Familiar concept (Godot, Phaser, Qt, …) 64
65. In Go terms • Signal = a field inside a struct 65
66. In Go terms • Signal = a field inside a struct • Slot = a function bound to a signal 66
67. In Go terms • Signal = a field inside a struct • Slot = a function bound to a signal • Disconnect = remove bound function 67
68. In Go terms • Signal = a field inside a struct • Slot = a function bound to a signal • Disconnect = remove bound function • Emit = call all bound functions 68
69. type Event[T any] struct { handlers []eventHandler[T] } type eventHandler[T any] struct { c connection f func(T) } type connection interface { IsDisposed() bool } 69
70. type Event[T any] struct { handlers []eventHandler[T] } type eventHandler[T any] struct { c connection f func(T) } type connection interface { IsDisposed() bool } 70
71. type Event[T any] struct { handlers []eventHandler[T] } type eventHandler[T any] struct { c connection f func(T) } type connection interface { IsDisposed() bool } 71
72. func (e *Event[T]) Connect(conn connection, slot func(T)) { e.handlers = append(e.handlers, eventHandler[T]{ c: conn, f: slot, }) } 72
73. func (e *Event[T]) Disconnect(conn connection) { for i, h := range e.handlers { if h.c == conn { e.handlers[i].c = theRemovedConnection break } } } 73
74. type removedConnection struct{} func (r *removedConnection) IsDisposed() bool { return true } var theRemovedConnection = &removedConnection{} 74
75. func (e *Event[T]) Emit(arg T) { handlers := e.handlers[:0] for _, h := range e.handlers { if h.c != nil && h.c.IsDisposed() { continue // effectively removes the handler } h.f(arg) handlers = append(handlers, h) } e.handlers = handlers } 75
76. type Vessel struct { hp float64 EventDestroyed signals.Event[*Vessel] EventAllianceChanged signals.Event[???] } 76
77. func (s *state) NewVessel() *Vessel { v := newVessel() v.EventDestroyed.Connect(s.onVesselDestroyed) return v } func (s *state) onVesselDestroyed(v *Vessel) {} 77
78. func (v *Vessel) destroy() { // ... v.EventDestroyed.Emit(v) } 78
79. EventAllianceChanged signals.Event[???] -> * signals.Event2[*Vessel, int] * signals.Event[tuple.Value2[*Vessel, int]] 79
80. EventN vs Event[tuple] With EventN multiple-arg signals are more elegant. With tuples we get more code reusability. 80
81. func ConnectOneShot[T any](e *Event[T], c connection, f func(T)) { oneshot := &oneshotConnector[T]{conn: c} e.Connect(oneshot, func(arg T) { oneshot.fired = true f(arg) }) } 81
82. type oneshotConnector[T any] struct { conn connection fired bool } func (c *oneshotConnector[T]) IsDisposed() bool { if c.fired { return true } return c.conn != nil && c.conn.IsDisposed() } 82
83. type Void struct{} Event[Void] event.Emit(Void{}) 83
84. Implementation properties • Tiny overhead and no allocs with 0 connections 84
85. Implementation properties • Tiny overhead and no allocs with 0 connections • Statically typed signatures without interface{} 85
86. Implementation properties • Tiny overhead and no allocs with 0 connections • Statically typed signatures without interface{} • Fast connect+emit 86
87. Implementation properties • Tiny overhead and no allocs with 0 connections • Statically typed signatures without interface{} • Fast connect+emit • Not thread-safe 87
88. Tuples 88
89. Why tuples? • Make things like Event[T] viable • Abstract away the arity in generic code Go doesn’t have variadic templates, so we need a way to overcome this limitation 89
90. Why tuples? • Make things like Event[T] viable • Abstract away the arity in generic code Go doesn’t have variadic templates, so we need a way to overcome this limitation 90
91. type Value2[T1 any, T2 any] struct { First T1 Second T2 } func New2[T1 any, T2 any](a T1, b T2) Value2[T1, T2] { return Value2[T1, T2]{a, b} } 91
92. type Value3[T1 any, T2 any, T3 any] struct { First T1 Second T2 Third T3 } func New3[T1 any, T2 any, T3 any](...) Value2[T1, T2, T3] { return Value3[T1, T2, T3]{a, b, c} } 92
93. func (v Value2[T1, T2]) Fields() (T1, T2) { return v.First, v.Second } func (v Value3[T1, T2, T3]) Fields() (T1, T2, T3) { return v.First, v.Second, v.Third } 93
94. // Tuple creation tup := tuple.New2(10, "quasilyte") // Tuple destructuring id, username := tup.Fields() 94
95. Controls mapping (keymaps) 95
96. Keymap requirements • Input-device agnostic 96
97. Keymap requirements • Input-device agnostic • Supports N-to-M action-key mapping 97
98. Keymap requirements • Input-device agnostic • Supports N-to-M action-key mapping • Multi-device support (gamepads, etc.) 98
99. Keymap requirements • Input-device agnostic • Supports N-to-M action-key mapping • Multi-device support (gamepads, etc.) • Can be conveniently reconfigured at run time 99
100. if inpututil.IsKeyJustPressed(ebiten.KeyW) { obj.moveForward() } 100
101. if inpututil.IsKeyJustPressed(ebiten.KeyW) { obj.moveForward() } if obj.input.IsActionJustPressed(MoveForward) { obj.moveForward() } The exact key and input method is abstracted away 101
102. if inpututil.IsKeyJustPressed(ebiten.KeyW) { obj.moveForward() } if obj.input.IsActionJustPressed(MoveForward) { obj.moveForward() } ID-bound input handlers instead of global input system 102
103. Action can be associated with multiple input events Key W Arrow Up ActionForward D-Pad Up 103
104. Every input handler has its ID (useful for gamepads) Player 2 Gamepad 2 Player 1 Gamepad 1 Handler{ID:1} Handler{ID:0} 104
105. All handlers are connected to some shared “global input system” InputSystem Handler{ID:1} Handler{ID:0} 105
106. type Handler struct { id int keymap Keymap sys *System } func (sys *System) NewHandler(id int, k Keymap) *Handler { return &Handler{ id: id, keymap: k, sys: sys, } } 106
107. type Action uint32 type Keymap map[Action][]Key type Key struct { code int kind keyKind } 107
108. type Action uint32 type Keymap map[Action][]Key type Key struct { code int kind keyKind } type keyKind uint8 const ( keyKeyboard keyKind = iota keyGamepad keyMouse ) 108
109. var KeyW = Key{ code: int(ebiten.KeyW), kind: keyKeyboard, } var KeyGamepadUp = Key{ code: int(ebiten.StandardGamepadButtonLeftTop), kind: keyGamepad, } 109
110. const ( ActionNone Action = iota ActionForward ActionRotateLeft ActionRotateRight // ... ) 110
111. var keymap = Keymap{ ActionForward: { KeyW, KeyArrowUp, KeyGamepadUp, }, } inputHandler := isys.NewHandler(0, keymap) 111
112. func (h *Handler) ActionIsJustPressed(action Action) bool { keys, ok := h.keymap[action] if !ok { return false } for _, k := range keys { if h.keyIsJustPressed(k) { return true } } return false } 112
113. func (h *Handler) keyIsJustPressed(key Key) bool { switch key.kind { case keyGamepad: return h.gamepadKeyIsPressed(key) case keyMouse: return h.mouseKeyIsJustPressed(key) default: return h.keyboardKeyIsJustPressed(key) } } 113
114. func (h *Handler) gamepadKeyIsJustPressed(key Key) bool { return inpututil.IsStandardGamepadButtonJustPressed( ebiten.GamepadID(h.id), ebiten.StandardGamepadButton(key.code), ) } 114
115. ebitengine-input library github.com/quasilyte/ebitengine-input Implements everything mentioned above + more. Inspired by Godot too. 115
116. Resources & loaders 116
117. Resource loader requirements • Convenient to use to get resources 117
118. Resource loader requirements • Convenient to use to get resources • Efficient resource lookup and caching 118
119. Resource loader requirements • Convenient to use to get resources • Efficient resource lookup and caching • API that can prevent some mistyped keys, etc. 119
120. Resource loader requirements • Convenient to use to get resources • Efficient resource lookup and caching • API that can prevent some mistyped keys, etc. • Can preload resources (+ optionally unload them) 120
121. Typed, integer resource keys type AudioID int type ImageID int type FontID int 121
122. App enumerates all its resources as enums const ( ImageNone resource.ImageID = iota ImageTank ImageTurret ) 122
123. ...and then associates metadata with them imageResources := map[resource.ImageID]resource.ImageInfo{ ImageTank: {Path: "sprites/tank.png"}, ImageTurret: {Path: "sprites/turret.png"}, } 123
124. Getting a resource is easy tankImage := loader.GetImage(ImageTank) turretImage := loader.GetImage(ImageTurret) 124
125. Resource lookup 1. Find associated metadata a. Return from cache, if possible 2. Using path info, use asset finder to get raw data 3. Decode data into requested resource 4. Cache the result 5. Return the result 125
126. Asset finder can work with embed data loader.OpenAsset = func(p string) io.ReadCloser { f, err := gameAssets.Open("_assets/" + p) if err != nil { // handle error } return f } 126
127. Use embed.FS when embedding assets //go:embed all:_assets var gameAssets embed.FS 127
128. Resource preload Just call Get() method on the resource needed and ignore the results. The next time it’ll be returned from cache. 128
129. Explicit state passing 129
130. Why bother and avoid global state? • Easier to test your code 130
131. Why bother and avoid global state? • Easier to test your code • Can substitute dependencies easier 131
132. Why bother and avoid global state? • Easier to test your code • Can substitute dependencies easier • Scene transitions become trivial 132
133. if inpututil.IsKeyJustPressed(ebiten.KeyW) { obj.moveForward() } if obj.input.IsActionJustPressed(MoveForward) { obj.moveForward() } Remember this? How obj gets its input handler? 133
134. main() runGame(state) newMenuController(state) newBattleController(state) newPlayerTank(tank, state) Creates the gameState Accepts gameState as argument All scene controllers hold the gameState On scene change, gameState is passed The scene controller passes it to objects 134
135. type gameState struct { player1input *input.Handler player2input *input.Handler // + other common game state } 135
136. // This is just a simplified example. func main() { p1keymap, p2keymap := readKeymaps() state := newGameState() state.player1input = input.NewHandler(0, p1keymap) state.player2input = input.NewHandler(1, p2keymap) runGame(state) } 136
137. Maps, tiles 137
139. Tiled use cases Tiled can be your graphical level editor! • Object layers to deploy game entities • Tile layers to draw the level landscape • Can also be used to prototype the UI layouts • Tilesets for auto-tiling 139
141. Tiled + modders Non-programmers can use tiled to create levels for your game. A special triggers tileset can be used to apply visual programming, leveraging the Tiled limitations. 141
142. Closing words 142
143. Things I still try to figure out • Layers and rendering order abstractions • Viewports and cameras with Ebitengine • Smooth rendering of geometrical shapes • Etc, etc. 143
144. How to discover cool Ebitengine packages? awesome-ebitengine by sedyh 144
145. Additional resources • sfxr (or jsfxr) - generate game sound effects • ccmixter - find CC licensed music for your games I want to try using neural network generated images and music in one of my next games. :) 145
146. Go gamedev patterns @quasilyte for Golang United, 2022 146