// worldio.cpp: loading & saving of maps and savegames

#include "engine.h"

void validmapname(char *dst, const char *src, const char *prefix = NULL, const char *alt = "untitled", size_t maxlen = 100)
{
	if(prefix) while(*prefix) *dst++ = *prefix++;
	const char *start = dst;
	if(src) loopi(maxlen)
	{
		char c = *src++;
		if(iscubealnum(c) || c == '_' || c == '-' || c == '/' || c == '\\') *dst++ = c;
		else break;
	}
	if(dst > start) *dst = '\0';
	else if(dst != alt) copystring(dst, alt, maxlen);
}

void fixmapname(char *name)
{
	validmapname(name, name, NULL, "");
}

void getmapfilenames(const char *fname, const char *cname, char *pakname, char *mapname, char *cfgname)
{
	if(!cname) cname = fname;
	string name;
	validmapname(name, cname);
	char *slash = strpbrk(name, "/\\");
	if(slash)
	{
		copystring(pakname, name, slash-name+1);
		copystring(cfgname, slash+1, MAXSTRLEN);
	}
	else
	{
		copystring(pakname, "maps", MAXSTRLEN);
		copystring(cfgname, name, MAXSTRLEN);
	}
	validmapname(mapname, fname, strpbrk(fname, "/\\") ? NULL : "maps/");
}

bool loadents(const char *fname, vector<entity> &ents, uint *crc)
{
	string pakname, mapname, mcfgname, ogzname;
	getmapfilenames(fname, NULL, pakname, mapname, mcfgname);
	formatstring(ogzname, "packages/%s.ogz", mapname);
	path(ogzname);
	stream *f = opengzfile(ogzname, "rb");
	if(!f) return false;
	octaheader hdr;
	if(f->read(&hdr, 7*sizeof(int)) != 7*sizeof(int)) { conoutf(CON_ERROR, "map %s has malformatted header", ogzname); delete f; return false; }
	lilswap(&hdr.version, 6);
	if(memcmp(hdr.magic, "OCTA", 4) || hdr.worldsize <= 0|| hdr.numents < 0) { conoutf(CON_ERROR, "map %s has malformatted header", ogzname); delete f; return false; }
	if(hdr.version>MAPVERSION) { conoutf(CON_ERROR, "map %s requires a newer version of Cube 2: Sauerbraten", ogzname); delete f; return false; }

	lilswap(&hdr.numvslots, 1);

	loopi(hdr.numvars)
	{
		int type = f->getchar(), ilen = f->getlil<ushort>();
		f->seek(ilen, SEEK_CUR);
		switch(type)
		{
			case ID_VAR: f->getlil<int>(); break;
			case ID_FVAR: f->getlil<float>(); break;
			case ID_SVAR: { int slen = f->getlil<ushort>(); f->seek(slen, SEEK_CUR); break; }
		}
	}

	string gametype;
	copystring(gametype, "fps");
	bool samegame = true;
	int eif = 0;
	{
		int len = f->getchar();
		f->read(gametype, len+1);
	}
	if(strcmp(gametype, game::gameident()))
	{
		samegame = false;
		conoutf(CON_WARN, "WARNING: loading map from %s game, ignoring entities except for lights/mapmodels", gametype);
	}
	{
		eif = f->getlil<ushort>();
		int extrasize = f->getlil<ushort>();
		f->seek(extrasize, SEEK_CUR);
	}

	ushort nummru = f->getlil<ushort>();
	f->seek(nummru*sizeof(ushort), SEEK_CUR);

	loopi(min(hdr.numents, MAXENTS))
	{
		entity &e = ents.add();
		f->read(&e, sizeof(entity));
		lilswap(&e.o.x, 3);
		lilswap(&e.attr1, 5);
		if(eif > 0) f->seek(eif, SEEK_CUR);
		if(e.type>=ET_GAMESPECIFIC)
		{
			ents.pop();
			continue;
		}
	}

	if(crc)
	{
		f->seek(0, SEEK_END);
		*crc = f->getcrc();
	}

	delete f;

	return true;
}

#ifndef STANDALONE
string ogzname, bakname, cfgname, picname;

VARP(savebak, 0, 2, 2);

void setmapfilenames(const char *fname, const char *cname = NULL)
{
	string pakname, mapname, mcfgname;
	getmapfilenames(fname, cname, pakname, mapname, mcfgname);

	formatstring(ogzname, "packages/%s.ogz", mapname);
	if(savebak==1) formatstring(bakname, "packages/%s.BAK", mapname);
	else formatstring(bakname, "packages/%s_%d.BAK", mapname, totalmillis);
	formatstring(cfgname, "packages/%s/%s.cfg", pakname, mcfgname);
	formatstring(picname, "packages/%s.png", mapname);

	path(ogzname);
	path(bakname);
	path(cfgname);
	path(picname);
}

void mapcfgname()
{
	const char *mname = game::getclientmap();
	string pakname, mapname, mcfgname;
	getmapfilenames(mname, NULL, pakname, mapname, mcfgname);
	defformatstring(cfgname, "packages/%s/%s.cfg", pakname, mcfgname);
	path(cfgname);
	result(cfgname);
}

COMMAND(mapcfgname, "");

void backup(char *name, char *backupname)
{
	string backupfile;
	copystring(backupfile, findfile(backupname, "wb"));
	remove(backupfile);
	rename(findfile(name, "wb"), backupfile);
}

enum { OCTSAV_CHILDREN = 0, OCTSAV_EMPTY, OCTSAV_SOLID, OCTSAV_NORMAL, OCTSAV_LODCUBE };

static int savemapprogress = 0;

void savec(cube *c, const ivec &o, int size, stream *f, bool nolms)
{
	if((savemapprogress++&0xFFF)==0) renderprogress(float(savemapprogress)/allocnodes, "saving octree...");

	loopi(8)
	{
		ivec co(i, o, size);
		if(c[i].children)
		{
			f->putchar(OCTSAV_CHILDREN);
			savec(c[i].children, co, size>>1, f, nolms);
		}
		else
		{
			int oflags = 0, surfmask = 0, totalverts = 0;
			if(c[i].material!=MAT_AIR) oflags |= 0x40;
			if(isempty(c[i])) f->putchar(oflags | OCTSAV_EMPTY);
			else
			{
				if(!nolms)
				{
					if(c[i].merged) oflags |= 0x80;
					if(c[i].ext) loopj(6)
					{
						const surfaceinfo &surf = c[i].ext->surfaces[j];
						if(!surf.used()) continue;
						oflags |= 0x20;
						surfmask |= 1<<j;
						totalverts += surf.totalverts();
					}
				}

				if(isentirelysolid(c[i])) f->putchar(oflags | OCTSAV_SOLID);
				else
				{
					f->putchar(oflags | OCTSAV_NORMAL);
					f->write(c[i].edges, 12);
				}
			}

			loopj(6) f->putlil<ushort>(c[i].texture[j]);

			if(oflags&0x40) f->putlil<ushort>(c[i].material);
			if(oflags&0x80) f->putchar(c[i].merged);
			if(oflags&0x20)
			{
				f->putchar(surfmask);
				f->putchar(totalverts);
				loopj(6) if(surfmask&(1<<j))
				{
					surfaceinfo surf = c[i].ext->surfaces[j];
					vertinfo *verts = c[i].ext->verts() + surf.verts;
					int layerverts = surf.numverts&MAXFACEVERTS, numverts = surf.totalverts(),
						vertmask = 0, vertorder = 0, uvorder = 0,
						dim = dimension(j), vc = C[dim], vr = R[dim];
					if(numverts)
					{
						if(c[i].merged&(1<<j))
						{
							vertmask |= 0x04;
							if(layerverts == 4)
							{
								ivec v[4] = { verts[0].getxyz(), verts[1].getxyz(), verts[2].getxyz(), verts[3].getxyz() };
								loopk(4)
								{
									const ivec &v0 = v[k], &v1 = v[(k+1)&3], &v2 = v[(k+2)&3], &v3 = v[(k+3)&3];
									if(v1[vc] == v0[vc] && v1[vr] == v2[vr] && v3[vc] == v2[vc] && v3[vr] == v0[vr])
									{
										vertmask |= 0x01;
										vertorder = k;
										break;
									}
								}
							}
						}
						else
						{
							int vis = visibletris(c[i], j, co, size);
							if(vis&4 || faceconvexity(c[i], j) < 0) vertmask |= 0x01;
							if(layerverts < 4 && vis&2) vertmask |= 0x02;
						}
						bool matchnorm = true;
						loopk(numverts)
						{
							const vertinfo &v = verts[k];
							if(v.u || v.v) vertmask |= 0x40;
							if(v.norm) { vertmask |= 0x80; if(v.norm != verts[0].norm) matchnorm = false; }
						}
						if(matchnorm) vertmask |= 0x08;
						if(vertmask&0x40 && layerverts == 4)
						{
							loopk(4)
							{
								const vertinfo &v0 = verts[k], &v1 = verts[(k+1)&3], &v2 = verts[(k+2)&3], &v3 = verts[(k+3)&3];
								if(v1.u == v0.u && v1.v == v2.v && v3.u == v2.u && v3.v == v0.v)
								{
									if(surf.numverts&LAYER_DUP)
									{
										const vertinfo &b0 = verts[4+k], &b1 = verts[4+((k+1)&3)], &b2 = verts[4+((k+2)&3)], &b3 = verts[4+((k+3)&3)];
										if(b1.u != b0.u || b1.v != b2.v || b3.u != b2.u || b3.v != b0.v)
											continue;
									}
									uvorder = k;
									vertmask |= 0x02 | (((k+4-vertorder)&3)<<4);
									break;
								}
							}
						}
					}
					surf.verts = vertmask;
					f->write(&surf, sizeof(surfaceinfo));
					bool hasxyz = (vertmask&0x04)!=0, hasuv = (vertmask&0x40)!=0, hasnorm = (vertmask&0x80)!=0;
					if(layerverts == 4)
					{
						if(hasxyz && vertmask&0x01)
						{
							ivec v0 = verts[vertorder].getxyz(), v2 = verts[(vertorder+2)&3].getxyz();
							f->putlil<ushort>(v0[vc]); f->putlil<ushort>(v0[vr]);
							f->putlil<ushort>(v2[vc]); f->putlil<ushort>(v2[vr]);
							hasxyz = false;
						}
						if(hasuv && vertmask&0x02)
						{
							const vertinfo &v0 = verts[uvorder], &v2 = verts[(uvorder+2)&3];
							f->putlil<ushort>(v0.u); f->putlil<ushort>(v0.v);
							f->putlil<ushort>(v2.u); f->putlil<ushort>(v2.v);
							if(surf.numverts&LAYER_DUP)
							{
								const vertinfo &b0 = verts[4+uvorder], &b2 = verts[4+((uvorder+2)&3)];
								f->putlil<ushort>(b0.u); f->putlil<ushort>(b0.v);
								f->putlil<ushort>(b2.u); f->putlil<ushort>(b2.v);
							}
							hasuv = false;
						}
					}
					if(hasnorm && vertmask&0x08) { f->putlil<ushort>(verts[0].norm); hasnorm = false; }
					if(hasxyz || hasuv || hasnorm) loopk(layerverts)
					{
						const vertinfo &v = verts[(k+vertorder)%layerverts];
						if(hasxyz)
						{
							ivec xyz = v.getxyz();
							f->putlil<ushort>(xyz[vc]); f->putlil<ushort>(xyz[vr]);
						}
						if(hasuv) { f->putlil<ushort>(v.u); f->putlil<ushort>(v.v); }
						if(hasnorm) f->putlil<ushort>(v.norm);
					}
					if(surf.numverts&LAYER_DUP) loopk(layerverts)
					{
						const vertinfo &v = verts[layerverts + (k+vertorder)%layerverts];
						if(hasuv) { f->putlil<ushort>(v.u); f->putlil<ushort>(v.v); }
					}
				}
			}
		}
	}
}

struct surfacecompat
{
	uchar texcoords[8];
	uchar w, h;
	ushort x, y;
	uchar lmid, layer;
};

struct normalscompat
{
	bvec normals[4];
};

struct mergecompat
{
	ushort u1, u2, v1, v2;
};

cube *loadchildren(stream *f, const ivec &co, int size, bool &failed);

void loadc(stream *f, cube &c, const ivec &co, int size, bool &failed)
{
	bool haschildren = false;
	int octsav = f->getchar();
	switch(octsav&0x7)
	{
		case OCTSAV_CHILDREN:
			c.children = loadchildren(f, co, size>>1, failed);
			return;

		case OCTSAV_LODCUBE: haschildren = true;	break;
		case OCTSAV_EMPTY:  emptyfaces(c);		  break;
		case OCTSAV_SOLID:  solidfaces(c);		  break;
		case OCTSAV_NORMAL: f->read(c.edges, 12); break;
		default: failed = true; return;
	}
	loopi(6) c.texture[i] = mapversion<14 ? f->getchar() : f->getlil<ushort>();

	{
		if(octsav&0x40) c.material = f->getlil<ushort>();
		if(octsav&0x80) c.merged = f->getchar();
		if(octsav&0x20)
		{
			int surfmask, totalverts;
			surfmask = f->getchar();
			totalverts = max(f->getchar(), 0);
			newcubeext(c, totalverts, false);
			memset(c.ext->surfaces, 0, sizeof(c.ext->surfaces));
			memset(c.ext->verts(), 0, totalverts*sizeof(vertinfo));
			int offset = 0;
			loopi(6) if(surfmask&(1<<i))
			{
				surfaceinfo &surf = c.ext->surfaces[i];
				f->read(&surf, sizeof(surfaceinfo));
				int vertmask = surf.verts, numverts = surf.totalverts();
				if(!numverts) { surf.verts = 0; continue; }
				surf.verts = offset;
				vertinfo *verts = c.ext->verts() + offset;
				offset += numverts;
				ivec v[4], n, vo = ivec(co).mask(0xFFF).shl(3);
				int layerverts = surf.numverts&MAXFACEVERTS, dim = dimension(i), vc = C[dim], vr = R[dim], bias = 0;
				genfaceverts(c, i, v);
				bool hasxyz = (vertmask&0x04)!=0, hasuv = (vertmask&0x40)!=0, hasnorm = (vertmask&0x80)!=0;
				if(hasxyz)
				{
					ivec e1, e2, e3;
					n.cross((e1 = v[1]).sub(v[0]), (e2 = v[2]).sub(v[0]));
					if(n.iszero()) n.cross(e2, (e3 = v[3]).sub(v[0]));
					bias = -n.dot(ivec(v[0]).mul(size).add(vo));
				}
				else
				{
					int vis = layerverts < 4 ? (vertmask&0x02 ? 2 : 1) : 3, order = vertmask&0x01 ? 1 : 0, k = 0;
					verts[k++].setxyz(v[order].mul(size).add(vo));
					if(vis&1) verts[k++].setxyz(v[order+1].mul(size).add(vo));
					verts[k++].setxyz(v[order+2].mul(size).add(vo));
					if(vis&2) verts[k++].setxyz(v[(order+3)&3].mul(size).add(vo));
				}
				if(layerverts == 4)
				{
					if(hasxyz && vertmask&0x01)
					{
						ushort c1 = f->getlil<ushort>(), r1 = f->getlil<ushort>(), c2 = f->getlil<ushort>(), r2 = f->getlil<ushort>();
						ivec xyz;
						xyz[vc] = c1; xyz[vr] = r1; xyz[dim] = n[dim] ? -(bias + n[vc]*xyz[vc] + n[vr]*xyz[vr])/n[dim] : vo[dim];
						verts[0].setxyz(xyz);
						xyz[vc] = c1; xyz[vr] = r2; xyz[dim] = n[dim] ? -(bias + n[vc]*xyz[vc] + n[vr]*xyz[vr])/n[dim] : vo[dim];
						verts[1].setxyz(xyz);
						xyz[vc] = c2; xyz[vr] = r2; xyz[dim] = n[dim] ? -(bias + n[vc]*xyz[vc] + n[vr]*xyz[vr])/n[dim] : vo[dim];
						verts[2].setxyz(xyz);
						xyz[vc] = c2; xyz[vr] = r1; xyz[dim] = n[dim] ? -(bias + n[vc]*xyz[vc] + n[vr]*xyz[vr])/n[dim] : vo[dim];
						verts[3].setxyz(xyz);
						hasxyz = false;
					}
					if(hasuv && vertmask&0x02)
					{
						int uvorder = (vertmask&0x30)>>4;
						vertinfo &v0 = verts[uvorder], &v1 = verts[(uvorder+1)&3], &v2 = verts[(uvorder+2)&3], &v3 = verts[(uvorder+3)&3];
						v0.u = f->getlil<ushort>(); v0.v = f->getlil<ushort>();
						v2.u = f->getlil<ushort>(); v2.v = f->getlil<ushort>();
						v1.u = v0.u; v1.v = v2.v;
						v3.u = v2.u; v3.v = v0.v;
						if(surf.numverts&LAYER_DUP)
						{
							vertinfo &b0 = verts[4+uvorder], &b1 = verts[4+((uvorder+1)&3)], &b2 = verts[4+((uvorder+2)&3)], &b3 = verts[4+((uvorder+3)&3)];
							b0.u = f->getlil<ushort>(); b0.v = f->getlil<ushort>();
							b2.u = f->getlil<ushort>(); b2.v = f->getlil<ushort>();
							b1.u = b0.u; b1.v = b2.v;
							b3.u = b2.u; b3.v = b0.v;
						}
						hasuv = false;
					}
				}
				if(hasnorm && vertmask&0x08)
				{
					ushort norm = f->getlil<ushort>();
					loopk(layerverts) verts[k].norm = norm;
					hasnorm = false;
				}
				if(hasxyz || hasuv || hasnorm) loopk(layerverts)
				{
					vertinfo &v = verts[k];
					if(hasxyz)
					{
						ivec xyz;
						xyz[vc] = f->getlil<ushort>(); xyz[vr] = f->getlil<ushort>();
						xyz[dim] = n[dim] ? -(bias + n[vc]*xyz[vc] + n[vr]*xyz[vr])/n[dim] : vo[dim];
						v.setxyz(xyz);
					}
					if(hasuv) { v.u = f->getlil<ushort>(); v.v = f->getlil<ushort>(); }
					if(hasnorm) v.norm = f->getlil<ushort>();
				}
				if(surf.numverts&LAYER_DUP) loopk(layerverts)
				{
					vertinfo &v = verts[k+layerverts], &t = verts[k];
					v.setxyz(t.x, t.y, t.z);
					if(hasuv) { v.u = f->getlil<ushort>(); v.v = f->getlil<ushort>(); }
					v.norm = t.norm;
				}
			}
		}
	}

	c.children = (haschildren ? loadchildren(f, co, size>>1, failed) : NULL);
}

cube *loadchildren(stream *f, const ivec &co, int size, bool &failed)
{
	cube *c = newcubes();
	loopi(8)
	{
		loadc(f, c[i], ivec(i, co, size), size, failed);
		if(failed) break;
	}
	return c;
}

void savevslot(stream *f, VSlot &vs, int prev)
{
	f->putlil<int>(vs.changed);
	f->putlil<int>(prev);
	if(vs.changed & (1<<VSLOT_SHPARAM))
	{
		f->putlil<ushort>(vs.params.length());
		loopv(vs.params)
		{
			SlotShaderParam &p = vs.params[i];
			f->putlil<ushort>(strlen(p.name));
			f->write(p.name, strlen(p.name));
			loopk(4) f->putlil<float>(p.val[k]);
		}
	}
	if(vs.changed & (1<<VSLOT_SCALE)) f->putlil<float>(vs.scale);
	if(vs.changed & (1<<VSLOT_ROTATION)) f->putlil<int>(vs.rotation);
	if(vs.changed & (1<<VSLOT_OFFSET))
	{
		f->putlil<int>(vs.offset.x);
		f->putlil<int>(vs.offset.y);
	}
	if(vs.changed & (1<<VSLOT_SCROLL))
	{
		f->putlil<float>(vs.scroll.x);
		f->putlil<float>(vs.scroll.y);
	}
	if(vs.changed & (1<<VSLOT_LAYER)) f->putlil<int>(vs.layer);
	if(vs.changed & (1<<VSLOT_ALPHA))
	{
		f->putlil<float>(vs.alphafront);
		f->putlil<float>(vs.alphaback);
	}
	if(vs.changed & (1<<VSLOT_COLOR))
	{
		loopk(3) f->putlil<float>(vs.colorscale[k]);
	}
}

void savevslots(stream *f, int numvslots)
{
	if(vslots.empty()) return;
	int *prev = new int[numvslots];
	for(int i=0;i<numvslots;++i)prev[i]=-1;
	loopi(numvslots)
	{
		VSlot *vs = vslots[i];
		if(vs->changed) continue;
		for(;;)
		{
			VSlot *cur = vs;
			do vs = vs->next; while(vs && vs->index >= numvslots);
			if(!vs) break;
			prev[vs->index] = cur->index;
		}
	}
	int lastroot = 0;
	loopi(numvslots)
	{
		VSlot &vs = *vslots[i];
		if(!vs.changed) continue;
		if(lastroot < i) f->putlil<int>(-(i - lastroot));
		savevslot(f, vs, prev[i]);
		lastroot = i+1;
	}
	if(lastroot < numvslots) f->putlil<int>(-(numvslots - lastroot));
	delete[] prev;
}

void loadvslot(stream *f, VSlot &vs, int changed)
{
	vs.changed = changed;
	if(vs.changed & (1<<VSLOT_SHPARAM))
	{
		int numparams = f->getlil<ushort>();
		string name;
		loopi(numparams)
		{
			SlotShaderParam &p = vs.params.add();
			int nlen = f->getlil<ushort>();
			f->read(name, min(nlen, MAXSTRLEN-1));
			name[min(nlen, MAXSTRLEN-1)] = '\0';
			if(nlen >= MAXSTRLEN) f->seek(nlen - (MAXSTRLEN-1), SEEK_CUR);
			p.name = getshaderparamname(name);
			p.loc = -1;
			loopk(4) p.val[k] = f->getlil<float>();
		}
	}
	if(vs.changed & (1<<VSLOT_SCALE)) vs.scale = f->getlil<float>();
	if(vs.changed & (1<<VSLOT_ROTATION)) vs.rotation = clamp(f->getlil<int>(), 0, 7);
	if(vs.changed & (1<<VSLOT_OFFSET))
	{
		vs.offset.x = f->getlil<int>();
		vs.offset.y = f->getlil<int>();
	}
	if(vs.changed & (1<<VSLOT_SCROLL))
	{
		vs.scroll.x = f->getlil<float>();
		vs.scroll.y = f->getlil<float>();
	}
	if(vs.changed & (1<<VSLOT_LAYER)) vs.layer = f->getlil<int>();
	if(vs.changed & (1<<VSLOT_ALPHA))
	{
		vs.alphafront = f->getlil<float>();
		vs.alphaback = f->getlil<float>();
	}
	if(vs.changed & (1<<VSLOT_COLOR))
	{
		loopk(3) vs.colorscale[k] = f->getlil<float>();
	}
}

void loadvslots(stream *f, int numvslots)
{
	int *prev = new (false) int[numvslots];
	if(!prev) return;
	for(int i=0;i<numvslots;++i)prev[i]=-1;
	while(numvslots > 0)
	{
		int changed = f->getlil<int>();
		if(changed < 0)
		{
			loopi(-changed) vslots.add(new VSlot(NULL, vslots.length()));
			numvslots += changed;
		}
		else
		{
			prev[vslots.length()] = f->getlil<int>();
			loadvslot(f, *vslots.add(new VSlot(NULL, vslots.length())), changed);
			numvslots--;
		}
	}
	loopv(vslots) if(vslots.inrange(prev[i])) vslots[prev[i]]->next = vslots[i];
	delete[] prev;
}

bool save_world(const char *mname, bool nolms)
{
	if(!*mname) mname = game::getclientmap();
	setmapfilenames(mname);
	if(savebak) backup(ogzname, bakname);
	stream *f = opengzfile(ogzname, "wb");
	if(!f) { conoutf(CON_WARN, "could not write map to %s", ogzname); return false; }

	int numvslots = vslots.length();
	if(!nolms && !multiplayer(false))
	{
		numvslots = compactvslots();
		allchanged();
	}

	savemapprogress = 0;
	renderprogress(0, "saving map...");

	octaheader hdr;
	memcpy(hdr.magic, "OCTA", 4);
	hdr.version = MAPVERSION;
	hdr.headersize = sizeof(hdr);
	hdr.worldsize = worldsize;
	hdr.numents = 0;
	const vector<extentity *> &ents = entities::getents();
	loopv(ents) if(ents[i]->type!=ET_EMPTY || nolms) hdr.numents++;
	hdr.numpvs = 0;
	hdr.lightmaps = nolms ? 0 : lightmaps.length();
	hdr.numvars = 0;
	hdr.numvslots = numvslots;
	enumerate(idents, ident, id,
	{
		if((id.type == ID_VAR || id.type == ID_FVAR || id.type == ID_SVAR) && id.flags&IDF_OVERRIDE && !(id.flags&IDF_READONLY) && id.flags&IDF_OVERRIDDEN) hdr.numvars++;
	});
	lilswap(&hdr.version, 9);
	f->write(&hdr, sizeof(hdr));

	enumerate(idents, ident, id,
	{
		if((id.type!=ID_VAR && id.type!=ID_FVAR && id.type!=ID_SVAR) || !(id.flags&IDF_OVERRIDE) || id.flags&IDF_READONLY || !(id.flags&IDF_OVERRIDDEN)) continue;
		f->putchar(id.type);
		f->putlil<ushort>(strlen(id.name));
		f->write(id.name, strlen(id.name));
		switch(id.type)
		{
			case ID_VAR:
				f->putlil<int>(*id.storage.i);
				break;

			case ID_FVAR:
				f->putlil<float>(*id.storage.f);
				break;

			case ID_SVAR:
				f->putlil<ushort>(strlen(*id.storage.s));
				f->write(*id.storage.s, strlen(*id.storage.s));
				break;
		}
	});

	f->putchar((int)strlen(game::gameident()));
	f->write(game::gameident(), (int)strlen(game::gameident())+1);
	f->putlil<ushort>(entities::extraentinfosize());
	vector<char> extras;
	game::writegamedata(extras);
	f->putlil<ushort>(extras.length());
	f->write(extras.getbuf(), extras.length());

	f->putlil<ushort>(texmru.length());
	loopv(texmru) f->putlil<ushort>(texmru[i]);
	char *ebuf = new char[entities::extraentinfosize()];
	loopv(ents)
	{
		if(ents[i]->type!=ET_EMPTY || nolms)
		{
			entity tmp = *ents[i];
			lilswap(&tmp.o.x, 3);
			lilswap(&tmp.attr1, 5);
			f->write(&tmp, sizeof(entity));
			if(entities::extraentinfosize()) f->write(ebuf, entities::extraentinfosize());
		}
	}
	delete[] ebuf;

	savevslots(f, numvslots);

	renderprogress(0, "saving octree...");
	savec(worldroot, ivec(0, 0, 0), worldsize>>1, f, nolms);

	if(!nolms)
	{
		if(lightmaps.length()) renderprogress(0, "saving lightmaps...");
		loopv(lightmaps)
		{
			LightMap &lm = lightmaps[i];
			f->putchar(lm.type | (lm.unlitx>=0 ? 0x80 : 0));
			if(lm.unlitx>=0)
			{
				f->putlil<ushort>(ushort(lm.unlitx));
				f->putlil<ushort>(ushort(lm.unlity));
			}
			f->write(lm.data, lm.bpp*LM_PACKW*LM_PACKH);
			renderprogress(float(i+1)/lightmaps.length(), "saving lightmaps...");
		}
	}

	delete f;
	conoutf("wrote map file %s", ogzname);
	return true;
}

static uint mapcrc = 0;

uint getmapcrc() { return mapcrc; }
void clearmapcrc() { mapcrc = 0; }

bool load_world(const char *mname, const char *cname)		// still supports all map formats that have existed since the earliest cube betas!
{
	int loadingstart = SDL_GetTicks();
	setmapfilenames(mname, cname);
	stream *f = opengzfile(ogzname, "rb");
	if(!f) { conoutf(CON_ERROR, "could not read map %s", ogzname); return false; }
	octaheader hdr;
	if(f->read(&hdr, 7*sizeof(int)) != 7*sizeof(int)) { conoutf(CON_ERROR, "map %s has malformatted header", ogzname); delete f; return false; }
	lilswap(&hdr.version, 6);
	if(memcmp(hdr.magic, "OCTA", 4) || hdr.worldsize <= 0|| hdr.numents < 0) { conoutf(CON_ERROR, "map %s has malformatted header", ogzname); delete f; return false; }
	if(hdr.version>MAPVERSION) { conoutf(CON_ERROR, "map %s requires a newer version of Cube 2: Sauerbraten", ogzname); delete f; return false; }

	resetmap();

	Texture *mapshot = textureload(picname, 3, true, false);
	renderbackground("loading...", mapshot, mname, game::getmapinfo());

	game::loadingmap(cname ? cname : mname);

	setvar("mapversion", hdr.version, true, false);

	lilswap(&hdr.numvslots, 1);

	renderprogress(0, "clearing world...");

	freeocta(worldroot);
	worldroot = NULL;

	int worldscale = 0;
	while(1<<worldscale < hdr.worldsize) worldscale++;
	setvar("mapsize", 1<<worldscale, true, false);
	setvar("mapscale", worldscale, true, false);

	renderprogress(0, "loading vars...");

	loopi(hdr.numvars)
	{
		int type = f->getchar(), ilen = f->getlil<ushort>();
		string name;
		f->read(name, min(ilen, MAXSTRLEN-1));
		name[min(ilen, MAXSTRLEN-1)] = '\0';
		if(ilen >= MAXSTRLEN) f->seek(ilen - (MAXSTRLEN-1), SEEK_CUR);
		ident *id = getident(name);
		bool exists = id && id->type == type && id->flags&IDF_OVERRIDE;
		switch(type)
		{
			case ID_VAR:
			{
				int val = f->getlil<int>();
				if(exists && id->minval <= id->maxval) setvar(name, val);
				break;
			}

			case ID_FVAR:
			{
				float val = f->getlil<float>();
				if(exists && id->minvalf <= id->maxvalf) setfvar(name, val);
				break;
			}

			case ID_SVAR:
			{
				int slen = f->getlil<ushort>();
				string val;
				f->read(val, min(slen, MAXSTRLEN-1));
				val[min(slen, MAXSTRLEN-1)] = '\0';
				if(slen >= MAXSTRLEN) f->seek(slen - (MAXSTRLEN-1), SEEK_CUR);
				if(exists) setsvar(name, val);
				break;
			}
		}
	}

	string gametype;
	copystring(gametype, "fps");
	bool samegame = true;
	int eif = 0;
	{
		int len = f->getchar();
		f->read(gametype, len+1);
	}
	if(strcmp(gametype, game::gameident())!=0)
	{
		samegame = false;
		conoutf(CON_WARN, "WARNING: loading map from %s game, ignoring entities except for lights/mapmodels", gametype);
	}
	{
		eif = f->getlil<ushort>();
		int extrasize = f->getlil<ushort>();
		vector<char> extras;
		f->read(extras.pad(extrasize), extrasize);
		if(samegame) game::readgamedata(extras);
	}

	texmru.shrink(0);
	ushort nummru = f->getlil<ushort>();
	loopi(nummru) texmru.add(f->getlil<ushort>());

	renderprogress(0, "loading entities...");

	vector<extentity *> &ents = entities::getents();
	int einfosize = entities::extraentinfosize();
	char *ebuf = einfosize > 0 ? new char[einfosize] : NULL;
	loopi(min(hdr.numents, MAXENTS))
	{
		extentity &e = *entities::newentity();
		ents.add(&e);
		f->read(&e, sizeof(entity));
		lilswap(&e.o.x, 3);
		lilswap(&e.attr1, 5);
		if(samegame)
		{
			if(einfosize > 0) f->read(ebuf, einfosize);
		}
		else
		{
			if(eif > 0) f->seek(eif, SEEK_CUR);
			if(e.type>=ET_GAMESPECIFIC)
			{
				entities::deleteentity(ents.pop());
				continue;
			}
		}
		if(!insideworld(e.o))
		{
			if(e.type != ET_LIGHT && e.type != ET_SPOTLIGHT)
			{
				conoutf(CON_WARN, "warning: ent outside of world: enttype[%s] index %d (%f, %f, %f)", entities::entname(e.type), i, e.o.x, e.o.y, e.o.z);
			}
		}
	}
	if(ebuf) delete[] ebuf;

	if(hdr.numents > MAXENTS)
	{
		conoutf(CON_WARN, "warning: map has %d entities", hdr.numents);
		f->seek((hdr.numents-MAXENTS)*(samegame ? sizeof(entity) + einfosize : eif), SEEK_CUR);
	}

	renderprogress(0, "loading slots...");
	loadvslots(f, hdr.numvslots);

	renderprogress(0, "loading octree...");
	bool failed = false;
	worldroot = loadchildren(f, ivec(0, 0, 0), hdr.worldsize>>1, failed);
	if(failed) conoutf(CON_ERROR, "garbage in map");

	renderprogress(0, "validating...");
	validatec(worldroot, hdr.worldsize>>1);

	if(!failed)
	{
		loopi(hdr.lightmaps)
		{
			renderprogress(i/(float)hdr.lightmaps, "loading lightmaps...");
			LightMap &lm = lightmaps.add();
			{
				int type = f->getchar();
				lm.type = type&0x7F;
				if(type&0x80)
				{
					lm.unlitx = f->getlil<ushort>();
					lm.unlity = f->getlil<ushort>();
				}
			}
			if(lm.type&LM_ALPHA && (lm.type&LM_TYPE)!=LM_BUMPMAP1) lm.bpp = 4;
			lm.data = new uchar[lm.bpp*LM_PACKW*LM_PACKH];
			f->read(lm.data, lm.bpp * LM_PACKW * LM_PACKH);
			lm.finalize();
		}
	}

	mapcrc = f->getcrc();
	delete f;

	conoutf("read map %s (%.1f seconds)", ogzname, (SDL_GetTicks()-loadingstart)/1000.0f);

	clearmainmenu();

	identflags |= IDF_OVERRIDDEN;
	execfile("data/default_map.cfg", false);
	execfile(cfgname, false);
	identflags &= ~IDF_OVERRIDDEN;

	preloadusedmapmodels(true);

	game::preload();
	flushpreloadedmodels();

	preloadmapsounds();

	entitiesinoctanodes();
	attachentities();
	initlights();
	allchanged(true);

	renderbackground("loading...", mapshot, mname, game::getmapinfo());

	if(maptitle[0] && strcmp(maptitle, "Untitled Map by Unknown")) conoutf(CON_ECHO, "%s", maptitle);

	startmap(cname ? cname : mname);

	return true;
}

void savecurrentmap() { save_world(game::getclientmap()); }
void savemap(char *mname) { save_world(mname); }

COMMAND(savemap, "s");
COMMAND(savecurrentmap, "");

#endif