YourWishes/dusk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

prog

Browse Source
This commit is contained in:
Dominic Masters
2025-02-22 20:22:58 -06:00
parent ec4312c189
commit cebe1bb05c
21 changed files with 402 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/dusk/CMakeLists.txt
View File

@ -26,7 +26,6 @@ target_sources(${DUSK_TARGET_NAME}
# Subdirs
add_subdirectory(assert)
add_subdirectory(console)
add_subdirectory(client)
add_subdirectory(server)
add_subdirectory(net)
add_subdirectory(entity)
add_subdirectory(display)

13
src/dusk/client/CMakeLists.txt
View File

@ -1,13 +0,0 @@
# Copyright (c) 2025 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DUSK_TARGET_NAME}
PRIVATE
client.c
clientremote.c
)
# Subdirs

71
src/dusk/client/client.c
View File

@ -1,71 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "client.h"
#include "assert/assert.h"
void clientInit(
client_t *client,
const clientinit_t init
) {
assertNotNull(client, "Client cannot be NULL.");
memset(client, 0, sizeof(client_t));
client->type = init.type;
client->state = CLIENT_STATE_CONNECTING;
// Perform connection
switch(init.type) {
case CLIENT_TYPE_REMOTE:
clientRemoteInit(client, init.remote);
break;
default:
assertUnreachable("Invalid client type.");
}
// Begin exchanging.
// clientSend(client, (packet_t){
// .type = PACKET_TYPE_HELLO
// });
}
void clientSend(
client_t *client,
const packet_t packet
) {
assertNotNull(client, "Client cannot be NULL.");
assertTrue(
client->state == CLIENT_STATE_CONNECTED,
"Client must be connected to send packets."
);
switch(client->type) {
case CLIENT_TYPE_REMOTE:
clientRemoteSend(client, packet);
break;
default:
assertUnreachable("Invalid client type.");
}
}
void clientDispose(client_t *client) {
assertNotNull(client, "Client cannot be NULL.");
client->state = CLIENT_STATE_DISCONNECTING;
switch(client->type) {
case CLIENT_TYPE_REMOTE:
clientRemoteDispose(client);
break;
default:
assertUnreachable("Invalid client type.");
}
client->state = CLIENT_STATE_DISCONNECTED;
}

51
src/dusk/client/client.h
View File

@ -1,51 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "clientremote.h"
typedef enum {
CLIENT_TYPE_SINGLE_PLAYER,
CLIENT_TYPE_LOCAL,
CLIENT_TYPE_REMOTE
} clienttype_t;
typedef enum {
CLIENT_STATE_DISCONNECTED,
CLIENT_STATE_DISCONNECTING,
CLIENT_STATE_CONNECTING,
CLIENT_STATE_CONNECTED
} clientstate_t;
typedef struct _client_t {
clienttype_t type;
clientstate_t state;
union {
clientremote_t remote;
};
} client_t;
typedef struct {
clienttype_t type;
union {
clientremoteinit_t remote;
};
} clientinit_t;
void clientInit(
client_t *client,
const clientinit_t init
);
void clientSend(
client_t *client,
const packet_t packet
);
void clientDispose(client_t *client);

45
src/dusk/client/clientremote.c
View File

@ -1,45 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "client.h"
#include "assert/assert.h"
#include "console/console.h"
void* clientRemoteThreadFunc(void* arg) {
client_t *client = (client_t*)arg;
assertNotNull(client, "Client is NULL");
client->state = CLIENT_STATE_CONNECTED;
// Send some data
write(client->remote.clientSockDesc, "Hello, World!", 13);
printf("Thread func\n");
return NULL;
}
void clientRemoteInit(
client_t *client,
const clientremoteinit_t init
) {
client->remote.clientSockDesc = init.clientSockDesc;
consolePrint("Accepted a new connection.");
pthread_create(&client->remote.thread, NULL, clientRemoteThreadFunc, client);
}
void clientRemoteSend(client_t *client, const packet_t packet) {
printf("send pack\n");
}
void clientRemoteDispose(client_t *client) {
pthread_join(client->remote.thread, NULL);
close(client->remote.clientSockDesc);
consolePrint("Client disconnected.");
}

26
src/dusk/client/clientremote.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "dusk.h"
#include "net/packet.h"
typedef struct _client_t client_t;
typedef struct {
int32_t clientSockDesc;
} clientremoteinit_t;
typedef struct {
int32_t clientSockDesc;
pthread_t thread;
} clientremote_t;
void clientRemoteInit(client_t *client, const clientremoteinit_t init);
void clientRemoteSend(client_t *client, const packet_t packet);
void * clientRemoteThread(void *arg);
void clientRemoteDispose(client_t *client);

4
src/dusk/dusk.h
View File

@ -22,4 +22,6 @@
typedef float float_t;
typedef double double_t;
typedef bool bool_t;
typedef char char_t;
typedef char char_t;
#define DUSK_VERSION "1.0.0"

12
src/dusk/game.c
View File

@ -9,7 +9,7 @@
#include "gametime.h"
#include "input.h"
#include "console/console.h"
#include "server/server.h"
#include "net/server/server.h"
#include "entity/entity.h"
@ -18,11 +18,10 @@ void gameInit() {
gameTimeInit();
inputInit();
serverInit();
serverStart((serverstart_t){
.type = SERVER_TYPE_LOCAL,
.local = {
.port = SERVER_LOCAL_PORT_DEFAULT
serverInit((serverinit_t){
.type = SERVER_TYPE_ONLINE,
.online = {
.port = SERVER_PORT_DEFAULT
}
});
@ -32,7 +31,6 @@ void gameInit() {
void gameUpdate(const float delta) {
gameTimeUpdate(delta);
inputUpdate();
serverUpdate();
}
void gameDispose() {

12
src/dusk/net/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https:#opensource.org/licenses/MIT
# Sources
target_sources(${DUSK_TARGET_NAME}
PRIVATE
)
# Subdirs
add_subdirectory(server)

11
src/dusk/net/server/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https:#opensource.org/licenses/MIT
# Sources
target_sources(${DUSK_TARGET_NAME}
PRIVATE
server.c
serverclient.c
)

145
src/dusk/net/server/server.c Normal file
View File

@ -0,0 +1,145 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "server.h"
#include "assert/assert.h"
#include "console/console.h"
server_t SERVER;
void serverInit(const serverinit_t init) {
memset(&SERVER, 0, sizeof(server_t));
SERVER.state = SERVER_STATE_STARTING;
SERVER.type = init.type;
// Create the server
switch(init.type) {
case SERVER_TYPE_ONLINE:
SERVER.online.socket = socket(AF_INET, SOCK_STREAM, 0);
SERVER.online.address.sin_family = AF_INET;
SERVER.online.address.sin_addr.s_addr = INADDR_ANY;
SERVER.online.address.sin_port = htons(init.online.port);
// Bind
if(bind(
SERVER.online.socket,
(struct sockaddr *)&SERVER.online.address,
sizeof(SERVER.online.address)
) < 0) {
assertUnreachable("Failed to bind server.");
}
// Begin listening
if(listen(SERVER.online.socket, SERVER_CLIENT_COUNT_MAX) < 0) {
assertUnreachable("Failed to listen on server.");
}
// Set the socket to non-blocking mode
int flags = fcntl(SERVER.online.socket, F_GETFL, 0);
fcntl(SERVER.online.socket, F_SETFL, flags | O_NONBLOCK);
break;
default:
assertUnreachable("Invalid server type.");
break;
}
// Start thread
pthread_create(&SERVER.thread, NULL, serverThread, NULL);
// Wait for server to start
while(SERVER.state == SERVER_STATE_STARTING) usleep(1000);
}
void * serverThread(void *arg) {
assertNull(arg, "Server thread does not accept arguments.");
// Server now running
SERVER.state = SERVER_STATE_RUNNING;
fd_set readfds;
int32_t activity;
int32_t error;
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 1000;
// Start server
while(SERVER.state == SERVER_STATE_RUNNING) {
FD_ZERO(&readfds);
FD_SET(SERVER.online.socket, &readfds);
activity = select(
SERVER.online.socket + 1,
&readfds,
NULL,
NULL,
&timeout
);
if(activity < 0) assertUnreachable("Select error");
if(!FD_ISSET(SERVER.online.socket, &readfds)) {
continue;
}
// Accept incoming connections
int32_t clientSockDesc = accept(SERVER.online.socket, NULL, NULL);
if(clientSockDesc < 0) {
printf("Failed to accept connection\n");
continue;
}
// Now, is the server full?
if(SERVER.clientCount >= SERVER_CLIENT_COUNT_MAX) {
consolePrint("Server is full, rejecting connection.");
// TODO: Write a reason to client.
close(clientSockDesc);
continue;
}
// Create server client for handling
serverclient_t *client = &SERVER.clients[SERVER.clientCount];
serverClientInit(client, (serverclientinit_t){
.socket = clientSockDesc
});
SERVER.clientCount++;
}
SERVER.state = SERVER_STATE_STOPPED;
return NULL;
}
void serverDispose() {
// Disconnect clients
for(uint8_t i = 0; i < SERVER.clientCount; i++) {
serverClientDispose(&SERVER.clients[i]);
}
SERVER.clientCount = 0;
// Stop server thread.
if(SERVER.state == SERVER_STATE_RUNNING) {
// Request thread to stop
SERVER.state = SERVER_STATE_STOPPING;
// Wait for server to stop
while(SERVER.state == SERVER_STATE_STOPPING) usleep(1000);
pthread_join(SERVER.thread, NULL);
// Close the socket
switch(SERVER.type) {
case SERVER_TYPE_ONLINE:
close(SERVER.online.socket);
break;
default:
assertUnreachable("Invalid server type.");
break;
}
}
}

55
src/dusk/net/server/server.h Normal file
View File

@ -0,0 +1,55 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "serverclient.h"
#define SERVER_CLIENT_COUNT_MAX 8
#define SERVER_PORT_DEFAULT 24555
typedef enum {
SERVER_STATE_STOPPED,
SERVER_STATE_STARTING,
SERVER_STATE_RUNNING,
SERVER_STATE_STOPPING
} serverstate_t;
typedef enum {
SERVER_TYPE_OFFLINE,
SERVER_TYPE_ONLINE
} servertype_t;
typedef struct {
serverstate_t state;
servertype_t type;
serverclient_t clients[SERVER_CLIENT_COUNT_MAX];
uint8_t clientCount;
pthread_t thread;
union {
struct {
int32_t socket;
struct sockaddr_in address;
} online;
};
} server_t;
typedef struct {
servertype_t type;
union {
struct {
int32_t port;
} online;
};
} serverinit_t;
extern server_t SERVER;
void serverInit(const serverinit_t init);
void * serverThread(void* arg);
void serverDispose();

101
src/dusk/net/server/serverclient.c Normal file
View File

@ -0,0 +1,101 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "serverclient.h"
#include "assert/assert.h"
#include "console/console.h"
void serverClientInit(serverclient_t *client, const serverclientinit_t init) {
assertNotNull(client, "Client cannot be NULL.");
client->socket = init.socket;
consolePrint("Accepted client %i", client->socket);
client->state = SERVER_CLIENT_STATE_CONNECTING;
// Set socket to non-blocking
int flags = fcntl(client->socket, F_GETFL, 0);
fcntl(client->socket, F_SETFL, flags | O_NONBLOCK);
// Start thread
pthread_create(&client->thread, NULL, serverClientThread, client);
// Wait for client to connect
while(client->state == SERVER_CLIENT_STATE_CONNECTING) usleep(1000);
}
void * serverClientThread(void *arg) {
serverclient_t *client = (serverclient_t*)arg;
assertNotNull(client, "Client cannot be NULL.");
// Set the client state to connected
client->state = SERVER_CLIENT_STATE_CONNECTED;
// Send hello to client, as well as the version number.
{
uint8_t hello[16];
memset(hello, 0, sizeof(hello));
memcpy(hello, "Dusk", 4);
strcpy((char*)&hello[4], DUSK_VERSION);
_serverClientSend(client, hello, sizeof(hello));
}
// Client should respond "OK"
{
uint8_t response[2];
_serverClientReceive(client, response, sizeof(response));
assertTrue(
response[0] == 'O' &&
response[1] == 'K',
"Client did not respond with OK."
);
}
while(client->state == SERVER_CLIENT_STATE_CONNECTED) {
// Do nothing for now.
usleep(1000);
}
// Disconnect
client->state = SERVER_CLIENT_STATE_DISCONNECTED;
return NULL;
}
void _serverClientSend(
serverclient_t *client,
const uint8_t *data,
const size_t size
) {
assertNotNull(client, "Client cannot be NULL.");
assertNotNull(data, "Data cannot be NULL.");
assertTrue(size > 0, "Size cannot be zero.");
}
void _serverClientReceive(
serverclient_t *client,
uint8_t *data,
const size_t size
) {
assertNotNull(client, "Client cannot be NULL.");
assertNotNull(data, "Data cannot be NULL.");
assertTrue(size > 0, "Size cannot be zero.");
recv(client->socket, data, size, 0);
}
void serverClientDispose(serverclient_t *client) {
assertNotNull(client, "Client cannot be NULL.");
if(client->state == SERVER_CLIENT_STATE_CONNECTED) {
// Let the thread know we are disconnecting
client->state = SERVER_CLIENT_STATE_DISCONNECTING;
// Wait for the thread to finish
while(client->state == SERVER_CLIENT_STATE_DISCONNECTING) usleep(1000);
pthread_join(client->thread, NULL);
}
}

45
src/dusk/net/server/serverclient.h Normal file
View File

@ -0,0 +1,45 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "dusk.h"
#include <netinet/in.h>
#include <fcntl.h>
typedef enum {
SERVER_CLIENT_STATE_DISCONNECTED,
SERVER_CLIENT_STATE_CONNECTING,
SERVER_CLIENT_STATE_CONNECTED,
SERVER_CLIENT_STATE_DISCONNECTING
} serverclientstate_t;
typedef struct {
serverclientstate_t state;
pthread_t thread;
int32_t socket;
} serverclient_t;
typedef struct {
int32_t socket;
} serverclientinit_t;
void serverClientInit(serverclient_t *client, const serverclientinit_t init);
void * serverClientThread(void *arg);
void _serverClientSend(
serverclient_t *client,
const uint8_t *data,
const size_t size
);
void _serverClientReceive(
serverclient_t *client,
uint8_t *buffer,
const size_t size
);
void serverClientDispose(serverclient_t *client);

14
src/dusk/server/CMakeLists.txt
View File

@ -1,14 +0,0 @@
# Copyright (c) 2025 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DUSK_TARGET_NAME}
PRIVATE
server.c
serverlocal.c
serversingleplayer.c
)
# Subdirs

77
src/dusk/server/server.c
View File

@ -1,77 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "server.h"
#include "console/console.h"
#include "assert/assert.h"
server_t SERVER;
void serverInit() {
memset(&SERVER, 0, sizeof(server_t));
}
void serverStart(const serverstart_t start) {
assertTrue(SERVER.state==SERVER_STATE_STOPPED, "Server is already running.");
SERVER.type = start.type;
SERVER.clientCount = 0;
switch(start.type) {
case SERVER_TYPE_SINGLE_PLAYER:
serverSinglePlayerStart(start.singlePlayer);
break;
case SERVER_TYPE_LOCAL:
serverLocalStart(start.local);
break;
case SERVER_TYPE_REMOTE:
assertUnreachable("Remote server not implemented.");
break;
default:
assertUnreachable("Unknown server type.");
}
SERVER.state = SERVER_STATE_RUNNING;
}
void serverStop() {
assertTrue(SERVER.state == SERVER_STATE_RUNNING,"Server is already stopped.");
for(uint8_t i = 0; i < SERVER.clientCount; i++) {
clientDispose(&SERVER.clients[i]);
}
switch(SERVER.type) {
case SERVER_TYPE_SINGLE_PLAYER:
assertUnreachable("Single player server not implemented.");
break;
case SERVER_TYPE_LOCAL:
serverLocalStop();
break;
case SERVER_TYPE_REMOTE:
assertUnreachable("Remote server not implemented.");
break;
default:
assertUnreachable("Unknown server type.");
}
SERVER.state = SERVER_STATE_STOPPED;
}
void serverUpdate() {
if(SERVER.state == SERVER_STATE_STOPPED) return;
}
void serverDispose() {
if(SERVER.state == SERVER_STATE_RUNNING) serverStop();
}

53
src/dusk/server/server.h
View File

@ -1,53 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "client/client.h"
#include "serversingleplayer.h"
#include "serverlocal.h"
#define SERVER_CLIENT_COUNT_MAX 4
typedef enum {
SERVER_TYPE_SINGLE_PLAYER = 0,
SERVER_TYPE_LOCAL = 1,
SERVER_TYPE_REMOTE = 2
} servertype_t;
typedef enum {
SERVER_STATE_STOPPED = 0,
SERVER_STATE_RUNNING = 1
} serverstate_t;
typedef struct {
servertype_t type;
union {
serversingleplayerstart_t singlePlayer;
serverlocalstart_t local;
};
} serverstart_t;
typedef struct {
serverstate_t state;
servertype_t type;
client_t clients[SERVER_CLIENT_COUNT_MAX];
uint8_t clientCount;
union {
serverlocal_t local;
};
} server_t;
extern server_t SERVER;
void serverInit();
void serverStart(const serverstart_t start);
void serverStop();
void serverUpdate();
void serverDispose();

127
src/dusk/server/serverlocal.c
View File

@ -1,127 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "server.h"
#include "assert/assert.h"
#include "console/console.h"
#include <fcntl.h>
void serverLocalStart(const serverlocalstart_t start) {
//Create the socket
SERVER.local.sockDesc = socket(AF_INET, SOCK_STREAM, 0);
if(SERVER.local.sockDesc < 0) {
assertUnreachable("Failed to create socket");
}
// Set the socket to non-blocking mode
int flags = fcntl(SERVER.local.sockDesc, F_GETFL, 0);
fcntl(SERVER.local.sockDesc, F_SETFL, flags | O_NONBLOCK);
//Bind the socket
SERVER.local.sockAddr.sin_family = AF_INET;
SERVER.local.sockAddr.sin_addr.s_addr = INADDR_ANY;
SERVER.local.sockAddr.sin_port = htons(start.port);
if(bind(
SERVER.local.sockDesc,
(struct sockaddr*)&SERVER.local.sockAddr,
sizeof(SERVER.local.sockAddr)
) < 0) {
assertUnreachable("Failed to bind socket");
}
//Listen on the socket
if(listen(SERVER.local.sockDesc, 5) < 0) {
assertUnreachable("Failed to listen on socket");
}
// Begin the server thread.
consolePrint("Server started.");
// Start the server thread
SERVER.local.threadState = SERVER_LOCAL_THREAD_STATE_STARTING;
pthread_create(&SERVER.local.thread, NULL, serverLocalThread, NULL);
while(SERVER.local.threadState == SERVER_LOCAL_THREAD_STATE_STARTING) {
usleep(SERVER_LOCAL_THREAD_SLEEP_TIME);
}
}
void serverLocalStop() {
SERVER.local.threadState = SERVER_LOCAL_THREAD_STATE_STOPPING;
while(SERVER.local.threadState == SERVER_LOCAL_THREAD_STATE_STOPPING) {
usleep(SERVER_LOCAL_THREAD_SLEEP_TIME);
}
// Stop the server thread.
pthread_cancel(SERVER.local.thread);
//Close the socket
close(SERVER.local.sockDesc);
// End the server thread.
consolePrint("Server stopped.");
}
void * serverLocalThread(void *arg) {
SERVER.local.threadState = SERVER_LOCAL_THREAD_STATE_RUNNING;
fd_set readfds;
int32_t activity;
int32_t error;
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = SERVER_LOCAL_THREAD_ACCEPT_SLEEP_TIME;
while(SERVER.local.threadState == SERVER_LOCAL_THREAD_STATE_RUNNING) {
FD_ZERO(&readfds);
FD_SET(SERVER.local.sockDesc, &readfds);
activity = select(
SERVER.local.sockDesc + 1,
&readfds,
NULL,
NULL,
&timeout
);
if(activity < 0) assertUnreachable("Select error");
if(!FD_ISSET(SERVER.local.sockDesc, &readfds)) {
continue;
}
// Accept incoming connections
int32_t clientSockDesc = accept(SERVER.local.sockDesc, NULL, NULL);
if(clientSockDesc < 0) {
printf("Failed to accept connection\n");
continue;
}
// Now, is the server full?
if(SERVER.clientCount >= SERVER_CLIENT_COUNT_MAX) {
consolePrint("Server is full, rejecting connection.");
// TODO: Write a reason to client.
close(clientSockDesc);
continue;
}
// Create client.
client_t *client = &SERVER.clients[SERVER.clientCount];
clientInit(client, (clientinit_t){
.type = CLIENT_TYPE_REMOTE,
.remote = {
.clientSockDesc = clientSockDesc
}
});
SERVER.clientCount++;
}
SERVER.local.threadState = SERVER_LOCAL_THREAD_STATE_STOPPED;
return NULL;
}

36
src/dusk/server/serverlocal.h
View File

@ -1,36 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "dusk.h"
#include <netinet/in.h>
#define SERVER_LOCAL_PORT_DEFAULT 8080
#define SERVER_LOCAL_THREAD_SLEEP_TIME 1000
#define SERVER_LOCAL_THREAD_ACCEPT_SLEEP_TIME 60000
typedef enum {
SERVER_LOCAL_THREAD_STATE_STOPPED = 0,
SERVER_LOCAL_THREAD_STATE_STARTING = 1,
SERVER_LOCAL_THREAD_STATE_RUNNING = 2,
SERVER_LOCAL_THREAD_STATE_STOPPING = 3
} serverlocalthreadstate_t;
typedef struct {
uint32_t port;
} serverlocalstart_t;
typedef struct {
int32_t sockDesc;
struct sockaddr_in sockAddr;
pthread_t thread;
uint8_t threadState;
} serverlocal_t;
void serverLocalStart(const serverlocalstart_t start);
void serverLocalStop();
void * serverLocalThread(void *arg);

12
src/dusk/server/serversingleplayer.c
View File

@ -1,12 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "server.h"
void serverSinglePlayerStart(const serversingleplayerstart_t start) {
}

15
src/dusk/server/serversingleplayer.h
View File

@ -1,15 +0,0 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "dusk.h"
typedef struct {
int32_t nothing;
} serversingleplayerstart_t;
void serverSinglePlayerStart(const serversingleplayerstart_t start);