Rename the library to netty.

Author: treeform

README.md

@@ -2,7 +2,7 @@
 
 Netty is a reliable connection over UDP aimed at games. Normally UDP packets can get duplicated, dropped, or come out of order. Netty makes sure packets are not duplicated, re-sends them if they get dropped, and all packets come in order. UDP packets might also get split if they are above 512 bytes and also can fail to be sent if they are bigger than 1-2k. Netty breaks up big packets and sends them in pieces making sure each piece comes reliably in order. Finally sometimes it's impossible for two clients to communicate direclty with TCP because of NATs, but Netty provides hole punching which allows them to connect.
 
-## Is Netty a reimplementation of TCP?
+## Is Netty a implementation of TCP?
 
 TCP is really bad for short latency sensitive messages. TCP was designed for throughput (downloading files) not latency (games). Netty will resend stuff faster than TCP, Netty will not buffer and you also get nat punch-through (which TCP does not have). Netty is basically "like TCP but for games". You should not be using Netty if you are will be sending large mount of data. By default Netty is capped at 250K of data in flight.
 
@@ -16,7 +16,7 @@ TCP is really bad for short latency sensitive messages. TCP was designed for thr
 | packet ordering           | yes   | no       | yes     |
 | packet splitting          | yes   | no       | yes     |
 | packet retry              | yes   | no       | yes     |
-| packet deduplication      | yes   | no       | yes     |
+| packet reduplication      | yes   | no       | yes     |
 | hole punch through        | no    | yes      | yes     |
 | connection handling       | yes   | no       | yes     |
 | congestion control        | yes   | no       | yes     |

examples/chatclient.nim

@@ -0,0 +1,19 @@
+import netty
+
+var client = newReactor()
+var connection = client.connect("127.0.0.1", 2001)
+
+# get persons name
+echo "what is your name?"
+var name = readLine(stdin)
+echo "note: press enter to see if people sent you things"
+
+while true:
+  client.tick()
+  for packet in client.packets:
+    echo packet.data
+
+  # wait for user to type a line
+  let line = readLine(stdin)
+  if line.len > 0:
+    connection.send(name & ":" & line)

examples/chatclientthreads.nim

@@ -0,0 +1,62 @@
+# nim c -r --threads:on --tlsEmulation:off tests\chatclientthreads
+
+import netty, terminal
+
+var client = newReactor()
+var connection = client.connect("127.0.0.1", 2001)
+
+# get persons name
+echo "what is your name?"
+var name = readLine(stdin)
+
+# handle ctrl-c correclty on windows by stopping all threads
+proc handleCtrlC() {.noconv.} =
+  setupForeignThreadGc()
+  quit(1)
+setControlCHook(handleCtrlC)
+
+# create a thread that just reads a single chart
+var
+  thread: Thread[tuple[a: int]]
+  singleChar: char
+proc readSingleChar(interval: tuple[a: int]) {.thread.} =
+  while true:
+    singleChar = getch()
+createThread(thread, readSingleChar, (0, ))
+
+# main loop
+var line: string
+while true:
+  client.tick()
+  for packet in client.packets:
+    # we got a packet, rase current line user is typing
+    stdout.eraseLine()
+    # write packet line
+    echo packet.data
+    # write back the line was typing
+    writeStyled(line)
+
+  if singleChar != char(0):
+    if singleChar == char(8):
+      # handle backspace
+      line.setLen(line.len - 1)
+    else:
+      line.add(singleChar)
+    # a char got added, erase current line
+    stdout.eraseLine()
+    # write the line again
+    writeStyled(line & " ")
+    # put cursor in right spot
+    stdout.setCursorXPos(line.len)
+
+    if singleChar == char(13):
+      # handle sending
+      connection.send(name & ":" & line)
+      # clear line, reset eveything
+      # server should echo the line back
+      line = ""
+      stdout.eraseLine()
+      stdout.setCursorXPos(0)
+
+    # reset character
+    singleChar = char(0)

examples/chatclientthreads.nims

@@ -0,0 +1,2 @@
+--threads:on
+--tlsEmulation:off

examples/chatserver.nim

@@ -0,0 +1,15 @@
+import netty
+
+var server = newReactor("127.0.0.1", 2001)
+echo "Listenting for UDP on 127.0.0.1:2001"
+while true:
+  server.tick()
+  for connection in server.newConnections:
+    echo "[new] ", connection.address
+  for connection in server.deadConnections:
+    echo "[dead] ", connection.address
+  for packet in server.packets:
+    echo "[msg]", packet.data
+    # send packet data to all connections
+    for connection in server.connections:
+      connection.send(packet.data)

examples/client.nim

@@ -0,0 +1,16 @@
+import netty
+
+# create connection
+var client = newReactor()
+# connect to server
+var c2s = client.connect("127.0.0.1", 1999)
+# send message on the connection
+c2s.send("hi")
+# main loop
+while true:
+  # must call tick to both read and write
+  client.tick()
+  # usually there are no new packets, but if there are
+  for packet in client.packets:
+    # print packet data
+    echo "GOT PACKET: ", packet.data

examples/server.nim

@@ -0,0 +1,15 @@
+import netty
+
+# listen for a connection on localhost port 1999
+var server = newReactor("127.0.0.1", 1999)
+echo "Listenting for UDP on 127.0.0.1:1999"
+# main loop
+while true:
+  # must call tick to both read and write
+  server.tick()
+  # usually there are no new packets, but if there are
+  for packet in server.packets:
+    # print packet data
+    echo "GOT PACKET: ", packet.data
+    # echo packet back to the client
+    packet.connection.send("you said:" & packet.data)

netty.nimble

@@ -0,0 +1,11 @@
+# Package
+
+version       = "0.1.0"
+author        = "treeform"
+description   = "Netty is a reliable UDP connection for games in Nim."
+license       = "MIT"
+srcDir        = "src"
+
+# Dependencies
+
+requires "nim >= 0.19.0"