Cube  Check-in [71ebb79f8f]

	OFString *msg =
	    [OFString stringWithFormat:@"%@%@ (%s)\n", s, o, SDL_GetError()];

	[Cube.sharedInstance showMessage:msg];
	[OFApplication terminateWithStatus:1];
}

void *
alloc(int s) // for some big chunks... most other allocs use the memory pool
{
	void *b = calloc(1, s);
	if (!b)
		fatal(@"out of memory!");
	return b;
}

void
quit() // normal exit
{
	[Cube.sharedInstance quit];
}
COMMAND(quit, ARG_NONE)

		d->ammo[GUN_SG] = 5;
	}
}

dynent *
newdynent() // create a new blank player or monster
{
	dynent *d = (dynent *)malloc(sizeof(dynent));
	dynent *d = (dynent *)OFAllocMemory(1, sizeof(dynent));
	d->o.x = 0;
	d->o.y = 0;
	d->o.z = 0;
	d->yaw = 270;
	d->pitch = 0;
	d->roll = 0;
	d->maxspeed = 22;

		}
	}
}

void
zapdynent(dynent *&d)
{
	if (d)
	OFFreeMemory(d);
		free(d);
	d = NULL;
}

extern int democlientnum;

void
otherplayers()

			c2sinfo(player1); // do this last, to reduce the
			                  // effective frame lag
		}
	}
	lastmillis = millis;
}

// brute force but effective way to find a free spawn spot in the map
void
entinmap(dynent *
entinmap(dynent *d)
        d) // brute force but effective way to find a free spawn spot in the map
{
	loopi(100) // try max 100 times
	{
		float dx = (rnd(21) - 10) / 10.0f * i; // increasing distance
		float dy = (rnd(21) - 10) / 10.0f * i;
		d->o.x += dx;
		d->o.y += dy;

pruneundos(int maxremain) // bound memory
{
	int t = 0;
	loopvrev(undos)
	{
		t += undos[i]->xs * undos[i]->ys * sizeof(sqr);
		if (t > maxremain)
			free(undos.remove(i));
			OFFreeMemory(undos.remove(i));
	}
}

void
makeundo()
{
	undos.add(blockcopy(sel));
	pruneundos(undomegs << 20);
}

void
editundo()
{
	EDITMP;
	if (undos.empty()) {
		conoutf(@"nothing more to undo");
		return;
	}
	block *p = undos.pop();
	blockpaste(*p);
	free(p);
	OFFreeMemory(p);
}

block *copybuf = NULL;

void
copy()
{
	EDITSELMP;
	if (copybuf)
		free(copybuf);
		OFFreeMemory(copybuf);
	copybuf = blockcopy(sel);
}

void
paste()
{
	EDITMP;

// worldocull
extern void computeraytable(float vx, float vy);
extern int isoccluded(float vx, float vy, float cx, float cy, float csize);

// main
extern void fatal(OFString *s, OFString *o = @"");
extern void *alloc(int s);

// rendertext
extern void draw_text(OFString *string, int left, int top, int gl_num);
extern void draw_textf(
    OFConstantString *format, int left, int top, int gl_num, ...);
extern int text_width(OFString *string);
extern void draw_envbox(int t, int fogdist);

	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(vertex), &verts[0].r);
	glTexCoordPointer(2, GL_FLOAT, sizeof(vertex), &verts[0].u);
}

void
reallocv()
{
	verts =
	verts = (vertex *)realloc(verts, (curmaxverts *= 2) * sizeof(vertex));
	    (vertex *)OFResizeMemory(verts, (curmaxverts *= 2), sizeof(vertex));
	curmaxverts -= 10;
	if (!verts)
		fatal(@"no vertex memory!");
	setarraypointers();
}

// generating the actual vertices is done dynamically every frame and sits at
// the leaves of all these functions, and are part of the cpu bottleneck on
// really slow machines, hence the macros.

		}

		void *scaledimg = s->pixels;

		if (*xs != s->w) {
			conoutf(@"warning: quality loss: scaling %@",
			    IRI.string); // for voodoo cards under linux
			scaledimg = alloc(*xs * *ys * 3);
			scaledimg = OFAllocMemory(1, *xs * *ys * 3);
			gluScaleImage(GL_RGB, s->w, s->h, GL_UNSIGNED_BYTE,
			    s->pixels, *xs, *ys, GL_UNSIGNED_BYTE, scaledimg);
		}

		if (gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, *xs, *ys, GL_RGB,
		        GL_UNSIGNED_BYTE, scaledimg))
			fatal(@"could not build mipmaps");

sendmaps(int n, OFString *mapname, int mapsize, uchar *mapdata)
{
	if (mapsize <= 0 || mapsize > 256 * 256)
		return;
	copyname = mapname;
	copysize = mapsize;
	if (copydata)
		free(copydata);
	copydata = (uchar *)alloc(mapsize);
		OFFreeMemory(copydata);
	copydata = (uchar *)OFAllocMemory(1, mapsize);
	memcpy(copydata, mapdata, mapsize);
}

ENetPacket *
recvmap(int n)
{
	if (!copydata)

#include <string.h>
#ifdef __GNUC__
# include <new>
#else
# include <new.h>
#endif

#import <ObjFW/ObjFW.h>

#ifdef NULL
# undef NULL
#endif
#define NULL 0

typedef unsigned char uchar;
typedef unsigned short ushort;

	T *buf;
	int alen;
	int ulen;

	vector()
	{
		alen = 8;
		buf = (T *)malloc(alen * sizeof(T));
		buf = (T *)OFAllocMemory(alen, sizeof(T));
		ulen = 0;
	}

	~vector()
	{
		setsize(0);
		free(buf);

		qsort(buf, ulen, sizeof(T),
		    (int(__cdecl *)(const void *, const void *))cf);
	}

	void
	realloc()
	{
		buf = (T *)::realloc(buf, (alen *= 2) * sizeof(T));
		buf = (T *)OFResizeMemory(buf, (alen *= 2), sizeof(T));
	}

	T
	remove(int i)
	{
		T e = buf[i];
		for (int p = i + 1; p < ulen; p++)

void
setupworld(int factor)
{
	ssize = 1 << (sfactor = factor);
	cubicsize = ssize * ssize;
	mipsize = cubicsize * 134 / 100;
	sqr *w = world = (sqr *)alloc(mipsize * sizeof(sqr));
	sqr *w = world = (sqr *)OFAllocZeroedMemory(mipsize, sizeof(sqr));
	loopi(LARGEST_FACTOR * 2)
	{
		wmip[i] = w;
		w += cubicsize >> (i * 2);
	}
}

// main empty world creation routine, if passed factor -1 will enlarge old
// world by 1
void
empty_world(
empty_world(int factor, bool force)
    int factor, bool force) // main empty world creation routine, if passed
                            // factor -1 will enlarge old world by 1
{
	if (!force && noteditmode())
		return;
	cleardlights();
	pruneundos();
	sqr *oldworld = world;
	bool copy = false;

		block b = { 8, 8, ssize - 16, ssize - 16 };
		edittypexy(SPACE, b);
	}

	calclight();
	startmap(@"base/unnamed");
	if (oldworld) {
		free(oldworld);
		OFFreeMemory(oldworld);
		toggleedit();
		execute(@"fullbright 1");
	}
}

void
mapenlarge()

}

// utility functions also used by editing code

block *
blockcopy(block &s)
{
	block *b = (block *)OFAllocZeroedMemory(
	block *b = (block *)alloc(sizeof(block) + s.xs * s.ys * sizeof(sqr));
	    1, sizeof(block) + s.xs * s.ys * sizeof(sqr));
	*b = s;
	sqr *q = (sqr *)(b + 1);
	for (int x = s.x; x < s.xs + s.x; x++)
		for (int y = s.y; y < s.ys + s.y; y++)
			*q++ = *S(x, y);
	return b;
}