Source code, broken...

1 files changed, 244 insertions, 0 deletions

diff --git a/src/shared/tools.cpp b/src/shared/tools.cpp
new file mode 100644
index 0000000..ca82e8f
--- /dev/null
+++ b/src/shared/tools.cpp
@@ -0,0 +1,244 @@
+// implementation of generic tools
+
+#include "cube.h"
+
+void *operator new(size_t size)
+{
+    void *p = malloc(size);
+    if(!p) abort();
+    return p;
+}
+
+void *operator new[](size_t size)
+{
+    void *p = malloc(size);
+    if(!p) abort();
+    return p;
+}
+
+void operator delete(void *p) { if(p) free(p); }
+
+void operator delete[](void *p) { if(p) free(p); }
+
+void *operator new(size_t size, bool err)
+{
+    void *p = malloc(size);
+    if(!p && err) abort();
+    return p;
+}
+
+void *operator new[](size_t size, bool err)
+{
+    void *p = malloc(size);
+    if(!p && err) abort();
+    return p;
+}
+
+////////////////////////// rnd numbers ////////////////////////////////////////
+
+#define N (624)             
+#define M (397)                
+#define K (0x9908B0DFU)       
+
+static uint state[N];
+static int next = N;
+
+void seedMT(uint seed)
+{
+    state[0] = seed;
+    for(uint i = 1; i < N; i++)
+        state[i] = seed = 1812433253U * (seed ^ (seed >> 30)) + i;
+    next = 0;
+}
+
+uint randomMT()
+{
+    int cur = next;
+    if(++next >= N)
+    {
+        if(next > N) { seedMT(5489U + time(NULL)); cur = next++; }
+        else next = 0;
+    }
+    uint y = (state[cur] & 0x80000000U) | (state[next] & 0x7FFFFFFFU);
+    state[cur] = y = state[cur < N-M ? cur + M : cur + M-N] ^ (y >> 1) ^ (-int(y & 1U) & K);
+    y ^= (y >> 11);
+    y ^= (y <<  7) & 0x9D2C5680U;
+    y ^= (y << 15) & 0xEFC60000U;
+    y ^= (y >> 18);
+    return y;
+}
+
+///////////////////////// network ///////////////////////
+
+// all network traffic is in 32bit ints, which are then compressed using the following simple scheme (assumes that most values are small).
+
+template<class T>
+static inline void putint_(T &p, int n)
+{
+    if(n<128 && n>-127) p.put(n);
+    else if(n<0x8000 && n>=-0x8000) { p.put(0x80); p.put(n); p.put(n>>8); }
+    else { p.put(0x81); p.put(n); p.put(n>>8); p.put(n>>16); p.put(n>>24); }
+}
+void putint(ucharbuf &p, int n) { putint_(p, n); }
+void putint(packetbuf &p, int n) { putint_(p, n); }
+void putint(vector<uchar> &p, int n) { putint_(p, n); }
+
+int getint(ucharbuf &p)
+{
+    int c = (schar)p.get();
+    if(c==-128) { int n = p.get(); n |= ((schar)p.get())<<8; return n; }
+    else if(c==-127) { int n = p.get(); n |= p.get()<<8; n |= p.get()<<16; return n|(p.get()<<24); }
+    else return c;
+}
+
+// much smaller encoding for unsigned integers up to 28 bits, but can handle signed
+template<class T>
+static inline void putuint_(T &p, int n)
+{
+    if(n < 0 || n >= (1<<21))
+    {
+        p.put(0x80 | (n & 0x7F));
+        p.put(0x80 | ((n >> 7) & 0x7F));
+        p.put(0x80 | ((n >> 14) & 0x7F));
+        p.put(n >> 21);
+    }
+    else if(n < (1<<7)) p.put(n);
+    else if(n < (1<<14))
+    {
+        p.put(0x80 | (n & 0x7F));
+        p.put(n >> 7);
+    }
+    else
+    {
+        p.put(0x80 | (n & 0x7F));
+        p.put(0x80 | ((n >> 7) & 0x7F));
+        p.put(n >> 14);
+    }
+}
+void putuint(ucharbuf &p, int n) { putuint_(p, n); }
+void putuint(packetbuf &p, int n) { putuint_(p, n); }
+void putuint(vector<uchar> &p, int n) { putuint_(p, n); }
+
+int getuint(ucharbuf &p)
+{
+    int n = p.get();
+    if(n & 0x80)
+    {
+        n += (p.get() << 7) - 0x80;
+        if(n & (1<<14)) n += (p.get() << 14) - (1<<14);
+        if(n & (1<<21)) n += (p.get() << 21) - (1<<21);
+        if(n & (1<<28)) n |= ~0U<<28;
+    }
+    return n;
+}
+
+template<class T>
+static inline void putfloat_(T &p, float f)
+{
+    lilswap(&f, 1);
+    p.put((uchar *)&f, sizeof(float));
+}
+void putfloat(ucharbuf &p, float f) { putfloat_(p, f); }
+void putfloat(packetbuf &p, float f) { putfloat_(p, f); }
+void putfloat(vector<uchar> &p, float f) { putfloat_(p, f); }
+
+float getfloat(ucharbuf &p)
+{
+    float f;
+    p.get((uchar *)&f, sizeof(float));
+    return lilswap(f);
+}
+
+template<class T>
+static inline void sendstring_(const char *t, T &p)
+{
+    while(*t) putint(p, *t++);
+    putint(p, 0);
+}
+void sendstring(const char *t, ucharbuf &p) { sendstring_(t, p); }
+void sendstring(const char *t, packetbuf &p) { sendstring_(t, p); }
+void sendstring(const char *t, vector<uchar> &p) { sendstring_(t, p); }
+
+void getstring(char *text, ucharbuf &p, size_t len)
+{
+    char *t = text;
+    do
+    {
+        if(t>=&text[len]) { text[len-1] = 0; return; }
+        if(!p.remaining()) { *t = 0; return; }
+        *t = getint(p);
+    }
+    while(*t++);
+}
+
+void filtertext(char *dst, const char *src, bool whitespace, bool forcespace, size_t len)
+{
+    for(int c = uchar(*src); c; c = uchar(*++src))
+    {
+        if(c == '\f')
+        {
+            if(!*++src) break;
+            continue;
+        }
+        if(!iscubeprint(c))
+        {
+            if(!iscubespace(c) || !whitespace) continue;
+            if(forcespace) c = ' ';
+        }
+        *dst++ = c;
+        if(!--len) break;
+    }
+    *dst = '\0';
+}
+
+void ipmask::parse(const char *name)
+{
+    union { uchar b[sizeof(enet_uint32)]; enet_uint32 i; } ipconv, maskconv;
+    ipconv.i = 0;
+    maskconv.i = 0;
+    loopi(4)
+    {
+        char *end = NULL;
+        int n = strtol(name, &end, 10);
+        if(!end) break;
+        if(end > name) { ipconv.b[i] = n; maskconv.b[i] = 0xFF; }
+        name = end;
+        while(int c = *name)
+        {
+            ++name;
+            if(c == '.') break;
+            if(c == '/')
+            {
+                int range = clamp(int(strtol(name, NULL, 10)), 0, 32);
+                mask = range ? ENET_HOST_TO_NET_32(0xFFffFFff << (32 - range)) : maskconv.i;
+                ip = ipconv.i & mask;
+                return;
+            }
+        }
+    }
+    ip = ipconv.i;
+    mask = maskconv.i;
+}
+
+int ipmask::print(char *buf) const
+{
+    char *start = buf;
+    union { uchar b[sizeof(enet_uint32)]; enet_uint32 i; } ipconv, maskconv;
+    ipconv.i = ip;
+    maskconv.i = mask;
+    int lastdigit = -1;
+    loopi(4) if(maskconv.b[i])
+    {
+        if(lastdigit >= 0) *buf++ = '.';
+        loopj(i - lastdigit - 1) { *buf++ = '*'; *buf++ = '.'; }
+        buf += sprintf(buf, "%d", ipconv.b[i]);
+        lastdigit = i;
+    }
+    enet_uint32 bits = ~ENET_NET_TO_HOST_32(mask);
+    int range = 32;
+    for(; (bits&0xFF) == 0xFF; bits >>= 8) range -= 8;
+    for(; bits&1; bits >>= 1) --range;
+    if(!bits && range%8) buf += sprintf(buf, "/%d", range);
+    return int(buf-start);
+}
+