simple server/client

src/client.odin

@@ -2,16 +2,14 @@ package hanabi
 
 import "core:fmt"
 import "core:net"
-import "core:os"
 
-client_connect :: proc(addr: net.Endpoint) -> net.TCP_Socket {
-	sock, dial_err := net.dial_tcp(addr)
-	if dial_err != nil do panic(fmt.tprintln("failed to dial", os.args[1]))
-	return sock
-}
 
-run_client :: proc(host: net.Endpoint) {
-	fmt.println("hello from client")
-	fmt.println(host)
+run_client :: proc(host_addr: net.Endpoint) {
+	sock, list_err := net.dial_tcp(host_addr)
+	if list_err != nil do panic(fmt.tprintln("failed to dial:", net.to_string(host_addr)))
+	defer net.close(sock)
+	buf: [256]byte
+	net.recv(sock, buf[:])
+	fmt.println(transmute(string)buf[:])
 }
 

src/main.odin

@@ -3,42 +3,42 @@ package hanabi
 import "core:fmt"
 import "core:net"
 import "core:os"
+import "core:strconv"
 
-USAGE :: `usage: hanabi (-c[onnect] <p0> | -h[ost] <p1> <p2> [p3] [p4] [p5])
-where px is of the form ip:port
+USAGE :: `usage: hanabi (-c[onnect] <ip:port> | -h[ost] <ip:port> <n players>)
+
+note: n players has to be between 2-5
 
 example host:
-  $ hanabi -h 127.0.0.1:42069 127.0.0.1:42070
+  $ hanabi -h 127.0.0.1:42069 4
 
 example player 1:
   $ hanabi -c 127.0.0.1:42069
 
 example player 2:
-  $ hanabi -c 127.0.0.1:42070`
+  $ hanabi -c 127.0.0.1:42069`
 
 
 main :: proc() {
 	ok := false
-	N := len(os.args) - 2
 	defer if !ok do fmt.println(USAGE)
+	N := len(os.args) - 2
 	if N <= 0 do return
 
 	switch os.args[1] {
 	case "-c", "-connect", "--connect":
 		if N != 1 do return
 		addr, ok := net.parse_endpoint(os.args[2])
-		if !ok do panic(fmt.tprintln("failed to parse host endpoint:", os.args[2]))
+		if !ok do panic(fmt.tprintln("failed to parse endpoint:", os.args[2]))
 		run_client(addr)
 	case "-h", "-host", "--host":
-		if !(2 <= N && N <= 5) do return
-		addrs: [dynamic]net.Endpoint
-		defer delete(addrs)
-		for addr_str in os.args[2:] {
-			addr, ok := net.parse_endpoint(os.args[2])
-			if !ok do panic(fmt.tprintln("failed to parse player endpoint:", addr_str))
-			append(&addrs, addr)
-		}
-		run_server(addrs[:])
+		if N != 2 do return
+		addr, endpoint_ok := net.parse_endpoint(os.args[2])
+		if !endpoint_ok do panic(fmt.tprintln("failed to parse endpoint:", os.args[2]))
+		num_players, int_ok := strconv.parse_int(os.args[3])
+		if !int_ok do panic(fmt.tprintln("failed to parse number of players:", os.args[3]))
+		if num_players < 2 || num_players > 5 do return
+		run_server(addr, num_players)
 	case:
 		return
 	}

src/server.odin

@@ -3,37 +3,21 @@ package hanabi
 import "core:fmt"
 import "core:net"
 
-Comm_World :: struct {
-	sockets: [dynamic]net.TCP_Socket,
-}
+run_server :: proc(listen_addr: net.Endpoint, num_players: int) {
+	listener, list_err := net.listen_tcp(listen_addr)
+	if list_err != nil do panic(fmt.tprintln("failed to listen:", net.to_string(listen_addr)))
+	defer net.close(listener)
 
-create_socket :: proc(addr_str: string) -> (net.TCP_Socket, bool) {
-	addr, endpoint_ok := net.parse_endpoint(addr_str)
-	if !endpoint_ok {
-		fmt.eprintln("failed to parse endpoint")
-		return 0, false
-	}
-	sock, dial_error := net.listen_tcp(addr)
-	if dial_error != nil {
-		fmt.eprintln(addr_str, dial_error)
-		return 0, false
-	}
-	return sock, true
-}
+	players: [dynamic]net.TCP_Socket
+	defer delete(players)
 
-create_comm_world :: proc(addresses: []string) -> (comm: Comm_World) {
-	for addr_str in addresses {
-		sock, ok := create_socket(addr_str)
-		if !ok do panic(fmt.tprintfln("%s: failed to create socket", addr_str))
-		append(&comm.sockets, sock)
-	}
-	return
-}
-
-run_server :: proc(players: []net.Endpoint) {
-	fmt.println("hello from server")
-	for p in players {
-		fmt.println(p)
+	for len(players) < num_players {
+		client_sock, source, err := net.accept_tcp(listener)
+		if err != nil {
+			fmt.eprintln("failed to connect:", err, source)
+		}
+		append(&players, client_sock)
+		fmt.println("player connected:", net.to_string(source))
 	}
 }