Index: src/MD2.m
==================================================================
--- src/MD2.m
+++ src/MD2.m
@@ -12,11 +12,11 @@
 	int offsetSkins, offsetTexcoords, offsetTriangles;
 	int offsetFrames, offsetGlCommands, offsetEnd;
 };
 
 struct md2_vertex {
-	uchar vertex[3], lightNormalIndex;
+	unsigned char vertex[3], lightNormalIndex;
 };
 
 struct md2_frame {
 	float scale[3];
 	float translate[3];
@@ -126,11 +126,11 @@
 	_mverts[frame] = OFAllocMemory(_numVerts, sizeof(OFVector3D));
 	struct md2_frame *cf =
 	    (struct md2_frame *)((char *)_frames + _frameSize * frame);
 	float sc = 16.0f / scale;
 	for (int vi = 0; vi < _numVerts; vi++) {
-		uchar *cv = (uchar *)&cf->vertices[vi].vertex;
+		unsigned char *cv = (unsigned char *)&cf->vertices[vi].vertex;
 		OFVector3D *v = &(_mverts[frame])[vi];
 		v->x = (snap(sn, cv[0] * cf->scale[0]) + cf->translate[0]) / sc;
 		v->y =
 		    -(snap(sn, cv[1] * cf->scale[1]) + cf->translate[1]) / sc;
 		v->z = (snap(sn, cv[2] * cf->scale[2]) + cf->translate[2]) / sc;

Index: src/clientextras.m
==================================================================
--- src/clientextras.m
+++ src/clientextras.m
@@ -187,12 +187,12 @@
 	OFData *mapdata = readmap(mapname);
 	if (mapdata == nil)
 		return;
 	ENetPacket *packet = enet_packet_create(
 	    NULL, MAXTRANS + mapdata.count, ENET_PACKET_FLAG_RELIABLE);
-	uchar *start = packet->data;
-	uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	unsigned char *p = start + 2;
 	putint(&p, SV_SENDMAP);
 	sendstring(mapname, &p);
 	putint(&p, mapdata.count);
 	if (65535 - (p - start) < mapdata.count) {
 		conoutf(@"map %@ is too large to send", mapname);
@@ -199,11 +199,11 @@
 		enet_packet_destroy(packet);
 		return;
 	}
 	memcpy(p, mapdata.items, mapdata.count);
 	p += mapdata.count;
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	sendpackettoserv(packet);
 	conoutf(@"sending map %@ to server...", mapname);
 	OFString *msg =
 	    [OFString stringWithFormat:@"[map %@ uploaded to server, "
@@ -215,16 +215,16 @@
 void
 getmap()
 {
 	ENetPacket *packet =
 	    enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
-	uchar *start = packet->data;
-	uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	unsigned char *p = start + 2;
 	putint(&p, SV_RECVMAP);
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	sendpackettoserv(packet);
 	conoutf(@"requesting map from server...");
 }
 
 COMMAND(sendmap, ARG_1STR)
 COMMAND(getmap, ARG_NONE)

Index: src/clients.m
==================================================================
--- src/clients.m
+++ src/clients.m
@@ -280,12 +280,12 @@
 	if (clientnum < 0)
 		return; // we haven't had a welcome message from the server yet
 	if (lastmillis - lastupdate < 40)
 		return; // don't update faster than 25fps
 	ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, 0);
-	uchar *start = packet->data;
-	uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	unsigned char *p = start + 2;
 	bool serveriteminitdone = false;
 	// suggest server to change map
 	if (toservermap.length > 0) {
 		// do this exclusively as map change may invalidate rest of
 		// update
@@ -352,11 +352,11 @@
 			putint(&p, SV_PING);
 			putint(&p, lastmillis);
 			lastping = lastmillis;
 		}
 	}
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	incomingdemodata(start, p - start, true);
 	if (clienthost) {
 		enet_host_broadcast(clienthost, 0, packet);
 		enet_host_flush(clienthost);

Index: src/clients2c.m
==================================================================
--- src/clients2c.m
+++ src/clients2c.m
@@ -62,18 +62,18 @@
 	}
 }
 
 // processes any updates from the server
 void
-localservertoclient(uchar *buf, int len)
+localservertoclient(unsigned char *buf, int len)
 {
-	if (ENET_NET_TO_HOST_16(*(ushort *)buf) != len)
+	if (ENET_NET_TO_HOST_16(*(unsigned short *)buf) != len)
 		neterr(@"packet length");
 	incomingdemodata(buf, len, false);
 
-	uchar *end = buf + len;
-	uchar *p = buf + 2;
+	unsigned char *end = buf + len;
+	unsigned char *p = buf + 2;
 	char text[MAXTRANS];
 	int cn = -1, type;
 	DynamicEntity *d = nil;
 	bool mapchanged = false;
 
@@ -282,13 +282,13 @@
 			setspawn(getint(&p), false);
 			getint(&p);
 			break;
 
 		case SV_ITEMSPAWN: {
-			uint i = getint(&p);
+			unsigned int i = getint(&p);
 			setspawn(i, true);
-			if (i >= (uint)ents.count)
+			if (i >= ents.count)
 				break;
 			OFVector3D v =
 			    OFMakeVector3D(ents[i].x, ents[i].y, ents[i].z);
 			playsound(S_ITEMSPAWN, &v);
 			break;
@@ -330,13 +330,13 @@
 			break;
 		}
 
 		case SV_EDITENT: // coop edit of ent
 		{
-			uint i = getint(&p);
+			unsigned int i = getint(&p);
 
-			while ((uint)ents.count <= i) {
+			while (ents.count <= i) {
 				Entity *e = [Entity entity];
 				e.type = NOTUSED;
 				[ents addObject:e];
 			}
 

Index: src/cube.h
==================================================================
--- src/cube.h
+++ src/cube.h
@@ -31,20 +31,28 @@
 	SEMISOLID, // generated by mipmapping
 	MAXTYPE
 };
 
 struct sqr {
-	uchar type;             // one of the above
-	char floor, ceil;       // height, in cubes
-	uchar wtex, ftex, ctex; // wall/floor/ceil texture ids
-	uchar r, g, b;          // light value at upper left vertex
-	uchar vdelta;           // vertex delta, used for heightfield cubes
-	char defer; // used in mipmapping, when true this cube is not a perfect
-	            // mip
-	char occluded; // true when occluded
-	uchar utex;    // upper wall tex id
-	uchar tag;     // used by triggers
+	// one of the above
+	unsigned char type;
+	// height, in cubes
+	char floor, ceil;
+	// wall/floor/ceil texture ids
+	unsigned char wtex, ftex, ctex;
+	// light value at upper left vertex
+	unsigned char r, g, b;
+	// vertex delta, used for heightfield cubes
+	unsigned char vdelta;
+	// used in mipmapping, when true this cube is not a perfect mip
+	char defer;
+	// true when occluded
+	char occluded;
+	// upper wall tex id
+	unsigned char utex;
+	// used by triggers
+	unsigned char tag;
 };
 
 // hardcoded texture numbers
 enum {
 	DEFAULT_SKY = 0,
@@ -85,11 +93,11 @@
 	int version;    // any >8bit quantity is a little indian
 	int headersize; // sizeof(header)
 	int sfactor;    // in bits
 	int numents;
 	char maptitle[128];
-	uchar texlists[3][256];
+	unsigned char texlists[3][256];
 	int waterlevel;
 	int reserved[15];
 };
 
 #define SWS(w, x, y, s) (&(w)[(y) * (s) + (x)])
@@ -235,11 +243,11 @@
 
 // vertex array format
 
 struct vertex {
 	float u, v, x, y, z;
-	uchar r, g, b, a;
+	unsigned char r, g, b, a;
 };
 
 // globals ooh naughty
 
 #ifdef __cplusplus

Index: src/editing.m
==================================================================
--- src/editing.m
+++ src/editing.m
@@ -325,11 +325,11 @@
              // texture
 {
 	for (int i = 0; i < 3; i++) {
 		int c = curedittex[i];
 		if (c >= 0) {
-			uchar *p = hdr.texlists[i];
+			unsigned char *p = hdr.texlists[i];
 			int t = p[c];
 			for (int a = c - 1; a >= 0; a--)
 				p[a + 1] = p[a];
 			p[0] = t;
 			curedittex[i] = -1;

Index: src/entities.m
==================================================================
--- src/entities.m
+++ src/entities.m
@@ -336,12 +336,13 @@
 		playsoundc(S_PUPOUT);
 		conoutf(@"quad damage is over");
 	}
 }
 
+// puts items in network stream and also spawns them locally
 void
-putitems(uchar **p) // puts items in network stream and also spawns them locally
+putitems(unsigned char **p)
 {
 	[ents enumerateObjectsUsingBlock:^(Entity *e, size_t i, bool *stop) {
 		if ((e.type >= I_SHELLS && e.type <= I_QUAD) ||
 		    e.type == CARROT) {
 			putint(p, i);
@@ -355,10 +356,10 @@
 {
 	for (Entity *e in ents)
 		e.spawned = false;
 }
 void
-setspawn(uint i, bool on)
+setspawn(size_t i, bool on)
 {
-	if (i < (uint)ents.count)
+	if (i < ents.count)
 		ents[i].spawned = on;
 }

Index: src/protos.h
==================================================================
--- src/protos.h
+++ src/protos.h
@@ -72,11 +72,11 @@
 extern int renderwater(float hf);
 extern void finishstrips();
 extern void setarraypointers();
 
 // client
-extern void localservertoclient(uchar *buf, int len);
+extern void localservertoclient(unsigned char *buf, int len);
 extern void connects(OFString *servername);
 extern void disconnect(bool onlyclean, bool async);
 extern void toserver(OFString *text);
 extern void addmsg(int rel, int num, int type, ...);
 extern bool multiplayer();
@@ -186,14 +186,14 @@
 extern void render_particles(int time);
 
 // worldio
 extern void save_world(OFString *fname);
 extern void load_world(OFString *mname);
-extern void writemap(OFString *mname, int msize, uchar *mdata);
+extern void writemap(OFString *mname, int msize, unsigned char *mdata);
 extern OFData *readmap(OFString *mname);
 extern void loadgamerest();
-extern void incomingdemodata(uchar *buf, int len, bool extras);
+extern void incomingdemodata(unsigned char *buf, int len, bool extras);
 extern void demoplaybackstep();
 extern void stop();
 extern void stopifrecording();
 extern void demodamage(int damage, const OFVector3D *o);
 extern void demoblend(int damage);
@@ -224,21 +224,22 @@
 extern void cleanupserver();
 extern void localconnect();
 extern void localdisconnect();
 extern void localclienttoserver(struct _ENetPacket *);
 extern void serverslice(int seconds, unsigned int timeout);
-extern void putint(uchar **p, int n);
-extern int getint(uchar **p);
-extern void sendstring(OFString *t, uchar **p);
+extern void putint(unsigned char **p, int n);
+extern int getint(unsigned char **p);
+extern void sendstring(OFString *t, unsigned char **p);
 extern void startintermission();
 extern void restoreserverstate(OFArray<Entity *> *ents);
-extern uchar *retrieveservers(uchar *buf, int buflen);
+extern unsigned char *retrieveservers(unsigned char *buf, int buflen);
 extern char msgsizelookup(int msg);
 extern void serverms(int mode, int numplayers, int minremain,
     OFString *smapname, int seconds, bool isfull);
 extern void servermsinit(OFString *master, OFString *sdesc, bool listen);
-extern void sendmaps(int n, OFString *mapname, int mapsize, uchar *mapdata);
+extern void sendmaps(
+    int n, OFString *mapname, int mapsize, unsigned char *mapdata);
 extern ENetPacket *recvmap(int n);
 
 // weapon
 extern void selectgun(int a, int b, int c);
 extern void shoot(DynamicEntity *d, const OFVector3D *to);
@@ -251,21 +252,21 @@
 extern int reloadtime(int gun);
 
 // entities
 extern void initEntities();
 extern void renderents();
-extern void putitems(uchar **p);
+extern void putitems(unsigned char **p);
 extern void checkquad(int time);
 extern void checkitems();
 extern void realpickup(int n, DynamicEntity *d);
 extern void renderentities();
 extern void resetspawns();
-extern void setspawn(uint i, bool on);
+extern void setspawn(size_t i, bool on);
 extern void teleport(int n, DynamicEntity *d);
 extern void baseammo(int gun);
 
 // rndmap
 extern void perlinarea(const struct block *b, int scale, int seed, int psize);
 
 #ifdef __cplusplus
 }
 #endif

Index: src/rendercubes.m
==================================================================
--- src/rendercubes.m
+++ src/rendercubes.m
@@ -147,15 +147,17 @@
 		        abs(ol4b - l4->b) < lighterr) ||
 		    !wtex) {
 			curvert -= 2;
 			nquads--;
 		} else {
-			uchar *p3 = (uchar *)(&verts[curvert - 1].r);
+			unsigned char *p3 =
+			    (unsigned char *)(&verts[curvert - 1].r);
 			ol3r = p3[0];
 			ol3g = p3[1];
 			ol3b = p3[2];
-			uchar *p4 = (uchar *)(&verts[curvert - 2].r);
+			unsigned char *p4 =
+			    (unsigned char *)(&verts[curvert - 2].r);
 			ol4r = p4[0];
 			ol4g = p4[1];
 			ol4b = p4[2];
 		}
 	}

Index: src/rendergl.m
==================================================================
--- src/rendergl.m
+++ src/rendergl.m
@@ -111,11 +111,11 @@
 		}
 	}
 
 #if 0
 	for (int i = 0; i < s->w * s->h * 3; i++) {
-		uchar *p = (uchar *)s->pixels + i;
+		unsigned char *p = (unsigned char *)s->pixels + i;
 		*p = 255 - *p;
 	}
 #endif
 	glBindTexture(GL_TEXTURE_2D, tnum);
 	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

Index: src/savegamedemo.m
==================================================================
--- src/savegamedemo.m
+++ src/savegamedemo.m
@@ -304,11 +304,11 @@
 {
 	bdamage = damage;
 }
 
 void
-incomingdemodata(uchar *buf, int len, bool extras)
+incomingdemodata(unsigned char *buf, int len, bool extras)
 {
 	if (!demorecording)
 		return;
 	gzputi(lastmillis - starttime);
 	gzputi(len);
@@ -430,11 +430,11 @@
 			conoutf(
 			    @"error: huge packet during demo play (%d)", len);
 			stopreset();
 			return;
 		}
-		uchar buf[MAXTRANS];
+		unsigned char buf[MAXTRANS];
 		gzread(f, buf, len);
 		localservertoclient(buf, len); // update game state
 
 		DynamicEntity *target = players[democlientnum];
 		assert(target);

Index: src/server.m
==================================================================
--- src/server.m
+++ src/server.m
@@ -66,15 +66,15 @@
 void
 send2(bool rel, int cn, int a, int b)
 {
 	ENetPacket *packet =
 	    enet_packet_create(NULL, 32, rel ? ENET_PACKET_FLAG_RELIABLE : 0);
-	uchar *start = packet->data;
-	uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	unsigned char *p = start + 2;
 	putint(&p, a);
 	putint(&p, b);
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	if (cn < 0)
 		process(packet, -1);
 	else
 		send_(cn, packet);
@@ -85,15 +85,15 @@
 void
 sendservmsg(OFString *msg)
 {
 	ENetPacket *packet = enet_packet_create(
 	    NULL, _MAXDEFSTR + 10, ENET_PACKET_FLAG_RELIABLE);
-	uchar *start = packet->data;
-	uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	unsigned char *p = start + 2;
 	putint(&p, SV_SERVMSG);
 	sendstring(msg, &p);
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	multicast(packet, -1);
 	if (packet->referenceCount == 0)
 		enet_packet_destroy(packet);
 }
@@ -115,14 +115,15 @@
 	notgotitems = true;
 }
 
 // server side item pickup, acknowledge first client that gets it
 static void
-pickup(uint i, int sec, int sender)
+pickup(size_t i, int sec, int sender)
 {
-	if (i >= (uint)sents.count)
+	if (i >= sents.count)
 		return;
+
 	if (sents[i].spawned) {
 		sents[i].spawned = false;
 		sents[i].spawnsecs = sec;
 		send2(true, sender, SV_ITEMACC, i);
 	}
@@ -176,18 +177,18 @@
 // lag)
 
 void
 process(ENetPacket *packet, int sender) // sender may be -1
 {
-	if (ENET_NET_TO_HOST_16(*(ushort *)packet->data) !=
+	if (ENET_NET_TO_HOST_16(*(unsigned short *)packet->data) !=
 	    packet->dataLength) {
 		disconnect_client(sender, @"packet length");
 		return;
 	}
 
-	uchar *end = packet->data + packet->dataLength;
-	uchar *p = packet->data + 2;
+	unsigned char *end = packet->data + packet->dataLength;
+	unsigned char *p = packet->data + 2;
 	char text[MAXTRANS];
 	int cn = -1, type;
 
 	while (p < end) {
 		switch ((type = getint(&p))) {
@@ -298,12 +299,12 @@
 void
 send_welcome(int n)
 {
 	ENetPacket *packet =
 	    enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
-	uchar *start = packet->data;
-	__block uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	__block unsigned char *p = start + 2;
 	putint(&p, SV_INITS2C);
 	putint(&p, n);
 	putint(&p, PROTOCOL_VERSION);
 	putint(&p, *smapname.UTF8String);
 	sendstring(serverpassword, &p);
@@ -318,11 +319,11 @@
 			if (e.spawned)
 				putint(&p, i);
 		}];
 		putint(&p, -1);
 	}
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	send_(n, packet);
 }
 
 void

Index: src/serverbrowser.m
==================================================================
--- src/serverbrowser.m
+++ src/serverbrowser.m
@@ -128,12 +128,12 @@
 
 void
 pingservers()
 {
 	ENetBuffer buf;
-	uchar ping[MAXTRANS];
-	uchar *p;
+	unsigned char ping[MAXTRANS];
+	unsigned char *p;
 
 	for (ServerInfo *si in servers) {
 		if (si.address.host == ENET_HOST_ANY)
 			continue;
 
@@ -171,11 +171,11 @@
 checkpings()
 {
 	enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
 	ENetBuffer buf;
 	ENetAddress addr;
-	uchar ping[MAXTRANS], *p;
+	unsigned char ping[MAXTRANS], *p;
 	char text[MAXTRANS];
 	buf.data = ping;
 	buf.dataLength = sizeof(ping);
 
 	while (enet_socket_wait(pingsock, &events, 0) >= 0 && events) {
@@ -264,12 +264,12 @@
 
 void
 updatefrommaster()
 {
 	const int MAXUPD = 32000;
-	uchar buf[MAXUPD];
-	uchar *reply = retrieveservers(buf, MAXUPD);
+	unsigned char buf[MAXUPD];
+	unsigned char *reply = retrieveservers(buf, MAXUPD);
 	if (!*reply || strstr((char *)reply, "<html>") ||
 	    strstr((char *)reply, "<HTML>"))
 		conoutf(@"master server not replying");
 	else {
 		[servers removeAllObjects];

Index: src/serverms.m
==================================================================
--- src/serverms.m
+++ src/serverms.m
@@ -54,24 +54,24 @@
 		((char *)buf->data)[0] = 0;
 		buf->dataLength -= len;
 	}
 }
 
-static uchar *
-stripheader(uchar *b)
+static unsigned char *
+stripheader(unsigned char *b)
 {
 	char *s = strstr((char *)b, "\n\r\n");
 	if (!s)
 		s = strstr((char *)b, "\n\n");
-	return s ? (uchar *)s : b;
+	return s ? (unsigned char *)s : b;
 }
 
 static ENetAddress masterserver = { ENET_HOST_ANY, 80 };
 static int updmaster = 0;
 static OFString *masterbase;
 static OFString *masterpath;
-static uchar masterrep[MAXTRANS];
+static unsigned char masterrep[MAXTRANS];
 static ENetBuffer masterb;
 
 static void
 updatemasterserver(int seconds)
 {
@@ -95,12 +95,12 @@
 	httpgetrecieve(&masterb);
 	if (busy && mssock == ENET_SOCKET_NULL)
 		printf("masterserver reply: %s\n", stripheader(masterrep));
 }
 
-uchar *
-retrieveservers(uchar *buf, int buflen)
+unsigned char *
+retrieveservers(unsigned char *buf, int buflen)
 {
 	OFString *path =
 	    [OFString stringWithFormat:@"%@retrieve.do?item=list", masterpath];
 	httpgetsend(
 	    &masterserver, masterbase, path, @"cubeserver", @"Cube Server");
@@ -124,11 +124,11 @@
 	updatemasterserver(seconds);
 
 	// reply all server info requests
 	ENetBuffer buf;
 	ENetAddress addr;
-	uchar pong[MAXTRANS], *p;
+	unsigned char pong[MAXTRANS], *p;
 	int len;
 	enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
 	buf.data = pong;
 	while (enet_socket_wait(pongsock, &events, 0) >= 0 && events) {
 		buf.dataLength = sizeof(pong);

Index: src/serverutil.m
==================================================================
--- src/serverutil.m
+++ src/serverutil.m
@@ -4,11 +4,11 @@
 
 // all network traffic is in 32bit ints, which are then compressed using the
 // following simple scheme (assumes that most values are small).
 
 void
-putint(uchar **p, int n)
+putint(unsigned char **p, int n)
 {
 	if (n < 128 && n > -127) {
 		*(*p)++ = n;
 	} else if (n < 0x8000 && n >= -0x8000) {
 		*(*p)++ = 0x80;
@@ -22,11 +22,11 @@
 		*(*p)++ = n >> 24;
 	}
 }
 
 int
-getint(uchar **p)
+getint(unsigned char **p)
 {
 	int c = *((char *)*p);
 	(*p)++;
 	if (c == -128) {
 		int n = *(*p)++;
@@ -41,11 +41,11 @@
 	} else
 		return c;
 }
 
 void
-sendstring(OFString *t_, uchar **p)
+sendstring(OFString *t_, unsigned char **p)
 {
 	const char *t = t_.UTF8String;
 
 	for (size_t i = 0; i < _MAXDEFSTR && *t != '\0'; i++)
 		putint(p, *t++);
@@ -96,22 +96,22 @@
 
 // sending of maps between clients
 
 static OFString *copyname;
 int copysize;
-uchar *copydata = NULL;
+unsigned char *copydata = NULL;
 
 void
-sendmaps(int n, OFString *mapname, int mapsize, uchar *mapdata)
+sendmaps(int n, OFString *mapname, int mapsize, unsigned char *mapdata)
 {
 	if (mapsize <= 0 || mapsize > 256 * 256)
 		return;
 	copyname = mapname;
 	copysize = mapsize;
 	if (copydata)
 		OFFreeMemory(copydata);
-	copydata = (uchar *)OFAllocMemory(1, mapsize);
+	copydata = (unsigned char *)OFAllocMemory(1, mapsize);
 	memcpy(copydata, mapdata, mapsize);
 }
 
 ENetPacket *
 recvmap(int n)
@@ -118,26 +118,26 @@
 {
 	if (!copydata)
 		return NULL;
 	ENetPacket *packet = enet_packet_create(
 	    NULL, MAXTRANS + copysize, ENET_PACKET_FLAG_RELIABLE);
-	uchar *start = packet->data;
-	uchar *p = start + 2;
+	unsigned char *start = packet->data;
+	unsigned char *p = start + 2;
 	putint(&p, SV_RECVMAP);
 	sendstring(copyname, &p);
 	putint(&p, copysize);
 	memcpy(p, copydata, copysize);
 	p += copysize;
-	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
+	*(unsigned short *)start = ENET_HOST_TO_NET_16(p - start);
 	enet_packet_resize(packet, p - start);
 	return packet;
 }
 
 #ifdef STANDALONE
 
 void
-localservertoclient(uchar *buf, int len)
+localservertoclient(unsigned char *buf, int len)
 {
 }
 
 void
 fatal(OFConstantString *s, ...)

Index: src/tools.h
==================================================================
--- src/tools.h
+++ src/tools.h
@@ -20,14 +20,10 @@
 #include <stdlib.h>
 #include <string.h>
 
 #import <ObjFW/ObjFW.h>
 
-typedef unsigned char uchar;
-typedef unsigned short ushort;
-typedef unsigned int uint;
-
 #define max(a, b) (((a) > (b)) ? (a) : (b))
 #define min(a, b) (((a) < (b)) ? (a) : (b))
 #define rnd(max) (rand() % (max))
 #define rndreset() (srand(1))
 #define rndtime()                                            \

Index: src/tools.m
==================================================================
--- src/tools.m
+++ src/tools.m
@@ -11,12 +11,12 @@
 	if (*((char *)&stride))
 		return;
 
 	for (int w = 0; w < length; w++) {
 		for (int i = 0; i < stride / 2; i++) {
-			uchar *p = (uchar *)memory + w * stride;
-			uchar t = p[i];
+			unsigned char *p = (unsigned char *)memory + w * stride;
+			unsigned char t = p[i];
 			p[i] = p[stride - i - 1];
 			p[stride - i - 1] = t;
 		}
 	}
 }

Index: src/world.m
==================================================================
--- src/world.m
+++ src/world.m
@@ -129,11 +129,11 @@
 			o[2] = SWS(w, x + 1, y + 1, ws);
 			o[3] = SWS(w, x, y + 1, ws);
 			// the target cube in the higher mip level
 			struct sqr *r = SWS(v, x / 2, y / 2, vs);
 			*r = *o[0];
-			uchar nums[MAXTYPE];
+			unsigned char nums[MAXTYPE];
 			for (int i = 0; i < MAXTYPE; i++)
 				nums[i] = 0;
 			for (int j = 0; j < 4; j++)
 				nums[o[j]->type]++;
 			// cube contains both solid and space, treated
@@ -379,11 +379,11 @@
 	case MAPMODEL:
 		e.attr4 = e.attr3;
 		e.attr3 = e.attr2;
 	case MONSTER:
 	case TELEDEST:
-		e.attr2 = (uchar)e.attr1;
+		e.attr2 = (unsigned char)e.attr1;
 	case PLAYERSTART:
 		e.attr1 = (int)player1.yaw;
 		break;
 	}
 	addmsg(1, 10, SV_EDITENT, ents.count, type, e.x, e.y, e.z, e.attr1,
@@ -412,12 +412,12 @@
 	if (type == LIGHT)
 		calclight();
 }
 COMMAND(clearents, ARG_1STR)
 
-static uchar
-scalecomp(uchar c, int intens)
+static unsigned char
+scalecomp(unsigned char c, int intens)
 {
 	int n = c * intens / 100;
 	if (n > 255)
 		n = 255;
 	return n;

Index: src/worldio.m
==================================================================
--- src/worldio.m
+++ src/worldio.m
@@ -5,12 +5,12 @@
 #import "Entity.h"
 
 struct persistent_entity {
 	short x, y, z; // cube aligned position
 	short attr1;
-	uchar type; // type is one of the above
-	uchar attr2, attr3, attr4;
+	unsigned char type; // type is one of the above
+	unsigned char attr2, attr3, attr4;
 };
 
 void
 backup(OFString *name, OFString *backupname)
 {
@@ -137,11 +137,11 @@
 }
 
 // these two are used by getmap/sendmap.. transfers compressed maps directly
 
 void
-writemap(OFString *mname, int msize, uchar *mdata)
+writemap(OFString *mname, int msize, unsigned char *mdata)
 {
 	setnames(mname);
 	backup(cgzname, bakname);
 
 	FILE *f = fopen([cgzname cStringWithEncoding:OFLocale.encoding], "wb");

Index: src/worldlight.m
==================================================================
--- src/worldlight.m
+++ src/worldlight.m
@@ -106,11 +106,11 @@
 	{
 		for (int i = 0; i < steps; i++) {
 			struct sqr *s = S(x >> PRECBITS, y >> PRECBITS);
 			int light = l >> PRECBITS;
 			if (light > s->r)
-				s->r = s->g = s->b = (uchar)light;
+				s->r = s->g = s->b = (unsigned char)light;
 			if (SOLID(s))
 				return;
 			x += stepx;
 			y += stepy;
 			l -= stepl;