Rename network symbols

include/core/Network.h

@@ -17,15 +17,15 @@ typedef struct {
 } CoreInPacket;
 
 void coreInitInPacket(CoreInPacket* in, const void* data, size_t n);
-bool coreInPacketReadU8(CoreInPacket* in, u8* u);
-bool coreInPacketReadU16(CoreInPacket* in, u16* u);
-bool coreInPacketReadU32(CoreInPacket* in, u32* u);
-bool coreInPacketReadI8(CoreInPacket* in, i8* i);
-bool coreInPacketReadI16(CoreInPacket* in, i16* i);
-bool coreInPacketReadI32(CoreInPacket* in, i32* i);
-bool coreInPacketReadFloat(CoreInPacket* in, float* f);
-size_t coreInPacketReadString(CoreInPacket* in, char* buffer, size_t n);
-bool coreInPacketRead(CoreInPacket* in, void* buffer, size_t n);
+bool coreReadInPacketU8(CoreInPacket* in, u8* u);
+bool coreReadInPacketU16(CoreInPacket* in, u16* u);
+bool coreReadInPacketU32(CoreInPacket* in, u32* u);
+bool coreReadInPacketI8(CoreInPacket* in, i8* i);
+bool coreReadInPacketI16(CoreInPacket* in, i16* i);
+bool coreReadInPacketI32(CoreInPacket* in, i32* i);
+bool coreReadInPacketFloat(CoreInPacket* in, float* f);
+size_t coreReadInPacketString(CoreInPacket* in, char* buffer, size_t n);
+bool coreReadInPacket(CoreInPacket* in, void* buffer, size_t n);
 
 typedef struct {
     CoreBuffer data;
@@ -33,53 +33,53 @@ typedef struct {
 
 void coreInitOutPacket(CoreOutPacket* out);
 void coreDestroyOutPacket(CoreOutPacket* out);
-CoreOutPacket* coreOutPacketWriteU8(CoreOutPacket* out, u8 u);
-CoreOutPacket* coreOutPacketWriteU16(CoreOutPacket* out, u16 u);
-CoreOutPacket* coreOutPacketWriteU32(CoreOutPacket* out, u32 u);
-CoreOutPacket* coreOutPacketWriteI8(CoreOutPacket* out, i8 i);
-CoreOutPacket* coreOutPacketWriteI16(CoreOutPacket* out, i16 i);
-CoreOutPacket* coreOutPacketWriteI32(CoreOutPacket* out, i32 i);
-CoreOutPacket* coreOutPacketWriteFloat(CoreOutPacket* out, float f);
-CoreOutPacket* coreOutPacketWriteString(CoreOutPacket* out, const char* buffer);
-CoreOutPacket* coreOutPacketWrite(CoreOutPacket* out, const void* buffer,
-                                  size_t n);
+void coreWriteOutPacketU8(CoreOutPacket* out, u8 u);
+void coreWriteOutPacketU16(CoreOutPacket* out, u16 u);
+void coreWriteOutPacketU32(CoreOutPacket* out, u32 u);
+void coreWriteOutPacketI8(CoreOutPacket* out, i8 i);
+void coreWriteOutPacketI16(CoreOutPacket* out, i16 i);
+void coreWriteOutPacketI32(CoreOutPacket* out, i32 i);
+void coreWriteOutPacketFloat(CoreOutPacket* out, float f);
+void coreWriteOutPacketString(CoreOutPacket* out, const char* buffer);
+void coreWriteOutPacket(CoreOutPacket* out, const void* buffer, size_t n);
 
 typedef u16 CorePort;
-typedef void (*CoreClientOnConnect)(void);
-typedef void (*CoreClientOnDisconnect)(void);
-typedef void (*CoreClientOnPacket)(CoreInPacket*);
+typedef void (*CoreOnServerConnect)(void);
+typedef void (*CoreOnServerDisconnect)(void);
+typedef void (*CoreOnServerPacket)(CoreInPacket*);
 
-bool coreClientStart(void);
-void coreClientStop(void);
-bool coreClientConnect(const char* server, CorePort port, int timeoutTicks);
-void coreClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax);
-void coreClientDisconnect(int timeoutTicks);
-void coreClientSend(const CoreOutPacket* p, CorePacketSendMode mode);
-void coreClientTick(void);
-void coreClientSetConnectHandler(CoreClientOnConnect oc);
-void coreClientSetDisconnectHandler(CoreClientOnDisconnect od);
-void coreClientSetPacketHandler(CoreClientOnPacket op);
-void coreClientResetHandler(void);
-bool coreClientIsConnecting(void);
-bool coreClientIsConnected(void);
+bool coreStartClient(void);
+void coreStopClient(void);
+bool coreConnectClient(const char* server, CorePort port, int timeoutTicks);
+void coreSetClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax);
+void coreDisconnectClient(int timeoutTicks);
+void coreSendClientPacket(const CoreOutPacket* p, CorePacketSendMode mode);
+void coreTickClient(void);
+void coreSetClientConnectHandler(CoreOnServerConnect oc);
+void coreSetClientDisconnectHandler(CoreOnServerDisconnect od);
+void coreSetClientPacketHandler(CoreOnServerPacket op);
+void coreResetClientHandler(void);
+bool coreIsClientConnecting(void);
+bool coreIsClientConnected(void);
 
 typedef int CoreClient;
-typedef void (*CoreServerOnConnect)(CoreClient);
-typedef void (*CoreServerOnDisconnect)(CoreClient);
-typedef void (*CoreServerOnPacket)(CoreClient, CoreInPacket*);
+typedef void (*CoreOnClientConnect)(CoreClient);
+typedef void (*CoreOnClientDisconnect)(CoreClient);
+typedef void (*CoreOnClientPacket)(CoreClient, CoreInPacket*);
 
-bool coreServerStart(CorePort port, size_t maxClients);
-void coreServerStop(void);
-void coreServerTick(void);
-void coreServerSendAll(const CoreOutPacket* p, CorePacketSendMode mode);
-void coreServerSend(CoreClient client, const CoreOutPacket* p,
-                    CorePacketSendMode mode);
+bool coreStartServer(CorePort port, size_t maxClients);
+void coreStopServer(void);
+void coreTickServer(void);
+void coreSendServerPacketBroadcast(const CoreOutPacket* p,
+                                   CorePacketSendMode mode);
+void coreSendServerPacket(CoreClient client, const CoreOutPacket* p,
+                          CorePacketSendMode mode);
 void coreServerTimeout(CoreClient client, u32 timeout, u32 timeoutMin,
                        u32 timeoutMax);
-void coreServerDisconnect(CoreClient client);
-void coreServerSetConnectHandler(CoreServerOnConnect oc);
-void coreServerSetDisconnectHandler(CoreServerOnDisconnect od);
-void coreServerSetPacketHandler(CoreServerOnPacket op);
-void coreServerResetHandler(void);
+void coreDisconnectServerClient(CoreClient client);
+void coreSetServerConnectHandler(CoreOnClientConnect oc);
+void coreSetServerDisconnectHandler(CoreOnClientDisconnect od);
+void coreSetServerPacketHandler(CoreOnClientPacket op);
+void coreResetServerHandler(void);
 
 #endif

src/Network.c

@@ -18,47 +18,47 @@ void coreInitInPacket(CoreInPacket* in, const void* data, size_t n) {
     in->index = 0;
 }
 
-bool coreInPacketReadU8(CoreInPacket* in, u8* u) {
-    return coreInPacketRead(in, u, sizeof(*u));
+bool coreReadInPacketU8(CoreInPacket* in, u8* u) {
+    return coreReadInPacket(in, u, sizeof(*u));
 }
 
-bool coreInPacketReadU16(CoreInPacket* in, u16* u) {
-    if(coreInPacketRead(in, u, sizeof(*u))) {
+bool coreReadInPacketU16(CoreInPacket* in, u16* u) {
+    if(coreReadInPacket(in, u, sizeof(*u))) {
         return true;
     }
     *u = ntohs(*u);
     return false;
 }
 
-bool coreInPacketReadU32(CoreInPacket* in, u32* u) {
-    if(coreInPacketRead(in, u, sizeof(*u))) {
+bool coreReadInPacketU32(CoreInPacket* in, u32* u) {
+    if(coreReadInPacket(in, u, sizeof(*u))) {
         return true;
     }
     *u = ntohl(*u);
     return false;
 }
 
-bool coreInPacketReadI8(CoreInPacket* in, i8* i) {
+bool coreReadInPacketI8(CoreInPacket* in, i8* i) {
     u8 u;
-    if(coreInPacketReadU8(in, &u)) {
+    if(coreReadInPacketU8(in, &u)) {
         return true;
     }
     *i = (i8)((i32)u - (i32)128);
     return false;
 }
 
-bool coreInPacketReadI16(CoreInPacket* in, i16* i) {
+bool coreReadInPacketI16(CoreInPacket* in, i16* i) {
     u16 u;
-    if(coreInPacketReadU16(in, &u)) {
+    if(coreReadInPacketU16(in, &u)) {
         return true;
     }
     *i = (i16)((i32)u - (i32)32768);
     return false;
 }
 
-bool coreInPacketReadI32(CoreInPacket* in, i32* i) {
+bool coreReadInPacketI32(CoreInPacket* in, i32* i) {
     u32 u;
-    if(coreInPacketReadU32(in, &u)) {
+    if(coreReadInPacketU32(in, &u)) {
         return true;
     }
     if(u < 2147483648) {
@@ -69,22 +69,22 @@ bool coreInPacketReadI32(CoreInPacket* in, i32* i) {
     return false;
 }
 
-bool coreInPacketReadFloat(CoreInPacket* in, float* f) {
+bool coreReadInPacketFloat(CoreInPacket* in, float* f) {
     u32 u;
     static_assert(sizeof(u) == sizeof(*f), "float and u32 size do not match");
-    if(coreInPacketReadU32(in, &u)) {
+    if(coreReadInPacketU32(in, &u)) {
         return true;
     }
     memcpy(f, &u, sizeof(float));
     return false;
 }
 
-size_t coreInPacketReadString(CoreInPacket* in, char* buffer, size_t n) {
+size_t coreReadInPacketString(CoreInPacket* in, char* buffer, size_t n) {
     if(n == 0) {
         return 0;
     }
     u16 size;
-    if(coreInPacketReadU16(in, &size)) {
+    if(coreReadInPacketU16(in, &size)) {
         return 0;
     }
     size_t end = size;
@@ -93,18 +93,18 @@ size_t coreInPacketReadString(CoreInPacket* in, char* buffer, size_t n) {
     while(n-- > 0 && end > 0) {
         end--;
         u8 u;
-        if(coreInPacketReadU8(in, &u)) {
+        if(coreReadInPacketU8(in, &u)) {
             *bufferStart = '\0';
             break;
         }
         *(buffer++) = (char)u;
     }
-    while(end-- > 0 && !coreInPacketReadU8(in, &(u8){0})) {}
+    while(end-- > 0 && !coreReadInPacketU8(in, &(u8){0})) {}
     *buffer = '\0';
     return size;
 }
 
-bool coreInPacketRead(CoreInPacket* in, void* buffer, size_t n) {
+bool coreReadInPacket(CoreInPacket* in, void* buffer, size_t n) {
     if(in->index + n > in->size) {
         return true;
     }
@@ -121,72 +121,69 @@ void coreDestroyOutPacket(OutPacket* out) {
     coreDestroyBuffer(&out->data);
 }
 
-OutPacket* coreOutPacketWriteU8(OutPacket* out, u8 u) {
+void coreWriteOutPacketU8(OutPacket* out, u8 u) {
     coreAddSizedBufferData(&out->data, &u, sizeof(u));
-    return out;
 }
 
-OutPacket* coreOutPacketWriteU16(OutPacket* out, u16 u) {
+void coreWriteOutPacketU16(OutPacket* out, u16 u) {
     u = htons(u);
     coreAddSizedBufferData(&out->data, &u, sizeof(u));
-    return out;
 }
 
-OutPacket* coreOutPacketWriteU32(OutPacket* out, u32 u) {
+void coreWriteOutPacketU32(OutPacket* out, u32 u) {
     u = htonl(u);
     coreAddSizedBufferData(&out->data, &u, sizeof(u));
-    return out;
 }
 
-OutPacket* coreOutPacketWriteI8(OutPacket* out, i8 i) {
+void coreWriteOutPacketI8(OutPacket* out, i8 i) {
     if(i < 0) {
-        return coreOutPacketWriteU8(out, (u8)((i32)i + (i32)128));
+        coreWriteOutPacketU8(out, (u8)((i32)i + (i32)128));
+    } else {
+        coreWriteOutPacketU8(out, (u8)((u32)i + (u32)128));
     }
-    return coreOutPacketWriteU8(out, (u8)((u32)i + (u32)128));
 }
 
-OutPacket* coreOutPacketWriteI16(OutPacket* out, i16 i) {
+void coreWriteOutPacketI16(OutPacket* out, i16 i) {
     if(i < 0) {
-        return coreOutPacketWriteU16(out, (u16)((i32)i + (i32)32768));
+        coreWriteOutPacketU16(out, (u16)((i32)i + (i32)32768));
+    } else {
+        coreWriteOutPacketU16(out, (u16)((u32)i + (u32)32768));
     }
-    return coreOutPacketWriteU16(out, (u16)((u32)i + (u32)32768));
 }
 
-OutPacket* coreOutPacketWriteI32(OutPacket* out, i32 i) {
+void coreWriteOutPacketI32(OutPacket* out, i32 i) {
     if(i < 0) {
-        return coreOutPacketWriteU32(out,
-                                     (u32)((i + (i32)2147483647) + (i32)1));
+        coreWriteOutPacketU32(out, (u32)((i + (i32)2147483647) + (i32)1));
+    } else {
+        coreWriteOutPacketU32(out, (u32)((u32)i + (u32)2147483648));
     }
-    return coreOutPacketWriteU32(out, (u32)((u32)i + (u32)2147483648));
 }
 
-OutPacket* coreOutPacketWriteFloat(OutPacket* out, float f) {
+void coreWriteOutPacketFloat(OutPacket* out, float f) {
     u32 u;
     static_assert(sizeof(u) == sizeof(f), "float and u32 size do not match");
     memcpy(&u, &f, sizeof(float));
-    return coreOutPacketWriteU32(out, u);
+    coreWriteOutPacketU32(out, u);
 }
 
-OutPacket* coreOutPacketWriteString(OutPacket* out, const char* s) {
+void coreWriteOutPacketString(OutPacket* out, const char* s) {
     size_t marker = out->data.size;
-    coreOutPacketWriteU16(out, 0);
+    coreWriteOutPacketU16(out, 0);
     size_t end = 0;
     while(end < 65534 && *s != '\0') {
-        coreOutPacketWriteU8(out, (u8)(*(s++)));
+        coreWriteOutPacketU8(out, (u8)(*(s++)));
         end++;
     }
-    coreOutPacketWriteU8(out, 0);
+    coreWriteOutPacketU8(out, 0);
     end++;
     size_t endMarker = out->data.size;
     out->data.size = marker;
-    coreOutPacketWriteU16(out, (u16)end);
+    coreWriteOutPacketU16(out, (u16)end);
     out->data.size = endMarker;
-    return out;
 }
 
-OutPacket* coreOutPacketWrite(OutPacket* out, const void* buffer, size_t n) {
+void coreWriteOutPacket(OutPacket* out, const void* buffer, size_t n) {
     coreAddSizedBufferData(&out->data, buffer, n);
-    return out;
 }
 
 static int enetCounter = 0;
@@ -216,9 +213,9 @@ static void voidInPacketDummy(CoreInPacket*) {
 typedef struct {
     ENetHost* client;
     ENetPeer* connection;
-    CoreClientOnConnect onConnect;
-    CoreClientOnDisconnect onDisconnect;
-    CoreClientOnPacket onPacket;
+    CoreOnServerConnect onConnect;
+    CoreOnServerDisconnect onDisconnect;
+    CoreOnServerPacket onPacket;
     int connectTicks;
     int connectTimeoutTicks;
     int disconnectTicks;
@@ -229,7 +226,7 @@ static Client client = {
     nullptr, nullptr, voidVoidDummy, voidVoidDummy, voidInPacketDummy, 0, 0,
     0,       0};
 
-bool coreClientStart(void) {
+bool coreStartClient(void) {
     if(client.client != nullptr) {
         CORE_LOG_WARNING("Client already started");
         return true;
@@ -239,14 +236,14 @@ bool coreClientStart(void) {
     }
     client.client = CORE_FAIL(enet_host_create(nullptr, 1, 2, 0, 0), nullptr);
     if(client.client == nullptr) {
-        coreClientStop();
+        coreStopClient();
         CORE_LOG_ERROR("Cannot create enet client host");
         return true;
     }
     return false;
 }
 
-void coreClientStop(void) {
+void coreStopClient(void) {
     if(client.connection != nullptr) {
         client.onDisconnect();
         CORE_FAIL(enet_peer_disconnect_now(client.connection, 0),
@@ -262,7 +259,7 @@ void coreClientStop(void) {
     client.disconnectTicks = 0;
 }
 
-bool coreClientConnect(const char* server, CorePort port, int timeoutTicks) {
+bool coreConnectClient(const char* server, CorePort port, int timeoutTicks) {
     if(client.client == nullptr) {
         CORE_LOG_WARNING("Client not started");
         return true;
@@ -286,13 +283,13 @@ bool coreClientConnect(const char* server, CorePort port, int timeoutTicks) {
     return false;
 }
 
-void coreClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax) {
+void coreSetClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax) {
     if(client.connection != nullptr) {
         enet_peer_timeout(client.connection, timeout, timeoutMin, timeoutMax);
     }
 }
 
-void coreClientDisconnect(int timeoutTicks) {
+void coreDisconnectClient(int timeoutTicks) {
     if(client.connection == nullptr) {
         return;
     }
@@ -302,7 +299,7 @@ void coreClientDisconnect(int timeoutTicks) {
     client.disconnectTimeoutTicks = timeoutTicks;
 }
 
-void coreClientSend(const OutPacket* p, CorePacketSendMode mode) {
+void coreSendClientPacket(const OutPacket* p, CorePacketSendMode mode) {
     if(client.client == nullptr || client.connection == nullptr ||
        client.connectTicks >= 0) {
         return;
@@ -341,7 +338,7 @@ static void tickClientEvents(void) {
     }
 }
 
-void coreClientTick(void) {
+void coreTickClient(void) {
     if(client.client == nullptr) {
         return;
     }
@@ -349,7 +346,7 @@ void coreClientTick(void) {
     if(client.connectTicks >= 1 &&
        ++client.connectTicks > client.connectTimeoutTicks) {
         client.connectTicks = 0;
-        coreClientDisconnect(client.connectTimeoutTicks);
+        coreDisconnectClient(client.connectTimeoutTicks);
     }
     if(client.disconnectTicks >= 1 &&
        ++client.disconnectTicks > client.disconnectTimeoutTicks) {
@@ -362,29 +359,29 @@ void coreClientTick(void) {
     }
 }
 
-void coreClientSetConnectHandler(CoreClientOnConnect oc) {
+void coreSetClientConnectHandler(CoreOnServerConnect oc) {
     client.onConnect = oc == nullptr ? voidVoidDummy : oc;
 }
 
-void coreClientSetDisconnectHandler(CoreClientOnDisconnect od) {
+void coreSetClientDisconnectHandler(CoreOnServerDisconnect od) {
     client.onDisconnect = od == nullptr ? voidVoidDummy : od;
 }
 
-void coreClientSetPacketHandler(CoreClientOnPacket op) {
+void coreSetClientPacketHandler(CoreOnServerPacket op) {
     client.onPacket = op == nullptr ? voidInPacketDummy : op;
 }
 
-void coreClientResetHandler(void) {
+void coreResetClientHandler(void) {
     client.onConnect = voidVoidDummy;
     client.onDisconnect = voidVoidDummy;
     client.onPacket = voidInPacketDummy;
 }
 
-bool coreClientIsConnecting(void) {
+bool coreIsClientConnecting(void) {
     return client.connectTicks >= 1;
 }
 
-bool coreClientIsConnected(void) {
+bool coreIsClientConnected(void) {
     return client.connectTicks < 0;
 }
 
@@ -398,15 +395,15 @@ typedef struct {
     ENetHost* server;
     CoreHashMap clients; // CoreClient -> ENetPeer*
     CoreClient idCounter;
-    CoreServerOnConnect onConnect;
-    CoreServerOnDisconnect onDisconnect;
-    CoreServerOnPacket onPacket;
+    CoreOnClientConnect onConnect;
+    CoreOnClientDisconnect onDisconnect;
+    CoreOnClientPacket onPacket;
 } Server;
 
 static Server server = {
     nullptr, {0}, 1, voidClientDummy, voidClientDummy, voidClientInPacketDummy};
 
-bool coreServerStart(CorePort port, size_t maxClients) {
+bool coreStartServer(CorePort port, size_t maxClients) {
     if(maxClients <= 0) {
         CORE_LOG_ERROR("Invalid max client amount");
         return true;
@@ -422,7 +419,7 @@ bool coreServerStart(CorePort port, size_t maxClients) {
     server.server =
         CORE_FAIL(enet_host_create(&address, maxClients, 3, 0, 0), nullptr);
     if(server.server == nullptr) {
-        coreServerStop();
+        coreStopServer();
         CORE_LOG_ERROR("Cannot create enet server host");
         return true;
     }
@@ -430,7 +427,7 @@ bool coreServerStart(CorePort port, size_t maxClients) {
     return false;
 }
 
-void coreServerStop(void) {
+void coreStopServer(void) {
     if(server.server != nullptr) {
         CoreHashMapIterator i;
         coreInitHashMapIterator(&i, &server.clients);
@@ -481,7 +478,7 @@ static void handleDisconnect(ENetEvent* e) {
     coreRemoveTypedHashMapKey(&server.clients, CoreClient, id);
 }
 
-void coreServerTick(void) {
+void coreTickServer(void) {
     if(server.server == nullptr) {
         return;
     }
@@ -506,15 +503,16 @@ static ENetPacket* fromBuffer(const CoreBuffer* buffer, enet_uint8 index) {
     return enet_packet_create(buffer->buffer, buffer->size, flags[index]);
 }
 
-void coreServerSendAll(const CoreOutPacket* p, CorePacketSendMode mode) {
+void coreSendServerPacketBroadcast(const CoreOutPacket* p,
+                                   CorePacketSendMode mode) {
     if(server.server != nullptr) {
         enet_uint8 index = (enet_uint8)mode;
         enet_host_broadcast(server.server, index, fromBuffer(&p->data, index));
     }
 }
 
-void coreServerSend(CoreClient clientId, const CoreOutPacket* p,
-                    CorePacketSendMode mode) {
+void coreSendServerPacket(CoreClient clientId, const CoreOutPacket* p,
+                          CorePacketSendMode mode) {
     if(server.server == nullptr) {
         return;
     }
@@ -536,7 +534,7 @@ void coreServerTimeout(CoreClient clientId, u32 timeout, u32 timeoutMin,
     }
 }
 
-void coreServerDisconnect(CoreClient clientId) {
+void coreDisconnectServerClient(CoreClient clientId) {
     if(server.server == nullptr) {
         return;
     }
@@ -546,19 +544,19 @@ void coreServerDisconnect(CoreClient clientId) {
     }
 }
 
-void coreServerSetConnectHandler(CoreServerOnConnect oc) {
+void coreSetServerConnectHandler(CoreOnClientConnect oc) {
     server.onConnect = oc == nullptr ? voidClientDummy : oc;
 }
 
-void coreServerSetDisconnectHandler(CoreServerOnDisconnect od) {
+void coreSetServerDisconnectHandler(CoreOnClientDisconnect od) {
     server.onDisconnect = od == nullptr ? voidClientDummy : od;
 }
 
-void coreServerSetPacketHandler(CoreServerOnPacket op) {
+void coreSetServerPacketHandler(CoreOnClientPacket op) {
     server.onPacket = op == nullptr ? voidClientInPacketDummy : op;
 }
 
-void coreServerResetHandler(void) {
+void coreResetServerHandler(void) {
     server.onConnect = voidClientDummy;
     server.onDisconnect = voidClientDummy;
     server.onPacket = voidClientInPacketDummy;

test/modules/NetworkTests.c

@@ -10,25 +10,25 @@
 #define TEST_READ(Type, type, value)                                           \
     {                                                                          \
         type u;                                                                \
-        CORE_TEST_FALSE(coreInPacketRead##Type(&in, &u));                      \
+        CORE_TEST_FALSE(coreReadInPacket##Type(&in, &u));                      \
         CORE_TEST_TRUE(u == value);                                            \
     }
 
 static void testWriteRead(void) {
     CoreOutPacket out;
     coreInitOutPacket(&out);
-    coreOutPacketWriteU8(&out, 200);
-    coreOutPacketWriteU16(&out, 6656);
-    coreOutPacketWriteU32(&out, 348923689);
-    coreOutPacketWriteI8(&out, 90);
-    coreOutPacketWriteI8(&out, -35);
-    coreOutPacketWriteI16(&out, 843);
-    coreOutPacketWriteI16(&out, -8961);
-    coreOutPacketWriteI32(&out, 100430199);
-    coreOutPacketWriteI32(&out, -534534);
-    coreOutPacketWriteFloat(&out, 64564.5346f);
+    coreWriteOutPacketU8(&out, 200);
+    coreWriteOutPacketU16(&out, 6656);
+    coreWriteOutPacketU32(&out, 348923689);
+    coreWriteOutPacketI8(&out, 90);
+    coreWriteOutPacketI8(&out, -35);
+    coreWriteOutPacketI16(&out, 843);
+    coreWriteOutPacketI16(&out, -8961);
+    coreWriteOutPacketI32(&out, 100430199);
+    coreWriteOutPacketI32(&out, -534534);
+    coreWriteOutPacketFloat(&out, 64564.5346f);
     const char s[] = "This is Great";
-    coreOutPacketWriteString(&out, s);
+    coreWriteOutPacketString(&out, s);
 
     CoreInPacket in;
     coreInitInPacket(&in, out.data.buffer, out.data.size);
@@ -42,22 +42,22 @@ static void testWriteRead(void) {
     TEST_READ(I32, i32, 100430199)
     TEST_READ(I32, i32, -534534)
     float f;
-    CORE_TEST_FALSE(coreInPacketReadFloat(&in, &f));
+    CORE_TEST_FALSE(coreReadInPacketFloat(&in, &f));
     CORE_TEST_FLOAT(64564.5346f, f, 0.00001f);
     char buffer[256];
-    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
+    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
     CORE_TEST_SIZE(14, n);
     CORE_TEST_STRING(s, buffer);
 
-    CORE_TEST_TRUE(coreInPacketReadU8(&in, &(u8){0}));
-    CORE_TEST_TRUE(coreInPacketReadU16(&in, &(u16){0}));
-    CORE_TEST_TRUE(coreInPacketReadU32(&in, &(u32){0}));
-    CORE_TEST_TRUE(coreInPacketReadI8(&in, &(i8){0}));
-    CORE_TEST_TRUE(coreInPacketReadI16(&in, &(i16){0}));
-    CORE_TEST_TRUE(coreInPacketReadI32(&in, &(i32){0}));
-    CORE_TEST_TRUE(coreInPacketReadFloat(&in, &(float){0}));
-    CORE_TEST_SIZE(0, coreInPacketReadString(&in, nullptr, 0));
-    CORE_TEST_SIZE(0, coreInPacketReadString(&in, buffer, sizeof(buffer)));
+    CORE_TEST_TRUE(coreReadInPacketU8(&in, &(u8){0}));
+    CORE_TEST_TRUE(coreReadInPacketU16(&in, &(u16){0}));
+    CORE_TEST_TRUE(coreReadInPacketU32(&in, &(u32){0}));
+    CORE_TEST_TRUE(coreReadInPacketI8(&in, &(i8){0}));
+    CORE_TEST_TRUE(coreReadInPacketI16(&in, &(i16){0}));
+    CORE_TEST_TRUE(coreReadInPacketI32(&in, &(i32){0}));
+    CORE_TEST_TRUE(coreReadInPacketFloat(&in, &(float){0}));
+    CORE_TEST_SIZE(0, coreReadInPacketString(&in, nullptr, 0));
+    CORE_TEST_SIZE(0, coreReadInPacketString(&in, buffer, sizeof(buffer)));
 
     coreDestroyOutPacket(&out);
 }
@@ -65,17 +65,17 @@ static void testWriteRead(void) {
 static void testTooShortBuffer(void) {
     CoreOutPacket out;
     coreInitOutPacket(&out);
-    coreOutPacketWriteString(&out, "This is Great");
-    coreOutPacketWriteString(&out, "Well hoho");
+    coreWriteOutPacketString(&out, "This is Great");
+    coreWriteOutPacketString(&out, "Well hoho");
 
     CoreInPacket in;
     coreInitInPacket(&in, out.data.buffer, out.data.size);
     char buffer[8];
-    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
+    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
     CORE_TEST_SIZE(14, n);
     CORE_TEST_STRING("This is", buffer);
     char buffer2[6];
-    size_t n2 = coreInPacketReadString(&in, buffer2, sizeof(buffer2));
+    size_t n2 = coreReadInPacketString(&in, buffer2, sizeof(buffer2));
     CORE_TEST_SIZE(10, n2);
     CORE_TEST_STRING("Well ", buffer2);
 
@@ -91,13 +91,13 @@ static void testBinaryData(void) {
     CoreOutPacket out;
     coreInitOutPacket(&out);
     PacketTest data = {56, 3};
-    coreOutPacketWrite(&out, &data, sizeof(data));
+    coreWriteOutPacket(&out, &data, sizeof(data));
 
     CoreInPacket in;
     coreInitInPacket(&in, out.data.buffer, out.data.size);
 
     PacketTest inData;
-    CORE_TEST_FALSE(coreInPacketRead(&in, &inData, sizeof(inData)));
+    CORE_TEST_FALSE(coreReadInPacket(&in, &inData, sizeof(inData)));
     CORE_TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);
 
     coreDestroyOutPacket(&out);
@@ -106,14 +106,14 @@ static void testBinaryData(void) {
 static void testShortString(void) {
     CoreOutPacket out;
     coreInitOutPacket(&out);
-    coreOutPacketWriteU16(&out, 200);
-    coreOutPacketWriteU16(&out, 65535);
+    coreWriteOutPacketU16(&out, 200);
+    coreWriteOutPacketU16(&out, 65535);
 
     CoreInPacket in;
     coreInitInPacket(&in, out.data.buffer, out.data.size);
 
     char buffer[256];
-    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
+    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
     CORE_TEST_SIZE(200, n);
     CORE_TEST_STRING("", buffer);
 
@@ -122,14 +122,14 @@ static void testShortString(void) {
 
 static void tickClient(int ticks) {
     for(int i = 0; i < ticks; i++) {
-        coreClientTick();
+        coreTickClient();
     }
 }
 
 static void tick(int ticks) {
     for(int i = 0; i < ticks; i++) {
-        coreClientTick();
-        coreServerTick();
+        coreTickClient();
+        coreTickServer();
     }
 }
 
@@ -160,26 +160,26 @@ static void onServerDisconnect(CoreClient) {
 }
 
 static void onServerPacket(CoreClient client, CoreInPacket* in) {
-    CORE_TEST_FALSE(coreInPacketReadU8(in, &data1));
-    CORE_TEST_FALSE(coreInPacketReadU16(in, &data2));
-    CORE_TEST_FALSE(coreInPacketReadU32(in, &data3));
-    CORE_TEST_FALSE(coreInPacketReadI8(in, &data4));
-    CORE_TEST_FALSE(coreInPacketReadI16(in, &data5));
-    CORE_TEST_FALSE(coreInPacketReadI32(in, &data6));
-    CORE_TEST_FALSE(coreInPacketReadI8(in, &data7));
-    CORE_TEST_FALSE(coreInPacketReadI16(in, &data8));
-    CORE_TEST_FALSE(coreInPacketReadI32(in, &data9));
-    CORE_TEST_SIZE(9, coreInPacketReadString(in, data10, sizeof(data10)));
-    CORE_TEST_FALSE(coreInPacketReadFloat(in, &data11));
+    CORE_TEST_FALSE(coreReadInPacketU8(in, &data1));
+    CORE_TEST_FALSE(coreReadInPacketU16(in, &data2));
+    CORE_TEST_FALSE(coreReadInPacketU32(in, &data3));
+    CORE_TEST_FALSE(coreReadInPacketI8(in, &data4));
+    CORE_TEST_FALSE(coreReadInPacketI16(in, &data5));
+    CORE_TEST_FALSE(coreReadInPacketI32(in, &data6));
+    CORE_TEST_FALSE(coreReadInPacketI8(in, &data7));
+    CORE_TEST_FALSE(coreReadInPacketI16(in, &data8));
+    CORE_TEST_FALSE(coreReadInPacketI32(in, &data9));
+    CORE_TEST_SIZE(9, coreReadInPacketString(in, data10, sizeof(data10)));
+    CORE_TEST_FALSE(coreReadInPacketFloat(in, &data11));
 
     CoreOutPacket out;
     coreInitOutPacket(&out);
     if(packageCounter == 0) {
-        coreServerSend(client, &out, CORE_RELIABLE);
+        coreSendServerPacket(client, &out, CORE_RELIABLE);
     } else if(packageCounter == 1) {
-        coreServerSend(client, &out, CORE_SEQUENCED);
+        coreSendServerPacket(client, &out, CORE_SEQUENCED);
     } else if(packageCounter == 2) {
-        coreServerSend(client, &out, CORE_UNSEQUENCED);
+        coreSendServerPacket(client, &out, CORE_UNSEQUENCED);
     }
     coreDestroyOutPacket(&out);
     packageCounter++;
@@ -215,45 +215,45 @@ static void testConnect(CorePacketSendMode mode) {
     *data10 = '\0';
     data11 = 0.0f;
 
-    coreServerResetHandler();
-    coreServerSetConnectHandler(onServerConnect);
-    coreServerSetDisconnectHandler(onServerDisconnect);
-    coreServerSetPacketHandler(onServerPacket);
+    coreResetServerHandler();
+    coreSetServerConnectHandler(onServerConnect);
+    coreSetServerDisconnectHandler(onServerDisconnect);
+    coreSetServerPacketHandler(onServerPacket);
 
-    coreClientResetHandler();
-    coreClientSetConnectHandler(onClientConnect);
-    coreClientSetDisconnectHandler(onClientDisconnect);
-    coreClientSetPacketHandler(onClientPacket);
+    coreResetClientHandler();
+    coreSetClientConnectHandler(onClientConnect);
+    coreSetClientDisconnectHandler(onClientDisconnect);
+    coreSetClientPacketHandler(onClientPacket);
 
-    if(!CORE_TEST_FALSE(coreServerStart(54321, 5))) {
+    if(!CORE_TEST_FALSE(coreStartServer(54321, 5))) {
         return;
-    } else if(!CORE_TEST_FALSE(coreClientStart())) {
+    } else if(!CORE_TEST_FALSE(coreStartClient())) {
         return;
-    } else if(!CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 90))) {
+    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
         return;
     }
-    CORE_TEST_FALSE(coreClientIsConnected());
-    CORE_TEST_TRUE(coreClientIsConnecting());
+    CORE_TEST_FALSE(coreIsClientConnected());
+    CORE_TEST_TRUE(coreIsClientConnecting());
     tick(100);
     CORE_TEST_TRUE(clientConnected);
-    CORE_TEST_TRUE(coreClientIsConnected());
-    CORE_TEST_FALSE(coreClientIsConnecting());
+    CORE_TEST_TRUE(coreIsClientConnected());
+    CORE_TEST_FALSE(coreIsClientConnecting());
 
     CoreOutPacket out;
     coreInitOutPacket(&out);
-    coreOutPacketWriteU8(&out, 0xF1);
-    coreOutPacketWriteU16(&out, 0xF123);
-    coreOutPacketWriteU32(&out, 0xF1234567);
-    coreOutPacketWriteI8(&out, -0x71);
-    coreOutPacketWriteI16(&out, -0x7123);
-    coreOutPacketWriteI32(&out, -0x71234567);
-    coreOutPacketWriteI8(&out, 0x71);
-    coreOutPacketWriteI16(&out, 0x7123);
-    coreOutPacketWriteI32(&out, 0x71234567);
+    coreWriteOutPacketU8(&out, 0xF1);
+    coreWriteOutPacketU16(&out, 0xF123);
+    coreWriteOutPacketU32(&out, 0xF1234567);
+    coreWriteOutPacketI8(&out, -0x71);
+    coreWriteOutPacketI16(&out, -0x7123);
+    coreWriteOutPacketI32(&out, -0x71234567);
+    coreWriteOutPacketI8(&out, 0x71);
+    coreWriteOutPacketI16(&out, 0x7123);
+    coreWriteOutPacketI32(&out, 0x71234567);
     const char s[] = "Hi there";
-    coreOutPacketWriteString(&out, s);
-    coreOutPacketWriteFloat(&out, 252345.983f);
-    coreClientSend(&out, mode);
+    coreWriteOutPacketString(&out, s);
+    coreWriteOutPacketFloat(&out, 252345.983f);
+    coreSendClientPacket(&out, mode);
     coreDestroyOutPacket(&out);
 
     tick(100);
@@ -273,15 +273,15 @@ static void testConnect(CorePacketSendMode mode) {
     CORE_TEST_STRING(s, data10);
     CORE_TEST_FLOAT(252345.983f, data11, 0.01f);
 
-    coreClientDisconnect(90);
-    CORE_TEST_FALSE(coreClientIsConnected());
-    CORE_TEST_FALSE(coreClientIsConnecting());
+    coreDisconnectClient(90);
+    CORE_TEST_FALSE(coreIsClientConnected());
+    CORE_TEST_FALSE(coreIsClientConnecting());
     tick(100);
     CORE_TEST_TRUE(clientDisconnected);
     CORE_TEST_TRUE(serverDisconnect);
 
-    coreClientStop();
-    coreServerStop();
+    coreStopClient();
+    coreStopServer();
 }
 
 static bool disconnected = false;
@@ -292,112 +292,112 @@ static void testStopDisconnect(void) {
 
 static void testDisconnect(void) {
     disconnected = false;
-    coreClientResetHandler();
-    coreClientSetDisconnectHandler(testStopDisconnect);
-    if(!CORE_TEST_FALSE(coreClientStart())) {
+    coreResetClientHandler();
+    coreSetClientDisconnectHandler(testStopDisconnect);
+    if(!CORE_TEST_FALSE(coreStartClient())) {
         return;
-    } else if(!CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 90))) {
+    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
         return;
     }
-    CORE_TEST_FALSE(coreClientIsConnected());
-    CORE_TEST_TRUE(coreClientIsConnecting());
-    coreClientDisconnect(50);
+    CORE_TEST_FALSE(coreIsClientConnected());
+    CORE_TEST_TRUE(coreIsClientConnecting());
+    coreDisconnectClient(50);
     tickClient(100);
-    CORE_TEST_FALSE(coreClientIsConnected());
-    CORE_TEST_FALSE(coreClientIsConnecting());
+    CORE_TEST_FALSE(coreIsClientConnected());
+    CORE_TEST_FALSE(coreIsClientConnecting());
     CORE_TEST_TRUE(disconnected);
-    coreClientStop();
+    coreStopClient();
 }
 
 static void testStop(void) {
     disconnected = false;
-    coreClientResetHandler();
-    coreClientSetDisconnectHandler(testStopDisconnect);
-    if(!CORE_TEST_FALSE(coreClientStart())) {
+    coreResetClientHandler();
+    coreSetClientDisconnectHandler(testStopDisconnect);
+    if(!CORE_TEST_FALSE(coreStartClient())) {
         return;
-    } else if(!CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 90))) {
+    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
         return;
     }
-    CORE_TEST_FALSE(coreClientIsConnected());
-    CORE_TEST_TRUE(coreClientIsConnecting());
-    coreClientStop();
-    CORE_TEST_FALSE(coreClientIsConnected());
-    CORE_TEST_FALSE(coreClientIsConnecting());
+    CORE_TEST_FALSE(coreIsClientConnected());
+    CORE_TEST_TRUE(coreIsClientConnecting());
+    coreStopClient();
+    CORE_TEST_FALSE(coreIsClientConnected());
+    CORE_TEST_FALSE(coreIsClientConnecting());
     CORE_TEST_TRUE(disconnected);
 }
 
 static void testClientStartFails(void) {
-    CORE_TEST_FALSE(coreClientStart());
+    CORE_TEST_FALSE(coreStartClient());
     logLevel = LOG_NONE;
-    CORE_TEST_TRUE(coreClientStart());
-    coreClientStop();
+    CORE_TEST_TRUE(coreStartClient());
+    coreStopClient();
 #ifdef ERROR_SIMULATOR
     coreFailCounter = 0;
-    CORE_TEST_TRUE(coreClientStart());
+    CORE_TEST_TRUE(coreStartClient());
     coreFailCounter = 1;
-    CORE_TEST_TRUE(coreClientStart());
+    CORE_TEST_TRUE(coreStartClient());
     coreFailCounter = -1;
 #endif
     logLevel = LOG_DEBUG;
 }
 
 static void testClientConnectionFails(void) {
-    coreClientResetHandler();
+    coreResetClientHandler();
     logLevel = LOG_NONE;
-    CORE_TEST_TRUE(coreClientConnect("", 54321, 100));
-    CORE_TEST_FALSE(coreClientStart());
+    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
+    CORE_TEST_FALSE(coreStartClient());
 #ifdef ERROR_SIMULATOR
     coreFailCounter = 0;
-    CORE_TEST_TRUE(coreClientConnect("", 54321, 100));
+    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
     coreFailCounter = -1;
 #endif
-    CORE_TEST_FALSE(coreClientConnect("", 54321, 100));
-    CORE_TEST_TRUE(coreClientConnect("", 54321, 100));
+    CORE_TEST_FALSE(coreConnectClient("", 54321, 100));
+    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
     logLevel = LOG_DEBUG;
     tickClient(100);
-    coreClientStop();
+    coreStopClient();
 }
 
 static void testInvalidClientAccess(void) {
-    coreClientDisconnect(0);
-    coreClientSend(nullptr, 0);
-    coreClientTick();
+    coreDisconnectClient(0);
+    coreSendClientPacket(nullptr, 0);
+    coreTickClient();
 }
 
 static void testServerStartFails(void) {
     logLevel = LOG_NONE;
-    CORE_TEST_TRUE(coreServerStart(54321, 0));
+    CORE_TEST_TRUE(coreStartServer(54321, 0));
 #ifdef ERROR_SIMULATOR
     coreFailCounter = 0;
-    CORE_TEST_TRUE(coreServerStart(54321, 5));
+    CORE_TEST_TRUE(coreStartServer(54321, 5));
     coreFailCounter = 1;
-    CORE_TEST_TRUE(coreServerStart(54321, 5));
+    CORE_TEST_TRUE(coreStartServer(54321, 5));
     coreFailCounter = -1;
 #endif
-    CORE_TEST_FALSE(coreServerStart(54321, 5));
-    CORE_TEST_TRUE(coreServerStart(54321, 5));
+    CORE_TEST_FALSE(coreStartServer(54321, 5));
+    CORE_TEST_TRUE(coreStartServer(54321, 5));
     logLevel = LOG_DEBUG;
-    coreServerStop();
+    coreStopServer();
 }
 
 static void testServerClosesOnConnected(void) {
     clientDisconnected = false;
-    CORE_TEST_FALSE(coreServerStart(54321, 5));
-    CORE_TEST_FALSE(coreClientStart());
-    coreClientSetDisconnectHandler(onClientDisconnect);
-    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
+    CORE_TEST_FALSE(coreStartServer(54321, 5));
+    CORE_TEST_FALSE(coreStartClient());
+    coreSetClientDisconnectHandler(onClientDisconnect);
+    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreClientIsConnected());
-    coreServerStop();
+    CORE_TEST_TRUE(coreIsClientConnected());
+    coreStopServer();
 
-    coreClientTimeout(500, 500, 500);
-    for(int i = 0; i < 500 && coreClientIsConnected(); i++) {
-        coreClientTick();
+    coreSetClientTimeout(500, 500, 500);
+    for(int i = 0; i < 500 && coreIsClientConnected(); i++) {
+        coreTickClient();
         coreSleepNanos(10000000);
     }
-    CORE_TEST_FALSE(coreClientIsConnected());
+    CORE_TEST_FALSE(coreIsClientConnected());
     CORE_TEST_TRUE(clientDisconnected);
-    coreClientStop();
+    coreStopClient();
 }
 
 static CoreClient clientId = 0;
@@ -408,25 +408,25 @@ static void onConnectSetClient(CoreClient client) {
 
 static void testServerDisconnectsClient(void) {
     clientDisconnected = false;
-    CORE_TEST_FALSE(coreServerStart(54321, 5));
-    CORE_TEST_FALSE(coreClientStart());
-    coreClientSetDisconnectHandler(onClientDisconnect);
-    coreServerSetConnectHandler(onConnectSetClient);
-    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
+    CORE_TEST_FALSE(coreStartServer(54321, 5));
+    CORE_TEST_FALSE(coreStartClient());
+    coreSetClientDisconnectHandler(onClientDisconnect);
+    coreSetServerConnectHandler(onConnectSetClient);
+    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreClientIsConnected());
+    CORE_TEST_TRUE(coreIsClientConnected());
 
-    coreServerDisconnect(clientId);
+    coreDisconnectServerClient(clientId);
 
-    for(int i = 0; i < 500 && coreClientIsConnected(); i++) {
-        coreClientTick();
-        coreServerTick();
+    for(int i = 0; i < 500 && coreIsClientConnected(); i++) {
+        coreTickClient();
+        coreTickServer();
         coreSleepNanos(10000000);
     }
-    CORE_TEST_FALSE(coreClientIsConnected());
+    CORE_TEST_FALSE(coreIsClientConnected());
     CORE_TEST_TRUE(clientDisconnected);
-    coreClientStop();
-    coreServerStop();
+    coreStopClient();
+    coreStopServer();
 }
 
 static void onConnectSetTimeout(CoreClient client) {
@@ -435,51 +435,51 @@ static void onConnectSetTimeout(CoreClient client) {
 
 static void testClientClosesOnConnected(void) {
     serverDisconnect = false;
-    CORE_TEST_FALSE(coreServerStart(54321, 5));
-    CORE_TEST_FALSE(coreClientStart());
-    coreServerSetDisconnectHandler(onServerDisconnect);
-    coreServerSetConnectHandler(onConnectSetTimeout);
-    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
+    CORE_TEST_FALSE(coreStartServer(54321, 5));
+    CORE_TEST_FALSE(coreStartClient());
+    coreSetServerDisconnectHandler(onServerDisconnect);
+    coreSetServerConnectHandler(onConnectSetTimeout);
+    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreClientIsConnected());
+    CORE_TEST_TRUE(coreIsClientConnected());
 #ifdef ERROR_SIMULATOR
     coreFailCounter = 0;
 #endif
-    coreClientStop();
+    coreStopClient();
 #ifdef ERROR_SIMULATOR
     coreFailCounter = -1;
 #endif
     for(int i = 0; i < 500 && !serverDisconnect; i++) {
-        coreServerTick();
+        coreTickServer();
         coreSleepNanos(10000000);
     }
     CORE_TEST_TRUE(serverDisconnect);
-    coreServerStop();
+    coreStopServer();
 }
 
 static void testInvalidServerAccess(void) {
-    coreServerTick();
-    coreServerSend(0, nullptr, 0);
+    coreTickServer();
+    coreSendServerPacket(0, nullptr, 0);
     coreServerTimeout(0, 500, 500, 500);
-    coreServerDisconnect(0);
+    coreDisconnectServerClient(0);
 }
 
 static void testDummyCallbacks(void) {
-    coreClientResetHandler();
-    coreServerResetHandler();
-    CORE_TEST_FALSE(coreServerStart(54321, 5));
-    CORE_TEST_FALSE(coreClientStart());
-    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
+    coreResetClientHandler();
+    coreResetServerHandler();
+    CORE_TEST_FALSE(coreStartServer(54321, 5));
+    CORE_TEST_FALSE(coreStartClient());
+    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreClientIsConnected());
+    CORE_TEST_TRUE(coreIsClientConnected());
     CoreOutPacket out;
     coreInitOutPacket(&out);
-    coreServerSendAll(&out, CORE_RELIABLE);
-    coreClientSend(&out, CORE_RELIABLE);
+    coreSendServerPacketBroadcast(&out, CORE_RELIABLE);
+    coreSendClientPacket(&out, CORE_RELIABLE);
     tick(100);
     coreDestroyOutPacket(&out);
-    coreClientStop();
-    coreServerStop();
+    coreStopClient();
+    coreStopServer();
 }
 
 void coreTestNetwork(void) {