Ebitengine Ecosystem Overview

Transcript

1. Ebitengine Ecosystem Overview quasilyte @ podlodka 2023
2. About me • Compiler engineer during the day • Game developer during the night • I also stream indie games from itch io • Playing video games since ~2000 I used Game Maker, Godot and Ebitengine a lot. I also tried making games with Defold, Phaser and SDL.
3. Before we start Please ⭐ Ebitengine (Eh-Bee-Ten-Gin) repository: github.com/hajimehoshi/ebiten It deserves some extra love.
4. Agenda • Check out some of the games made with Ebitengine • List Ebitengine features (as of today) • Discover 3rd-party Ebitengine libraries • Make some conclusions For inspiration
5. Agenda • Check out some of the games made with Ebitengine • List Ebitengine features (as of today) • Discover 3rd-party Ebitengine libraries • Make some conclusions Because this is the foundation of every game
6. Agenda • Check out some of the games made with Ebitengine • List Ebitengine features (as of today) • Discover 3rd-party Ebitengine libraries • Make some conclusions You’ll probably need some of those
7. Agenda • Check out some of the games made with Ebitengine • List Ebitengine features (as of today) • Discover 3rd-party Ebitengine libraries • Make some conclusions At least we’ll try to!
8. My Ebitengine Games
22. My published games • Autotanks • Retrowave City • Decipherism
23. Live coding a small game using Ebiten (Russian) • Part1 • Part2 • Sources Subscribe @quasilyte on YouTube
24. Commercial Ebitengine Games
31. Ebitengine & Nintendo Switch Bear's Restaurant and Fishing Pradiso are also available on Nintendo Switch!
32. More Ebitengine projects See made-with-ebitengine collection on itch.io. Also, Hajime usually re-twits Ebitengine projects, so check out his Twitter to find more interesting stuff. Awesome-ebitengine repository lists some Ebitengine games (with links to their repositories).
33. Ebitengine community links Most discussions happen at Discord channel (international, English). There is also /r/ebitengine. I started a small Russian-speaking community in Telegram.
34. Ebitengine Core Overview
35. Ebitengine is not “something experimental” • Repository created at 2013 • June of 2016: v1.0.0 is released • It flourishes up to this day (and beyond) Ebitengine is mature enough nowadays. 10 years!
36. Ebitengine • Game development framework written in Go • Minimal game architecture restrictions • Supports a fair range of platforms • Mostly for 2D games It feels like SDL for Go.
37. Ebitengine • Game development framework written in Go • Minimal game architecture restrictions • Supports a fair range of platforms • Mostly for 2D games It feels like SDL for Go.
38. Ebitengine • Game development framework written in Go • Minimal game architecture restrictions • Supports a fair range of platforms • Mostly for 2D games It feels like SDL for Go.
39. Ebitengine • Game development framework written in Go • Minimal game architecture restrictions • Supports a fair range of platforms • Mostly for 2D games It feels like SDL for Go.
40. Ebitengine We’ll start from here
41. Ebitengine Input Res. manager Math utils Slots/signals Tiles Those are covered in my other presentation. I’ll mention them here too nonetheless, but in much less details
42. Ebitengine Input Res. manager Math utils Collisions Slots/signals GUI Layers Camera Tiles Scripting + more We’ll mostly focus on these today
43. Ebitengine game interface • Separate update/draw loops • Fixed TPS idiom (no “time delta”) • You do ebiten.Run() explicitly Ebitengine gives you a freedom of choice here. You can choose whatever architecture you like.
44. Ebitengine game interface • Separate update/draw loops • Fixed TPS idiom (no “time delta”) • You do ebiten.Run() explicitly Ebitengine gives you a freedom of choice here. You can choose whatever architecture you like.
45. Ebitengine game interface • Separate update/draw loops • Fixed TPS idiom (no “time delta”) • You do ebiten.Run() explicitly Ebitengine gives you a freedom of choice here. You can choose whatever architecture you like.
46. Ebitengine rendering
47. Ebitengine features: graphics • Simple image rendering API • Image transformations API • Text rendering, good fonts support • Shaders support • Limited path drawing support (via vector package)
48. Ebitengine features: input handling • Rich devices support (gamepads, keyboards, etc.) • inpututil package that provides some helpers • Intuitive API
49. Ebitengine features: audio support • Can work with ogg, mp3, wav, pcm • Can re-encode with different sample rate
50. Graphical User Interface
51. ebitenui github.com/ebitenui/ebitenui is a good library if your game requires more than just a couple of buttons.
54. ebitenui API • Uses a custom events system • Uses functional options pattern a lot • Accepts *ebiten.Image as an input • Uses ints for measurements, coordinates It may be incompatible with the rest of your game. API wrapping can help here.
55. ebitenui API • Uses a custom events system • Uses functional options pattern a lot • Accepts *ebiten.Image as an input • Uses ints for measurements, coordinates It’s not a real problem but I personally don’t like it.
56. ebitenui API • Uses a custom events system • Uses functional options pattern a lot • Accepts *ebiten.Image as an input • Uses ints for measurements, coordinates This is very good. You can handle the image objects caching and loading on your side.
57. ebitenui API • Uses a custom events system • Uses functional options pattern a lot • Accepts *ebiten.Image as an input • Uses ints for measurements, coordinates This may result in many float64->int conversions around the UI-related code. Wrappers could help here too.
58. Using ebitenui All in all, it looks like a promising library (use it!) I highly recommend to wrap it, so you can benefit from the implementation while keeping the API surface more consistent with the rest of your game code. Smash that ⭐ button! -> github.com/ebitenui/ebitenui
59. Animation / Tween
60. Animation Spritesheet
61. Library options • yohamta/ganim8 (anim8-inspired library) • tanema/gween (tween) ◦ SolarLune/gween (it’s a fork) Both of them are good enough. Tweens are useful for more than just animating things.
62. tanema/gween • Uses float32 in its API • Not Ebitengine-centric • It’s quite lightweight It doesn’t “play” the animation for you, but you can use it to interpolate the frames.
63. ECS (Entity Component System)
64. Disclaimer I haven’t tried any of those. Artem Sedykh kindly provided their feedback on the subject. Artem works on a new ECS framework (mizu), so this experience report is worthwhile.
65. Library options • sedyh/mizu (54 ⭐) • yohamta/donburi (95 ⭐) • andygeiss/ecs (68 ⭐) • leopotam/goecs (14 ⭐) • 33blue/wecqs (archived, but could be a good read) + more!
66. sedyh/mizu • WIP, but could be promising • Less performance, but more convenience • Querying support: pointer swap & generics Documentation: good.
67. yohamta/donburi • Has archetypes support • The most performant choice right now • Requires some boilerplate from the user • Public API uses generics Documentation: good.
68. andygeiss/ecs • Quite fast • Requires lots of boilerplate from the user • Requires type assertions / casting Documentation: good.
69. Benchmarks Max objects at stable 60 fps: ebitengine @5ee32bba: 40000 objects donburi@d5a1431b: 33000 objects gohan @d6e94392: 28000 objects mizu @9387a0dd: 22000 objects wecqs @2a143f5e: 18000 objects
70. The state of ECS in Go Since generics are relatively new concept, the authors of ECS are trying to see what are the limits and how can we create both convenient and efficient ECS system. Perhaps Artem Sedykh will make a detailed talk about it one day. Let’s look forward to it.
71. Working with Text
72. Multi-language games • It’s good when game can infer the default language • In-game texts should not be hardcoded It could be OK-ish to use English as a default, but not everyone know that language. You may need some very easy to understand language switch buttons to make the game more accessible for the players.
73. Matching the languages To infer a good default language, you need to match the system language with dictionaries available first. golang.org/x/text/language can be useful to match and compare the languages. See also: golang.org/x/text/collate
76. How complex your game texts are? Simple texts, small set of languages Maybe you don’t even need a library Complicated texts with interpolation, many languages You’re probably screwed anyway (???)
77. Tiles and Map Editor
78. Tiled! • Tiled is a graphical map editor • There is go-tiled package Tiled also has simple JSON export format, so you can use it without any special libraries.
81. Collisions Detection
82. Library options • SolarLune/resolv (314 ⭐) • jakecoffman/cp (201 ⭐) • zergon321/cirno (20 ⭐) • ByteArena/box2d (254 ⭐) There are probably more libraries out there, but they escaped me successfully.
83. How to choose? SolarLune/resolv is quite popular, has idiomatic API and it’s easy to get started. zergon321/cirno is another good choice, it has oriented bounding box support. cp is more low-level and feature-rich.
84. Scripting
85. Why scripting? Sometimes it simplifies the content creating for your team and your users. User-created maps in WarCraft III wouldn’t be as great if there were no scripting support! Scripting makes it possible to extend the game without having to re-build it (good for the players).
86. Yaegi Good Go language support. Easy to integrate. A little bit slow right now, but it may improve in that regard. github.com/traefik/yaegi
87. Scriggo Less widely known, but it’s quite fast. Harder to integrate. May be less maintained nowadays. github.com/open2b/scriggo/
88. Quasigo My own creation. Used in ruleguard. Supports only limited subset of Go. I intend to keep it the fastest Go interpreter written in Go. github.com/quasilyte/quasigo
89. Lua (or other languages) You can use one of the few lua interpreters implementation for Go. There are plenty of them. I’m pretty sure there are dozens of various Lisps implementations too.
90. Path Finding
91. Library options • beefsack/go-astar • SolarLune/paths • fzipp/astar
92. SolarLune/paths • Grid cell size is easily configurable • Very slow (1000+ allocs on one call, ~200k ns time) • Supports diagonal moves • Outdated readme, weird go.mod (import path case) I can’t recommend it. :(
93. beefsack/go-astar • Slow as well • Inconvenient to use • Seems unmaintained I can’t recommend it. :(
94. fzipp/astar Not very impressive either. :(
95. What to do? • If your maps are small: do/use whatever • If your maps are big, implement your own algorithm
96. An advice You’re about to create a new path finding lib? • Try avoiding redundant allocs (slices, etc) • Do not use “container/heap” • Whether possible, use generics instead of interface{} The devil is in the details.
97. An advice You’re about to create a new path finding lib? • Try avoiding redundant allocs (slices, etc) • Do not use “container/heap” • Whether possible, use generics instead of interface{} The devil is in the details.
98. An advice You’re about to create a new path finding lib? • Try avoiding redundant allocs (slices, etc) • Do not use “container/heap” • Whether possible, use generics instead of interface{} The devil is in the details.
99. Vector (2D) Math
100. Library options • quartercastle/vector (used in resolv) • quasilyte/gmath (used in my games) There are probably tons of those. Pick the one you like or write your own.
101. quartercastle/vector • Used in resolve (yeah, I already said that) • Uses float64 slices for vectors I haven’t tried it since [ ]float64 for Vec2D is a red flag for me. This type is too ubiquitous in 2D games.
102. quasilyte/gmath • Godot-inspired API • gmath.Vec is a simple X,Y struct (no slices involved) • Compatible with ebitengine-input package • Includes utility things like convenient Rand sources gmath works for me, maybe it’s good enough for you too.
103. quasilyte/gmath • Godot-inspired API • gmath.Vec is a simple X,Y struct (no slices involved) • Compatible with ebitengine-input package • Includes utility things like convenient Rand sources gmath works for me, maybe it’s good enough for you too.
104. quasilyte/gmath • Godot-inspired API • gmath.Vec is a simple X,Y struct (no slices involved) • Compatible with ebitengine-input package • Includes utility things like convenient Rand sources gmath works for me, maybe it’s good enough for you too.
105. quasilyte/gmath • Godot-inspired API • gmath.Vec is a simple X,Y struct (no slices involved) • Compatible with ebitengine-input package • Includes utility things like convenient Rand sources gmath works for me, maybe it’s good enough for you too.
106. User Input Mapping
107. Why extra library for the input handling? • Input-device agnostic event checking • N-to-M action-key mapping support • Convenient re-configuration during the run-time • Virtual (simulated) input events • Easier modifiers bindings (ctrl+c, etc) go get github.com/quasilyte/ebitengine-input
108. Key W Arrow Up ActionForward D-Pad Up N keys to 1 action mapping
109. Signals/Slots
110. Why bother and use signals/slots? • It reduces the objects coupling • It's an elegant event listener solution for Go • Signals are a familiar concept (Godot, Phaser, Qt, ...)
111. quasilyte/gsignal • Godot/Qt inspired signals library • Amortized to zero allocs in most cases • Efficient Connect/Disconnect/Emit • Type safe API with generics go get github.com/quasilyte/gsignal
112. Combining with ebitenui events ebitenui component wrapper Game object ebitenui event gsignal event
113. Resource Manager / Loader
114. quasilyte/ebitengine-resource • Resource caching • Int-based resource keys => efficient and convenient • Allows metadata binding go get github.com/quasilyte/ebitengine-resource
115. Conclusions
116. My gamedev starter kit go get github.com/hajimehoshi/ebiten go get github.com/ebitenui/ebitenui go get github.com/SolarLune/resolv go get github.com/quasilyte/gmath go get github.com/quasilyte/gsignal go get github.com/quasilyte/ebitengine-input go get github.com/quasilyte/ebitengine-resource
117. What else you might need? • Some scene tree framework • Viewports/camera if your game needs it • Layers, things like YSort, etc. • ADs/Telemetry things for real products maybe
118. Ebitengine: pros • Allows you to write games in Go! • Supports many platforms • Relatively simple installation (few external deps) • Easy to get started (but maybe hard to master?) • Feature reach core (shaders, audio, etc.) • Good docs, many examples • An active community
119. Ebitengine: cons • Mobile platform targets could be challenging • Low performance in wasm build • Hard to write a library without Ebitengine dependency • Very limited touch (low-level) input support
120. Do I recommend you to try out Ebitengine? • Yes Just give it a try and see if it clicks with you. Pros: Ebitengine Cons: None (wink)
121. How to keep the code sane? Using multiple 3rd party libraries will make your code look less consistent due to different API styles. I suggest to wrap 3rd party libraries and use them via your own APIs. This will also help you to change the 3rd party dependency later if you’ll ever want to do that. This is better than writing everything from scratch.
122. Want to get involved? Want to help Ebitengine? • Consider becoming an Ebitengine sponsor • Contribute to Ebitengine (or submit bug reports) • Credit/mention #ebitengine in your game or content • Contribute to cool libraries or create your own • Be an active community member (Discord channel)
123. Created a game? Want to share it with community? • Tweet using #ebitengine tag • Post in show-and-tell channel in Discord • Create a reddit post in /r/ebitengine • For itch.io, add game to made-with-ebitengine • Open source? => submit to awesome-ebitengine • Let me know and I’ll stream it
124. If you love Godot, why do you use Ebitengine? I like Go more than gdscript or C#. It’s not only about the language: • I like Go communities • I like the 3rd party tooling (and the “go tool” itself) • I am feeling at home here
126. Ebitengine Ecosystem Overview quasilyte @ podlodka 2023