Import for Network

include/core/Network.h

@@ -5,9 +5,9 @@
 #include "core/Types.h"
 
 typedef enum {
-    CORE_RELIABLE,
-    CORE_SEQUENCED,
-    CORE_UNSEQUENCED
+    CORE_PACKET_RELIABLE,
+    CORE_PACKET_SEQUENCED,
+    CORE_PACKET_UNSEQUENCED
 } CorePacketSendMode;
 
 typedef struct {
@@ -74,12 +74,74 @@ 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 coreSetServerTimeout(CoreClient client, u32 timeout, u32 timeoutMin,
+                          u32 timeoutMax);
 void coreDisconnectServerClient(CoreClient client);
 void coreSetServerConnectHandler(CoreOnClientConnect oc);
 void coreSetServerDisconnectHandler(CoreOnClientDisconnect od);
 void coreSetServerPacketHandler(CoreOnClientPacket op);
 void coreResetServerHandler(void);
 
+#ifdef IMPORT_CORE
+#define PacketSendMode CorePacketSendMode
+#define PACKET_RELIABLE CORE_PACKET_RELIABLE
+#define PACKET_SEQUENCED CORE_PACKET_SEQUENCED
+#define PACKET_UNSEQUENCED CORE_PACKET_UNSEQUENCED
+#define InPacket CoreInPacket
+#define initInPacket coreInitInPacket
+#define readInPacketU8 coreReadInPacketU8
+#define readInPacketU16 coreReadInPacketU16
+#define readInPacketU32 coreReadInPacketU32
+#define readInPacketI8 coreReadInPacketI8
+#define readInPacketI16 coreReadInPacketI16
+#define readInPacketI32 coreReadInPacketI32
+#define readInPacketFloat coreReadInPacketFloat
+#define readInPacketString coreReadInPacketString
+#define readInPacket coreReadInPacket
+#define OutPacket CoreOutPacket
+#define initOutPacket coreInitOutPacket
+#define destroyOutPacket coreDestroyOutPacket
+#define writeOutPacketU8 coreWriteOutPacketU8
+#define writeOutPacketU16 coreWriteOutPacketU16
+#define writeOutPacketU32 coreWriteOutPacketU32
+#define writeOutPacketI8 coreWriteOutPacketI8
+#define writeOutPacketI16 coreWriteOutPacketI16
+#define writeOutPacketI32 coreWriteOutPacketI32
+#define writeOutPacketFloat coreWriteOutPacketFloat
+#define writeOutPacketString coreWriteOutPacketString
+#define writeOutPacket coreWriteOutPacket
+#define Port CorePort
+#define OnServerConnect CoreOnServerConnect
+#define OnServerDisconnect CoreOnServerDisconnect
+#define OnServerPacket CoreOnServerPacket
+#define startClient coreStartClient
+#define stopClient coreStopClient
+#define connectClient coreConnectClient
+#define setClientTimeout coreSetClientTimeout
+#define disconnectClient coreDisconnectClient
+#define sendClientPacket coreSendClientPacket
+#define tickClient coreTickClient
+#define setClientConnectHandler coreSetClientConnectHandler
+#define setClientDisconnectHandler coreSetClientDisconnectHandler
+#define setClientPacketHandler coreSetClientPacketHandler
+#define resetClientHandler coreResetClientHandler
+#define isClientConnecting coreIsClientConnecting
+#define isClientConnected coreIsClientConnected
+#define Client CoreClient
+#define OnClientConnect CoreOnClientConnect
+#define OnClientDisconnect CoreOnClientDisconnect
+#define OnClientPacket CoreOnClientPacket
+#define startServer coreStartServer
+#define stopServer coreStopServer
+#define tickServer coreTickServer
+#define sendServerPacketBroadcast coreSendServerPacketBroadcast
+#define sendServerPacket coreSendServerPacket
+#define setServerTimeout coreSetServerTimeout
+#define disconnectServerClient coreDisconnectServerClient
+#define setServerConnectHandler coreSetServerConnectHandler
+#define setServerDisconnectHandler coreSetServerDisconnectHandler
+#define setServerPacketHandler coreSetServerPacketHandler
+#define resetServerHandler coreResetServerHandler
+#endif
+
 #endif

src/ErrorSimulator.c

@@ -2,13 +2,13 @@
 
 #include "ErrorSimulator.h"
 
-int coreFailCounter = -1;
+int failCounter = -1;
 
-bool coreFail(void) {
-    if(coreFailCounter < 0) {
+bool checkFail(void) {
+    if(failCounter < 0) {
         return false;
     }
-    return coreFailCounter == 0 ? true : coreFailCounter-- == 0;
+    return failCounter == 0 ? true : failCounter-- == 0;
 }
 
 #endif

src/ErrorSimulator.h

@@ -2,11 +2,11 @@
 #define CORE_ERROR_SIMULATOR_H
 
 #ifdef ERROR_SIMULATOR
-extern int coreFailCounter;
-bool coreFail(void);
-#define CORE_FAIL(x, e) (coreFail() ? e : (x))
+extern int failCounter;
+bool checkFail(void);
+#define FAIL(x, e) (checkFail() ? e : (x))
 #else
-#define CORE_FAIL(x, e) x
+#define FAIL(x, e) x
 #endif
 
 #endif

src/Network.c

@@ -1,3 +1,4 @@
+#define IMPORT_CORE
 #include "core/Network.h"
 
 #define ENET_IMPLEMENTATION
@@ -10,55 +11,53 @@
 
 #include "ErrorSimulator.h"
 
-typedef CoreOutPacket OutPacket;
-
-void coreInitInPacket(CoreInPacket* in, const void* data, size_t n) {
+void initInPacket(InPacket* in, const void* data, size_t n) {
     in->data = data;
     in->size = n;
     in->index = 0;
 }
 
-bool coreReadInPacketU8(CoreInPacket* in, u8* u) {
-    return coreReadInPacket(in, u, sizeof(*u));
+bool readInPacketU8(InPacket* in, u8* u) {
+    return readInPacket(in, u, sizeof(*u));
 }
 
-bool coreReadInPacketU16(CoreInPacket* in, u16* u) {
-    if(coreReadInPacket(in, u, sizeof(*u))) {
+bool readInPacketU16(InPacket* in, u16* u) {
+    if(readInPacket(in, u, sizeof(*u))) {
         return true;
     }
     *u = ntohs(*u);
     return false;
 }
 
-bool coreReadInPacketU32(CoreInPacket* in, u32* u) {
-    if(coreReadInPacket(in, u, sizeof(*u))) {
+bool readInPacketU32(InPacket* in, u32* u) {
+    if(readInPacket(in, u, sizeof(*u))) {
         return true;
     }
     *u = ntohl(*u);
     return false;
 }
 
-bool coreReadInPacketI8(CoreInPacket* in, i8* i) {
+bool readInPacketI8(InPacket* in, i8* i) {
     u8 u;
-    if(coreReadInPacketU8(in, &u)) {
+    if(readInPacketU8(in, &u)) {
         return true;
     }
     *i = (i8)((i32)u - (i32)128);
     return false;
 }
 
-bool coreReadInPacketI16(CoreInPacket* in, i16* i) {
+bool readInPacketI16(InPacket* in, i16* i) {
     u16 u;
-    if(coreReadInPacketU16(in, &u)) {
+    if(readInPacketU16(in, &u)) {
         return true;
     }
     *i = (i16)((i32)u - (i32)32768);
     return false;
 }
 
-bool coreReadInPacketI32(CoreInPacket* in, i32* i) {
+bool readInPacketI32(InPacket* in, i32* i) {
     u32 u;
-    if(coreReadInPacketU32(in, &u)) {
+    if(readInPacketU32(in, &u)) {
         return true;
     }
     if(u < 2147483648) {
@@ -69,22 +68,22 @@ bool coreReadInPacketI32(CoreInPacket* in, i32* i) {
     return false;
 }
 
-bool coreReadInPacketFloat(CoreInPacket* in, float* f) {
+bool readInPacketFloat(InPacket* in, float* f) {
     u32 u;
     static_assert(sizeof(u) == sizeof(*f), "float and u32 size do not match");
-    if(coreReadInPacketU32(in, &u)) {
+    if(readInPacketU32(in, &u)) {
         return true;
     }
     memcpy(f, &u, sizeof(float));
     return false;
 }
 
-size_t coreReadInPacketString(CoreInPacket* in, char* buffer, size_t n) {
+size_t readInPacketString(InPacket* in, char* buffer, size_t n) {
     if(n == 0) {
         return 0;
     }
     u16 size;
-    if(coreReadInPacketU16(in, &size)) {
+    if(readInPacketU16(in, &size)) {
         return 0;
     }
     size_t end = size;
@@ -93,18 +92,18 @@ size_t coreReadInPacketString(CoreInPacket* in, char* buffer, size_t n) {
     while(n-- > 0 && end > 0) {
         end--;
         u8 u;
-        if(coreReadInPacketU8(in, &u)) {
+        if(readInPacketU8(in, &u)) {
             *bufferStart = '\0';
             break;
         }
         *(buffer++) = (char)u;
     }
-    while(end-- > 0 && !coreReadInPacketU8(in, &(u8){0})) {}
+    while(end-- > 0 && !readInPacketU8(in, &(u8){0})) {}
     *buffer = '\0';
     return size;
 }
 
-bool coreReadInPacket(CoreInPacket* in, void* buffer, size_t n) {
+bool readInPacket(InPacket* in, void* buffer, size_t n) {
     if(in->index + n > in->size) {
         return true;
     }
@@ -113,83 +112,83 @@ bool coreReadInPacket(CoreInPacket* in, void* buffer, size_t n) {
     return false;
 }
 
-void coreInitOutPacket(OutPacket* out) {
-    coreInitBuffer(&out->data);
+void initOutPacket(OutPacket* out) {
+    initBuffer(&out->data);
 }
 
-void coreDestroyOutPacket(OutPacket* out) {
-    coreDestroyBuffer(&out->data);
+void destroyOutPacket(OutPacket* out) {
+    destroyBuffer(&out->data);
 }
 
-void coreWriteOutPacketU8(OutPacket* out, u8 u) {
-    coreAddSizedBufferData(&out->data, &u, sizeof(u));
+void writeOutPacketU8(OutPacket* out, u8 u) {
+    addSizedBufferData(&out->data, &u, sizeof(u));
 }
 
-void coreWriteOutPacketU16(OutPacket* out, u16 u) {
+void writeOutPacketU16(OutPacket* out, u16 u) {
     u = htons(u);
-    coreAddSizedBufferData(&out->data, &u, sizeof(u));
+    addSizedBufferData(&out->data, &u, sizeof(u));
 }
 
-void coreWriteOutPacketU32(OutPacket* out, u32 u) {
+void writeOutPacketU32(OutPacket* out, u32 u) {
     u = htonl(u);
-    coreAddSizedBufferData(&out->data, &u, sizeof(u));
+    addSizedBufferData(&out->data, &u, sizeof(u));
 }
 
-void coreWriteOutPacketI8(OutPacket* out, i8 i) {
+void writeOutPacketI8(OutPacket* out, i8 i) {
     if(i < 0) {
-        coreWriteOutPacketU8(out, (u8)((i32)i + (i32)128));
+        writeOutPacketU8(out, (u8)((i32)i + (i32)128));
     } else {
-        coreWriteOutPacketU8(out, (u8)((u32)i + (u32)128));
+        writeOutPacketU8(out, (u8)((u32)i + (u32)128));
     }
 }
 
-void coreWriteOutPacketI16(OutPacket* out, i16 i) {
+void writeOutPacketI16(OutPacket* out, i16 i) {
     if(i < 0) {
-        coreWriteOutPacketU16(out, (u16)((i32)i + (i32)32768));
+        writeOutPacketU16(out, (u16)((i32)i + (i32)32768));
     } else {
-        coreWriteOutPacketU16(out, (u16)((u32)i + (u32)32768));
+        writeOutPacketU16(out, (u16)((u32)i + (u32)32768));
     }
 }
 
-void coreWriteOutPacketI32(OutPacket* out, i32 i) {
+void writeOutPacketI32(OutPacket* out, i32 i) {
     if(i < 0) {
-        coreWriteOutPacketU32(out, (u32)((i + (i32)2147483647) + (i32)1));
+        writeOutPacketU32(out, (u32)((i + (i32)2147483647) + (i32)1));
     } else {
-        coreWriteOutPacketU32(out, (u32)((u32)i + (u32)2147483648));
+        writeOutPacketU32(out, (u32)((u32)i + (u32)2147483648));
     }
 }
 
-void coreWriteOutPacketFloat(OutPacket* out, float f) {
+void writeOutPacketFloat(OutPacket* out, float f) {
     u32 u;
     static_assert(sizeof(u) == sizeof(f), "float and u32 size do not match");
     memcpy(&u, &f, sizeof(float));
-    coreWriteOutPacketU32(out, u);
+    writeOutPacketU32(out, u);
 }
 
-void coreWriteOutPacketString(OutPacket* out, const char* s) {
+void writeOutPacketString(OutPacket* out, const char* s) {
     size_t marker = out->data.size;
-    coreWriteOutPacketU16(out, 0);
+    writeOutPacketU16(out, 0);
     size_t end = 0;
     while(end < 65534 && *s != '\0') {
-        coreWriteOutPacketU8(out, (u8)(*(s++)));
+        writeOutPacketU8(out, (u8)(*(s++)));
         end++;
     }
-    coreWriteOutPacketU8(out, 0);
+    writeOutPacketU8(out, 0);
     end++;
     size_t endMarker = out->data.size;
     out->data.size = marker;
-    coreWriteOutPacketU16(out, (u16)end);
+    writeOutPacketU16(out, (u16)end);
     out->data.size = endMarker;
 }
 
-void coreWriteOutPacket(OutPacket* out, const void* buffer, size_t n) {
-    coreAddSizedBufferData(&out->data, buffer, n);
+void writeOutPacket(OutPacket* out, const void* buffer, size_t n) {
+    addSizedBufferData(&out->data, buffer, n);
 }
 
 static int enetCounter = 0;
 
 static bool addENet(void) {
-    if(enetCounter == 0 && CORE_FAIL(enet_initialize() != 0, true)) {
+    if(enetCounter == 0 && FAIL(enet_initialize() != 0, true)) {
         return true;
     }
     enetCounter++;
@@ -202,52 +201,52 @@ static void removeENet(void) {
     }
 }
 
-static_assert(sizeof(enet_uint16) == sizeof(CorePort), "port has wrong type");
+static_assert(sizeof(enet_uint16) == sizeof(Port), "port has wrong type");
 
 static void voidVoidDummy(void) {
 }
 
-static void voidInPacketDummy(CoreInPacket*) {
+static void voidInPacketDummy(InPacket*) {
 }
 
 typedef struct {
     ENetHost* client;
     ENetPeer* connection;
-    CoreOnServerConnect onConnect;
-    CoreOnServerDisconnect onDisconnect;
-    CoreOnServerPacket onPacket;
+    OnServerConnect onConnect;
+    OnServerDisconnect onDisconnect;
+    OnServerPacket onPacket;
     int connectTicks;
     int connectTimeoutTicks;
     int disconnectTicks;
     int disconnectTimeoutTicks;
-} Client;
+} ClientData;
 
-static Client client = {
+static ClientData client = {
     nullptr, nullptr, voidVoidDummy, voidVoidDummy, voidInPacketDummy, 0, 0,
     0,       0};
 
-bool coreStartClient(void) {
+bool startClient(void) {
     if(client.client != nullptr) {
-        CORE_LOG_WARNING("Client already started");
+        LOG_WARNING("Client already started");
         return true;
     } else if(addENet()) {
-        CORE_LOG_ERROR("Client cannot initialize enet");
+        LOG_ERROR("Client cannot initialize enet");
         return true;
     }
-    client.client = CORE_FAIL(enet_host_create(nullptr, 1, 2, 0, 0), nullptr);
+    client.client = FAIL(enet_host_create(nullptr, 1, 2, 0, 0), nullptr);
     if(client.client == nullptr) {
-        coreStopClient();
-        CORE_LOG_ERROR("Cannot create enet client host");
+        stopClient();
+        LOG_ERROR("Cannot create enet client host");
         return true;
     }
     return false;
 }
 
-void coreStopClient(void) {
+void stopClient(void) {
     if(client.connection != nullptr) {
         client.onDisconnect();
-        CORE_FAIL(enet_peer_disconnect_now(client.connection, 0),
-                  enet_peer_reset(client.connection));
+        FAIL(enet_peer_disconnect_now(client.connection, 0),
+             enet_peer_reset(client.connection));
         client.connection = nullptr;
     }
     if(client.client != nullptr) {
@@ -259,12 +258,12 @@ void coreStopClient(void) {
     client.disconnectTicks = 0;
 }
 
-bool coreConnectClient(const char* server, CorePort port, int timeoutTicks) {
+bool connectClient(const char* server, Port port, int timeoutTicks) {
     if(client.client == nullptr) {
-        CORE_LOG_WARNING("Client not started");
+        LOG_WARNING("Client not started");
         return true;
     } else if(client.connection != nullptr) {
-        CORE_LOG_WARNING("Connection already exists");
+        LOG_WARNING("Connection already exists");
         return true;
     }
 
@@ -273,9 +272,9 @@ bool coreConnectClient(const char* server, CorePort port, int timeoutTicks) {
     address.port = port;
 
     client.connection =
-        CORE_FAIL(enet_host_connect(client.client, &address, 3, 0), nullptr);
+        FAIL(enet_host_connect(client.client, &address, 3, 0), nullptr);
     if(client.connection == nullptr) {
-        CORE_LOG_ERROR("Cannot create connection");
+        LOG_ERROR("Cannot create connection");
         return true;
     }
     client.connectTicks = 1;
@@ -283,13 +282,13 @@ bool coreConnectClient(const char* server, CorePort port, int timeoutTicks) {
     return false;
 }
 
-void coreSetClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax) {
+void setClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax) {
     if(client.connection != nullptr) {
         enet_peer_timeout(client.connection, timeout, timeoutMin, timeoutMax);
     }
 }
 
-void coreDisconnectClient(int timeoutTicks) {
+void disconnectClient(int timeoutTicks) {
     if(client.connection == nullptr) {
         return;
     }
@@ -299,7 +298,7 @@ void coreDisconnectClient(int timeoutTicks) {
     client.disconnectTimeoutTicks = timeoutTicks;
 }
 
-void coreSendClientPacket(const OutPacket* p, CorePacketSendMode mode) {
+void sendClientPacket(const OutPacket* p, PacketSendMode mode) {
     if(client.client == nullptr || client.connection == nullptr ||
        client.connectTicks >= 0) {
         return;
@@ -327,8 +326,8 @@ static void tickClientEvents(void) {
                 client.connection = nullptr;
                 break;
             case ENET_EVENT_TYPE_RECEIVE: {
-                CoreInPacket in;
-                coreInitInPacket(&in, e.packet->data, e.packet->dataLength);
+                InPacket in;
+                initInPacket(&in, e.packet->data, e.packet->dataLength);
                 client.onPacket(&in);
                 enet_packet_destroy(e.packet);
                 break;
@@ -338,7 +337,7 @@ static void tickClientEvents(void) {
     }
 }
 
-void coreTickClient(void) {
+void tickClient(void) {
     if(client.client == nullptr) {
         return;
     }
@@ -346,7 +345,7 @@ void coreTickClient(void) {
     if(client.connectTicks >= 1 &&
        ++client.connectTicks > client.connectTimeoutTicks) {
         client.connectTicks = 0;
-        coreDisconnectClient(client.connectTimeoutTicks);
+        disconnectClient(client.connectTimeoutTicks);
     }
     if(client.disconnectTicks >= 1 &&
        ++client.disconnectTicks > client.disconnectTimeoutTicks) {
@@ -359,126 +358,125 @@ void coreTickClient(void) {
     }
 }
 
-void coreSetClientConnectHandler(CoreOnServerConnect oc) {
+void setClientConnectHandler(OnServerConnect oc) {
     client.onConnect = oc == nullptr ? voidVoidDummy : oc;
 }
 
-void coreSetClientDisconnectHandler(CoreOnServerDisconnect od) {
+void setClientDisconnectHandler(OnServerDisconnect od) {
     client.onDisconnect = od == nullptr ? voidVoidDummy : od;
 }
 
-void coreSetClientPacketHandler(CoreOnServerPacket op) {
+void setClientPacketHandler(OnServerPacket op) {
     client.onPacket = op == nullptr ? voidInPacketDummy : op;
 }
 
-void coreResetClientHandler(void) {
+void resetClientHandler(void) {
     client.onConnect = voidVoidDummy;
     client.onDisconnect = voidVoidDummy;
     client.onPacket = voidInPacketDummy;
 }
 
-bool coreIsClientConnecting(void) {
+bool isClientConnecting(void) {
     return client.connectTicks >= 1;
 }
 
-bool coreIsClientConnected(void) {
+bool isClientConnected(void) {
     return client.connectTicks < 0;
 }
 
-static void voidClientDummy(CoreClient) {
+static void voidClientDummy(Client) {
 }
 
-static void voidClientInPacketDummy(CoreClient, CoreInPacket*) {
+static void voidClientInPacketDummy(Client, InPacket*) {
 }
 
 typedef struct {
     ENetHost* server;
-    CoreHashMap clients; // CoreClient -> ENetPeer*
-    CoreClient idCounter;
-    CoreOnClientConnect onConnect;
-    CoreOnClientDisconnect onDisconnect;
-    CoreOnClientPacket onPacket;
-} Server;
-
-static Server server = {
+    HashMap clients; // Client -> ENetPeer*
+    Client idCounter;
+    OnClientConnect onConnect;
+    OnClientDisconnect onDisconnect;
+    OnClientPacket onPacket;
+} ServerData;
+
+static ServerData server = {
     nullptr, {0}, 1, voidClientDummy, voidClientDummy, voidClientInPacketDummy};
 
-bool coreStartServer(CorePort port, size_t maxClients) {
+bool startServer(Port port, size_t maxClients) {
     if(maxClients <= 0) {
-        CORE_LOG_ERROR("Invalid max client amount");
+        LOG_ERROR("Invalid max client amount");
         return true;
     } else if(server.server != nullptr) {
-        CORE_LOG_WARNING("Server already started");
+        LOG_WARNING("Server already started");
         return true;
     } else if(addENet()) {
-        CORE_LOG_ERROR("Server cannot initialize enet");
+        LOG_ERROR("Server cannot initialize enet");
         return true;
     }
 
     ENetAddress address = {.host = ENET_HOST_ANY, .port = port};
     server.server =
-        CORE_FAIL(enet_host_create(&address, maxClients, 3, 0, 0), nullptr);
+        FAIL(enet_host_create(&address, maxClients, 3, 0, 0), nullptr);
     if(server.server == nullptr) {
-        coreStopServer();
-        CORE_LOG_ERROR("Cannot create enet server host");
+        stopServer();
+        LOG_ERROR("Cannot create enet server host");
         return true;
     }
-    coreInitHashMap(&server.clients, sizeof(CoreClient), sizeof(ENetPeer*));
+    initHashMap(&server.clients, sizeof(Client), sizeof(ENetPeer*));
     return false;
 }
 
-void coreStopServer(void) {
+void stopServer(void) {
     if(server.server != nullptr) {
-        CoreHashMapIterator i;
-        coreInitHashMapIterator(&i, &server.clients);
-        while(coreHasNextHashMapNode(&i)) {
-            CoreHashMapNode* n = coreNextHashMapNode(&i);
+        HashMapIterator i;
+        initHashMapIterator(&i, &server.clients);
+        while(hasNextHashMapNode(&i)) {
+            HashMapNode* n = nextHashMapNode(&i);
             enet_peer_reset(*(ENetPeer**)n->value);
         }
         enet_host_destroy(server.server);
         server.server = nullptr;
-        coreDestroyHashMap(&server.clients);
+        destroyHashMap(&server.clients);
     }
     removeENet();
 }
 
-static void writeId(ENetPeer* peer, CoreClient id) {
+static void writeId(ENetPeer* peer, Client id) {
     static_assert(sizeof(peer->data) >= sizeof(id),
                   "private data not big enough for id");
     memcpy(&(peer->data), &id, sizeof(id));
 }
 
-static CoreClient getId(ENetPeer* peer) {
+static Client getId(ENetPeer* peer) {
     assert(peer->data != nullptr);
-    CoreClient id = -1;
+    Client id = -1;
     memcpy(&id, &(peer->data), sizeof(id));
     return id;
 }
 
 static void handleConnect(ENetEvent* e) {
-    CoreClient id = server.idCounter++;
-    assert(coreSearchTypedHashMapKey(&server.clients, CoreClient, id, void*) ==
+    Client id = server.idCounter++;
+    assert(searchTypedHashMapKey(&server.clients, Client, id, void*) ==
            nullptr);
-    corePutTypedHashMapPair(&server.clients, CoreClient, id, ENetPeer*,
-                            e->peer);
+    putTypedHashMapPair(&server.clients, Client, id, ENetPeer*, e->peer);
     writeId(e->peer, id);
     server.onConnect(id);
 }
 
 static void handlePacket(ENetEvent* e) {
-    CoreClient id = getId(e->peer);
-    CoreInPacket in;
-    coreInitInPacket(&in, e->packet->data, e->packet->dataLength);
+    Client id = getId(e->peer);
+    InPacket in;
+    initInPacket(&in, e->packet->data, e->packet->dataLength);
     server.onPacket(id, &in);
 }
 
 static void handleDisconnect(ENetEvent* e) {
-    CoreClient id = getId(e->peer);
+    Client id = getId(e->peer);
     server.onDisconnect(id);
-    coreRemoveTypedHashMapKey(&server.clients, CoreClient, id);
+    removeTypedHashMapKey(&server.clients, Client, id);
 }
 
-void coreTickServer(void) {
+void tickServer(void) {
     if(server.server == nullptr) {
         return;
     }
@@ -497,66 +495,65 @@ void coreTickServer(void) {
     }
 }
 
-static ENetPacket* fromBuffer(const CoreBuffer* buffer, enet_uint8 index) {
+static ENetPacket* fromBuffer(const Buffer* buffer, enet_uint8 index) {
     static const enet_uint32 flags[] = {ENET_PACKET_FLAG_RELIABLE, 0,
                                         ENET_PACKET_FLAG_UNSEQUENCED};
     return enet_packet_create(buffer->buffer, buffer->size, flags[index]);
 }
 
-void coreSendServerPacketBroadcast(const CoreOutPacket* p,
-                                   CorePacketSendMode mode) {
+void sendServerPacketBroadcast(const OutPacket* p, PacketSendMode mode) {
     if(server.server != nullptr) {
         enet_uint8 index = (enet_uint8)mode;
         enet_host_broadcast(server.server, index, fromBuffer(&p->data, index));
     }
 }
 
-void coreSendServerPacket(CoreClient clientId, const CoreOutPacket* p,
-                          CorePacketSendMode mode) {
+void sendServerPacket(Client clientId, const OutPacket* p,
+                      PacketSendMode mode) {
     if(server.server == nullptr) {
         return;
     }
-    ENetPeer** peer = coreSearchHashMapKey(&server.clients, &clientId);
+    ENetPeer** peer = searchHashMapKey(&server.clients, &clientId);
     if(peer != nullptr) {
         enet_uint8 index = (enet_uint8)mode;
         enet_peer_send(*peer, index, fromBuffer(&p->data, index));
     }
 }
 
-void coreServerTimeout(CoreClient clientId, u32 timeout, u32 timeoutMin,
-                       u32 timeoutMax) {
+void setServerTimeout(Client clientId, u32 timeout, u32 timeoutMin,
+                      u32 timeoutMax) {
     if(server.server == nullptr) {
         return;
     }
-    ENetPeer** peer = coreSearchHashMapKey(&server.clients, &clientId);
+    ENetPeer** peer = searchHashMapKey(&server.clients, &clientId);
     if(peer != nullptr) {
         enet_peer_timeout(*peer, timeout, timeoutMin, timeoutMax);
     }
 }
 
-void coreDisconnectServerClient(CoreClient clientId) {
+void disconnectServerClient(Client clientId) {
     if(server.server == nullptr) {
         return;
     }
-    ENetPeer** peer = coreSearchHashMapKey(&server.clients, &clientId);
+    ENetPeer** peer = searchHashMapKey(&server.clients, &clientId);
     if(peer != nullptr) {
         enet_peer_disconnect(*peer, 0);
     }
 }
 
-void coreSetServerConnectHandler(CoreOnClientConnect oc) {
+void setServerConnectHandler(OnClientConnect oc) {
     server.onConnect = oc == nullptr ? voidClientDummy : oc;
 }
 
-void coreSetServerDisconnectHandler(CoreOnClientDisconnect od) {
+void setServerDisconnectHandler(OnClientDisconnect od) {
     server.onDisconnect = od == nullptr ? voidClientDummy : od;
 }
 
-void coreSetServerPacketHandler(CoreOnClientPacket op) {
+void setServerPacketHandler(OnClientPacket op) {
     server.onPacket = op == nullptr ? voidClientInPacketDummy : op;
 }
 
-void coreResetServerHandler(void) {
+void resetServerHandler(void) {
     server.onConnect = voidClientDummy;
     server.onDisconnect = voidClientDummy;
     server.onPacket = voidClientInPacketDummy;

test/Main.c

@@ -61,8 +61,8 @@ int main(int argAmount, char** args) {
         CORE_LOG_ERROR("missing path to images and/or mode");
         return 0;
     } else if(strcmp("test", args[2]) == 0) {
-        coreTestImageReader(args[1]);
-        coreTestNetwork();
+        testImageReader(args[1]);
+        testNetwork();
     } else if(strcmp("window", args[2]) == 0) {
         testWindow();
     }

test/Tests.h

@@ -3,7 +3,7 @@
 
 #include "core/Test.h"
 
-void coreTestNetwork(void);
-void coreTestImageReader(const char* path);
+void testNetwork(void);
+void testImageReader(const char* path);
 
 #endif

test/modules/ImageTests.c

@@ -9,33 +9,33 @@ static void testReadPNG8(const char* path, const char* name, int width,
                          int height, int channels) {
     char fullPath[512];
     snprintf(fullPath, sizeof(fullPath), "%s/%s.png", path, name);
-    CoreImage8 image;
-    CORE_TEST_BOOL(width == 0, coreInitImage8(&image, fullPath));
+    Image8 image;
+    TEST_BOOL(width == 0, initImage8(&image, fullPath));
     if(width != 0) {
-        CORE_TEST_NOT_NULL(image.data);
+        TEST_NOT_NULL(image.data);
     }
-    CORE_TEST_INT(width, image.width);
-    CORE_TEST_INT(height, image.height);
-    CORE_TEST_INT(channels, image.channels);
-    coreDestroyImage8(&image);
+    TEST_INT(width, image.width);
+    TEST_INT(height, image.height);
+    TEST_INT(channels, image.channels);
+    destroyImage8(&image);
 }
 
 static void testReadPNG16(const char* path, const char* name, int width,
                           int height, int channels) {
     char fullPath[512];
     snprintf(fullPath, sizeof(fullPath), "%s/%s.png", path, name);
-    CoreImage16 image;
-    CORE_TEST_BOOL(width == 0, coreInitImage16(&image, fullPath));
+    Image16 image;
+    TEST_BOOL(width == 0, initImage16(&image, fullPath));
     if(width != 0) {
-        CORE_TEST_NOT_NULL(image.data);
+        TEST_NOT_NULL(image.data);
     }
-    CORE_TEST_INT(width, image.width);
-    CORE_TEST_INT(height, image.height);
-    CORE_TEST_INT(channels, image.channels);
-    coreDestroyImage16(&image);
+    TEST_INT(width, image.width);
+    TEST_INT(height, image.height);
+    TEST_INT(channels, image.channels);
+    destroyImage16(&image);
 }
 
-void coreTestImageReader(const char* path) {
+void testImageReader(const char* path) {
     testReadPNG8(path, "rgb8", 32, 64, 3);
     testReadPNG8(path, "rgb16", 32, 64, 3);
     testReadPNG8(path, "rgba8", 32, 64, 4);

test/modules/NetworkTests.c

@@ -10,28 +10,28 @@
 #define TEST_READ(Type, type, value)                                           \
     {                                                                          \
         type u;                                                                \
-        CORE_TEST_FALSE(coreReadInPacket##Type(&in, &u));                      \
-        CORE_TEST_TRUE(u == value);                                            \
+        TEST_FALSE(readInPacket##Type(&in, &u));                               \
+        TEST_TRUE(u == value);                                                 \
     }
 
 static void testWriteRead(void) {
-    CoreOutPacket out;
-    coreInitOutPacket(&out);
-    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);
+    OutPacket out;
+    initOutPacket(&out);
+    writeOutPacketU8(&out, 200);
+    writeOutPacketU16(&out, 6656);
+    writeOutPacketU32(&out, 348923689);
+    writeOutPacketI8(&out, 90);
+    writeOutPacketI8(&out, -35);
+    writeOutPacketI16(&out, 843);
+    writeOutPacketI16(&out, -8961);
+    writeOutPacketI32(&out, 100430199);
+    writeOutPacketI32(&out, -534534);
+    writeOutPacketFloat(&out, 64564.5346f);
     const char s[] = "This is Great";
-    coreWriteOutPacketString(&out, s);
+    writeOutPacketString(&out, s);
 
-    CoreInPacket in;
-    coreInitInPacket(&in, out.data.buffer, out.data.size);
+    InPacket in;
+    initInPacket(&in, out.data.buffer, out.data.size);
     TEST_READ(U8, u8, 200)
     TEST_READ(U16, u16, 6656)
     TEST_READ(U32, u32, 348923689)
@@ -42,44 +42,44 @@ static void testWriteRead(void) {
     TEST_READ(I32, i32, 100430199)
     TEST_READ(I32, i32, -534534)
     float f;
-    CORE_TEST_FALSE(coreReadInPacketFloat(&in, &f));
-    CORE_TEST_FLOAT(64564.5346f, f, 0.00001f);
+    TEST_FALSE(readInPacketFloat(&in, &f));
+    TEST_FLOAT(64564.5346f, f, 0.00001f);
     char buffer[256];
-    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(14, n);
-    CORE_TEST_STRING(s, 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);
+    size_t n = readInPacketString(&in, buffer, sizeof(buffer));
+    TEST_SIZE(14, n);
+    TEST_STRING(s, buffer);
+
+    TEST_TRUE(readInPacketU8(&in, &(u8){0}));
+    TEST_TRUE(readInPacketU16(&in, &(u16){0}));
+    TEST_TRUE(readInPacketU32(&in, &(u32){0}));
+    TEST_TRUE(readInPacketI8(&in, &(i8){0}));
+    TEST_TRUE(readInPacketI16(&in, &(i16){0}));
+    TEST_TRUE(readInPacketI32(&in, &(i32){0}));
+    TEST_TRUE(readInPacketFloat(&in, &(float){0}));
+    TEST_SIZE(0, readInPacketString(&in, nullptr, 0));
+    TEST_SIZE(0, readInPacketString(&in, buffer, sizeof(buffer)));
+
+    destroyOutPacket(&out);
 }
 
 static void testTooShortBuffer(void) {
-    CoreOutPacket out;
-    coreInitOutPacket(&out);
-    coreWriteOutPacketString(&out, "This is Great");
-    coreWriteOutPacketString(&out, "Well hoho");
+    OutPacket out;
+    initOutPacket(&out);
+    writeOutPacketString(&out, "This is Great");
+    writeOutPacketString(&out, "Well hoho");
 
-    CoreInPacket in;
-    coreInitInPacket(&in, out.data.buffer, out.data.size);
+    InPacket in;
+    initInPacket(&in, out.data.buffer, out.data.size);
     char buffer[8];
-    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(14, n);
-    CORE_TEST_STRING("This is", buffer);
+    size_t n = readInPacketString(&in, buffer, sizeof(buffer));
+    TEST_SIZE(14, n);
+    TEST_STRING("This is", buffer);
     char buffer2[6];
-    size_t n2 = coreReadInPacketString(&in, buffer2, sizeof(buffer2));
-    CORE_TEST_SIZE(10, n2);
-    CORE_TEST_STRING("Well ", buffer2);
+    size_t n2 = readInPacketString(&in, buffer2, sizeof(buffer2));
+    TEST_SIZE(10, n2);
+    TEST_STRING("Well ", buffer2);
 
-    coreDestroyOutPacket(&out);
+    destroyOutPacket(&out);
 }
 
 typedef struct {
@@ -88,48 +88,48 @@ typedef struct {
 } PacketTest;
 
 static void testBinaryData(void) {
-    CoreOutPacket out;
-    coreInitOutPacket(&out);
+    OutPacket out;
+    initOutPacket(&out);
     PacketTest data = {56, 3};
-    coreWriteOutPacket(&out, &data, sizeof(data));
+    writeOutPacket(&out, &data, sizeof(data));
 
-    CoreInPacket in;
-    coreInitInPacket(&in, out.data.buffer, out.data.size);
+    InPacket in;
+    initInPacket(&in, out.data.buffer, out.data.size);
 
     PacketTest inData;
-    CORE_TEST_FALSE(coreReadInPacket(&in, &inData, sizeof(inData)));
-    CORE_TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);
+    TEST_FALSE(readInPacket(&in, &inData, sizeof(inData)));
+    TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);
 
-    coreDestroyOutPacket(&out);
+    destroyOutPacket(&out);
 }
 
 static void testShortString(void) {
-    CoreOutPacket out;
-    coreInitOutPacket(&out);
-    coreWriteOutPacketU16(&out, 200);
-    coreWriteOutPacketU16(&out, 65535);
+    OutPacket out;
+    initOutPacket(&out);
+    writeOutPacketU16(&out, 200);
+    writeOutPacketU16(&out, 65535);
 
-    CoreInPacket in;
-    coreInitInPacket(&in, out.data.buffer, out.data.size);
+    InPacket in;
+    initInPacket(&in, out.data.buffer, out.data.size);
 
     char buffer[256];
-    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
-    CORE_TEST_SIZE(200, n);
-    CORE_TEST_STRING("", buffer);
+    size_t n = readInPacketString(&in, buffer, sizeof(buffer));
+    TEST_SIZE(200, n);
+    TEST_STRING("", buffer);
 
-    coreDestroyOutPacket(&out);
+    destroyOutPacket(&out);
 }
 
-static void tickClient(int ticks) {
+static void tickClientN(int ticks) {
     for(int i = 0; i < ticks; i++) {
-        coreTickClient();
+        tickClient();
     }
 }
 
 static void tick(int ticks) {
     for(int i = 0; i < ticks; i++) {
-        coreTickClient();
-        coreTickServer();
+        tickClient();
+        tickServer();
     }
 }
 
@@ -151,37 +151,37 @@ static i32 data9 = 0;
 static char data10[20];
 static float data11 = 0.0f;
 
-static void onServerConnect(CoreClient) {
+static void onServerConnect(Client) {
     serverConnected = true;
 }
 
-static void onServerDisconnect(CoreClient) {
+static void onServerDisconnect(Client) {
     serverDisconnect = true;
 }
 
-static void onServerPacket(CoreClient client, CoreInPacket* in) {
-    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);
+static void onServerPacket(Client client, InPacket* in) {
+    TEST_FALSE(readInPacketU8(in, &data1));
+    TEST_FALSE(readInPacketU16(in, &data2));
+    TEST_FALSE(readInPacketU32(in, &data3));
+    TEST_FALSE(readInPacketI8(in, &data4));
+    TEST_FALSE(readInPacketI16(in, &data5));
+    TEST_FALSE(readInPacketI32(in, &data6));
+    TEST_FALSE(readInPacketI8(in, &data7));
+    TEST_FALSE(readInPacketI16(in, &data8));
+    TEST_FALSE(readInPacketI32(in, &data9));
+    TEST_SIZE(9, readInPacketString(in, data10, sizeof(data10)));
+    TEST_FALSE(readInPacketFloat(in, &data11));
+
+    OutPacket out;
+    initOutPacket(&out);
     if(packageCounter == 0) {
-        coreSendServerPacket(client, &out, CORE_RELIABLE);
+        sendServerPacket(client, &out, PACKET_RELIABLE);
     } else if(packageCounter == 1) {
-        coreSendServerPacket(client, &out, CORE_SEQUENCED);
+        sendServerPacket(client, &out, PACKET_SEQUENCED);
     } else if(packageCounter == 2) {
-        coreSendServerPacket(client, &out, CORE_UNSEQUENCED);
+        sendServerPacket(client, &out, PACKET_UNSEQUENCED);
     }
-    coreDestroyOutPacket(&out);
+    destroyOutPacket(&out);
     packageCounter++;
 }
 
@@ -193,11 +193,11 @@ static void onClientDisconnect() {
     clientDisconnected = true;
 }
 
-static void onClientPacket(CoreInPacket*) {
+static void onClientPacket(InPacket*) {
     clientPackage = true;
 }
 
-static void testConnect(CorePacketSendMode mode) {
+static void testConnect(PacketSendMode mode) {
     clientConnected = false;
     clientDisconnected = false;
     clientPackage = false;
@@ -215,73 +215,73 @@ static void testConnect(CorePacketSendMode mode) {
     *data10 = '\0';
     data11 = 0.0f;
 
-    coreResetServerHandler();
-    coreSetServerConnectHandler(onServerConnect);
-    coreSetServerDisconnectHandler(onServerDisconnect);
-    coreSetServerPacketHandler(onServerPacket);
+    resetServerHandler();
+    setServerConnectHandler(onServerConnect);
+    setServerDisconnectHandler(onServerDisconnect);
+    setServerPacketHandler(onServerPacket);
 
-    coreResetClientHandler();
-    coreSetClientConnectHandler(onClientConnect);
-    coreSetClientDisconnectHandler(onClientDisconnect);
-    coreSetClientPacketHandler(onClientPacket);
+    resetClientHandler();
+    setClientConnectHandler(onClientConnect);
+    setClientDisconnectHandler(onClientDisconnect);
+    setClientPacketHandler(onClientPacket);
 
-    if(!CORE_TEST_FALSE(coreStartServer(54321, 5))) {
+    if(!TEST_FALSE(startServer(54321, 5))) {
         return;
-    } else if(!CORE_TEST_FALSE(coreStartClient())) {
+    } else if(!TEST_FALSE(startClient())) {
         return;
-    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
+    } else if(!TEST_FALSE(connectClient("127.0.0.1", 54321, 90))) {
         return;
     }
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_TRUE(coreIsClientConnecting());
+    TEST_FALSE(isClientConnected());
+    TEST_TRUE(isClientConnecting());
     tick(100);
-    CORE_TEST_TRUE(clientConnected);
-    CORE_TEST_TRUE(coreIsClientConnected());
-    CORE_TEST_FALSE(coreIsClientConnecting());
-
-    CoreOutPacket out;
-    coreInitOutPacket(&out);
-    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);
+    TEST_TRUE(clientConnected);
+    TEST_TRUE(isClientConnected());
+    TEST_FALSE(isClientConnecting());
+
+    OutPacket out;
+    initOutPacket(&out);
+    writeOutPacketU8(&out, 0xF1);
+    writeOutPacketU16(&out, 0xF123);
+    writeOutPacketU32(&out, 0xF1234567);
+    writeOutPacketI8(&out, -0x71);
+    writeOutPacketI16(&out, -0x7123);
+    writeOutPacketI32(&out, -0x71234567);
+    writeOutPacketI8(&out, 0x71);
+    writeOutPacketI16(&out, 0x7123);
+    writeOutPacketI32(&out, 0x71234567);
     const char s[] = "Hi there";
-    coreWriteOutPacketString(&out, s);
-    coreWriteOutPacketFloat(&out, 252345.983f);
-    coreSendClientPacket(&out, mode);
-    coreDestroyOutPacket(&out);
+    writeOutPacketString(&out, s);
+    writeOutPacketFloat(&out, 252345.983f);
+    sendClientPacket(&out, mode);
+    destroyOutPacket(&out);
 
     tick(100);
 
-    CORE_TEST_TRUE(clientPackage);
-    CORE_TEST_TRUE(serverConnected);
-
-    CORE_TEST_U64(0xF1, data1);
-    CORE_TEST_U64(0xF123, data2);
-    CORE_TEST_U64(0xF1234567, data3);
-    CORE_TEST_I64(-0x71, data4);
-    CORE_TEST_I64(-0x7123, data5);
-    CORE_TEST_I64(-0x71234567, data6);
-    CORE_TEST_I64(0x71, data7);
-    CORE_TEST_I64(0x7123, data8);
-    CORE_TEST_I64(0x71234567, data9);
-    CORE_TEST_STRING(s, data10);
-    CORE_TEST_FLOAT(252345.983f, data11, 0.01f);
-
-    coreDisconnectClient(90);
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_FALSE(coreIsClientConnecting());
+    TEST_TRUE(clientPackage);
+    TEST_TRUE(serverConnected);
+
+    TEST_U64(0xF1, data1);
+    TEST_U64(0xF123, data2);
+    TEST_U64(0xF1234567, data3);
+    TEST_I64(-0x71, data4);
+    TEST_I64(-0x7123, data5);
+    TEST_I64(-0x71234567, data6);
+    TEST_I64(0x71, data7);
+    TEST_I64(0x7123, data8);
+    TEST_I64(0x71234567, data9);
+    TEST_STRING(s, data10);
+    TEST_FLOAT(252345.983f, data11, 0.01f);
+
+    disconnectClient(90);
+    TEST_FALSE(isClientConnected());
+    TEST_FALSE(isClientConnecting());
     tick(100);
-    CORE_TEST_TRUE(clientDisconnected);
-    CORE_TEST_TRUE(serverDisconnect);
+    TEST_TRUE(clientDisconnected);
+    TEST_TRUE(serverDisconnect);
 
-    coreStopClient();
-    coreStopServer();
+    stopClient();
+    stopServer();
 }
 
 static bool disconnected = false;
@@ -292,204 +292,204 @@ static void testStopDisconnect(void) {
 
 static void testDisconnect(void) {
     disconnected = false;
-    coreResetClientHandler();
-    coreSetClientDisconnectHandler(testStopDisconnect);
-    if(!CORE_TEST_FALSE(coreStartClient())) {
+    resetClientHandler();
+    setClientDisconnectHandler(testStopDisconnect);
+    if(!TEST_FALSE(startClient())) {
         return;
-    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
+    } else if(!TEST_FALSE(connectClient("127.0.0.1", 54321, 90))) {
         return;
     }
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_TRUE(coreIsClientConnecting());
-    coreDisconnectClient(50);
-    tickClient(100);
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_FALSE(coreIsClientConnecting());
-    CORE_TEST_TRUE(disconnected);
-    coreStopClient();
+    TEST_FALSE(isClientConnected());
+    TEST_TRUE(isClientConnecting());
+    disconnectClient(50);
+    tickClientN(100);
+    TEST_FALSE(isClientConnected());
+    TEST_FALSE(isClientConnecting());
+    TEST_TRUE(disconnected);
+    stopClient();
 }
 
 static void testStop(void) {
     disconnected = false;
-    coreResetClientHandler();
-    coreSetClientDisconnectHandler(testStopDisconnect);
-    if(!CORE_TEST_FALSE(coreStartClient())) {
+    resetClientHandler();
+    setClientDisconnectHandler(testStopDisconnect);
+    if(!TEST_FALSE(startClient())) {
         return;
-    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
+    } else if(!TEST_FALSE(connectClient("127.0.0.1", 54321, 90))) {
         return;
     }
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_TRUE(coreIsClientConnecting());
-    coreStopClient();
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_FALSE(coreIsClientConnecting());
-    CORE_TEST_TRUE(disconnected);
+    TEST_FALSE(isClientConnected());
+    TEST_TRUE(isClientConnecting());
+    stopClient();
+    TEST_FALSE(isClientConnected());
+    TEST_FALSE(isClientConnecting());
+    TEST_TRUE(disconnected);
 }
 
 static void testClientStartFails(void) {
-    CORE_TEST_FALSE(coreStartClient());
+    TEST_FALSE(startClient());
     logLevel = LOG_NONE;
-    CORE_TEST_TRUE(coreStartClient());
-    coreStopClient();
+    TEST_TRUE(startClient());
+    stopClient();
 #ifdef ERROR_SIMULATOR
-    coreFailCounter = 0;
-    CORE_TEST_TRUE(coreStartClient());
-    coreFailCounter = 1;
-    CORE_TEST_TRUE(coreStartClient());
-    coreFailCounter = -1;
+    failCounter = 0;
+    TEST_TRUE(startClient());
+    failCounter = 1;
+    TEST_TRUE(startClient());
+    failCounter = -1;
 #endif
     logLevel = LOG_DEBUG;
 }
 
 static void testClientConnectionFails(void) {
-    coreResetClientHandler();
+    resetClientHandler();
     logLevel = LOG_NONE;
-    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
-    CORE_TEST_FALSE(coreStartClient());
+    TEST_TRUE(connectClient("", 54321, 100));
+    TEST_FALSE(startClient());
 #ifdef ERROR_SIMULATOR
-    coreFailCounter = 0;
-    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
-    coreFailCounter = -1;
+    failCounter = 0;
+    TEST_TRUE(connectClient("", 54321, 100));
+    failCounter = -1;
 #endif
-    CORE_TEST_FALSE(coreConnectClient("", 54321, 100));
-    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
+    TEST_FALSE(connectClient("", 54321, 100));
+    TEST_TRUE(connectClient("", 54321, 100));
     logLevel = LOG_DEBUG;
-    tickClient(100);
-    coreStopClient();
+    tickClientN(100);
+    stopClient();
 }
 
 static void testInvalidClientAccess(void) {
-    coreDisconnectClient(0);
-    coreSendClientPacket(nullptr, 0);
-    coreTickClient();
+    disconnectClient(0);
+    sendClientPacket(nullptr, 0);
+    tickClient();
 }
 
 static void testServerStartFails(void) {
     logLevel = LOG_NONE;
-    CORE_TEST_TRUE(coreStartServer(54321, 0));
+    TEST_TRUE(startServer(54321, 0));
 #ifdef ERROR_SIMULATOR
-    coreFailCounter = 0;
-    CORE_TEST_TRUE(coreStartServer(54321, 5));
-    coreFailCounter = 1;
-    CORE_TEST_TRUE(coreStartServer(54321, 5));
-    coreFailCounter = -1;
+    failCounter = 0;
+    TEST_TRUE(startServer(54321, 5));
+    failCounter = 1;
+    TEST_TRUE(startServer(54321, 5));
+    failCounter = -1;
 #endif
-    CORE_TEST_FALSE(coreStartServer(54321, 5));
-    CORE_TEST_TRUE(coreStartServer(54321, 5));
+    TEST_FALSE(startServer(54321, 5));
+    TEST_TRUE(startServer(54321, 5));
     logLevel = LOG_DEBUG;
-    coreStopServer();
+    stopServer();
 }
 
 static void testServerClosesOnConnected(void) {
     clientDisconnected = false;
-    CORE_TEST_FALSE(coreStartServer(54321, 5));
-    CORE_TEST_FALSE(coreStartClient());
-    coreSetClientDisconnectHandler(onClientDisconnect);
-    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
+    TEST_FALSE(startServer(54321, 5));
+    TEST_FALSE(startClient());
+    setClientDisconnectHandler(onClientDisconnect);
+    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreIsClientConnected());
-    coreStopServer();
+    TEST_TRUE(isClientConnected());
+    stopServer();
 
-    coreSetClientTimeout(500, 500, 500);
-    for(int i = 0; i < 500 && coreIsClientConnected(); i++) {
-        coreTickClient();
-        coreSleepNanos(10000000);
+    setClientTimeout(500, 500, 500);
+    for(int i = 0; i < 500 && isClientConnected(); i++) {
+        tickClient();
+        sleepNanos(10000000);
     }
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_TRUE(clientDisconnected);
-    coreStopClient();
+    TEST_FALSE(isClientConnected());
+    TEST_TRUE(clientDisconnected);
+    stopClient();
 }
 
-static CoreClient clientId = 0;
+static Client clientId = 0;
 
-static void onConnectSetClient(CoreClient client) {
+static void onConnectSetClient(Client client) {
     clientId = client;
 }
 
 static void testServerDisconnectsClient(void) {
     clientDisconnected = false;
-    CORE_TEST_FALSE(coreStartServer(54321, 5));
-    CORE_TEST_FALSE(coreStartClient());
-    coreSetClientDisconnectHandler(onClientDisconnect);
-    coreSetServerConnectHandler(onConnectSetClient);
-    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
+    TEST_FALSE(startServer(54321, 5));
+    TEST_FALSE(startClient());
+    setClientDisconnectHandler(onClientDisconnect);
+    setServerConnectHandler(onConnectSetClient);
+    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreIsClientConnected());
+    TEST_TRUE(isClientConnected());
 
-    coreDisconnectServerClient(clientId);
+    disconnectServerClient(clientId);
 
-    for(int i = 0; i < 500 && coreIsClientConnected(); i++) {
-        coreTickClient();
-        coreTickServer();
-        coreSleepNanos(10000000);
+    for(int i = 0; i < 500 && isClientConnected(); i++) {
+        tickClient();
+        tickServer();
+        sleepNanos(10000000);
     }
-    CORE_TEST_FALSE(coreIsClientConnected());
-    CORE_TEST_TRUE(clientDisconnected);
-    coreStopClient();
-    coreStopServer();
+    TEST_FALSE(isClientConnected());
+    TEST_TRUE(clientDisconnected);
+    stopClient();
+    stopServer();
 }
 
-static void onConnectSetTimeout(CoreClient client) {
-    coreServerTimeout(client, 500, 500, 500);
+static void onConnectSetTimeout(Client client) {
+    setServerTimeout(client, 500, 500, 500);
 }
 
 static void testClientClosesOnConnected(void) {
     serverDisconnect = false;
-    CORE_TEST_FALSE(coreStartServer(54321, 5));
-    CORE_TEST_FALSE(coreStartClient());
-    coreSetServerDisconnectHandler(onServerDisconnect);
-    coreSetServerConnectHandler(onConnectSetTimeout);
-    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
+    TEST_FALSE(startServer(54321, 5));
+    TEST_FALSE(startClient());
+    setServerDisconnectHandler(onServerDisconnect);
+    setServerConnectHandler(onConnectSetTimeout);
+    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreIsClientConnected());
+    TEST_TRUE(isClientConnected());
 #ifdef ERROR_SIMULATOR
-    coreFailCounter = 0;
+    failCounter = 0;
 #endif
-    coreStopClient();
+    stopClient();
 #ifdef ERROR_SIMULATOR
-    coreFailCounter = -1;
+    failCounter = -1;
 #endif
     for(int i = 0; i < 500 && !serverDisconnect; i++) {
-        coreTickServer();
-        coreSleepNanos(10000000);
+        tickServer();
+        sleepNanos(10000000);
     }
-    CORE_TEST_TRUE(serverDisconnect);
-    coreStopServer();
+    TEST_TRUE(serverDisconnect);
+    stopServer();
 }
 
 static void testInvalidServerAccess(void) {
-    coreTickServer();
-    coreSendServerPacket(0, nullptr, 0);
-    coreServerTimeout(0, 500, 500, 500);
-    coreDisconnectServerClient(0);
+    tickServer();
+    sendServerPacket(0, nullptr, 0);
+    setServerTimeout(0, 500, 500, 500);
+    disconnectServerClient(0);
 }
 
 static void testDummyCallbacks(void) {
-    coreResetClientHandler();
-    coreResetServerHandler();
-    CORE_TEST_FALSE(coreStartServer(54321, 5));
-    CORE_TEST_FALSE(coreStartClient());
-    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
+    resetClientHandler();
+    resetServerHandler();
+    TEST_FALSE(startServer(54321, 5));
+    TEST_FALSE(startClient());
+    TEST_FALSE(connectClient("127.0.0.1", 54321, 50));
     tick(100);
-    CORE_TEST_TRUE(coreIsClientConnected());
-    CoreOutPacket out;
-    coreInitOutPacket(&out);
-    coreSendServerPacketBroadcast(&out, CORE_RELIABLE);
-    coreSendClientPacket(&out, CORE_RELIABLE);
+    TEST_TRUE(isClientConnected());
+    OutPacket out;
+    initOutPacket(&out);
+    sendServerPacketBroadcast(&out, PACKET_RELIABLE);
+    sendClientPacket(&out, PACKET_RELIABLE);
     tick(100);
-    coreDestroyOutPacket(&out);
-    coreStopClient();
-    coreStopServer();
+    destroyOutPacket(&out);
+    stopClient();
+    stopServer();
 }
 
-void coreTestNetwork(void) {
+void testNetwork(void) {
     testWriteRead();
     testTooShortBuffer();
     testBinaryData();
     testShortString();
-    testConnect(CORE_UNSEQUENCED);
-    testConnect(CORE_SEQUENCED);
-    testConnect(CORE_RELIABLE);
+    testConnect(PACKET_UNSEQUENCED);
+    testConnect(PACKET_SEQUENCED);
+    testConnect(PACKET_RELIABLE);
     testDisconnect();
     testStop();
     testClientStartFails();