├── .gitignore
├── LICENSE.md
├── README.md
├── cmd
├── asset-server
│ └── asset-server.go
└── dev-server
│ ├── dev-server.go
│ └── internal
│ └── devwebserver
│ ├── devwebserver.go
│ ├── index.html
│ └── wasm_exec.js
├── dist
├── index.html
└── wasm_exec.js
├── go.mod
├── go.sum
├── internal
├── app
│ └── app.go
├── asset
│ ├── asset.go
│ ├── background.png
│ ├── player_idle_left.png
│ └── player_idle_right.png
├── ent
│ └── player.go
├── input
│ ├── input.go
│ ├── input_headless.go
│ └── input_noheadless.go
├── monotime
│ ├── monotime.go
│ ├── monotime_js.go
│ ├── monotime_nojs.go
│ └── monotime_windows.go
├── netcode
│ ├── client
│ │ └── client.go
│ ├── client_or_server
│ │ ├── client_or_server_client.go
│ │ └── client_or_server_server.go
│ ├── netcode.go
│ ├── netconf
│ │ └── netconf.go
│ ├── netconst
│ │ └── netconst.go
│ ├── packbuf
│ │ ├── packbuf_test.go
│ │ ├── packbufread.go
│ │ └── packbufwrite.go
│ ├── packs
│ │ ├── packs.go
│ │ └── packs_test.go
│ ├── rtt
│ │ ├── rtt.go
│ │ └── rtt_test.go
│ └── server
│ │ └── server.go
├── netdriver
│ └── webrtcdriver
│ │ ├── webrtcclient
│ │ └── webrtcclient.go
│ │ ├── webrtcserver
│ │ ├── stunserver
│ │ │ └── stunserver.go
│ │ └── webrtcserver.go
│ │ └── webrtcshared
│ │ └── webrtcshared.go
├── renderer
│ ├── internal
│ │ ├── ebiten
│ │ │ └── ebiten.go
│ │ ├── headless
│ │ │ └── headless.go
│ │ └── rendereriface
│ │ │ └── rendereriface.go
│ ├── renderer.go
│ ├── renderer_ebiten.go
│ └── renderer_headless.go
└── world
│ └── world.go
├── main.go
└── screens
└── web-browser-and-server.png
/.gitignore:
--------------------------------------------------------------------------------
1 | *.zip
2 | /toy-webrtc-mmo.exe
3 | /toy-webrtc-mmo.exe~
4 | /toy-webrtc-mmo
5 | /server
6 | /server.exe
7 | /server.exe~
8 | /dev-server
9 | /dev-server.exe
10 | /cmd/serve/serve
11 | /cmd/serve/serve.exe
12 | /asset-server
13 | /asset-server.exe
14 | /dist/main.wasm
15 | /TODO.md
16 | /.vscode
17 |
--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright © 2021 Jae Bentvelzen
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 |
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 |
7 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Ebiten WebRTC Toy MMO
2 |
3 | ⚠️ *This is a piece of incomplete hobby work and not robust. Please read the "Why does this project exist?" section.*
4 |
5 | ## What is this project?
6 |
7 | This is an authoritative server model demonstrating a very simple platformer game where players can move left, right and jump around. When running from the client from the browser, which in my testing, works fine on Chrome, Firefox and on Safari with my iPhone 6S.
8 |
9 | 
10 |
11 | **Controls:**
12 |
13 | - Move Left = Left Arrow Key or Mouse/Touch Left Side of Screen
14 | - Move Right = Right Arrow Key or Mouse/Touch Right Side of Screen
15 | - Jump = Spacebar or Mouse/Touch Middle of Screen
16 |
17 | ## Why does this project exist?
18 |
19 | This is a project that exists because I wanted practice applying concepts blogged about on [Gaffer On Games](https://gafferongames.com/), get better at networking code and leverage WebRTC to get UDP in the browser, as [UDP is recommended over TCP for real-time games](https://gafferongames.com/post/why_cant_i_send_udp_packets_from_a_browser/).
20 |
21 | I consider myself to be game development hobbyist who isn't that experienced, so this project is likely to have code smells, mistakes or whatever else. However, I still thought it'd be valuable to put online, even in it's current incomplete state, because I've personally found that half-baked game developer examples get me closer to solving problems I wanted to solve, even if they lack correctness.
22 |
23 | ## Known problems and design choices
24 |
25 | Here's a list of design choices made as well as known problems. There's more I'm probably not thinking of but hopefully they're somewhat commented in the code.
26 |
27 | - We don't timeout the connection of the client reliably. It can hang trying to connect if UDP ports are blocked on either the server or client-side as it'll never end up opening a Data Channel.
28 | - We don't support `ICERestart`, ie. if someones connection shifts from WiFi to 4G, the connection will probably be lost.
29 | - We haven't thought about making the jitter buffer nice for getting client state from the server, so I'm not sure how smooth other players movement will be in poorer network conditions.
30 | - The server doesn't reflect clients leaving on other clients.
31 | - If the server is closed, the clients aren't notified or booted out.
32 | - We chose to create packet data using Go structs and reflection instead of protobuf as protobuf comes with the overhead of requiring additional tools for code generation and adds a non-trivial amount of byte overhead. A [Gaffer On Games article](https://gafferongames.com/post/reading_and_writing_packets/) goes into detail on why hand-rolling packet types once you know your data is the better option. We didn't end up doing any sort of compression on packet data in this project.
33 |
34 | ## How to run locally and develop
35 |
36 | The following commands need to be run from the root directory of the project.
37 |
38 | ### Server
39 |
40 | ```sh
41 | go build -tags "server" -o server && ./server
42 | ```
43 |
44 | We also have a headless server option which allows us to run on machines without graphic rendering capabilities.
45 |
46 | ```sh
47 | go build -tags "server headless" -o server && ./server
48 | ```
49 |
50 | ### Client
51 |
52 | #### Native
53 |
54 | ```sh
55 | go build && ./toy-webrtc-mmo
56 | ```
57 |
58 | #### Web
59 |
60 | Start a web server that will serve the game client on http://localhost:8080/. This will rebuild the client everytime you refresh the page.
61 |
62 | ```sh
63 | go build -o dev-server ./cmd/dev-server && ./dev-server
64 | ```
65 |
66 | ## How to deploy and server configuration
67 |
68 | ### Client
69 |
70 | 1.) Build WASM binary
71 |
72 | ```sh
73 | GOOS=js GOARCH=wasm go build -o dist/main.wasm
74 | ```
75 |
76 | 2.) Zip up contents and put on a host somewhere. I put it on my Amazon EC2 instance and then served it with the "Asset Server" below.
77 |
78 | ### Server
79 |
80 | This command builds a headless server which has two advantages:
81 |
82 | - No overhead from rendering or draw calls
83 | - Cross-compilation with environment variables just works
84 |
85 | ```
86 | go build -tags "server headless" -o server
87 | ```
88 |
89 | ### Asset Server (optional)**
90 |
91 | This is the server that serves the asset files for the web client:
92 |
93 | - index.html
94 | - main.wasm
95 | - wasm_exec.js
96 |
97 | 1) Build asset-server from the "cmd/asset-server" folder
98 |
99 | ```
100 | go build -o asset-server ./cmd/asset-server
101 | ```
102 |
103 | 2) Copy both "asset-server" and the "dist" folder to your server
104 |
105 | 3) Run the "asset-server" on your server. For me, my server was an Amazon EC2 instance.
106 |
107 | ```
108 | ./asset-server
109 | ```
110 |
111 | ### Server configuration
112 |
113 | | Type | Port | Description |
114 | | ----------- | ----------- | ----------- |
115 | | TCP | 50000 | Allow HTTP POST access to get WebRTC SDP / ConnectAuth |
116 | | TCP | 8080 | (Optional if you serve web files elsewhere) If using Asset Server, allow HTTP access for the web game client (serving assets, WASM file) |
117 | | UDP | 3478 | Allow STUN server |
118 | | UDP | 10000 - 11999 | UDP ports used by WebRTC DataChannels (We called `SetEphemeralUDPPortRange` in our code to make the UDP port range predictable / lockdownable) |
119 |
120 |
121 | ## Credits
122 |
123 | * [Pions WebRTC Authors and Contributors](https://github.com/pion/webrtc) for all their hard work on the Golang WebRTC libraries and allowing me to get this working in pure Go.
124 | * [Glenn Fiedler](https://gafferongames.com/) for all their detailed blog posts on doing netcode, including *why you dont do* certain things.
125 | * [Chen Tao](https://github.com/jagt) for their tool [clumsy](https://jagt.github.io/clumsy/), which has been invaluable for simulating and debugging weird network conditions on Windows.
126 |
--------------------------------------------------------------------------------
/cmd/asset-server/asset-server.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | )
7 |
8 | // main will start serving all files in the "dist" folder on the server
9 | // on port 8080
10 | func main() {
11 | fs := http.FileServer(http.Dir("./dist"))
12 | http.Handle("/", fs)
13 |
14 | log.Println("Listening on :8080...")
15 | err := http.ListenAndServe(":8080", nil)
16 | if err != nil {
17 | log.Fatal(err)
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/cmd/dev-server/dev-server.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "github.com/silbinarywolf/toy-webrtc-mmo/cmd/dev-server/internal/devwebserver"
4 |
5 | func main() {
6 | devwebserver.Serve()
7 | }
8 |
--------------------------------------------------------------------------------
/cmd/dev-server/internal/devwebserver/devwebserver.go:
--------------------------------------------------------------------------------
1 | package devwebserver
2 |
3 | import (
4 | "errors"
5 | "flag"
6 | "fmt"
7 | "io/ioutil"
8 | "log"
9 | "net/http"
10 | "os"
11 | "os/exec"
12 | "path/filepath"
13 | "runtime"
14 | "strings"
15 | "time"
16 |
17 | "golang.org/x/tools/go/packages"
18 | )
19 |
20 | const (
21 | packagePath = "github.com/silbinarywolf/toy-webrtc-mmo/cmd/dev-server/internal/devwebserver"
22 | )
23 |
24 | var flagSet = flag.NewFlagSet("serve", flag.ExitOnError)
25 |
26 | // Serve will serve a build of the application to the web browser.
27 | // This function will block until exit.
28 | func Serve() {
29 | tags := flagSet.String("tags", "", "a list of build tags to consider satisfied during the build")
30 | //verbose := flagSet.Bool("verbose", false, "verbose")
31 |
32 | // Setup
33 | args := Arguments{}
34 | args.Port = ":8080"
35 | args.Directory = "."
36 | if tags != nil {
37 | args.Tags = *tags
38 | }
39 | arguments = args
40 |
41 | // Validation of settings
42 | dir := args.Directory
43 | if dir != "." {
44 | panic("Specifying a custom directory is not currently supported.")
45 | }
46 |
47 | // Get default resources
48 | var err error
49 | wasmJSPath, err = getDefaultWasmJSPath(args.Directory)
50 | if err != nil {
51 | panic(err)
52 | }
53 | //fmt.Printf("wasm_exec.js: %s\n", wasmJSPath)
54 | indexHTMLPath, err = getDefaultIndexHTMLPath(args.Directory)
55 | if err != nil {
56 | panic(err)
57 | }
58 | //fmt.Printf("index.html: %s\n", indexHTMLPath)
59 |
60 | // Start server
61 | fmt.Printf("Listening on http://localhost%s...\n", args.Port)
62 | http.HandleFunc("/", handle)
63 | //shared.OpenBrowser("http://localhost" + args.Port)
64 | if err := http.ListenAndServe(args.Port, nil); err != nil {
65 | panic(err)
66 | }
67 | }
68 |
69 | var wasmJSPath string
70 |
71 | var indexHTMLPath string
72 |
73 | var (
74 | arguments Arguments
75 | tmpOutputDir = ""
76 | )
77 |
78 | type Arguments struct {
79 | Port string // :8080
80 | Directory string // .
81 | Tags string // ie. "debug"
82 | }
83 |
84 | func handle(w http.ResponseWriter, r *http.Request) {
85 | output, err := ensureTmpOutputDir()
86 | if err != nil {
87 | http.Error(w, err.Error(), http.StatusInternalServerError)
88 | return
89 | }
90 | dir := arguments.Directory
91 | tags := arguments.Tags
92 |
93 | // Get path and package
94 | upath := r.URL.Path[1:]
95 | pkg := filepath.Dir(upath)
96 | fpath := filepath.Join(".", filepath.Base(upath))
97 | if strings.HasSuffix(r.URL.Path, "/") {
98 | fpath = filepath.Join(fpath, "index.html")
99 | }
100 |
101 | parts := strings.Split(upath, "/")
102 | isAsset := len(parts) > 0 && parts[0] == "asset"
103 |
104 | if isAsset {
105 | // Load asset
106 | log.Print("serving asset: " + upath)
107 |
108 | // todo(Jake): 2018-12-30
109 | // Improve this so when "data" folder support
110 | // is added, this allows any filetype from the "data" folder.
111 | switch ext := filepath.Ext(upath); ext {
112 | case ".ttf",
113 | ".data",
114 | ".json":
115 | http.ServeFile(w, r, upath)
116 | }
117 | return
118 | }
119 |
120 | switch filepath.Base(fpath) {
121 | case "index.html":
122 | log.Print("serving index.html: " + indexHTMLPath)
123 | http.ServeFile(w, r, indexHTMLPath)
124 | case "wasm_exec.js":
125 | log.Print("serving index.html: " + wasmJSPath)
126 | http.ServeFile(w, r, wasmJSPath)
127 | return
128 | case "main.wasm":
129 | if _, err := os.Stat(fpath); os.IsNotExist(err) {
130 | // go build
131 | args := []string{"build", "-o", filepath.Join(output, "main.wasm")}
132 | if tags != "" {
133 | args = append(args, "-tags", tags)
134 | }
135 | args = append(args, pkg)
136 | log.Print("go ", strings.Join(args, " "))
137 | cmdBuild := exec.Command(gobin(), args...)
138 | cmdBuild.Env = append(os.Environ(), "GOOS=js", "GOARCH=wasm")
139 | cmdBuild.Dir = dir
140 | out, err := cmdBuild.CombinedOutput()
141 | if err != nil {
142 | log.Print(err)
143 | log.Print(string(out))
144 | http.Error(w, string(out), http.StatusInternalServerError)
145 | return
146 | }
147 | if len(out) > 0 {
148 | log.Print(string(out))
149 | }
150 |
151 | f, err := os.Open(filepath.Join(output, "main.wasm"))
152 | if err != nil {
153 | http.Error(w, err.Error(), http.StatusInternalServerError)
154 | return
155 | }
156 | defer f.Close()
157 | http.ServeContent(w, r, "main.wasm", time.Now(), f)
158 | return
159 | }
160 | }
161 | }
162 |
163 | func gobin() string {
164 | return filepath.Join(runtime.GOROOT(), "bin", "go")
165 | }
166 |
167 | func ensureTmpOutputDir() (string, error) {
168 | if tmpOutputDir != "" {
169 | return tmpOutputDir, nil
170 | }
171 |
172 | tmp, err := ioutil.TempDir("", "")
173 | if err != nil {
174 | return "", err
175 | }
176 | tmpOutputDir = tmp
177 | return tmpOutputDir, nil
178 | }
179 |
180 | var (
181 | cmdDir string
182 | cmdErr error
183 | )
184 |
185 | func computeCmdSourceDir(gameDir string) (string, error) {
186 | if cmdDir == "" && cmdErr == nil {
187 | cmdDir, cmdErr = computeCmdSourceDirUncached(gameDir)
188 | }
189 | return cmdDir, cmdErr
190 | }
191 |
192 | func computeCmdSourceDirUncached(gameDir string) (string, error) {
193 | currentDir, err := filepath.Abs(gameDir)
194 | if err != nil {
195 | return "", err
196 | }
197 | cfg := &packages.Config{
198 | Dir: currentDir,
199 | }
200 | pkgs, err := packages.Load(cfg, packagePath)
201 | if err != nil {
202 | return "", err
203 | }
204 | if len(pkgs) == 0 {
205 | return "", errors.New("Unable to find package: " + packagePath)
206 | }
207 | pkg := pkgs[0]
208 | if len(pkg.GoFiles) == 0 {
209 | return "", errors.New("Cannot find *.go files in:" + currentDir)
210 | }
211 | dir := filepath.Dir(pkg.GoFiles[0])
212 | return dir, nil
213 | }
214 |
215 | func getDefaultWasmJSPath(gameDir string) (string, error) {
216 | const baseName = "wasm_exec.js"
217 | // Look for user-override
218 | /* {
219 | dir := gameDir + "/html/" + baseName
220 | if _, err := os.Stat(dir); !os.IsNotExist(err) {
221 | return dir, nil
222 | }
223 | } */
224 | // Look for engine default
225 | dir, err := computeCmdSourceDir(gameDir)
226 | if err != nil {
227 | return "", err
228 | }
229 | dir = dir + "/" + baseName
230 | return dir, nil
231 | }
232 |
233 | func getDefaultIndexHTMLPath(gameDir string) (string, error) {
234 | const baseName = "index.html"
235 | // Look for user-override
236 | /* {
237 | dir := gameDir + "/html/" + baseName
238 | if _, err := os.Stat(dir); !os.IsNotExist(err) {
239 | return dir, nil
240 | }
241 | } */
242 | // Look for engine default
243 | dir, err := computeCmdSourceDir(gameDir)
244 | if err != nil {
245 | return "", err
246 | }
247 | dir = dir + "/" + baseName
248 | return dir, nil
249 | }
250 |
--------------------------------------------------------------------------------
/cmd/dev-server/internal/devwebserver/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
33 |
34 |
35 |
36 |
Loading...
37 |
40 |
36 |
Loading...
37 |
40 |