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

#include "cube.h"

#define DEBUGCOND (worldiodebug==1)
VARP(worldiodebug, 0, 0, 1);

static string cgzname, ocgzname, bakname, cbakname, mcfname, omcfname;

const char **setnames(const char *name)
{
    static const char *paths[2] = { ocgzname, cgzname };
    const char *mapname = behindpath(name), *nt = numtime();
    formatstring(cgzname) ("packages" PATHDIVS "maps" PATHDIVS                     "%s.cgz",        mapname);
    formatstring(mcfname) ("packages" PATHDIVS "maps" PATHDIVS                     "%s.cfg",        mapname);
    formatstring(ocgzname)("packages" PATHDIVS "maps" PATHDIVS "official" PATHDIVS "%s.cgz",        mapname);
    formatstring(omcfname)("packages" PATHDIVS "maps" PATHDIVS "official" PATHDIVS "%s.cfg",        mapname);
    formatstring(bakname) ("packages" PATHDIVS "maps" PATHDIVS                     "%s_%s.BAK",     mapname, nt);
    formatstring(cbakname)("packages" PATHDIVS "maps" PATHDIVS                     "%s.cfg_%s.BAK", mapname, nt);
    return paths;
}

// the optimize routines below are here to reduce the detrimental effects of messy mapping by
// setting certain properties (vdeltas and textures) to neighbouring values wherever there is no
// visible difference. This allows the mipmapper to generate more efficient mips.
// the reason it is done on save is to reduce the amount spend in the mipmapper (as that is done
// in realtime).

inline bool nhf(sqr *s) { return s->type!=FHF && s->type!=CHF; }

void voptimize()        // reset vdeltas on non-hf cubes
{
    loop(y, ssize) loop(x, ssize)
    {
        sqr *s = S(x, y);
        if(x && y) { if(nhf(s) && nhf(S(x-1, y)) && nhf(S(x-1, y-1)) && nhf(S(x, y-1))) s->vdelta = 0; }
        else s->vdelta = 0;
    }
}

// these two are used by getmap/sendmap.. transfers compressed maps directly

void writemap(const char *name, int msize, uchar *mdata)
{
    setnames(name);
    backup(cgzname, bakname);
    stream *f = openfile(cgzname, "wb");
    if(!f) { conoutf("\f3could not write map to %s", cgzname); return; }
    f->write(mdata, msize);
    delete f;
    conoutf("wrote map %s as file %s", name, cgzname);
}

uchar *readmap(const char *name, int *size, int *revision)
{
    setnames(name);
    uchar *data = (uchar *)loadfile(cgzname, size);
    if(!data) { conoutf("\f3could not read map %s", cgzname); return NULL; }
    header *h = peekmapheader(data, *size);
    if(revision) *revision = h ? h->maprevision : 0;
    return data;
}

void writecfggz(const char *name, int size, int sizegz, uchar *data)
{
    if(size < 1 || !sizegz || size > MAXCFGFILESIZE) return;
    setnames(name);

    uchar *rawcfg = new uchar[size];
    uLongf rawsize = size;
    if(rawcfg && uncompress(rawcfg, &rawsize, data, sizegz) == Z_OK && rawsize - size == 0)
    {
        stream *f = openfile(mcfname, "w");
        if(f)
        {
            f->write(rawcfg, size);
            delete f;
            conoutf("wrote map config to %s", mcfname);
        }
        else
        {
            conoutf("\f3could not write config to %s", mcfname);
        }
    }
    DELETEA(rawcfg);
}

#define GZBUFSIZE ((MAXCFGFILESIZE * 11) / 10)

uchar *readmcfggz(const char *name, int *size, int *sizegz)
{
    setnames(name);
    uchar *gzbuf = new uchar[GZBUFSIZE];
    uchar *data = (uchar*)loadfile(mcfname, size, "rb");
    if(data && *size < MAXCFGFILESIZE)
    {
        uLongf gzbufsize = GZBUFSIZE;
        if(compress2(gzbuf, &gzbufsize, data, *size, 9) != Z_OK)
        {
            *size = 0;
            gzbufsize = 0;
            DELETEA(gzbuf);
        }
        *sizegz = (int) gzbufsize;
    }
    else
    {
        DELETEA(gzbuf);
    }
    DELETEA(data);
    return gzbuf;
}

// save map as .cgz file. uses 2 layers of compression: first does simple run-length
// encoding and leaves out data for certain kinds of cubes, then zlib removes the
// last bits of redundancy. Both passes contribute greatly to the miniscule map sizes.

void rlencodecubes(vector<uchar> &f, sqr *s, int len, bool preservesolids) // run-length encoding and serialisation of a series of cubes
{
    sqr *t = NULL;
    int sc = 0;
    #define spurge while(sc) { f.add(255); if(sc>255) { f.add(255); sc -= 255; } else { f.add(sc); sc = 0; } }
    #define c(f) (s->f==t->f)
    while(len-- > 0)
    {
        // 4 types of blocks, to compress a bit:
        // 255 (2): same as previous block + count
        // 254 (3): same as previous, except light // deprecated
        // SOLID (5)
        // anything else (9)

        if(SOLID(s) && !preservesolids)
        {
            if(t && c(type) && c(wtex) && c(vdelta))
            {
                sc++;
            }
            else
            {
                spurge;
                f.add(s->type);
                f.add(s->wtex);
                f.add(s->vdelta);
            }
        }
        else
        {
            if(t && c(type) && c(floor) && c(ceil) && c(ctex) && c(ftex) && c(utex) && c(wtex) && c(vdelta) && c(tag))
            {
                sc++;
            }
            else
            {
                spurge;
                f.add(s->type == SOLID ? 253 : s->type);
                f.add(s->floor);
                f.add(s->ceil);
                f.add(s->wtex);
                f.add(s->ftex);
                f.add(s->ctex);
                f.add(s->vdelta);
                f.add(s->utex);
                f.add(s->tag);
            }
        }
        t = s;
        s++;
    }
    spurge;
}

bool rldecodecubes(ucharbuf &f, sqr *s, int len, int version, bool silent) // run-length decoding of a series of cubes (version is only relevant, if < 6)
{
    sqr *t = NULL, *e = s + len;
    while(s < e)
    {
        int type = f.overread() ? -1 : f.get();
        switch(type)
        {
            case -1:
            {
                if(!silent) conoutf("while reading map at %d: unexpected end of file", int(cubicsize - (e - s)));
                f.forceoverread();
                silent = true;
                sqrdefault(s);
                break;
            }
            case 255:
            {
                if(!t) { f.forceoverread(); continue; }
                int n = f.get();
                loopi(n) memcpy(s++, t, sizeof(sqr));
                s--;
                break;
            }
            case 254: // only in MAPVERSION<=2
            {
                if(!t) { f.forceoverread(); continue; }
                memcpy(s, t, sizeof(sqr));
                f.get(); f.get();
                break;
            }
            case SOLID:
            {
                sqrdefault(s);                  // takes care of ftex, ctex, floor, ceil and tag
                s->type = SOLID;
                s->utex = s->wtex = f.get();
                s->vdelta = f.get();
                if(version<=2) { f.get(); f.get(); }
                break;
            }
            case 253: // SOLID with all textures during editing (undo)
                type = SOLID;
            default:
            {
                if(type<0 || type>=MAXTYPE)
                {
                    if(!silent) conoutf("while reading map at %d: type %d out of range", int(cubicsize - (e - s)), type);
                    f.forceoverread();
                    continue;
                }
                sqrdefault(s);
                s->type = type;
                s->floor = f.get();
                s->ceil = f.get();
                if(s->floor>=s->ceil) s->floor = s->ceil-1;  // for pre 12_13
                s->wtex = f.get();
                s->ftex = f.get();
                s->ctex = f.get();
                if(version<=2) { f.get(); f.get(); }
                s->vdelta = f.get();
                s->utex = (version>=2) ? f.get() : s->wtex;
                s->tag = (version>=5) ? f.get() : 0;
            }
        }
        s->defer = 0;
        t = s;
        s++;
    }
    return !f.overread();  // true: no problem
}

// headerextra stores additional data in a map file (support since format 10)
// data can be persistent or oneway
// the format and handling is explicitly designed to handle yet unknown header types to avoid further format version bumps

struct headerextra
{
    int len, flags;
    uchar *data;
    headerextra() : len(0), flags(0), data(NULL) {}
    headerextra(int l, int f, uchar *d) : len(l), flags(f), data(NULL) { if(d) { data = new uchar[len]; memcpy(data, d, len); } }
    ~headerextra() { DELETEA(data); }
    headerextra *duplicate() { return new headerextra(len, flags, data); }
};
vector<headerextra *> headerextras;

const char *hx_names[] = { "unused", "mapinfo", "modeinfo", "artist", "editundo", "config", "vantage point", "unknown" };
#define addhxpacket(p, len, flags, buffer) { if(p.length() + len < MAXHEADEREXTRA) { putuint(p, len); putuint(p, flags); p.put(buffer, len); } }
#define hx_name(t) hx_names[min((t) & HX_TYPEMASK, int(HX_NUM))]

void clearheaderextras() { loopvrev(headerextras) delete headerextras.remove(i); }

void deleteheaderextra(int n) { if(headerextras.inrange(n)) delete headerextras.remove(n); }

void listheaderextras()
{
    loopv(headerextras) conoutf("extra header record %d: %s, %d bytes", i, hx_name(headerextras[i]->flags), headerextras[i]->len);
    if(!headerextras.length()) conoutf("no extra header records found");
}
COMMAND(listheaderextras, "");

int findheaderextra(int type)
{
    loopv(headerextras) if((headerextras[i]->flags & HX_TYPEMASK) == type) return i;
    return -1;
}

void unpackheaderextra(uchar *buf, int len)  // break the extra data from the mapheader into its pieces
{
    ucharbuf p(buf, len);
    DEBUG("unpacking " << len << " bytes");
    while(1)
    {
        int len = getuint(p), flags = getuint(p);
        if(p.overread() || len > p.remaining() || len < 0 || flags < 0) break;
        DEBUGCODE(clientlogf(" found headerextra \"%s\", %d bytes%s", hx_name(flags & HX_TYPEMASK), len, flags & HX_FLAG_PERSIST ? ", persistent" : ""));  // debug info
        headerextras.add(new headerextra(len, flags, p.subbuf(len).buf));
    }
}

void parseheaderextra(bool clearnonpersist = true, int ignoretypes = 0)  // parse all headerextra packets, delete the nonpersistent ones (like editundos)
{
    DEBUG("parsing " << headerextras.length() << " packets");
    loopv(headerextras)
    {
        ucharbuf q(headerextras[i]->data, headerextras[i]->len);
        int type = headerextras[i]->flags & HX_TYPEMASK;
        DEBUG("packet " << i << " type " << type);
        bool deletethis = false;                               // (set deletethis for headers that persist outside headerextras and get reinserted by packheaderextras())
        if(!(ignoretypes & (1 << type))) switch(type)
        {
            case HX_EDITUNDO:
                restoreeditundo(q);
                break;

            case HX_CONFIG:
                setcontext("map", "embedded");
                if(headerextras[i]->len > 0 && headerextras[i]->data[headerextras[i]->len - 1] == '\0') execute((const char *)q.buf); // needs to have '\0' at the end, better check...
                else conoutf("malformed emb config");
                resetcontext();
                break;

            case HX_MAPINFO:
            {
                string l, c;
                getstring(l, q, MAXSTRLEN - 1);
                getstring(c, q, MAXSTRLEN - 1);
                setmapinfo(l, c);
                break;
            }
            case HX_MODEINFO:
            case HX_ARTIST:
            default:
                break;
        }
        if(deletethis || (clearnonpersist && !(headerextras[i]->flags & HX_FLAG_PERSIST))) delete headerextras.remove(i--);
    }
}

ucharbuf packheaderextras(int ignoretypes = 0)  // serialise all extra data packets to save with the map header
{
    vector<uchar> buf, tmp;
    // rewrite some headers every time
    if(!(ignoretypes & (1 << HX_MAPINFO)))
    {
        for(int n; (n = findheaderextra(HX_MAPINFO)) >= 0; ) deleteheaderextra(n);
        if(mapinfo_license[0])
        {
            sendstring(mapinfo_license, tmp);
            sendstring(mapinfo_comment, tmp);
            headerextras.add(new headerextra(tmp.length(), HX_MAPINFO|HX_FLAG_PERSIST, tmp.getbuf()));
            tmp.setsize(0);
        }
    }
    loopv(headerextras) if(!(ignoretypes & (1 << (headerextras[i]->flags & HX_TYPEMASK))))
    { // copy existing persistent hx packets
        addhxpacket(buf, headerextras[i]->len, headerextras[i]->flags, headerextras[i]->data);
    }
    // create non-persistent ones, if wanted
    if(!(ignoretypes & (1 << HX_EDITUNDO)))
    {
        int limit = (MAXHEADEREXTRA - buf.length()) / 3;
        backupeditundo(tmp, limit, limit);
        addhxpacket(buf, tmp.length(), HX_EDITUNDO, tmp.getbuf());
    }
    ucharbuf q(new uchar[buf.length()], buf.length());
    memcpy(q.buf, buf.getbuf(), q.maxlen);
    DEBUG("packed " << q.maxlen << " bytes");
    return q;
}

bool embedconfigfile()
{
    if(securemapcheck(getclientmap())) return false;
    if(unsavededits) { conoutf("There are unsaved edits: they need to be saved or discarded before a config file can be embedded."); return false; }
    setnames(getclientmap());
    int len;
    uchar *buf = (uchar *)loadfile(mcfname, &len);
    if(buf)
    {
        for(int n; (n = findheaderextra(HX_CONFIG)) >= 0; ) deleteheaderextra(n);
        headerextras.add(new headerextra(len + 1, HX_CONFIG|HX_FLAG_PERSIST, NULL))->data = buf;
        backup(mcfname, cbakname); // don't delete the config file, just rename
        conoutf("embedded map config file \"%s\"", mcfname);
    }
    else conoutf("\f3failed to load config file %s", mcfname);
    return buf != NULL;
}
COMMANDF(embedconfigfile, "", () { if(embedconfigfile()) save_world(getclientmap()); });

void extractconfigfile()
{
    if(securemapcheck(getclientmap())) return;
    if(unsavededits) { conoutf("There are unsaved edits: they need to be saved or discarded before the config file can be extracted."); return; }
    setnames(getclientmap());
    int n = findheaderextra(HX_CONFIG);
    if(n < 0) conoutf("no embedded config found");
    else
    {
        backup(mcfname, cbakname); // don't overwrite an existing config file, just rename it
        stream *f = openfile(mcfname, "w");
        if(f)
        {
            f->write(headerextras[n]->data, headerextras[n]->len > 0 ? headerextras[n]->len - 1 : 0);
            delete f;
            conoutf("extracted embedded map config to file %s", mcfname);
            deleteheaderextra(n);
            hdr.flags &= ~MHF_AUTOMAPCONFIG; // external config file, manually edited
        }
        else conoutf("\f3failed to write config to %s", mcfname);
    }
}
COMMAND(extractconfigfile, "");

void automapconfig()
{
    conoutf("\"automatic embedded map config data\" %senabled", hdr.flags & MHF_AUTOMAPCONFIG ? "was already " : "");
    hdr.flags |= MHF_AUTOMAPCONFIG;
}
COMMAND(automapconfig, "");

COMMANDF(getautomapconfig, "", () { intret((hdr.flags & MHF_AUTOMAPCONFIG) != 0); });

void flagmapconfigchange()
{ // if changes are tracked, because automapcfg is enabled and the change is not read from a config file -> set unsaved edits flag
    if(execcontext != IEXC_MAPCFG && hdr.flags & MHF_AUTOMAPCONFIG) unsavededits++;
}

int mapconfigerror = 0;

void flagmapconfigerror(int what)
{
    if(execcontext == IEXC_MAPCFG || execcontext == IEXC_MDLCFG) mapconfigerror |= what;
}

void getcurrentmapconfig(vector<char> &f, bool onlysounds)
{
    if(!onlysounds)
    {
        extern int fogcolour, shadowyaw;
        extern char *loadsky;
        if(fog != DEFAULT_FOG)             cvecprintf(f, "fog %d\n", fog);
        if(fogcolour != DEFAULT_FOGCOLOUR) cvecprintf(f, "fogcolour 0x%06x\n", fogcolour);
        if(shadowyaw != DEFAULT_SHADOWYAW) cvecprintf(f, "shadowyaw %d\n", shadowyaw);
        if(*mapconfigdata.notexturename)   cvecprintf(f, "loadnotexture \"%s\"\n", mapconfigdata.notexturename);
        if(*loadsky)                       cvecprintf(f, "loadsky \"%s\"\n", loadsky);
        cvecprintf(f, "%smapmodelreset\n", f.length() ? "\n" : "");
        loopi(256)
        {
            mapmodelinfo *mmi = getmminfo(i);
            if(!mmi) break;
            cvecprintf(f, "mapmodel %d %d %d %s \"%s\"", mmi->rad, mmi->h, mmi->zoff, mmi->scale == 1.0f ? "0" : floatstr(mmi->scale, true), mmshortname(mmi->name));
            if(mmi->flags & MMF_CONFIGMASK) cvecprintf(f, " %d", mmi->flags & MMF_CONFIGMASK);
            f.add('\n');
        }
        cvecprintf(f, "\ntexturereset\n");
        loopi(256)
        {
            const char *t = gettextureslot(i);
            if(!t) break;
            cvecprintf(f, "%s\n", t);
        }
        cvecprintf(f, "\n");
    }
    cvecprintf(f, "mapsoundreset\n");
    loopv(mapconfigdata.mapsoundlines)
    {
        mapsoundline &s = mapconfigdata.mapsoundlines[i];
        cvecprintf(f, "mapsound \"ambience/%s\" %d\n", s.name, s.maxuses);
    }
    cvecprintf(f, "\n");
    f.add('\0');
}

#ifdef _DEBUG
COMMANDF(dumpmapconfig, "", ()
{
    vector<char> buf;
    updatemapmodeldependencies();
    getcurrentmapconfig(buf, false);
    stream *f = openfile("dumpmapconfig.txt", "w");
    if(f) f->write(buf.getbuf(), buf.length() - 1);
    DELETEP(f);
    hdr.flags |= MHF_AUTOMAPCONFIG;
});
#endif

bool clearvantagepoint()
{
    bool yep = false;
    for(int n; (n = findheaderextra(HX_VANTAGEPOINT)) >= 0; yep = true) deleteheaderextra(n);
    unsavededits++;
    return yep;
}
COMMANDF(clearvantagepoint, "", () { if(!noteditmode("clearvantagepoint") && !multiplayer() && clearvantagepoint()) conoutf("cleared vantage point"); });

void setvantagepoint()
{
    if(multiplayer("setvantagepoint") || (!player1->isspectating() && noteditmode("setvantagepoint"))) return;
    clearvantagepoint();
    short p[5];
    storeposition(p);
    vector<uchar> buf;
    loopi(5) putint(buf, p[i]);
    physent d = *player1;
    d.radius = d.eyeheight = d.maxeyeheight = d.aboveeye = 0.1;
    if(collide(&d, false)) { conoutf("\f3collision with map: vantage point not set"); return; }
    if(!OUTBORD(p[0] / DMF, p[1] / DMF) && iabs(p[2]) < 127 * int(DMF) && p[3] >= 0 && p[3] < 360 && iabs(p[4]) <= 90)
    {
        headerextras.add(new headerextra(buf.length(), HX_VANTAGEPOINT|HX_FLAG_PERSIST, buf.getbuf()));
        conoutf("vantage point set");
    }
}
COMMAND(setvantagepoint, "");

bool getvantagepoint(short p[5])
{
    int n = findheaderextra(HX_VANTAGEPOINT);
    if(n >= 0)
    {
        ucharbuf q(headerextras[n]->data, headerextras[n]->len);
        loopi(5) p[i] = getint(q);
        if(!OUTBORD(p[0] / DMF, p[1] / DMF) && iabs(p[2]) < 127 * int(DMF) && p[3] >= 0 && p[3] < 360 && iabs(p[4]) <= 90) return true; // check for sane values
    }
    return false;
}

COMMANDF(getvantagepoint, "", ()
{
    short p[5];
    string res = "";
    if(getvantagepoint(p)) formatstring(res)("%s %s %s %d %d", floatstr(p[0] / DMF), floatstr(p[1] / DMF), floatstr(p[2] / DMF), p[3], p[4]);
    result(res);
});

bool gotovantagepoint()
{
    short p[5];
    if(getvantagepoint(p))
    {
        restoreposition(p);
        physent d = *player1;
        d.radius = d.eyeheight = d.maxeyeheight = d.aboveeye = 0.1;
        if(!collide(&d, false)) return true;  // don't use out-of-map vantage points
    }
    // if there is no (valid) vantage point set, we go to the first playerstart instead
    int s = findentity(PLAYERSTART, 0);
    if(ents.inrange(s)) gotoplayerstart(player1, &ents[s]);
    entinmap(player1);
    return false;
}
COMMANDF(gotovantagepoint, "", () { intret((editmode || (!multiplayer(NULL) && player1->isspectating())) && gotovantagepoint() ? 1 : 0); });

void modeinfo(char *mode, char *info)
{
    char *modeinfolines[GMODE_NUM] = { NULL };
    string line, tmp;

    // find and unpack HX_MODEINFO
    int he = findheaderextra(HX_MODEINFO);
    if(he >= 0)
    {
        ucharbuf q(headerextras[he]->data, headerextras[he]->len);
        for(int mode = getuint(q); !q.overread() && mode > 0; mode = getuint(q))
        {
            getstring(line, q, MAXSTRLEN);
            filterconfigset(line);
            loopi(GMODE_NUM) if((mode & (1 << i)) && !modeinfolines[i]) modeinfolines[i] = newstring(line);
        }
    }

    // parse command arguments and apply changes or generate output
    vector<char> res;
    copystring(line, info);
    filterconfigset(line);
    int modes = gmode_parse(mode), n = 0;
    if(!strcmp(mode, "*") || !strcmp(mode, "all")) modes = GMMASK__MPNOCOOP;
    else if(!strcmp(mode, "list"))
    {
        loopi(GMODE_NUM) if(modeinfolines[i] && ++n) conoutf("%s: %s", gmode_enum(1 << i, tmp), escapestring(modeinfolines[i]));
        if(!n) conoutf("no modeinfo lines set");
    }
    else if(!strcmp(mode, "get"))
    {
        loopi(GMODE_NUM) if(modeinfolines[i]) cvecprintf(res, "%s %s\n", gmode_enum(1 << i, tmp), escapestring(modeinfolines[i]));
    }
    else if(!strcmp(mode, "clear"))
    {
        loopi(GMODE_NUM) if(modeinfolines[i]) { n++; DELSTRING(modeinfolines[i]); }
        conoutf("deleted %d modeinfo lines", n);
    }
    if(modes) loopi(GMODE_NUM)
    {
        if(modes & (1 << i))
        {
            DELSTRING(modeinfolines[i]);
            modeinfolines[i] = newstring(line);
        }
    }
    if(res.length()) res.last() = '\0';
    else res.add('\0');
    result(res.getbuf());

    // recreate HX_MODEINFO
    for(int n; (n = findheaderextra(HX_MODEINFO)) >= 0; ) deleteheaderextra(n);
    vector<uchar> p;
    entitystats_s es;
    calcentitystats(es, NULL, 0);
    int todo = es.modes_possible;
    bool have_modeinfo = false;
    loopk(GMODE_NUM) if(modeinfolines[k] && modeinfolines[k][0] && (todo & (1 << k)))
    {
        int modes = 0;
        for(int i = k; i < GMODE_NUM; i++)
        {
            if(modeinfolines[i] && !strcmp(modeinfolines[k], modeinfolines[i]))  modes |= (1 << i);
        }
        putuint(p, modes);
        sendstring(modeinfolines[k], p);
        todo &= ~modes;
        have_modeinfo = true;
    }
    putuint(p, 0);
    if(have_modeinfo) headerextras.add(new headerextra(p.length(), HX_MODEINFO|HX_FLAG_PERSIST, p.getbuf()));
}
COMMAND(modeinfo, "ss");

void mapartist(char *what)
{
    uchar32 buf;
    bool update = false, remove = false;;

    // find and unpack HX_ARTIST
    int he = findheaderextra(HX_ARTIST);
    if(he >= 0 && headerextras[he]->len == 32) memcpy(buf.u, headerextras[he]->data, 32);

    // parse command arguments and apply changes or generate output
    string tmp;
    if(!strcmp(what, "print")) conoutf("map artist key: %s", bin2hex(tmp, buf.u, 32));
    else if(!strcmp(what, "set"))
    {
        if(*sk)
        {
            memcpy(buf.u, sk + 32, 32);
            update = true;
        }
        else conoutf("no player account in use");
    }
    else if(!strcmp(what, "clear")) remove = true;
    bin2hex(tmp, buf.u, 32);
    result(he >= 0 || update ? tmp : "");

    // recreate HX_ARTIST
    if(update || remove) for(int n; (n = findheaderextra(HX_ARTIST)) >= 0; ) deleteheaderextra(n);
    if(update) headerextras.add(new headerextra(32, HX_ARTIST|HX_FLAG_PERSIST, buf.u));
}
COMMAND(mapartist, "s");

void setmapinfo(const char *newlicense, const char *newcomment)
{
    string s;
    filtertext(s, newlicense ? newlicense : mapinfo_license, FTXT__MAPINFO_LICENSE, 20);
    mapinfo_license = exchangestr(mapinfo_license, s);
    filtertext(s, newcomment ? newcomment : mapinfo_comment, FTXT__MAPINFO_COMMENT, 60);
    mapinfo_comment = exchangestr(mapinfo_comment, s);
}

SVARF(mapinfo_license, "", setmapinfo(); );
SVARF(mapinfo_comment, "", setmapinfo(); );

VAR(advancemaprevision, 1, 1, 100);

VARP(mapbackupsonsave, 0, 1, 1);

void rebuildtexlists()  // checks the texlists, if they still contain all possible textures
{
    short h[256];
    int mk[3], mt = 0;
    vector<uchar> missing;
    loopk(3)
    {
        missing.setsize(0);
        uchar *p = hdr.texlists[k];
        loopi(256) h[i] = 0;
        loopi(256) h[p[i]]++;
        loopi(256) if(h[i] == 0) missing.add(i);
        mt += mk[k] = missing.length();
        loopi(256) if(h[p[i]] > 1)
        {
            h[p[i]]--;
            p[i] = missing.pop();
        }
    }
    if(mt) conoutf("WARNING: rebuildtexlists() fixed %d|%d|%d missing entries", mk[0], mk[1], mk[2]);
}

static const uchar sortenttab[] = {  // 1..9: used in network protocol, 10..19: sorted lights, 20..29: misc, 30..39: clipped ents at the end of the list
    99,         // NOTUSED                          // entity slot not in use in map (usually seen at deleted entities)
    10,         // LIGHT (colored: 11, shadow: 12)  // lightsource, attr1 = radius, attr2 = intensity (or attr2..4 = r-g-b)
    2,          // PLAYERSTART                      // attr1 = angle, attr2 = team
    1, 1, 1,    // I_CLIPS, I_AMMO, I_GRENADE,      // attr1 = elevation
    1, 1, 1, 1, // I_HEALTH, I_HELMET, I_ARMOUR, I_AKIMBO,
    30,         // MAPMODEL (clipped: 31)           // attr1 = angle, attr2 = idx, attr3 = elevation, attr4 = texture, attr5 = pitch, attr6 = roll
    21,         // CARROT                           // attr1 = tag, attr2 = type
    3,          // LADDER                           // attr1 = height
    1,          // CTF_FLAG                         // attr1 = angle, attr2 = red/blue
    20,         // SOUND                            // attr1 = idx, attr2 = radius, attr3 = size, attr4 = volume
    32,         // CLIP                             // attr1 = elevation, attr2 = xradius, attr3 = yradius, attr4 = height, attr6 = slope, attr7 = shape
    33};        // PLCLIP                           // attr1 = elevation, attr2 = xradius, attr3 = yradius, attr4 = height, attr6 = slope, attr7 = shape

struct numbered_persistent_entity { persistent_entity e; int n; };

int cmp_npe(const numbered_persistent_entity *a, const numbered_persistent_entity *b) { ASSERT(a->n != b->n); return a->n - b->n; }

void save_world(char *mname, bool skipoptimise, bool addcomfort)
{
    if(!*mname) mname = getclientmap();
    if(securemapcheck(mname)) return;
    DEBUG("writing map \"" << mname << "\"");
    if(!validmapname(mname))
    {
        conoutf("\f3Invalid map name. It must only contain letters, digits, '-', '_' and be less than %d characters long", MAXMAPNAMELEN);
        return;
    }
    if(!skipoptimise)
    { // optimisation works on the real world geometry, not on a copy
        voptimize();
        mapmrproper(false);
        addcomfort = false; // "optimized + undos" is not useful
    }

    // get target file ready
    setnames(mname);
    if(mapbackupsonsave) backup(cgzname, bakname);
    stream *f = opengzfile(cgzname, "wb");
    if(!f) { conoutf("could not write map to %s", cgzname); return; }

    // update embedded config file (if used)
    updatemapmodeldependencies();
    bool autoembedconfig = (hdr.flags & MHF_AUTOMAPCONFIG) != 0;
    if(autoembedconfig)
    { // write embedded map config
        backup(mcfname, cbakname); // rename possibly existing external map config file
        for(int n; (n = findheaderextra(HX_CONFIG)) >= 0; ) deleteheaderextra(n);  // delete existing embedded config
        vector<char> ec;
        getcurrentmapconfig(ec, false);
        uchar *ecu = new uchar[ec.length()];
        memcpy(ecu, ec.getbuf(), ec.length());
        headerextras.add(new headerextra(ec.length(), HX_CONFIG|HX_FLAG_PERSIST, NULL))->data = ecu;
    }

    // update (and fix) map header
    memcpy(hdr.head, "ACMP", 4); // ensure map now declares itself as an AssaultCube map, even if imported as CUBE
    hdr.version = MAPVERSION;
    hdr.headersize = sizeof(header);
    hdr.timestamp = (int) time(NULL);
    rebuildtexlists();

    // create sorted entity list
    vector<numbered_persistent_entity> sortedents;
    hdr.numents = 0;
    ASSERT(MAXENTITIES < (1 << 16));
    numbered_persistent_entity npe;
    loopv(ents) if(ents[i].type != NOTUSED && ents[i].type != DUMMYENT) // omit deleted entities and dummies
    {
        hdr.numents++;
        npe.e = ents[i];
        int t = npe.e.type, nt = t < MAXENTTYPES ? sortenttab[t] : 100 + t;
        if(t == LIGHT)
        {
            if(npe.e.attr3 || npe.e.attr4) nt++; // sort white lights before colored ones to fix light bug
            if(npe.e.attr1 < 0) nt += 2; // sort shadows after lights
        }
        else if(t == MAPMODEL)
        {
            mapmodelinfo *mmi = getmminfo(npe.e.attr2);
            if(mmi && mmi->h) nt++; // sort clipped mapmodels right after unclipped mapmodels, but before clips and plclips
        }
        npe.n = i | (nt << 16); // numbers have to be unique for the sort to be stable
        sortedents.add(npe);
    }
    sortedents.sort(cmp_npe);
    if(hdr.numents > MAXENTITIES)
    {
        conoutf("too many map entities (%d), only %d will be written to file", hdr.numents, MAXENTITIES);
        hdr.numents = MAXENTITIES;
    }

    // write header and extras to file
    header tmp = hdr;
    ucharbuf hx = packheaderextras(addcomfort ? 0 : (1 << HX_EDITUNDO));   // if addcomfort -> add undos/redos
    int writeextra = 0;
    if(hx.maxlen) tmp.headersize += writeextra = clamp(hx.maxlen, 0, MAXHEADEREXTRA);
    tmp.maprevision += advancemaprevision;
    DEBUG("version " << tmp.version << " headersize " << tmp.headersize << " entities " << tmp.numents << " factor " << tmp.sfactor << " revision " << tmp.maprevision);
    lilswap(&tmp.version, 4); // version, headersize, sfactor, numents
    lilswap(&tmp.waterlevel, 1);
    lilswap(&tmp.maprevision, 4); // maprevision, ambient, flags, timestamp
    f->write(&tmp, sizeof(header));
    if(writeextra) f->write(hx.buf, writeextra);
    delete[] hx.buf;

    // write entities
    loopi(hdr.numents)
    {
        persistent_entity &tmp = sortedents[i].e;
        clampentityattributes(tmp);
        lilswap((short *)&tmp, 4);
        lilswap(&tmp.attr5, 1);
        f->write(&tmp, sizeof(persistent_entity));
    }

    // fix world border
    if(editmode)
    {
        int nonsolid = 0;
        loop(y, ssize) loop(x, ssize)
        {
            if(OUTBORD(x, y))
            {
                sqr *s = S(x, y);
                if(!SOLID(s)) { sqrdefault(s); s->type = SOLID; nonsolid++; }
            }
            else x = ssize - MINBORD - 1;
        }
        if(nonsolid) conoutf("\f3fixed %d non-solid world border cubes", nonsolid);
    }
    // write map geometry
    vector<uchar> rawcubes;
    rlencodecubes(rawcubes, world, cubicsize, skipoptimise);  // if skipoptimize -> keep properties of solid cubes (forces format 10)
    f->write(rawcubes.getbuf(), rawcubes.length());
    delete f;
    unsavededits = 0;
    conoutf("wrote map file %s %s%s%s", cgzname, skipoptimise ? "without optimisation" : "(optimised)", addcomfort ? " (including editing history)" : "", autoembedconfig ? " (including map config)" : "");
}
VARP(preserveundosonsave, 0, 0, 1);
COMMANDF(savemap, "s", (char *name) { save_world(name, preserveundosonsave && editmode, preserveundosonsave && editmode); } );
COMMANDF(savemapoptimised, "s", (char *name) { save_world(name, false, false); } );

void save_world9(char *mname)
{
    if(unsavededits) { conoutf("\f3There are unsaved changes to the map. Please save them to a lossless format first (\"savemap\")."); return; }
    if(!*mname) { conoutf("\f3You need to specify a map file name."); return; }
    if(securemapcheck(mname)) return;
    if(!validmapname(mname)) { conoutf("\f3Invalid map name. It must only contain letters, digits, '-', '_' and be less than %d characters long", MAXMAPNAMELEN); return; }
    if(findheaderextra(HX_CONFIG) >= 0)
    { // extract embedded config file first
        string clientmapbak;
        copystring(clientmapbak, getclientmap());
        copystring(getclientmap(), mname); // hack!
        extractconfigfile();
        copystring(getclientmap(), clientmapbak);
    }
    if(headerextras.length())
    {
        conoutf("\f3not writing header extra information:");
        listheaderextras();
    }
    setnames(mname);
    backup(cgzname, bakname);
    stream *f = opengzfile(cgzname, "wb");
    if(!f) { conoutf("could not write map to %s", cgzname); return; }
    memcpy(hdr.head, "ACMP", 4); // ensure map now declares itself as an AssaultCube map, even if imported as CUBE
    hdr.version = 9;
    hdr.headersize = sizeof(header);
    hdr.timestamp = (int) time(NULL); // non-zero timestamps in format 9 can be used to identify "exported" maps
    hdr.numents = 0;
    loopv(ents) if(ents[i].type != NOTUSED && ents[i].type != DUMMYENT) hdr.numents++;
    if(hdr.numents > MAXENTITIES)
    {
        conoutf("too many map entities (%d), only %d will be written to file", hdr.numents, MAXENTITIES);
        hdr.numents = MAXENTITIES;
    }
    header tmp = hdr;
    tmp.maprevision += advancemaprevision;
    tmp.flags = 0;
    tmp.waterlevel /= WATERLEVELSCALING;
    lilswap(&tmp.version, 4); // version, headersize, sfactor, numents
    lilswap(&tmp.waterlevel, 1);
    lilswap(&tmp.maprevision, 4); // maprevision, ambient, flags, timestamp
    f->write(&tmp, sizeof(header));
    int ne = hdr.numents, ec = 0;
    loopv(ents)
    {
        if(ents[i].type != NOTUSED && ents[i].type != DUMMYENT)
        {
            if(!ne--) break;
            persistent_entity tmp = ents[i];
            clampentityattributes(tmp);
            tmp.attr1 /= entscale[tmp.type][0];
            tmp.attr2 /= entscale[tmp.type][1];
            tmp.attr3 /= entscale[tmp.type][2];
            tmp.attr4 /= entscale[tmp.type][3];
            if(tmp.attr5 || tmp.attr6 || tmp.attr7) conoutf("\f3lost some attributes for entity #%d (%d)", i, ++ec);
            lilswap((short *)&tmp, 4);
            f->write(&tmp, 12);
        }
    }
    vector<uchar> rawcubes;
    rlencodecubes(rawcubes, world, cubicsize, false);
    f->write(rawcubes.getbuf(), rawcubes.length());
    delete f;
    conoutf("wrote map file %s with format 9", cgzname);
}
COMMANDN(savemap9, save_world9, "s");

void showmapdims()
{
    conoutf("  min X|Y|Z: %3d : %3d : %3d", clmapdims.x1, clmapdims.y1, clmapdims.minfloor);
    conoutf("  max X|Y|Z: %3d : %3d : %3d", clmapdims.x2, clmapdims.y2, clmapdims.maxceil);
    conoutf("delta X|Y|Z: %3d : %3d : %3d", clmapdims.xspan, clmapdims.yspan, clmapdims.maxceil - clmapdims.minfloor);
}
COMMAND(showmapdims, "");

extern void preparectf(bool cleanonly = false);
int maploaded = 0;
VAR(curmaprevision, 1, 0, 0);
COMMANDF(getmaptimestamp, "s", (char *fmt) { result(hdr.timestamp ? timestring((time_t)hdr.timestamp, *fmt != 'U', *fmt == 'U' ? fmt + 1 : fmt) : "no timestamp stored"); });

void changemapflag(int val, int mask)
{
    int old = hdr.flags;
    if(val) hdr.flags |= mask;
    else hdr.flags &= ~mask;
    if(editmode && old != hdr.flags) unsavededits++;
}
VARF(mapoverride_nowaterreflect, 0, 0, 1, changemapflag(mapoverride_nowaterreflect, MHF_DISABLEWATERREFLECT));
VARF(mapoverride_limitwaveheight, 0, 0, 1, changemapflag(mapoverride_limitwaveheight, MHF_LIMITWATERWAVEHEIGHT));
VARF(mapoverride_nostencilshadows, 0, 0, 1, changemapflag(mapoverride_nostencilshadows, MHF_DISABLESTENCILSHADOWS));
VAR(_ignoreillegalpaths, 0, 0, 1);

static string lastloadedconfigfile;

bool incompatiblemap = false;

int load_world(char *mname)        // still supports all map formats that have existed since the earliest cube betas!
{
    incompatiblemap = false;
    const int sizeof_header = sizeof(header), sizeof_baseheader = sizeof_header - sizeof(int) * 16;
    stopwatch watch;
    watch.start();

    advancemaprevision = 1;
    setnames(mname);
    maploaded = getfilesize(ocgzname);
    if(maploaded > 0)
    {
        copystring(cgzname, ocgzname);
        copystring(mcfname, omcfname);
    }
    else maploaded = getfilesize(cgzname);
    if(!validmapname(mname))
    {
        conoutf("\f3Invalid map name. It must only contain letters, digits, '-', '_' and be less than %d characters long", MAXMAPNAMELEN);
        return -1;
    }
    stream *f = opengzfile(cgzname, "rb");
    if(!f) { conoutf("\f3could not read map %s", cgzname); return -2; }
    if(unsavededits) xmapbackup("load_map_", mname);
    unsavededits = 0;
    DEBUG("reading map \"" << cgzname << "\"");
    header tmp;
    memset(&tmp, 0, sizeof_header);
    if(f->read(&tmp, sizeof_baseheader) != sizeof_baseheader ||
       (strncmp(tmp.head, "CUBE", 4)!=0 && strncmp(tmp.head, "ACMP",4)!=0)) { conoutf("\f3while reading map: header malformatted (1)"); delete f; return -3; }
    lilswap(&tmp.version, 4); // version, headersize, sfactor, numents
    if(tmp.version > MAPVERSION) { conoutf("\f3this map requires a newer version of AssaultCube"); delete f; return -4; }
    if(tmp.sfactor<SMALLEST_FACTOR || tmp.sfactor>LARGEST_FACTOR || tmp.numents > MAXENTITIES) { conoutf("\f3illegal map size"); delete f; return -5; }
    tmp.headersize = fixmapheadersize(tmp.version, tmp.headersize);
    int restofhead = min(tmp.headersize, sizeof_header) - sizeof_baseheader;
    if(f->read(&tmp.waterlevel, restofhead) != restofhead) { conoutf("\f3while reading map: header malformatted (2)"); delete f; return -6; }
    DEBUG("version " << tmp.version << " headersize " << tmp.headersize << " headerextrasize " << tmp.headersize - int(sizeof(header)) << " entities " << tmp.numents << " factor " << tmp.sfactor << " revision " << tmp.maprevision);
    clearheaderextras();
    if(tmp.headersize > sizeof_header)
    {
        int extrasize = tmp.headersize - sizeof_header;
        if(tmp.version < 9) extrasize = 0;  // throw away mediareq...
        else if(extrasize > MAXHEADEREXTRA) extrasize = MAXHEADEREXTRA;
        if(extrasize)
        { // map file actually has extra header data that we want too preserve
            uchar *extrabuf = new uchar[extrasize];
            if(f->read(extrabuf, extrasize) != extrasize) { conoutf("\f3while reading map: header malformatted (3)"); delete f; delete[] extrabuf; return -7; }
            unpackheaderextra(extrabuf, extrasize);
            delete[] extrabuf;
        }
        f->seek(tmp.headersize, SEEK_SET);
    }
    hdr = tmp;
    mapconfigdata.clear();
    rebuildtexlists();
    loadingscreen("%s", hdr.maptitle);
    resetmap();
    int res = 0;
    if(hdr.version>=4)
    {
        lilswap(&hdr.waterlevel, 1);
        if(!hdr.watercolor[3]) setwatercolor();
        lilswap(&hdr.maprevision, 4); // maprevision, ambient, flags, timestamp
        curmaprevision = hdr.maprevision;
    }
    else
    {
        hdr.waterlevel = -100000;
        hdr.ambient = 0;
    }
    extern int ambient;
    ambient = hdr.ambient;
    if(hdr.version < 10) hdr.waterlevel *= WATERLEVELSCALING;
    setfvar("waterlevel", float(hdr.waterlevel) / WATERLEVELSCALING);
    mapoverride_nowaterreflect = (hdr.flags & MHF_DISABLEWATERREFLECT) ? 1 : 0;
    mapoverride_limitwaveheight = (hdr.flags & MHF_LIMITWATERWAVEHEIGHT) ? 1 : 0;
    mapoverride_nostencilshadows = (hdr.flags & MHF_DISABLESTENCILSHADOWS) ? 1 : 0;

    // read and convert all entities
    cleartodoentities();
    persistent_entity *tempents = new persistent_entity[hdr.numents];
    bool oldentityformat = hdr.version < 10; // version < 10 have only 4 attributes and no scaling
    loopi(hdr.numents)
    {
        persistent_entity &e = tempents[i];
        f->read(&e, oldentityformat ? 12 : sizeof(persistent_entity));
        lilswap((short *)&e, 4);
        if(oldentityformat) e.attr5 = e.attr6 = e.attr7 = 0;
        else lilswap(&e.attr5, 1);
        if(e.type == LIGHT && e.attr1 >= 0)
        {
            if(!e.attr2) e.attr2 = 255; // needed for MAPVERSION<=2
            if(e.attr1 > 32) e.attr1 = 32; // 12_03 and below (but applied to _all_ files!)
        }
        transformoldentitytypes(hdr.version, e.type);
        if(oldentityformat && e.type < MAXENTTYPES)
        {
            if(e.type == CTF_FLAG || e.type == MAPMODEL) e.attr1 = e.attr1 + 7 - (e.attr1 + 7) % 15;  // round the angle to the nearest 15-degree-step, like old versions did during rendering
            if(e.type == LIGHT && e.attr1 < 0) e.attr1 = 0; // negative lights had no meaning before version 10
            int ov, ss;
            persistent_entity oe = e;
            #define SCALEATTR(x) \
            if((ss = abs(entwraparound[e.type][x - 1] / entscale[e.type][x - 1]))) e.attr##x = (int(e.attr##x) % ss + ss) % ss; \
            e.attr##x = ov = e.attr##x * entscale[e.type][x - 1]; \
            if(ov != e.attr##x) { conoutf("overflow during conversion of attr%d of entity #%d (%s): value %d can no longer be represented - pls fix manually before saving the map",\
                                           x, i, entnames[e.type], oe.attr##x); e.attr##x = oe.attr##x; res |= LWW_ENTATTROVERFLOW; \
                                  defformatstring(desc)("%s: attr%d was %d, value can no longer be represented", entnames[e.type], x, oe.attr##x); addtodoentity(i, desc); incompatiblemap = true; }
            SCALEATTR(1);
            SCALEATTR(2);
            SCALEATTR(3);
            SCALEATTR(4);
            //SCALEATTR(5);  // no need to scale zeros
            //SCALEATTR(6);
            //SCALEATTR(7);
            #undef SCALEATTR
        }
    }
    // create entities (and update some statistics)
    calcentitystats(clentstats, tempents, hdr.numents);
    ents.shrink(0);
    loopi(hdr.numents)
    {
        entity &e = ents.add();
        memcpy((void *)&e, &tempents[i], sizeof(persistent_entity));
        e.spawned = false;
    }
    delete[] tempents;

    // read world geometry
    delete[] world;
    setupworld(hdr.sfactor);
    if(!mapinfo.numelems || (mapinfo.access(mname) && !cmpf(cgzname, mapinfo[mname]))) world = (sqr *)ents.getbuf();
    c2skeepalive();

    vector<uchar> rawcubes; // fetch whole file into buffer
    loopi(9)
    {
        ucharbuf q = rawcubes.reserve(cubicsize);
        q.len = f->read(q.buf, cubicsize);
        rawcubes.addbuf(q);
        if(q.len < cubicsize) break;
    }
    delete f;
    ucharbuf uf(rawcubes.getbuf(), rawcubes.length());
    res |= rldecodecubes(uf, world, cubicsize, hdr.version, false) ? 0 : LWW_DECODEERR; // decode file
    c2skeepalive();

    // calculate map statistics
    servsqr *smallworld = createservworld(world, cubicsize);
    int we = calcmapdims(clmapdims, smallworld, ssize);
    if(we) conoutf("world error %d", we);
    res |= LWW_WORLDERROR * (iabs(we) & 0xf);
    delete[] smallworld;

    // check texture slot usage
    char texuse[256] = { 0 };
    sqr *s = world;
    loopirev(cubicsize)
    {
        if(!SOLID(s)) texuse[s->utex] = texuse[s->ftex] = texuse[s->ctex] = 1;
        texuse[s->wtex] = 1;
        s++;
    }
    c2skeepalive();
    calclight();
    conoutf("read map %s rev %d (%d milliseconds)", cgzname, hdr.maprevision, watch.elapsed());
    conoutf("%s", hdr.maptitle);
    mapconfigerror = 0;
    pushscontext(IEXC_MAPCFG); // untrusted altogether
    if(hdr.flags & MHF_AUTOMAPCONFIG)
    { // full featured embedded config: no need to read any other map config files
        copystring(lastloadedconfigfile, "");
    }
    else
    { // map config from files
        execfile("config/default_map_settings.cfg");
        execfile(mcfname);
        copystring(lastloadedconfigfile, mcfname);
    }
    parseheaderextra();
    popscontext();

    c2skeepalive();

    watch.start();
    loopi(256) if(texuse[i]) lookupworldtexture(i, autodownload ? true : false);
    int texloadtime = watch.elapsed();

    c2skeepalive();

    watch.start();
    if(autodownload) resetmdlnotfound();
    preload_mapmodels(autodownload ? true : false);
    int mdlloadtime = watch.elapsed();

    c2skeepalive();

    watch.start();
    audiomgr.preloadmapsounds(autodownload ? true : false);
    int audioloadtime = watch.elapsed();

    c2skeepalive();

    watch.start();
    int downloaded = downloadpackages();
    if(downloaded > 0) clientlogf("downloaded content (%d KB in %d seconds)", downloaded/1024, watch.elapsed()/1000);

    c2skeepalive();

    res |= loadskymap(true) ? 0 : LWW_MISSINGMEDIA * 1;

    watch.start();
    loopi(256) if(texuse[i] && lookupworldtexture(i, false) == notexture && (!_ignoreillegalpaths || gettextureslot(i))) res |= LWW_MISSINGMEDIA * 2;
    clientlogf("loaded textures (%d milliseconds)", texloadtime+watch.elapsed());
    c2skeepalive();
    watch.start();
    res |= preload_mapmodels(false) ? 0 : LWW_MISSINGMEDIA * 4;
    clientlogf("loaded mapmodels (%d milliseconds)", mdlloadtime+watch.elapsed());
    c2skeepalive();
    watch.start();
    res |= audiomgr.preloadmapsounds(false) ? 0 : LWW_MISSINGMEDIA * 8; // also set, if soundvol == 0, because no sounds are loaded (or checked) in that case
    clientlogf("loaded mapsounds (%d milliseconds)", audioloadtime+watch.elapsed());
    c2skeepalive();

    // determine index of first clipped entity
    clentstats.firstclip = max(0, ents.length() - 1); // fallback for "no clipped entities at all"
    loopv(ents)
    {
        entity &e = ents[i];
        mapmodelinfo *mmi;
        if(e.type == CLIP || e.type == PLCLIP || (e.type == MAPMODEL && (mmi = getmminfo(e.attr2)) && mmi->h))
        {
            clentstats.firstclip = i;
            break;
        }
    }

    defformatstring(startmillis)("%d", totalmillis);
    alias("gametimestart", startmillis, true);
    startmap(mname);
    res |= mapconfigerror;
    if(res) conoutf("\f3unresolved problems occurred during load_world(), warning: 0x%x", res);
    return res; // negative: error (no map loaded), zero: no problem, positive: some problems (bitmask value)
}

COMMANDF(loadmap, "s", (char *mapname)
{
    intret(!multiplayer("loadmap") ? load_world(mapname) : -42);
});

char *getfiledesc(const char *dir, const char *name, const char *ext) // extract demo and map descriptions
{
    if(!dir || !name || !ext) return NULL;
    defformatstring(fn)("%s/%s.%s", dir, name, ext);
    path(fn);
    string text, demodescalias;
    if(!strcmp(ext, "dmo"))
    {
        stream *f = opengzfile(fn, "rb");
        if(!f) return NULL;
        demoheader hdr;
        if(f->read(&hdr, sizeof(demoheader))!=sizeof(demoheader) || memcmp(hdr.magic, DEMO_MAGIC, sizeof(hdr.magic))) { delete f; return NULL; }
        delete f;
        lilswap(&hdr.version, 1);
        lilswap(&hdr.protocol, 1);
        const char *tag = "(incompatible file) ";
        if(hdr.version == DEMO_VERSION)
        {
            if(hdr.protocol == PROTOCOL_VERSION) tag = "";
            else if(hdr.protocol == -PROTOCOL_VERSION) tag = "(recorded on modded server) ";
        }
        formatstring(text)("%s%s", tag, hdr.desc);
        text[DHDR_DESCCHARS - 1] = '\0';
        formatstring(demodescalias)("demodesc_%s", name);
        const char *customdesc = getalias(demodescalias);
        if(customdesc)
        {
            int textlen = strlen(text);
            concatformatstring(text, " \n\f4(Description: \f0%s\f4)", customdesc);
            ASSERT(MAXSTRLEN > 2 * DHDR_DESCCHARS);
            text[textlen + DHDR_DESCCHARS - 1] = '\0';
        }
        return newstring(text);
    }
    else if(!strcmp(ext, "cgz"))
    {
        stream *f = opengzfile(fn, "rb");
        if(!f) return NULL;
        header hdr;
        if(f->read(&hdr, sizeof(header))!=sizeof(header) || (strncmp(hdr.head, "CUBE", 4) && strncmp(hdr.head, "ACMP",4))) { delete f; return NULL; }
        delete f;
        lilswap(&hdr.version, 1);
        filtertext(hdr.maptitle, hdr.maptitle, FTXT__MAPMSG, 127);
        formatstring(text)("%s%s", (hdr.version>MAPVERSION) ? "(incompatible file) " : "", hdr.maptitle);
        text[DHDR_DESCCHARS - 1] = '\0';
        return newstring(text);
    }
    return NULL;
}

void enumfiles(char *dir, char *ext)
{
    vector<char> res;
    vector<char *> files;
    if(!strcasecmp(ext, "dir")) listsubdirs(dir, files, stringsort);
    else listfiles(dir, *ext ? ext : NULL, files, stringsort);
    loopv(files) cvecprintf(res, "%s\n", escapestring(files[i]));
    files.deletearrays();
    resultcharvector(res, -1);
}
COMMAND(enumfiles, "ss");

// support reading and writing binary data in config files

static bool hexbinenabled = false;
static vector<uchar> hexbin;

void hexbinwrite(stream *f, void *data, int len, bool ascii = true)   // write block of binary data as hex values with up to 24 bytes per line
{
    string asc;
    uchar *s = (uchar *) data;
    while(len > 0)
    {
        int chunk = min(len, 24);
        f->printf("hexbinchunk");
        loopi(chunk)
        {
            asc[i] = isalnum(*s) ? *s : '.'; asc[i + 1] = '\0';
            f->printf(" %02x", int(*s++));
        }
        if(ascii) f->printf("   // %s\n", asc);
        else f->printf("\n");
        len -= chunk;
    }
}

COMMANDF(hexbinchunk, "v", (char **args, int numargs)      // read up to 24 bytes from the command's arguments to the hexbin buffer
{
    if(!hexbinenabled) { conoutf("hexbinchunk out of context"); return; }
    loopi(numargs) hexbin.add(strtol(args[i], NULL, 16));
});


// multi-map editmode extensions (xmap)
//
// keep several (versions of) maps in memory at the same time
// compare maps and visualise differences
//
// the general assumption is, that ram is cheap, and that a copy of a size-9 map should be below 10MB (including undo data)

#define XMAPVERSION  1001001

VARP(persistentxmaps, 0, 1, 1);    // save all xmaps on exit, restore them at game start

struct xmap
{
    string nick;      // unique handle
    string name;
    vector<headerextra *> headerextras;
    vector<persistent_entity> ents, delents;
    vector<char> mapconfig;
    vector<int> todoents;
    vector<char *> todoentdescs;
    sqr *world;
    header hdr;
    int ssize, cubicsize, numundo;
    string mcfname;
    short position[5];

    xmap() : world(NULL), ssize(0), cubicsize(0), numundo(0) { *nick = *name = *mcfname = '\0'; }

    xmap(const char *nnick)    // take the current map and store it in an xmap
    {
        copystring(nick, nnick);
        copystring(name, getclientmap());
        hdr = ::hdr; ssize = ::ssize; cubicsize = ::cubicsize;
        loopv(::headerextras) headerextras.add(::headerextras[i]->duplicate());
        world = new sqr[cubicsize];
        memcpy(world, ::world, cubicsize * sizeof(sqr));
        loopv(::ents) if(::ents[i].type != NOTUSED) ents.add() = ::ents[i];
        loopv(deleted_ents) delents.add() = deleted_ents[i];
        copystring(mcfname, lastloadedconfigfile);   // may have been "official" or not
        if(hdr.flags & MHF_AUTOMAPCONFIG) getcurrentmapconfig(mapconfig, false);
        storeposition(position);
        vector<uchar> tmp;  // add undo/redo data in compressed form as temporary headerextra
        numundo = backupeditundo(tmp, MAXHEADEREXTRA, MAXHEADEREXTRA);
        headerextras.add(new headerextra(tmp.length(), HX_EDITUNDO, tmp.getbuf()));
        loopv(::todoents) { todoents.add(::todoents[i]); todoentdescs.add(newstring(::todoentdescs[i])); }
    }

    ~xmap()
    {
        headerextras.deletecontents();
        delete[] world;
        ents.setsize(0);
        delents.setsize(0);
        mapconfig.setsize(0);
        todoents.setsize(0);
        todoentdescs.deletearrays();
    }

    void restoreent(int i)
    {
        entity &e = ::ents.add();
        memcpy((void *)&e, &ents[i], sizeof(persistent_entity));
        e.spawned = true;
    }

    void restore()      // overwrite the current map with the contents of an xmap
    {
        setnames(name);
        copystring(lastloadedconfigfile, mcfname);
        ::hdr = hdr;
        clearheaderextras();
        resetmap(true);
        curmaprevision = hdr.maprevision;
        setfvar("waterlevel", float(hdr.waterlevel) / WATERLEVELSCALING);
        ::ents.shrink(0);
        loopv(ents) restoreent(i);
        deleted_ents.setsize(0);
        loopv(delents) deleted_ents.add(delents[i]);
        delete[] ::world;
        setupworld(hdr.sfactor);
        memcpy(::world, world, cubicsize * sizeof(sqr));
        calclight();  // includes full remip()
        loopv(headerextras) ::headerextras.add(headerextras[i]->duplicate());
        pushscontext(IEXC_MAPCFG); // untrusted altogether
        if(mapconfig.length()) execute(mapconfig.getbuf());
        else
        {
            execfile("config/default_map_settings.cfg");
            execfile(lastloadedconfigfile);
        }
        parseheaderextra(true, mapconfig.length() ? (1<<HX_CONFIG) : 0); // don't execute headerextra config, if we already executed an autostored config
        popscontext();
        loadskymap(true);
        startmap(name, false, true);      // "start" but don't respawn: basically just set clientmap
        restoreposition(position);
        cleartodoentities();
        loopv(todoents) addtodoentity(todoents[i], todoentdescs[i]);
    }

    void write(stream *f)   // write xmap as cubescript to a file
    {
        f->printf("restorexmap version %d %d %d\n", XMAPVERSION, isbigendian() ? 1 : 0, int(sizeof(world)));  // it is a non-portable binary file format, so we have to check...
        f->printf("restorexmap names \"%s\" \"%s\"\n", name, mcfname);
        f->printf("restorexmap sizes %d %d %d\n", ssize, cubicsize, numundo);
        hexbinwrite(f, &hdr, sizeof(header));
        f->printf("restorexmap header\n");
        uLongf worldsize = cubicsize * sizeof(sqr), gzbufsize = (worldsize * 11) / 10;     // gzip the world, so the file will only be big instead of huge
        uchar *gzbuf = new uchar[gzbufsize];
        if(compress2(gzbuf, &gzbufsize, (uchar *)world, worldsize, 9) != Z_OK) gzbufsize = 0;
        hexbinwrite(f, gzbuf, gzbufsize, false);
        f->printf("restorexmap world\n");
        DELETEA(gzbuf);
        loopv(headerextras)
        {
            hexbinwrite(f, headerextras[i]->data, headerextras[i]->len);
            f->printf("restorexmap headerextra %d  // %s\n", headerextras[i]->flags, hx_name(headerextras[i]->flags));
        }
        int el = ents.length(), all = el + delents.length();
        loopi(all) // entities are stored as plain text - you may edit them
        {
            persistent_entity &e = i >= el ? delents[i - el] : ents[i];
            f->printf("restorexmap %sent %d  %d %d %d  %d %d %d %d %d %d %d // %s\n", i >= el ? "del": "", e.type, e.x, e.y, e.z, e.attr1, e.attr2, e.attr3, e.attr4, e.attr5, e.attr6, e.attr7, e.type >= 0 && e.type < MAXENTTYPES ? entnames[e.type] : "unknown");
        }
        if(mapconfig.length())
        {
            char *t = newstring(mapconfig.getbuf()), *p, *l = t;
            while((p = strchr(l, '\n')))
            {
                *p = '\0';
                f->printf("restorexmap config %s\n", escapestring(l));
                l = p + 1;
            }
            delstring(t);
        }
        loopv(todoents) f->printf("restorexmap todoent %d %s\n", todoents[i], escapestring(todoentdescs[i]));
        f->printf("restorexmap position %d %d %d %d %d  // EOF, don't touch this\n\n", int(position[0]), int(position[1]), int(position[2]), int(position[3]), int(position[4]));
    }
};

static vector<xmap *> xmaps;
static xmap *bak, *xmjigsaw;                               // only bak needs to be deleted before reuse

bool validxmapname(const char *nick) { if(validmapname(nick)) return true; conoutf("sry, %s is not a valid xmap nickname", nick); return false; }

void xmapdelete(xmap *&xm)  // make sure, we don't point to deleted xmaps
{
    DELETEP(xm);
}

void xmapbackup(const char *nickprefix, const char *nick)   // throw away existing backup and make a new one
{
    xmapdelete(bak);
    defformatstring(text)("%s%s", nickprefix, nick);
    bak = new xmap(text);
    if(unsavededits) conoutf("\f3stored backup of unsaved edits on map '%s'; to restore, type \"/xmap_restore\"", bak->name);
}

const char *xmapdescstring(xmap *xm, bool shortform = false)
{
    static string s[2];
    static int toggle;
    toggle = !toggle;
    formatstring(s[toggle])("\"%s\": %s rev %d, %d ents%c size %d, hdrs %d, %d undo steps", xm->nick, xm->name, xm->hdr.maprevision, xm->ents.length(),
                        shortform ? '\0' : ',', xm->hdr.sfactor, xm->headerextras.length() - 1, xm->numundo);
    return s[toggle];
}

xmap *getxmapbynick(const char *nick, int *index = NULL, bool errmsg = true)
{
    if(*nick) loopvrev(xmaps)
    {
        if(!strcmp(nick, xmaps[i]->nick))
        {
            if(index) *index = i;
            return xmaps[i];
        }
    }
    if(errmsg) conoutf("xmap \"%s\" not found", nick);
    return NULL;
}

COMMANDF(xmap_list, "", ()                       // list xmaps (and status)
{
    loopv(xmaps) conoutf("xmap %d %s", i, xmapdescstring(xmaps[i]));
    if(xmaps.length() == 0) conoutf("no xmaps in memory");
    if(bak) conoutf("backup stored before %s", xmapdescstring(bak));
} );

COMMANDF(getxmaplist, "s", (char *what)          // return list of xmap nicks and descriptions
{
    vector<char> res;
    if(strcasecmp(what, "bak")) loopv(xmaps) cvecprintf(res, "%s %s\n", escapestring(xmaps[i]->nick), escapestring(xmapdescstring(xmaps[i])));
    else if(bak) cvecprintf(res, "%s %s", escapestring(bak->nick), escapestring(xmapdescstring(bak)));
    resultcharvector(res, -1);
} );

COMMANDF(xmap_store, "s", (const char *nick)     // store current map in an xmap buffer
{
    if(noteditmode("xmap_store")) return;   // (may also be used in coopedit)
    if(!*nick || !validxmapname(nick)) return;
    int i;
    if(getxmapbynick(nick, &i, false)) { xmap *xm = xmaps.remove(i); xmapdelete(xm); }   // overwrite existing same nick
    xmaps.add(new xmap(nick));
    unsavededits = 0;
    conoutf("stored xmap %s", xmapdescstring(xmaps.last()));
} );

COMMANDF(xmap_delete, "s", (const char *nick)     // delete xmap buffer
{
    if(!*nick) return;
    int i;
    if(getxmapbynick(nick, &i))
    {
        xmap *xm = xmaps.remove(i);
        xmapdelete(xm);
        conoutf("deleted xmap \"%s\"", nick);
    }
} );

COMMANDF(xmap_delete_backup, "", () { if(bak) { xmapdelete(bak); conoutf("deleted backup xmap"); }} );

COMMANDF(xmap_keep_backup, "s", (const char *nick)     // move backup xmap to more permanent position
{
    if(!bak) { conoutf("no backup xmap available"); return ; }
    defformatstring(bakdesc)("%s", bak->nick);
    if(*nick)
    {
        if(validxmapname(nick)) copystring(bak->nick, nick);
        else return;
    }
    loopi(42) if(getxmapbynick(bak->nick, NULL, false)) concatstring(bak->nick, "_");  // evade existing nicknames
    xmaps.add(bak);
    bak = NULL;
    conoutf("stored backup xmap \"%s\" as xmap %s", bakdesc, xmapdescstring(xmaps.last()));
} );

COMMANDF(xmap_rename, "ss", (const char *oldnick, const char *newnick)     // rename xmap buffer
{
    if(!*oldnick || !*newnick) return;
    xmap *xm = getxmapbynick(oldnick);
    if(!xm || !validxmapname(newnick) || getxmapbynick(newnick, NULL, false)) return;
    copystring(xm->nick, newnick);
} );

COMMANDF(xmap_restore, "s", (const char *nick)     // use xmap as current map
{
    EDITMP("xmap_restore");
    if(*nick)
    {
        xmap *xm = getxmapbynick(nick);
        if(!xm) return;
        xmapbackup("restore_xmap_", nick);  // keep backup, so we can restore from the restore :)
        xm->restore();
        unsavededits = 0;
        conoutf("restored xmap %s", xmapdescstring(xm));
    }
    else if(bak)
    {
        bak->restore();
        unsavededits = 0;
        conoutf("restored backup created before %s", xmapdescstring(bak));
    }
} );

void restorexmap(char **args, int numargs)   // read an xmap from a cubescript file
{
    const char *cmdnames[] = { "version", "names", "sizes", "header", "world", "headerextra", "ent", "delent", "config", "todoent", "position", "" };
    const char cmdnumarg[] = {         3,       2,       3,        0,       0,             1,    11,       11,        1,         2,          5     };

    if(!xmjigsaw || numargs < 1) return; // { conoutf("restorexmap out of context"); return; }
    bool abort = false;
    int cmd = getlistindex(args[0], cmdnames, false, -1);
    if(cmd < 0 || numargs != cmdnumarg[cmd] + 1) { conoutf("restorexmap error"); return; }
    switch(cmd)
    {
        case 0:     // version
            if(ATOI(args[1]) != XMAPVERSION || ATOI(args[2]) != (isbigendian() ? 1 : 0) || ATOI(args[3]) != int(sizeof(world)))
            {
                conoutf("restorexmap: file is from different game version");
                abort = true;
            }
            break;
        case 1:     // names
            copystring(xmjigsaw->name, args[1]);
            copystring(xmjigsaw->mcfname, args[2]);
            break;
        case 2:     // sizes
            xmjigsaw->ssize = ATOI(args[1]);
            xmjigsaw->cubicsize = ATOI(args[2]);
            xmjigsaw->numundo = ATOI(args[3]);
            break;
        case 3:     // header
            if(hexbin.length() == sizeof(header)) memcpy(&xmjigsaw->hdr, hexbin.getbuf(), sizeof(header));
            else abort = true;
            break;
        case 4:     // world
        {
            int rawworldsize = xmjigsaw->cubicsize * sizeof(sqr);
            xmjigsaw->world = new sqr[rawworldsize];
            uLongf rawsize = rawworldsize;
            if(uncompress((uchar *)xmjigsaw->world, &rawsize, hexbin.getbuf(), hexbin.length()) != Z_OK || rawsize - rawworldsize != 0) abort = true;
            break;
        }
        case 5:     // headerextra
            xmjigsaw->headerextras.add(new headerextra(hexbin.length(), ATOI(args[1]), hexbin.getbuf()));
            break;
        case 6:     // ent
        case 7:     // delent
        {
            persistent_entity &e = cmd == 6 ? xmjigsaw->ents.add() : xmjigsaw->delents.add();
            int a[11];
            loopi(11) a[i] = ATOI(args[i + 1]);
            e.type = a[0]; e.x = a[1]; e.y = a[2]; e.z = a[3]; e.attr1 = a[4]; e.attr2 = a[5]; e.attr3 = a[6]; e.attr4 = a[7]; e.attr5 = a[8]; e.attr6 = a[9]; e.attr7 = a[10];
            break;
        }
        case 8:     // config
            cvecprintf(xmjigsaw->mapconfig, "%s\n", args[1]);
            break;
        case 9:     // todoent
            xmjigsaw->todoents.add(ATOI(args[1]));
            xmjigsaw->todoentdescs.add(newstring(args[2]));
            break;
        case 10:     // position - this is also the last command and will finish the xmap
        {
            loopi(5) xmjigsaw->position[i] = ATOI(args[i + 1]);
            int i;
            if(getxmapbynick(xmjigsaw->nick, &i, false)) { xmap *xm = xmaps.remove(i); xmapdelete(xm); }   // overwrite existing same nick
            if(!xmjigsaw->world) abort = true;
            else
            {
                if(xmjigsaw->mapconfig.length()) xmjigsaw->mapconfig.add('\0');
                xmaps.add(xmjigsaw);
                xmjigsaw = NULL;  // no abort!
            }
        }
    }
    hexbin.setsize(0);
    if(abort) DELETEP(xmjigsaw);
}
COMMAND(restorexmap, "v");

static const char *bakprefix = "(backup)", *xmapspath = "mapediting/xmaps";
char *xmapfilename(const char *nick, const char *prefix = "") { static defformatstring(fn)("%s/%s%s.xmap", xmapspath, prefix, nick); return path(fn); }

void writexmap(xmap *xm, const char *prefix = "")
{
    stream *f = openfile(xmapfilename(xm->nick, prefix), "w");
    if(f)
    {
        xm->write(f);
        delete f;
    }
}

void writeallxmaps()   // at game exit, write all xmaps to cubescript files in mapediting/xmaps
{
    if(!persistentxmaps) return;
    loopv(xmaps) writexmap(xmaps[i]);
    if(unsavededits) xmapbackup("gameend", "");
    if(bak) writexmap(bak, bakprefix);
}

void loadxmap(const char *nick)
{
    DELETEP(xmjigsaw);
    xmjigsaw = new xmap();
    copystring(xmjigsaw->nick, nick);
    hexbinenabled = true;
    execfile(xmapfilename(nick));
    hexbinenabled = false;
    hexbin.setsize(0);    // just to make sure
}

int loadallxmaps()     // at game start, load all xmaps from mapediting/xmaps
{
    vector<char *> xmapnames;
    string filename;
    listfiles(xmapspath, "xmap", xmapnames, stringsort);
    loopv(xmapnames)
    {
        loadxmap(xmapnames[i]);
        copystring(filename, xmapfilename(xmapnames[i]));
        backup(filename, xmapfilename(xmapnames[i], "backups/"));   // move to backup folder - we will write new files at exit
        delete[] xmapnames[i];
    }
    loopv(xmaps) if(!strncmp(xmaps[i]->nick, bakprefix, strlen(bakprefix)))
    {
        xmapdelete(bak);
        bak = xmaps.remove(i);
        copystring(bak->nick, bak->nick + strlen(bakprefix));
        break;
    }
    return xmapnames.length();
}
