all repos — engine.git @ 70d5a5f53436c4848616132f2ff47c4036adc224

Unnamed repository; edit this file 'description' to name the repository.

src/network.odin

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 
package main

import "core:fmt"
import net "vendor:ENet"
import str "core:strings"

clientNetworkState: struct{
	client: ^net.Host,
	peer: ^net.Peer,
	serverAddress: net.Address,
	event: net.Event
}

serverNetworkState: struct{
	server: ^net.Host,
	address: net.Address,
	event: net.Event,
	maxClients: uint
}

StartClient :: proc() {
	if net.initialize() != 0 {
		fmt.printfln("ENet failed to Initialize")
		return
	}
	clientNetworkState.client =  net.host_create(nil,1,2,0,0)
	if clientNetworkState.client == nil {
		fmt.printfln("Client could not be created")
	}
	fmt.printfln("Client Created")
}

KillClient :: proc() {
	net.host_destroy(clientNetworkState.client)
	net.deinitialize()
}

StartServer :: proc() {
	if net.initialize() != 0 {
		fmt.printfln("ENet failed to Initialize")
		return
	}
	serverNetworkState.server =  net.host_create(&serverNetworkState.address,serverNetworkState.maxClients,2,0,0)
	if serverNetworkState.server == nil {
		fmt.printfln("Server could not be created")
	}
	fmt.printfln("Server Created")
}

KillServer :: proc() {
	net.host_destroy(serverNetworkState.server)
	net.deinitialize()
}

ConnectToServer :: proc() {
	clientNetworkState.peer = net.host_connect(clientNetworkState.client, &clientNetworkState.serverAddress,2,0)
	if clientNetworkState.peer == nil {
		fmt.printfln("No Available Connection")
		return
	}
	if net.host_service(clientNetworkState.client, &clientNetworkState.event, 5000) > 0 &&
		clientNetworkState.event.type == net.EventType.CONNECT {
		fmt.printfln("Connection Succeeded")
	} else {
		net.peer_reset(clientNetworkState.peer)
		fmt.printfln("Connection Failed")
	}
}

ServerListen :: proc() {
	for net.host_service(serverNetworkState.server, &serverNetworkState.event, 0) > 0 {
			switch serverNetworkState.event.type {
					case net.EventType.CONNECT:
							fmt.printfln("Client connected.")
							break
					case net.EventType.RECEIVE:
							fmt.printfln("Received %i bytes of data", serverNetworkState.event.packet.dataLength)
							fmt.printfln("Received %s", str.string_from_null_terminated_ptr(
									serverNetworkState.event.packet.data, int(serverNetworkState.event.packet.dataLength)))
							net.packet_destroy(serverNetworkState.event.packet)
							break
					case net.EventType.NONE:
							break
					case net.EventType.DISCONNECT:
							fmt.printfln("Client disconnected.")
							break
			}
	}
}

YellAtServer :: proc() {
	scream :cstring = "Niggers"
	flag := net.PacketFlags{net.PacketFlag.RELIABLE,}
	packet := net.packet_create(rawptr(scream),len(scream)+1,flag)
	net.peer_send(clientNetworkState.peer,0,packet)
	net.host_flush(clientNetworkState.client)
}