Cube  Check-in [142095b08f]

// clientgame.cpp: core game related stuff

#include "cube.h"

#include <memory>

int nextmode = 0; // nextmode becomes gamemode after next map load
VAR(gamemode, 1, 0, 0);

void
mode(int n)
{
	addmsg(1, 2, SV_GAMEMODE, nextmode = n);

}
COMMAND(mode, ARG_1INT)

bool intermission = false;

dynent *player1 = newdynent(); // our client
dvector players;               // other clients

initclient()
{
	clientmap = @"";
	initclientnet();
}

void
startmap(OFString *name) // called just after a map load
{
	if (netmapstart() && m_sp) {
		gamemode = 0;
		conoutf(@"coop sp not supported yet");
	}
	sleepwait = 0;
	monsterclear();
	projreset();
	spawncycle = -1;
	spawnplayer(player1);
	player1->frags = 0;
	loopv(players) if (players[i]) players[i]->frags = 0;
	resetspawns();

	clientmap = name;

	if (editmode)
		toggleedit();
	setvar(@"gamespeed", 100);
	setvar(@"fog", 180);
	setvar(@"fogcolour", 0x8099B3);
	showscores(false);
	intermission = false;
	Cube.sharedInstance.framesInMap = 0;
	conoutf(@"game mode is %s", modestr(gamemode));
}

COMMANDN(map, changemap, ARG_1STR)

	disconnect();
}

void
changemapserv(char *name, int mode) // forced map change from the server
{
	gamemode = mode;
	@autoreleasepool {
		load_world(@(name));
	}
}

void
changemap(OFString *name) // request map change, server may ignore
{
	toservermap = name;
}

			break;

		case SV_RECVMAP: {
			sgetstr();
			conoutf(@"received map \"%s\" from server, reloading..",
			    text);
			int mapsize = getint(p);
			@autoreleasepool {
				writemap(@(text), mapsize, p);
			}
			p += mapsize;
			changemapserv(text, gamemode);
			break;
		}

		case SV_SERVMSG:
			sgetstr();

extern int getclientnum();
extern void changemapserv(char *name, int mode);
extern void writeclientinfo(OFStream *stream);

// clientgame
extern void mousemove(int dx, int dy);
extern void updateworld(int millis);
extern void startmap(OFString *name);
extern void changemap(OFString *name);
extern void initclient();
extern void spawnplayer(dynent *d);
extern void selfdamage(int damage, int actor, dynent *act);
extern dynent *newdynent();
extern OFString *getclientmap();
extern const char *modestr(int n);

extern void particle_splash(int type, int num, int fade, OFVector3D &p);
extern void particle_trail(
    int type, int fade, OFVector3D &from, OFVector3D &to);
extern void render_particles(int time);

// worldio
extern void save_world(OFString *fname);
extern void load_world(OFString *mname);
extern void writemap(OFString *mname, int msize, uchar *mdata);
extern OFData *readmap(OFString *mname);
extern void loadgamerest();
extern void incomingdemodata(uchar *buf, int len, bool extras = false);
extern void demoplaybackstep();
extern void stop();
extern void stopifrecording();
extern void demodamage(int damage, OFVector3D &o);

		s->ctex = DEFAULT_CEIL;
		s->wtex = s->utex = DEFAULT_WALL;
		s->type = SOLID;
		s->floor = 0;
		s->ceil = 16;
		s->vdelta = 0;
		s->defer = 0;

	}

	strncpy(hdr.head, "CUBE", 4);
	hdr.version = MAPVERSION;
	hdr.headersize = sizeof(header);
	hdr.sfactor = sfactor;

	if (copy) {
		loop(x, ssize / 2) loop(y, ssize / 2)
		{
			*S(x + ssize / 4, y + ssize / 4) =
			    *SWS(oldworld, x, y, ssize / 2);

		}
		loopv(ents)
		{
			ents[i].x += ssize / 4;
			ents[i].y += ssize / 4;

		}
	} else {
		strn0cpy(hdr.maptitle, "Untitled Map by Unknown", 128);
		hdr.waterlevel = -100000;
		loopi(15) hdr.reserved[i] = 0;
		loopk(3) loopi(256) hdr.texlists[k][i] = i;
		ents.setsize(0);
		block b = {8, 8, ssize - 16, ssize - 16};
		edittypexy(SPACE, b);

	}

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


	}
}

void
mapenlarge()
{
	empty_world(-1, false);
}

void
newmap(int i)
{
	empty_world(i, false);

}

COMMAND(mapenlarge, ARG_NONE)
COMMAND(newmap, ARG_1INT)
COMMANDN(recalc, calclight, ARG_NONE)
COMMAND(delent, ARG_NONE)
COMMAND(entproperty, ARG_2INT)

		}
	}
}

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

void
writemap(OFString *mname, int msize, uchar *mdata)
{
	@autoreleasepool {
		setnames(mname.UTF8String);
	}
	backup(cgzname, bakname);

	FILE *f = fopen(cgzname, "wb");
	if (!f) {
		conoutf(@"could not write map to %s", cgzname);
		return;
	}
	fwrite(mdata, 1, msize, f);
	fclose(f);
	conoutf(@"wrote map %@ as file %s", mname, cgzname);
}

OFData *
readmap(OFString *mname)
{
	@autoreleasepool {
		setnames(mname.UTF8String);

		conoutf(@"wrote map file %s", cgzname);
		settagareas();
	}
}
COMMANDN(savemap, save_world, ARG_1STR)

void
load_world(OFString *mname) // still supports all map formats that have existed
                            // since the earliest cube betas!
{
	stopifrecording();
	cleardlights();
	pruneundos();
	@autoreleasepool {
		setnames(mname.UTF8String);
	}
	gzFile f = gzopen(cgzname, "rb9");
	if (!f) {
		conoutf(@"could not read map %s", cgzname);
		return;
	}
	gzread(f, &hdr, sizeof(header) - sizeof(int) * 16);
	endianswap(&hdr.version, sizeof(int), 4);