

Show HN: Multiplayer NES Server in 77 Lines of Go - ola
https://github.com/olahol/melody-jsnes

======
sschueller
mmm, not sure if doing this counts as using 77 lines of code:

    
    
      import (
    	"github.com/gin-gonic/gin"
    	"github.com/gorilla/websocket"
    	"github.com/olahol/melody"
    	"net/http"
    	"sync"
      )
    

But still impressive.

~~~
mrweasel
Also the NES emulation is done in Javascript, making the 77 lines a little
less impressive. It's "just" server for handling multiplayer part.

~~~
vog
Indeed, the title is a bit misleading.

~~~
reedlaw
I didn't expect anything but a multiplayer proxy. If it was truly an emulator
in 77 lines it must be horribly obfuscated.

------
andrewliebchen
It might be simple, but it's certainly not simplistic :)

------
eynix_
I don't get the difference between github.com/gorilla/websocket &
github.com/olahol/melody. Does someone have a clue ?

~~~
ola
It's a higher level framework built on top of github.com/gorilla/websocket .
Some features include

* Clear and easy interface similar to net/http or Gin with event handlers.

* A simple way to broadcast to all or selected connected sessions.

* Message buffers making concurrent writing safe.

* Automatic handling of ping/pong and session timeouts.

------
tokenrove
It would be nice to see state-synchronization using rewinding like GGPO,
instead of just sending the inputs which introduces a lot of latency.

~~~
ola
I think that would be a beyond the scope of this project which is to demo Go
websockets, I wanted to keep it as simple as possible and not hack the JSNES
source code.

Although it would be a cool thing to make a production ready web hosted
multiplayer NES.

------
geff82
So how many stories "X in Go" or "Y in Rust" a day will we have in future? Its
a bit much currently...

------
SpaceManNabs
Is there any documentation around? I have no idea how any of this code works,
and it doesn't seem to similar to the web apps that I have seen before.
Haven't worked with melody before either...

~~~
ola
The server works by using HTML5 Websockets ([https://developer.mozilla.org/en-
US/docs/WebSockets](https://developer.mozilla.org/en-US/docs/WebSockets))
which allows browsers to do full duplex communication with the servers (they
can push and receive messages without having to poll).

The implementation of the multiplayer itself is very simple and consists of
these steps:

* Pair up players using a map from one session to another.

* Start an instance of [https://github.com/bfirsh/jsnes](https://github.com/bfirsh/jsnes) on Player 1

* Screenshot the canvas of JSNES using toDataUrl.

* Send the screenshot to Player 2 and render it into a canvas.

* Send Player 2's keyup and keydown event's to Player 1.

The communication over the WebSocket is very fast, the screenshot is being
sent at 30 frames per second.

Melody is just a small framework to make WebSockets easier to work with.

~~~
edc117
That's really neat - forgive my ignorance on the subject, but how possible is
something like this for local multiplayer games in general (outside of NES)?
With all the streaming options we've seen recently, I'm surprised something
like this hasn't been developed.

------
mappu
What's the best solution in Go to support graceful degradation for browsers
without websockets / networks that disallow it?

~~~
jkarneges
Something using the SockJS protocol. A quick google search for "sockjs go"
brings up multiple options.

------
oknoorap
well done, impressive.

