Add vendor/ENet example

[karl-zylinski]

[Ezro]

Not sure how valid / ergonomic this example is but I wrote a client / server based on the budget chat problem from Protohackers. Feel free to iterate, tear this apart, or use this however people see fit to contribute a more proper example to the repo.

package enet_server

import "core:fmt"
import "core:log"
import "core:math/rand"
import "core:os"
import "core:strings"
import "core:sync"
import "vendor:enet"

ClientData :: struct {
	peer: ^enet.Peer,
	name: string,
}

clients_mutex: sync.Mutex
client_map: map[u32]ClientData

logger := log.create_console_logger(lowest = log.Level.Debug)

main :: proc() {
	context.logger = logger
	if enet.initialize() != 0 {
		log.error("Failed to initialize ENet")
		os.exit(1)
	}
	defer enet.deinitialize()
	address: enet.Address
	address.host = enet.HOST_ANY
	address.port = 8096
	server := enet.host_create(&address, 32, 2, 0, 0)
	if server == nil {
		log.error("Failed to create ENet server host")
		os.exit(1)
	}
	log.info("ENet server started on port 8096")
	event: enet.Event
	for {
		if enet.host_service(server, &event, 1000) == 0 {continue}
		switch event.type {
		case enet.EventType.CONNECT:
			handle_connect(&event)
		case enet.EventType.RECEIVE:
			handle_receive(&event)
			enet.packet_destroy(event.packet)
		case enet.EventType.DISCONNECT:
			handle_disconnect(&event)
		case enet.EventType.NONE:
		}
	}
}

handle_connect :: proc(event: ^enet.Event) {
	log.infof("Client connected: id=%v", event.peer.connectID)
	welcome: cstring = "Welcome to budgetchat! What shall I call you?"
	send_to_peer(event.peer, rawptr(welcome), len(welcome))
}

handle_receive :: proc(event: ^enet.Event) {
	message := string(event.packet.data[:event.packet.dataLength])
	message = strings.trim_right(message, "\r\n")
	sync.mutex_lock(&clients_mutex)
	defer sync.mutex_unlock(&clients_mutex)
	if event.peer.connectID not_in client_map {
		if !name_is_valid(message) {
			enet.peer_disconnect(event.peer, 0)
			return
		}
		welcome_message: cstring = strings.clone_to_cstring(
			strings.concatenate({"* ", message, " has entered the room\n"}),
		)
		welcome_packet := enet.packet_create(
			rawptr(welcome_message),
			len(welcome_message),
			{.RELIABLE},
		)
		room_contains_message: string = "* The room contains: "
		i := 0
		for id, c in client_map {
			enet.peer_send(c.peer, 0, welcome_packet)
			strings.concatenate({room_contains_message, c.name})
			if i < len(client_map) - 1 {
				strings.concatenate({room_contains_message, ", "})
			}
			i += 1
		}
		contains_packet := enet.packet_create(
			rawptr(strings.clone_to_cstring(room_contains_message)),
			len(room_contains_message),
			{.RELIABLE},
		)
		enet.peer_send(event.peer, 0, contains_packet)
		client_map[event.peer.connectID] = ClientData{event.peer, message}
	} else {
		user_message: cstring = strings.clone_to_cstring(
			strings.concatenate({"[", client_map[event.peer.connectID].name, "] ", message}),
		)
		message_packet := enet.packet_create(rawptr(user_message), len(user_message), {.RELIABLE})
		for id, c in client_map {
			if event.peer.connectID == id {continue}
			enet.peer_send(c.peer, 0, message_packet)
		}
	}
}

handle_disconnect :: proc(event: ^enet.Event) {
	sync.mutex_lock(&clients_mutex)
	defer sync.mutex_unlock(&clients_mutex)
	if event.peer.connectID in client_map {
		name := client_map[event.peer.connectID].name
		delete_key(&client_map, event.peer.connectID)
		// broadcast(fmt.tprintf("* %s has left the room\n", name))
	}
	log.infof("Client disconnected: id=%v", event.peer.connectID)
}

send_to_peer :: proc(peer: ^enet.Peer, data: rawptr, msg_len: uint) {
	packet := enet.packet_create(data, msg_len, {.RELIABLE})
	enet.peer_send(peer, 0, packet)
}

broadcast :: proc(data: rawptr, msg_len: uint, exclude: u32 = 0) {
	packet := enet.packet_create(data, msg_len, {.RELIABLE})
	for id, c in client_map {
		if id == exclude do continue
		enet.peer_send(c.peer, 0, packet)
	}
}

name_is_valid :: proc(name: string) -> bool {
	for c in name {
		if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9')) {
			return false
		}
	}
	return true
}

package enet_client

import "core:io"
import "core:log"
import "core:os"
import "core:strings"
import "core:thread"
import "vendor:enet"

ENetData :: struct {
	client: enet.Host,
	peer:   ^enet.Peer,
}
logger := log.create_console_logger(lowest = log.Level.Debug)

main :: proc() {
	context.logger = logger
	if enet.initialize() != 0 {os.exit(1)}
	defer enet.deinitialize()
	client := enet.host_create(nil, 1, 2, 0, 0)
	if client == nil {os.exit(1)}
	address: enet.Address
	enet.address_set_host(&address, "127.0.0.1")
	address.port = 8096
	peer := enet.host_connect(client, &address, 2, 0)
	if peer == nil {os.exit(1)}
	log.infof("Client connected: id=%v", peer.connectID)
	enet_data, allocator_error := new(ENetData)
	if allocator_error != nil {
		log.errorf("Error allocating ENet data: %v", allocator_error)
		return
	}
	enet_data.client = client^
	enet_data.peer = peer
	thread_pool: thread.Pool
	thread.pool_init(&thread_pool, context.allocator, 16)
	thread.pool_start(&thread_pool)
	thread.pool_add_task(&thread_pool, context.allocator, listen, client)
	stdin_stream: io.Stream
	message_buffer: [1000]byte
	message: cstring
	total_read: int
	for {
		total_read, _ = os.read(os.stdin, message_buffer[:])
		if total_read == 0 {continue}
		message = strings.clone_to_cstring(string(message_buffer[:]), context.allocator)
		packet := enet.packet_create(rawptr(message), len(message), {.RELIABLE})
		enet.peer_send(peer, 0, packet)
	}
}

listen :: proc(t: thread.Task) {
	context.logger = logger
	enet_data := cast(^ENetData)t.data
	event: enet.Event
	for {
		if enet.host_service(&enet_data.client, &event, 5000) > 0 {
			if event.type == enet.EventType.RECEIVE {
				msg := string(event.packet.data[:event.packet.dataLength])
				log.info(msg)
				enet.packet_destroy(event.packet)
			}
		}
	}
}