Cube  Check-in [0a0d4f9155]

*.a
*.dep
*.o
*/.deps
aclocal.m4
autom4te.cache
buildsys.mk
config.cfg
config.log
config.status
configure

// client.cpp, mostly network related client game code

#include "cube.h"

ENetHost *clienthost = NULL;
int connecting = 0;
int connattempts = 0;
int disconnecting = 0;
int clientnum = -1;         // our client id in the game
bool c2sinit = false;       // whether we need to tell the other clients our stats
int clientnum = -1;   // our client id in the game
bool c2sinit = false; // whether we need to tell the other clients our stats

int
getclientnum()
{
int getclientnum() { return clientnum; };
	return clientnum;
};

bool
bool multiplayer()
multiplayer()
{
    // check not correct on listen server?
    if(clienthost) conoutf("operation not available in multiplayer");
    return clienthost!=NULL;
	// check not correct on listen server?
	if (clienthost)
		conoutf("operation not available in multiplayer");
	return clienthost != NULL;
};

bool
bool allowedittoggle()
allowedittoggle()
{
    bool allow = !clienthost || gamemode==1;
    if(!allow) conoutf("editing in multiplayer requires coopedit mode (1)");
    return allow; 
	bool allow = !clienthost || gamemode == 1;
	if (!allow)
		conoutf("editing in multiplayer requires coopedit mode (1)");
	return allow;
};

VARF(rate, 0, 0, 25000, if(clienthost && (!rate || rate>1000)) enet_host_bandwidth_limit (clienthost, rate, rate));
VARF(rate, 0, 0, 25000,
    if (clienthost && (!rate || rate > 1000))
        enet_host_bandwidth_limit(clienthost, rate, rate));

void throttle();

VARF(throttle_interval, 0, 5, 30, throttle());
VARF(throttle_accel,    0, 2, 32, throttle());
VARF(throttle_decel,    0, 2, 32, throttle());
VARF(throttle_accel, 0, 2, 32, throttle());
VARF(throttle_decel, 0, 2, 32, throttle());

void
void throttle()
throttle()
{
    if(!clienthost || connecting) return;
    assert(ENET_PEER_PACKET_THROTTLE_SCALE==32);
    enet_peer_throttle_configure(clienthost->peers, throttle_interval*1000, throttle_accel, throttle_decel);
	if (!clienthost || connecting)
		return;
	assert(ENET_PEER_PACKET_THROTTLE_SCALE == 32);
	enet_peer_throttle_configure(clienthost->peers,
	    throttle_interval * 1000, throttle_accel, throttle_decel);
};

void
newname(char *name)
{
	c2sinit = false;
void newname(char *name) { c2sinit = false; strn0cpy(player1->name, name, 16); };
void newteam(char *name) { c2sinit = false; strn0cpy(player1->team, name, 5); };
	strn0cpy(player1->name, name, 16);
};
void
newteam(char *name)
{
	c2sinit = false;
	strn0cpy(player1->team, name, 5);
};

COMMANDN(team, newteam, ARG_1STR);
COMMANDN(name, newname, ARG_1STR);

void
void writeclientinfo(FILE *f)
writeclientinfo(FILE *f)
{
    fprintf(f, "name \"%s\"\nteam \"%s\"\n", player1->name, player1->team);
	fprintf(f, "name \"%s\"\nteam \"%s\"\n", player1->name, player1->team);
};

void
void connects(char *servername)
{   
    disconnect(1);  // reset state
    addserver(servername);
connects(char *servername)
{
	disconnect(1); // reset state
	addserver(servername);

    conoutf("attempting to connect to %s", servername);
    ENetAddress address = { ENET_HOST_ANY, CUBE_SERVER_PORT };
    if(enet_address_set_host(&address, servername) < 0)
	conoutf("attempting to connect to %s", servername);
	ENetAddress address = {ENET_HOST_ANY, CUBE_SERVER_PORT};
	if (enet_address_set_host(&address, servername) < 0) {
    {
        conoutf("could not resolve server %s", servername);
        return;
    };
		conoutf("could not resolve server %s", servername);
		return;
	};

    clienthost = enet_host_create(NULL, 1, rate, rate);
	clienthost = enet_host_create(NULL, 1, rate, rate);

    if(clienthost)
	if (clienthost) {
    {
        enet_host_connect(clienthost, &address, 1); 
        enet_host_flush(clienthost);
        connecting = lastmillis;
        connattempts = 0;
		enet_host_connect(clienthost, &address, 1);
		enet_host_flush(clienthost);
		connecting = lastmillis;
		connattempts = 0;
    }
    else
	} else {
    {
        conoutf("could not connect to server");
        disconnect();
    };
		conoutf("could not connect to server");
		disconnect();
	};
};

void
void disconnect(int onlyclean, int async)
disconnect(int onlyclean, int async)
{
    if(clienthost) 
	if (clienthost) {
    {
        if(!connecting && !disconnecting) 
		if (!connecting && !disconnecting) {
        {
            enet_peer_disconnect(clienthost->peers);
            enet_host_flush(clienthost);
            disconnecting = lastmillis;
        };
        if(clienthost->peers->state != ENET_PEER_STATE_DISCONNECTED)
			enet_peer_disconnect(clienthost->peers);
			enet_host_flush(clienthost);
			disconnecting = lastmillis;
		};
		if (clienthost->peers->state != ENET_PEER_STATE_DISCONNECTED) {
        {
            if(async) return;
            enet_peer_reset(clienthost->peers);
        };
        enet_host_destroy(clienthost);
    };
			if (async)
				return;
			enet_peer_reset(clienthost->peers);
		};
		enet_host_destroy(clienthost);
	};

    if(clienthost && !connecting) conoutf("disconnected");
    clienthost = NULL;
    connecting = 0;
    connattempts = 0;
    disconnecting = 0;
    clientnum = -1;
    c2sinit = false;
    player1->lifesequence = 0;
    loopv(players) zapdynent(players[i]);
    
    localdisconnect();
	if (clienthost && !connecting)
		conoutf("disconnected");
	clienthost = NULL;
	connecting = 0;
	connattempts = 0;
	disconnecting = 0;
	clientnum = -1;
	c2sinit = false;
	player1->lifesequence = 0;
	loopv(players) zapdynent(players[i]);

	localdisconnect();

	if (!onlyclean) {
		stop();
    if(!onlyclean) { stop(); localconnect(); };
};
		localconnect();
	};
};

void
void trydisconnect()
trydisconnect()
{
    if(!clienthost)
	if (!clienthost) {
    {
        conoutf("not connected");
        return;
    };
    if(connecting) 
		conoutf("not connected");
		return;
	};
	if (connecting) {
    {
        conoutf("aborting connection attempt");
        disconnect();
        return;
    };
    conoutf("attempting to disconnect...");
    disconnect(0, !disconnecting);
		conoutf("aborting connection attempt");
		disconnect();
		return;
	};
	conoutf("attempting to disconnect...");
	disconnect(0, !disconnecting);
};

string ctext;
void
toserver(char *text)
{
void toserver(char *text) { conoutf("%s:\f %s", player1->name, text); strn0cpy(ctext, text, 80); };
void echo(char *text) { conoutf("%s", text); };
	conoutf("%s:\f %s", player1->name, text);
	strn0cpy(ctext, text, 80);
};
void
echo(char *text)
{
	conoutf("%s", text);
};

COMMAND(echo, ARG_VARI);
COMMANDN(say, toserver, ARG_VARI);
COMMANDN(connect, connects, ARG_1STR);
COMMANDN(disconnect, trydisconnect, ARG_NONE);

// collect c2s messages conveniently

vector<ivector> messages;

void
void addmsg(int rel, int num, int type, ...)
addmsg(int rel, int num, int type, ...)
{
    if(demoplayback) return;
    if(num!=msgsizelookup(type)) { sprintf_sd(s)("inconsistant msg size for %d (%d != %d)", type, num, msgsizelookup(type)); fatal(s); };
    if(messages.length()==100) { conoutf("command flood protection (type %d)", type); return; };
    ivector &msg = messages.add();
    msg.add(num);
    msg.add(rel);
    msg.add(type);
    va_list marker;
    va_start(marker, type); 
    loopi(num-1) msg.add(va_arg(marker, int));
    va_end(marker);  
	if (demoplayback)
		return;
	if (num != msgsizelookup(type)) {
		sprintf_sd(s)("inconsistant msg size for %d (%d != %d)", type,
		    num, msgsizelookup(type));
		fatal(s);
	};
	if (messages.length() == 100) {
		conoutf("command flood protection (type %d)", type);
		return;
	};
	ivector &msg = messages.add();
	msg.add(num);
	msg.add(rel);
	msg.add(type);
	va_list marker;
	va_start(marker, type);
	loopi(num - 1) msg.add(va_arg(marker, int));
	va_end(marker);
};

void
void server_err()
server_err()
{
    conoutf("server network error, disconnecting...");
    disconnect();
	conoutf("server network error, disconnecting...");
	disconnect();
};

int lastupdate = 0, lastping = 0;
string toservermap;
bool senditemstoserver =
bool senditemstoserver = false;     // after a map change, since server doesn't have map data
    false; // after a map change, since server doesn't have map data

string clientpassword;
void
password(char *p)
{
void password(char *p) { strcpy_s(clientpassword, p); };
	strcpy_s(clientpassword, p);
};
COMMAND(password, ARG_1STR);

bool
netmapstart()
{
bool netmapstart() { senditemstoserver = true; return clienthost!=NULL; };
	senditemstoserver = true;
	return clienthost != NULL;
};

void
void initclientnet()
initclientnet()
{
    ctext[0] = 0;
    toservermap[0] = 0;
    clientpassword[0] = 0;
    newname("unnamed");
    newteam("red");
	ctext[0] = 0;
	toservermap[0] = 0;
	clientpassword[0] = 0;
	newname("unnamed");
	newteam("red");
};

void
void sendpackettoserv(void *packet)
sendpackettoserv(void *packet)
{
	if (clienthost) {
    if(clienthost) { enet_host_broadcast(clienthost, 0, (ENetPacket *)packet); enet_host_flush(clienthost); }
    else localclienttoserver((ENetPacket *)packet);
		enet_host_broadcast(clienthost, 0, (ENetPacket *)packet);
		enet_host_flush(clienthost);
	} else
		localclienttoserver((ENetPacket *)packet);
}

void
void c2sinfo(dynent *d)                     // send update to the server
c2sinfo(dynent *d) // send update to the server
{
	if (clientnum < 0)
    if(clientnum<0) return;                 // we haven't had a welcome message from the server yet
    if(lastmillis-lastupdate<40) return;    // don't update faster than 25fps
    ENetPacket *packet = enet_packet_create (NULL, MAXTRANS, 0);
    uchar *start = packet->data;
    uchar *p = start+2;
    bool serveriteminitdone = false;
    if(toservermap[0])                      // suggest server to change map
    {                                       // do this exclusively as map change may invalidate rest of update
        packet->flags = ENET_PACKET_FLAG_RELIABLE;
        putint(p, SV_MAPCHANGE);
        sendstring(toservermap, p);
        toservermap[0] = 0;
        putint(p, nextmode);
		return; // we haven't had a welcome message from the server yet
	if (lastmillis - lastupdate < 40)
		return; // don't update faster than 25fps
	ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, 0);
	uchar *start = packet->data;
	uchar *p = start + 2;
	bool serveriteminitdone = false;
	if (toservermap[0]) // suggest server to change map
	{ // do this exclusively as map change may invalidate rest of update
		packet->flags = ENET_PACKET_FLAG_RELIABLE;
		putint(p, SV_MAPCHANGE);
		sendstring(toservermap, p);
		toservermap[0] = 0;
		putint(p, nextmode);
    }
    else
	} else {
    {
        putint(p, SV_POS);
        putint(p, clientnum);
        putint(p, (int)(d->o.x*DMF));       // quantize coordinates to 1/16th of a cube, between 1 and 3 bytes
        putint(p, (int)(d->o.y*DMF));
        putint(p, (int)(d->o.z*DMF));
        putint(p, (int)(d->yaw*DAF));
        putint(p, (int)(d->pitch*DAF));
        putint(p, (int)(d->roll*DAF));
        putint(p, (int)(d->vel.x*DVF));     // quantize to 1/100, almost always 1 byte
        putint(p, (int)(d->vel.y*DVF));
        putint(p, (int)(d->vel.z*DVF));
        // pack rest in 1 byte: strafe:2, move:2, onfloor:1, state:3
        putint(p, (d->strafe&3) | ((d->move&3)<<2) | (((int)d->onfloor)<<4) | ((editmode ? CS_EDITING : d->state)<<5) );
 
        if(senditemstoserver)
		putint(p, SV_POS);
		putint(p, clientnum);
		putint(
		    p, (int)(d->o.x * DMF)); // quantize coordinates to 1/16th
		                             // of a cube, between 1 and 3 bytes
		putint(p, (int)(d->o.y * DMF));
		putint(p, (int)(d->o.z * DMF));
		putint(p, (int)(d->yaw * DAF));
		putint(p, (int)(d->pitch * DAF));
		putint(p, (int)(d->roll * DAF));
		putint(
		    p, (int)(d->vel.x *
		             DVF)); // quantize to 1/100, almost always 1 byte
		putint(p, (int)(d->vel.y * DVF));
		putint(p, (int)(d->vel.z * DVF));
		// pack rest in 1 byte: strafe:2, move:2, onfloor:1, state:3
		putint(p, (d->strafe & 3) | ((d->move & 3) << 2) |
		              (((int)d->onfloor) << 4) |
		              ((editmode ? CS_EDITING : d->state) << 5));

		if (senditemstoserver) {
        {
            packet->flags = ENET_PACKET_FLAG_RELIABLE;
            putint(p, SV_ITEMLIST);
            if(!m_noitems) putitems(p);
            putint(p, -1);
            senditemstoserver = false;
            serveriteminitdone = true;
        };
        if(ctext[0])    // player chat, not flood protected for now
        {
            packet->flags = ENET_PACKET_FLAG_RELIABLE;
            putint(p, SV_TEXT);
            sendstring(ctext, p);
            ctext[0] = 0;
        };
        if(!c2sinit)    // tell other clients who I am
        {
            packet->flags = ENET_PACKET_FLAG_RELIABLE;
            c2sinit = true;
            putint(p, SV_INITC2S);
            sendstring(player1->name, p);
            sendstring(player1->team, p);
            putint(p, player1->lifesequence);
        };
        loopv(messages)     // send messages collected during the previous frames
        {
            ivector &msg = messages[i];
            if(msg[1]) packet->flags = ENET_PACKET_FLAG_RELIABLE;
            loopi(msg[0]) putint(p, msg[i+2]);
        };
        messages.setsize(0);
        if(lastmillis-lastping>250)
			packet->flags = ENET_PACKET_FLAG_RELIABLE;
			putint(p, SV_ITEMLIST);
			if (!m_noitems)
				putitems(p);
			putint(p, -1);
			senditemstoserver = false;
			serveriteminitdone = true;
		};
		if (ctext[0]) // player chat, not flood protected for now
		{
			packet->flags = ENET_PACKET_FLAG_RELIABLE;
			putint(p, SV_TEXT);
			sendstring(ctext, p);
			ctext[0] = 0;
		};
		if (!c2sinit) // tell other clients who I am
		{
			packet->flags = ENET_PACKET_FLAG_RELIABLE;
			c2sinit = true;
			putint(p, SV_INITC2S);
			sendstring(player1->name, p);
			sendstring(player1->team, p);
			putint(p, player1->lifesequence);
		};
		loopv(messages) // send messages collected during the previous
		                // frames
		{
			ivector &msg = messages[i];
			if (msg[1])
				packet->flags = ENET_PACKET_FLAG_RELIABLE;
			loopi(msg[0]) putint(p, msg[i + 2]);
		};
		messages.setsize(0);
		if (lastmillis - lastping > 250) {
        {
            putint(p, SV_PING);
            putint(p, lastmillis);
            lastping = lastmillis;
        };
    };
    *(ushort *)start = ENET_HOST_TO_NET_16(p-start);
    enet_packet_resize(packet, p-start);
    incomingdemodata(start, p-start, true);
    if(clienthost) { enet_host_broadcast(clienthost, 0, packet); enet_host_flush(clienthost); }
    else localclienttoserver(packet);
    lastupdate = lastmillis;
    if(serveriteminitdone) loadgamerest();  // hack
			putint(p, SV_PING);
			putint(p, lastmillis);
			lastping = lastmillis;
		};
	};
	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	incomingdemodata(start, p - start, true);
	if (clienthost) {
		enet_host_broadcast(clienthost, 0, packet);
		enet_host_flush(clienthost);
	} else
		localclienttoserver(packet);
	lastupdate = lastmillis;
	if (serveriteminitdone)
		loadgamerest(); // hack
};

void
void gets2c()           // get updates from the server
gets2c() // get updates from the server
{
    ENetEvent event;
    if(!clienthost) return;
    if(connecting && lastmillis/3000 > connecting/3000)
	ENetEvent event;
	if (!clienthost)
		return;
	if (connecting && lastmillis / 3000 > connecting / 3000) {
    {
        conoutf("attempting to connect...");
        connecting = lastmillis;
        ++connattempts; 
        if(connattempts > 3)
		conoutf("attempting to connect...");
		connecting = lastmillis;
		++connattempts;
		if (connattempts > 3) {
        {
            conoutf("could not connect to server");
            disconnect();
            return;
        };
    };
    while(clienthost!=NULL && enet_host_service(clienthost, &event, 0)>0)
    switch(event.type)
			conoutf("could not connect to server");
			disconnect();
			return;
		};
	};
	while (
	    clienthost != NULL && enet_host_service(clienthost, &event, 0) > 0)
		switch (event.type) {
    {
        case ENET_EVENT_TYPE_CONNECT:
            conoutf("connected to server");
            connecting = 0;
            throttle();
            break;
         
        case ENET_EVENT_TYPE_RECEIVE:
            if(disconnecting) conoutf("attempting to disconnect...");
            else localservertoclient(event.packet->data, event.packet->dataLength);
            enet_packet_destroy(event.packet);
            break;
		case ENET_EVENT_TYPE_CONNECT:
			conoutf("connected to server");
			connecting = 0;
			throttle();
			break;

		case ENET_EVENT_TYPE_RECEIVE:
			if (disconnecting)
				conoutf("attempting to disconnect...");
			else
				localservertoclient(event.packet->data,
				    event.packet->dataLength);
			enet_packet_destroy(event.packet);
			break;

        case ENET_EVENT_TYPE_DISCONNECT:
            if(disconnecting) disconnect();
            else server_err();
            return;
    }
		case ENET_EVENT_TYPE_DISCONNECT:
			if (disconnecting)
				disconnect();
			else
				server_err();
			return;
		}
};

// clientextras.cpp: stuff that didn't fit in client.cpp or clientgame.cpp :)

#include "cube.h"

// render players & monsters
// very messy ad-hoc handling of animation frames, should be made more configurable
// very messy ad-hoc handling of animation frames, should be made more
// configurable

//              D    D    D    D'   D    D    D    D'   A   A'  P   P'  I   I' R,  R'  E    L    J   J'
int frame[] = { 178, 184, 190, 137, 183, 189, 197, 164, 46, 51, 54, 32, 0,  0, 40, 1,  162, 162, 67, 168 };
int range[] = { 6,   6,   8,   28,  1,   1,   1,   1,   8,  19, 4,  18, 40, 1, 6,  15, 1,   1,   1,  1   };
//              D    D    D    D'   D    D    D    D'   A   A'  P   P'  I   I'
//              R,  R'  E    L    J   J'
int frame[] = {178, 184, 190, 137, 183, 189, 197, 164, 46, 51, 54, 32, 0, 0, 40,
    1, 162, 162, 67, 168};
int range[] = {6, 6, 8, 28, 1, 1, 1, 1, 8, 19, 4, 18, 40, 1, 6, 15, 1, 1, 1, 1};

void
void renderclient(dynent *d, bool team, char *mdlname, bool hellpig, float scale)
renderclient(dynent *d, bool team, char *mdlname, bool hellpig, float scale)
{
    int n = 3;
    float speed = 100.0f;
    float mz = d->o.z-d->eyeheight+1.55f*scale;
    int basetime = -((int)d&0xFFF);
    if(d->state==CS_DEAD)
	int n = 3;
	float speed = 100.0f;
	float mz = d->o.z - d->eyeheight + 1.55f * scale;
	int basetime = -((int)d & 0xFFF);
	if (d->state == CS_DEAD) {
    {
        int r;
        if(hellpig) { n = 2; r = range[3]; } else { n = (int)d%3; r = range[n]; };
        basetime = d->lastaction;
		int r;
		if (hellpig) {
			n = 2;
			r = range[3];
		} else {
			n = (int)d % 3;
			r = range[n];
		};
		basetime = d->lastaction;
		int t = lastmillis - d->lastaction;
		if (t < 0 || t > 20000)
			return;
		if (t > (r - 1) * 100) {
			n += 4;
			if (t > (r + 10) * 100) {
				t -= (r + 10) * 100;
        int t = lastmillis-d->lastaction;
        if(t<0 || t>20000) return;
        if(t>(r-1)*100) { n += 4; if(t>(r+10)*100) { t -= (r+10)*100; mz -= t*t/10000000000.0f*t; }; };
        if(mz<-1000) return;
        //mdl = (((int)d>>6)&1)+1;
        //mz = d->o.z-d->eyeheight+0.2f;
        //scale = 1.2f;
				mz -= t * t / 10000000000.0f * t;
			};
		};
		if (mz < -1000)
			return;
		// mdl = (((int)d>>6)&1)+1;
		// mz = d->o.z-d->eyeheight+0.2f;
		// scale = 1.2f;
    }
    else if(d->state==CS_EDITING)                   { n = 16; }
    else if(d->state==CS_LAGGED)                    { n = 17; }
    else if(d->monsterstate==M_ATTACKING)           { n = 8;  }
    else if(d->monsterstate==M_PAIN)                { n = 10; } 
    else if((!d->move && !d->strafe) || !d->moving) { n = 12; } 
    else if(!d->onfloor && d->timeinair>100)        { n = 18; }
    else                                            { n = 14; speed = 1200/d->maxspeed*scale; if(hellpig) speed = 300/d->maxspeed;  }; 
    if(hellpig) { n++; scale *= 32; mz -= 1.9f; };
    rendermodel(mdlname, frame[n], range[n], 0, 1.5f, d->o.x, mz, d->o.y, d->yaw+90, d->pitch/2, team, scale, speed, 0, basetime);
	} else if (d->state == CS_EDITING) {
		n = 16;
	} else if (d->state == CS_LAGGED) {
		n = 17;
	} else if (d->monsterstate == M_ATTACKING) {
		n = 8;
	} else if (d->monsterstate == M_PAIN) {
		n = 10;
	} else if ((!d->move && !d->strafe) || !d->moving) {
		n = 12;
	} else if (!d->onfloor && d->timeinair > 100) {
		n = 18;
	} else {
		n = 14;
		speed = 1200 / d->maxspeed * scale;
		if (hellpig)
			speed = 300 / d->maxspeed;
	};
	if (hellpig) {
		n++;
		scale *= 32;
		mz -= 1.9f;
	};
	rendermodel(mdlname, frame[n], range[n], 0, 1.5f, d->o.x, mz, d->o.y,
	    d->yaw + 90, d->pitch / 2, team, scale, speed, 0, basetime);
};

extern int democlientnum;

void
void renderclients()
renderclients()
{
    dynent *d;
    loopv(players) if((d = players[i]) && (!demoplayback || i!=democlientnum)) renderclient(d, isteam(player1->team, d->team), "monster/ogro", false, 1.0f);
	dynent *d;
	loopv(players) if ((d = players[i]) &&
	                   (!demoplayback || i != democlientnum))
	    renderclient(
	        d, isteam(player1->team, d->team), "monster/ogro", false, 1.0f);
};

// creation of scoreboard pseudo-menu

bool scoreson = false;

void
void showscores(bool on)
showscores(bool on)
{
    scoreson = on;
    menuset(((int)on)-1);
	scoreson = on;
	menuset(((int)on) - 1);
};

struct sline { string s; };
struct sline {
	string s;
};
vector<sline> scorelines;

void
void renderscore(dynent *d)
renderscore(dynent *d)
{
    sprintf_sd(lag)("%d", d->plag);
    sprintf_sd(name) ("(%s)", d->name); 
    sprintf_s(scorelines.add().s)("%d\t%s\t%d\t%s\t%s", d->frags, d->state==CS_LAGGED ? "LAG" : lag, d->ping, d->team, d->state==CS_DEAD ? name : d->name);
    menumanual(0, scorelines.length()-1, scorelines.last().s); 
	sprintf_sd(lag)("%d", d->plag);
	sprintf_sd(name)("(%s)", d->name);
	sprintf_s(scorelines.add().s)("%d\t%s\t%d\t%s\t%s", d->frags,
	    d->state == CS_LAGGED ? "LAG" : lag, d->ping, d->team,
	    d->state == CS_DEAD ? name : d->name);
	menumanual(0, scorelines.length() - 1, scorelines.last().s);
};

const int maxteams = 4;
char *teamname[maxteams];
int teamscore[maxteams], teamsused;
string teamscores;
int timeremain = 0;

void
void addteamscore(dynent *d)
addteamscore(dynent *d)
{
	if (!d)
    if(!d) return;
    loopi(teamsused) if(strcmp(teamname[i], d->team)==0) { teamscore[i] += d->frags; return; };
    if(teamsused==maxteams) return;
    teamname[teamsused] = d->team;
    teamscore[teamsused++] = d->frags;
		return;
	loopi(teamsused) if (strcmp(teamname[i], d->team) == 0)
	{
		teamscore[i] += d->frags;
		return;
	};
	if (teamsused == maxteams)
		return;
	teamname[teamsused] = d->team;
	teamscore[teamsused++] = d->frags;
};

void
void renderscores()
renderscores()
{
    if(!scoreson) return;
    scorelines.setsize(0);
    if(!demoplayback) renderscore(player1);
    loopv(players) if(players[i]) renderscore(players[i]);
    sortmenu(0, scorelines.length());
    if(m_teammode)
	if (!scoreson)
		return;
	scorelines.setsize(0);
	if (!demoplayback)
		renderscore(player1);
	loopv(players) if (players[i]) renderscore(players[i]);
	sortmenu(0, scorelines.length());
	if (m_teammode) {
    {
        teamsused = 0;
        loopv(players) addteamscore(players[i]);
        if(!demoplayback) addteamscore(player1);
        teamscores[0] = 0;
        loopj(teamsused)
        {
            sprintf_sd(sc)("[ %s: %d ]", teamname[j], teamscore[j]);
            strcat_s(teamscores, sc);
        };
        menumanual(0, scorelines.length(), "");
        menumanual(0, scorelines.length()+1, teamscores);
    };
		teamsused = 0;
		loopv(players) addteamscore(players[i]);
		if (!demoplayback)
			addteamscore(player1);
		teamscores[0] = 0;
		loopj(teamsused)
		{
			sprintf_sd(sc)("[ %s: %d ]", teamname[j], teamscore[j]);
			strcat_s(teamscores, sc);
		};
		menumanual(0, scorelines.length(), "");
		menumanual(0, scorelines.length() + 1, teamscores);
	};
};

// sendmap/getmap commands, should be replaced by more intuitive map downloading

void
void sendmap(char *mapname)
sendmap(char *mapname)
{
	if (*mapname)
    if(*mapname) save_world(mapname);
    changemap(mapname);
    mapname = getclientmap();
    int mapsize;
    uchar *mapdata = readmap(mapname, &mapsize); 
    if(!mapdata) return;
    ENetPacket *packet = enet_packet_create(NULL, MAXTRANS + mapsize, ENET_PACKET_FLAG_RELIABLE);
    uchar *start = packet->data;
    uchar *p = start+2;
    putint(p, SV_SENDMAP);
    sendstring(mapname, p);
    putint(p, mapsize);
    if(65535 - (p - start) < mapsize)
		save_world(mapname);
	changemap(mapname);
	mapname = getclientmap();
	int mapsize;
	uchar *mapdata = readmap(mapname, &mapsize);
	if (!mapdata)
		return;
	ENetPacket *packet = enet_packet_create(
	    NULL, MAXTRANS + mapsize, ENET_PACKET_FLAG_RELIABLE);
	uchar *start = packet->data;
	uchar *p = start + 2;
	putint(p, SV_SENDMAP);
	sendstring(mapname, p);
	putint(p, mapsize);
	if (65535 - (p - start) < mapsize) {
    {
        conoutf("map %s is too large to send", mapname);
        free(mapdata);
        enet_packet_destroy(packet);
        return;
    };
    memcpy(p, mapdata, mapsize);
    p += mapsize;
    free(mapdata); 
    *(ushort *)start = ENET_HOST_TO_NET_16(p-start);
    enet_packet_resize(packet, p-start);
    sendpackettoserv(packet);
    conoutf("sending map %s to server...", mapname);
    sprintf_sd(msg)("[map %s uploaded to server, \"getmap\" to receive it]", mapname);
    toserver(msg);
		conoutf("map %s is too large to send", mapname);
		free(mapdata);
		enet_packet_destroy(packet);
		return;
	};
	memcpy(p, mapdata, mapsize);
	p += mapsize;
	free(mapdata);
	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	sendpackettoserv(packet);
	conoutf("sending map %s to server...", mapname);
	sprintf_sd(msg)(
	    "[map %s uploaded to server, \"getmap\" to receive it]", mapname);
	toserver(msg);
}

void
void getmap()
getmap()
{
	ENetPacket *packet =
    ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
    uchar *start = packet->data;
    uchar *p = start+2;
    putint(p, SV_RECVMAP);
    *(ushort *)start = ENET_HOST_TO_NET_16(p-start);
    enet_packet_resize(packet, p-start);
    sendpackettoserv(packet);
    conoutf("requesting map from server...");
	    enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
	uchar *start = packet->data;
	uchar *p = start + 2;
	putint(p, SV_RECVMAP);
	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	sendpackettoserv(packet);
	conoutf("requesting map from server...");
}

COMMAND(sendmap, ARG_1STR);
COMMAND(getmap, ARG_NONE);

// clientgame.cpp: core game related stuff

#include "cube.h"

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

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

bool intermission = false;

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

VARP(sensitivity, 0, 10, 10000);
VARP(sensitivityscale, 1, 1, 10000);
VARP(invmouse, 0, 0, 1);

int lastmillis = 0;
int curtime = 10;
string clientmap;

extern int framesinmap;

char *
getclientmap()
{
char *getclientmap() { return clientmap; };
	return clientmap;
};

void
void resetmovement(dynent *d)
resetmovement(dynent *d)
{
    d->k_left = false;
    d->k_right = false;
    d->k_up = false;
    d->k_down = false;  
    d->jumpnext = false;
    d->strafe = 0;
    d->move = 0;
	d->k_left = false;
	d->k_right = false;
	d->k_up = false;
	d->k_down = false;
	d->jumpnext = false;
	d->strafe = 0;
	d->move = 0;
};

void
void spawnstate(dynent *d)              // reset player state not persistent accross spawns
spawnstate(dynent *d) // reset player state not persistent accross spawns
{
    resetmovement(d);
    d->vel.x = d->vel.y = d->vel.z = 0; 
    d->onfloor = false;
    d->timeinair = 0;
    d->health = 100;
    d->armour = 50;
    d->armourtype = A_BLUE;
    d->quadmillis = 0;
    d->lastattackgun = d->gunselect = GUN_SG;
    d->gunwait = 0;
	resetmovement(d);
	d->vel.x = d->vel.y = d->vel.z = 0;
	d->onfloor = false;
	d->timeinair = 0;
	d->health = 100;
	d->armour = 50;
	d->armourtype = A_BLUE;
	d->quadmillis = 0;
	d->lastattackgun = d->gunselect = GUN_SG;
	d->gunwait = 0;
	d->attacking = false;
    d->lastaction = 0;
    loopi(NUMGUNS) d->ammo[i] = 0;
    d->ammo[GUN_FIST] = 1;
    if(m_noitems)
	d->lastaction = 0;
	loopi(NUMGUNS) d->ammo[i] = 0;
	d->ammo[GUN_FIST] = 1;
	if (m_noitems) {
    {
        d->gunselect = GUN_RIFLE;
        d->armour = 0;
        if(m_noitemsrail)
		d->gunselect = GUN_RIFLE;
		d->armour = 0;
		if (m_noitemsrail) {
        {
            d->health = 1;
            d->ammo[GUN_RIFLE] = 100;
			d->health = 1;
			d->ammo[GUN_RIFLE] = 100;
        }
        else
		} else {
        {
            if(gamemode==12) { d->gunselect = GUN_FIST; return; };  // eihrul's secret "instafist" mode
            d->health = 256;
            if(m_tarena)
			if (gamemode == 12) {
				d->gunselect = GUN_FIST;
				return;
			}; // eihrul's secret "instafist" mode
			d->health = 256;
			if (m_tarena) {
            {
                int gun1 = rnd(4)+1;
                baseammo(d->gunselect = gun1);
                for(;;)
				int gun1 = rnd(4) + 1;
				baseammo(d->gunselect = gun1);
				for (;;) {
                {
                    int gun2 = rnd(4)+1;
                    if(gun1!=gun2) { baseammo(gun2); break; };
                };
            }
            else if(m_arena)    // insta arena
            {
                d->ammo[GUN_RIFLE] = 100;
					int gun2 = rnd(4) + 1;
					if (gun1 != gun2) {
						baseammo(gun2);
						break;
					};
				};
			} else if (m_arena) // insta arena
			{
				d->ammo[GUN_RIFLE] = 100;
            }
            else // efficiency
            {
                loopi(4) baseammo(i+1);
                d->gunselect = GUN_CG;
            };
            d->ammo[GUN_CG] /= 2;
        };
			} else // efficiency
			{
				loopi(4) baseammo(i + 1);
				d->gunselect = GUN_CG;
			};
			d->ammo[GUN_CG] /= 2;
		};
    }
    else
	} else {
    {
        d->ammo[GUN_SG] = 5;
    };
		d->ammo[GUN_SG] = 5;
	};
};
    
dynent *newdynent()                 // create a new blank player or monster

dynent *
newdynent() // create a new blank player or monster
{
    dynent *d = (dynent *)gp()->alloc(sizeof(dynent));
    d->o.x = 0;
    d->o.y = 0;
    d->o.z = 0;
    d->yaw = 270;
    d->pitch = 0;
    d->roll = 0;
    d->maxspeed = 22;
    d->outsidemap = false;
    d->inwater = false;
    d->radius = 1.1f;
    d->eyeheight = 3.2f;
    d->aboveeye = 0.7f;
    d->frags = 0;
    d->plag = 0;
    d->ping = 0;
    d->lastupdate = lastmillis;
    d->enemy = NULL;
    d->monsterstate = 0;
    d->name[0] = d->team[0] = 0;
    d->blocked = false;
    d->lifesequence = 0;
    d->state = CS_ALIVE;
    spawnstate(d);
    return d;
	dynent *d = (dynent *)gp()->alloc(sizeof(dynent));
	d->o.x = 0;
	d->o.y = 0;
	d->o.z = 0;
	d->yaw = 270;
	d->pitch = 0;
	d->roll = 0;
	d->maxspeed = 22;
	d->outsidemap = false;
	d->inwater = false;
	d->radius = 1.1f;
	d->eyeheight = 3.2f;
	d->aboveeye = 0.7f;
	d->frags = 0;
	d->plag = 0;
	d->ping = 0;
	d->lastupdate = lastmillis;
	d->enemy = NULL;
	d->monsterstate = 0;
	d->name[0] = d->team[0] = 0;
	d->blocked = false;
	d->lifesequence = 0;
	d->state = CS_ALIVE;
	spawnstate(d);
	return d;
};

void
void respawnself()
respawnself()
{
	spawnplayer(player1);
	showscores(false);
};

void
void arenacount(dynent *d, int &alive, int &dead, char *&lastteam, bool &oneteam)
arenacount(dynent *d, int &alive, int &dead, char *&lastteam, bool &oneteam)
{
    if(d->state!=CS_DEAD)
	if (d->state != CS_DEAD) {
    {
        alive++;
        if(lastteam && strcmp(lastteam, d->team)) oneteam = false;
        lastteam = d->team;
		alive++;
		if (lastteam && strcmp(lastteam, d->team))
			oneteam = false;
		lastteam = d->team;
    }
    else
	} else {
    {
        dead++;
    };
		dead++;
	};
};

int arenarespawnwait = 0;
int arenadetectwait  = 0;
int arenadetectwait = 0;

void
void arenarespawn()
arenarespawn()
{
    if(arenarespawnwait)
	if (arenarespawnwait) {
    {
        if(arenarespawnwait<lastmillis)
		if (arenarespawnwait < lastmillis) {
        {
            arenarespawnwait = 0;
            conoutf("new round starting... fight!");
            respawnself();
        };
			arenarespawnwait = 0;
			conoutf("new round starting... fight!");
			respawnself();
		};
    }
    else if(arenadetectwait==0 || arenadetectwait<lastmillis)
	} else if (arenadetectwait == 0 || arenadetectwait < lastmillis) {
    {
        arenadetectwait = 0;
        int alive = 0, dead = 0;
        char *lastteam = NULL;
        bool oneteam = true;
        loopv(players) if(players[i]) arenacount(players[i], alive, dead, lastteam, oneteam);
        arenacount(player1, alive, dead, lastteam, oneteam);
        if(dead>0 && (alive<=1 || (m_teammode && oneteam)))
		arenadetectwait = 0;
		int alive = 0, dead = 0;
		char *lastteam = NULL;
		bool oneteam = true;
		loopv(players) if (players[i])
		    arenacount(players[i], alive, dead, lastteam, oneteam);
		arenacount(player1, alive, dead, lastteam, oneteam);
		if (dead > 0 && (alive <= 1 || (m_teammode && oneteam))) {
        {
            conoutf("arena round is over! next round in 5 seconds...");
            if(alive) conoutf("team %s is last man standing", lastteam);
            else conoutf("everyone died!");
            arenarespawnwait = lastmillis+5000;
            arenadetectwait  = lastmillis+10000;
            player1->roll = 0;
        }; 
    };
			conoutf(
			    "arena round is over! next round in 5 seconds...");
			if (alive)
				conoutf(
				    "team %s is last man standing", lastteam);
			else
				conoutf("everyone died!");
			arenarespawnwait = lastmillis + 5000;
			arenadetectwait = lastmillis + 10000;
			player1->roll = 0;
		};
	};
};

void
void zapdynent(dynent *&d)
zapdynent(dynent *&d)
{
	if (d)
    if(d) gp()->dealloc(d, sizeof(dynent));
    d = NULL;
		gp()->dealloc(d, sizeof(dynent));
	d = NULL;
};

extern int democlientnum;

void
void otherplayers()
otherplayers()
{
    loopv(players) if(players[i])
    {
        const int lagtime = lastmillis-players[i]->lastupdate;
        if(lagtime>1000 && players[i]->state==CS_ALIVE)
	loopv(players) if (players[i])
	{
		const int lagtime = lastmillis - players[i]->lastupdate;
		if (lagtime > 1000 && players[i]->state == CS_ALIVE) {
        {
            players[i]->state = CS_LAGGED;
            continue;
        };
        if(lagtime && players[i]->state != CS_DEAD && (!demoplayback || i!=democlientnum)) moveplayer(players[i], 2, false);   // use physics to extrapolate player position
    };
			players[i]->state = CS_LAGGED;
			continue;
		};
		if (lagtime && players[i]->state != CS_DEAD &&
		    (!demoplayback || i != democlientnum))
			moveplayer(
			    players[i], 2, false); // use physics to extrapolate
			                           // player position
	};
};

void
void respawn()
respawn()
{
    if(player1->state==CS_DEAD)
	if (player1->state == CS_DEAD) {
    { 
        player1->attacking = false;
        if(m_arena) { conoutf("waiting for new round to start..."); return; };
        if(m_sp) { nextmode = gamemode; changemap(clientmap); return; };    // if we die in SP we try the same map again
		player1->attacking = false;
		if (m_arena) {
			conoutf("waiting for new round to start...");
			return;
		};
		if (m_sp) {
			nextmode = gamemode;
			changemap(clientmap);
			return;
		}; // if we die in SP we try the same map again
		respawnself();
	};
};

int sleepwait = 0;
string sleepcmd;
void
void sleepf(char *msec, char *cmd) { sleepwait = atoi(msec)+lastmillis; strcpy_s(sleepcmd, cmd); };
sleepf(char *msec, char *cmd)
{
	sleepwait = atoi(msec) + lastmillis;
	strcpy_s(sleepcmd, cmd);
};
COMMANDN(sleep, sleepf, ARG_2STR);

void
void updateworld(int millis)        // main game update loop
updateworld(int millis) // main game update loop
{
    if(lastmillis)
	if (lastmillis) {
    {     
        curtime = millis - lastmillis;
        if(sleepwait && lastmillis>sleepwait) { sleepwait = 0; execute(sleepcmd); };
        physicsframe();
        checkquad(curtime);
		if(m_arena) arenarespawn();
        moveprojectiles((float)curtime);
        demoplaybackstep();
        if(!demoplayback)
		curtime = millis - lastmillis;
		if (sleepwait && lastmillis > sleepwait) {
			sleepwait = 0;
			execute(sleepcmd);
		};
		physicsframe();
		checkquad(curtime);
		if (m_arena)
			arenarespawn();
		moveprojectiles((float)curtime);
		demoplaybackstep();
		if (!demoplayback) {
        {
            if(getclientnum()>=0) shoot(player1, worldpos);     // only shoot when connected to server
            gets2c();           // do this first, so we have most accurate information when our player moves
        };
        otherplayers();
        if(!demoplayback)
			if (getclientnum() >= 0)
				shoot(player1, worldpos); // only shoot when
				                          // connected to server
			gets2c(); // do this first, so we have most accurate
			          // information when our player moves
		};
		otherplayers();
		if (!demoplayback) {
        {
            monsterthink();
            if(player1->state==CS_DEAD)
			monsterthink();
			if (player1->state == CS_DEAD) {
            {
				if(lastmillis-player1->lastaction<2000)
				if (lastmillis - player1->lastaction < 2000) {
				{
					player1->move = player1->strafe = 0;
					moveplayer(player1, 10, false);
				}
                else if(!m_arena && !m_sp && lastmillis-player1->lastaction>10000) respawn();
				} else if (!m_arena && !m_sp &&
				           lastmillis - player1->lastaction >
            }
            else if(!intermission)
				               10000)
					respawn();
			} else if (!intermission) {
            {
                moveplayer(player1, 20, true);
                checkitems();
            };
            c2sinfo(player1);   // do this last, to reduce the effective frame lag
        };
    };
    lastmillis = millis;
				moveplayer(player1, 20, true);
				checkitems();
			};
			c2sinfo(player1); // do this last, to reduce the
			                  // effective frame lag
		};
	};
	lastmillis = millis;
};

void
entinmap(dynent *
void entinmap(dynent *d)    // brute force but effective way to find a free spawn spot in the map
        d) // brute force but effective way to find a free spawn spot in the map
{
    loopi(100)              // try max 100 times
    {
        float dx = (rnd(21)-10)/10.0f*i;  // increasing distance
        float dy = (rnd(21)-10)/10.0f*i;
        d->o.x += dx;
        d->o.y += dy;
        if(collide(d, true, 0, 0)) return;
        d->o.x -= dx;
        d->o.y -= dy;
    };
    conoutf("can't find entity spawn spot! (%d, %d)", (int)d->o.x, (int)d->o.y);
    // leave ent at original pos, possibly stuck
	loopi(100) // try max 100 times
	{
		float dx = (rnd(21) - 10) / 10.0f * i; // increasing distance
		float dy = (rnd(21) - 10) / 10.0f * i;
		d->o.x += dx;
		d->o.y += dy;
		if (collide(d, true, 0, 0))
			return;
		d->o.x -= dx;
		d->o.y -= dy;
	};
	conoutf(
	    "can't find entity spawn spot! (%d, %d)", (int)d->o.x, (int)d->o.y);
	// leave ent at original pos, possibly stuck
};

int spawncycle = -1;
int fixspawn = 2;

void
void spawnplayer(dynent *d)   // place at random spawn. also used by monsters!
spawnplayer(dynent *d) // place at random spawn. also used by monsters!
{
    int r = fixspawn-->0 ? 4 : rnd(10)+1;
    loopi(r) spawncycle = findentity(PLAYERSTART, spawncycle+1);
    if(spawncycle!=-1)
	int r = fixspawn-- > 0 ? 4 : rnd(10) + 1;
	loopi(r) spawncycle = findentity(PLAYERSTART, spawncycle + 1);
	if (spawncycle != -1) {
    {
        d->o.x = ents[spawncycle].x;
        d->o.y = ents[spawncycle].y;
        d->o.z = ents[spawncycle].z;
        d->yaw = ents[spawncycle].attr1;
        d->pitch = 0;
        d->roll = 0;
		d->o.x = ents[spawncycle].x;
		d->o.y = ents[spawncycle].y;
		d->o.z = ents[spawncycle].z;
		d->yaw = ents[spawncycle].attr1;
		d->pitch = 0;
		d->roll = 0;
    }
    else
	} else {
    {
        d->o.x = d->o.y = (float)ssize/2;
        d->o.z = 4;
    };
    entinmap(d);
    spawnstate(d);
    d->state = CS_ALIVE;
		d->o.x = d->o.y = (float)ssize / 2;
		d->o.z = 4;
	};
	entinmap(d);
	spawnstate(d);
	d->state = CS_ALIVE;
};

// movement input code

#define dir(name, v, d, s, os)                                                 \
	void name(bool isdown)                                                 \
	{                                                                      \
		player1->s = isdown;                                           \
#define dir(name,v,d,s,os) void name(bool isdown) { player1->s = isdown; player1->v = isdown ? d : (player1->os ? -(d) : 0); player1->lastmove = lastmillis; };
		player1->v = isdown ? d : (player1->os ? -(d) : 0);            \
		player1->lastmove = lastmillis;                                \
	};

dir(backward, move,   -1, k_down,  k_up);
dir(forward,  move,    1, k_up,    k_down);
dir(left,     strafe,  1, k_left,  k_right); 
dir(right,    strafe, -1, k_right, k_left); 
dir(backward, move, -1, k_down, k_up);
dir(forward, move, 1, k_up, k_down);
dir(left, strafe, 1, k_left, k_right);
dir(right, strafe, -1, k_right, k_left);

void
void attack(bool on)
attack(bool on)
{
    if(intermission) return;
    if(editmode) editdrag(on);
    else if(player1->attacking = on) respawn();
	if (intermission)
		return;
	if (editmode)
		editdrag(on);
	else if (player1->attacking = on)
		respawn();
};

void
jumpn(bool on)
{
void jumpn(bool on) { if(!intermission && (player1->jumpnext = on)) respawn(); };
	if (!intermission && (player1->jumpnext = on))
		respawn();
};

COMMAND(backward, ARG_DOWN);
COMMAND(forward, ARG_DOWN);
COMMAND(left, ARG_DOWN);
COMMAND(right, ARG_DOWN);
COMMANDN(jump, jumpn, ARG_DOWN);
COMMAND(attack, ARG_DOWN);
COMMAND(showscores, ARG_DOWN);

void
void fixplayer1range()
fixplayer1range()
{
    const float MAXPITCH = 90.0f;
    if(player1->pitch>MAXPITCH) player1->pitch = MAXPITCH;
    if(player1->pitch<-MAXPITCH) player1->pitch = -MAXPITCH;
    while(player1->yaw<0.0f) player1->yaw += 360.0f;
    while(player1->yaw>=360.0f) player1->yaw -= 360.0f;
	const float MAXPITCH = 90.0f;
	if (player1->pitch > MAXPITCH)
		player1->pitch = MAXPITCH;
	if (player1->pitch < -MAXPITCH)
		player1->pitch = -MAXPITCH;
	while (player1->yaw < 0.0f)
		player1->yaw += 360.0f;
	while (player1->yaw >= 360.0f)
		player1->yaw -= 360.0f;
};

void
void mousemove(int dx, int dy)
mousemove(int dx, int dy)
{
    if(player1->state==CS_DEAD || intermission) return;
    const float SENSF = 33.0f;     // try match quake sens
    player1->yaw += (dx/SENSF)*(sensitivity/(float)sensitivityscale);
    player1->pitch -= (dy/SENSF)*(sensitivity/(float)sensitivityscale)*(invmouse ? -1 : 1);
	if (player1->state == CS_DEAD || intermission)
		return;
	const float SENSF = 33.0f; // try match quake sens
	player1->yaw += (dx / SENSF) * (sensitivity / (float)sensitivityscale);
	player1->pitch -= (dy / SENSF) *
	                  (sensitivity / (float)sensitivityscale) *
	                  (invmouse ? -1 : 1);
	fixplayer1range();
};

// damage arriving from the network, monsters, yourself, all ends up here.

void
void selfdamage(int damage, int actor, dynent *act)
selfdamage(int damage, int actor, dynent *act)
{
    if(player1->state!=CS_ALIVE || editmode || intermission) return;
    damageblend(damage);
	if (player1->state != CS_ALIVE || editmode || intermission)
		return;
	damageblend(damage);
	demoblend(damage);
	int ad = damage * (player1->armourtype + 1) * 20 /
    int ad = damage*(player1->armourtype+1)*20/100;     // let armour absorb when possible
    if(ad>player1->armour) ad = player1->armour;
    player1->armour -= ad;
    damage -= ad;
    float droll = damage/0.5f;
    player1->roll += player1->roll>0 ? droll : (player1->roll<0 ? -droll : (rnd(2) ? droll : -droll));  // give player a kick depending on amount of damage
    if((player1->health -= damage)<=0)
	         100; // let armour absorb when possible
	if (ad > player1->armour)
		ad = player1->armour;
	player1->armour -= ad;
	damage -= ad;
	float droll = damage / 0.5f;
	player1->roll +=
	    player1->roll > 0
	        ? droll
	        : (player1->roll < 0
	                  ? -droll
	                  : (rnd(2) ? droll
	                            : -droll)); // give player a kick depending
	                                        // on amount of damage
	if ((player1->health -= damage) <= 0) {
    {
        if(actor==-2)
		if (actor == -2) {
        {
            conoutf("you got killed by %s!", act->name);
			conoutf("you got killed by %s!", act->name);
        }
        else if(actor==-1)
		} else if (actor == -1) {
        {
            actor = getclientnum();
            conoutf("you suicided!");
            addmsg(1, 2, SV_FRAGS, --player1->frags);
			actor = getclientnum();
			conoutf("you suicided!");
			addmsg(1, 2, SV_FRAGS, --player1->frags);
        }
        else
		} else {
        {
            dynent *a = getclient(actor);
            if(a)
			dynent *a = getclient(actor);
			if (a) {
            {
                if(isteam(a->team, player1->team))
				if (isteam(a->team, player1->team)) {
                {
                    conoutf("you got fragged by a teammate (%s)", a->name);
					conoutf("you got fragged by a teammate "
                }
                else
					        "(%s)",
					    a->name);
				} else {
                {
                    conoutf("you got fragged by %s", a->name);
                };
            };
        };
        showscores(true);
        addmsg(1, 2, SV_DIED, actor);
        player1->lifesequence++;
        player1->attacking = false;
        player1->state = CS_DEAD;
        player1->pitch = 0;
        player1->roll = 60;
        playsound(S_DIE1+rnd(2));
        spawnstate(player1);
        player1->lastaction = lastmillis;
					conoutf(
					    "you got fragged by %s", a->name);
				};
			};
		};
		showscores(true);
		addmsg(1, 2, SV_DIED, actor);
		player1->lifesequence++;
		player1->attacking = false;
		player1->state = CS_DEAD;
		player1->pitch = 0;
		player1->roll = 60;
		playsound(S_DIE1 + rnd(2));
		spawnstate(player1);
		player1->lastaction = lastmillis;
    }
    else
	} else {
    {
        playsound(S_PAIN6);
    };
		playsound(S_PAIN6);
	};
};

void
void timeupdate(int timeremain)
timeupdate(int timeremain)
{
    if(!timeremain)
	if (!timeremain) {
    {
        intermission = true;
        player1->attacking = false;
        conoutf("intermission:");
        conoutf("game has ended!");
        showscores(true);
		intermission = true;
		player1->attacking = false;
		conoutf("intermission:");
		conoutf("game has ended!");
		showscores(true);
    }
    else
	} else {
    {
        conoutf("time remaining: %d minutes", timeremain);
    };
		conoutf("time remaining: %d minutes", timeremain);
	};
};

dynent *
dynent *getclient(int cn)   // ensure valid entity
getclient(int cn) // ensure valid entity
{
    if(cn<0 || cn>=MAXCLIENTS)
	if (cn < 0 || cn >= MAXCLIENTS) {
    {
        neterr("clientnum");
        return NULL;
    };
    while(cn>=players.length()) players.add(NULL);
    return players[cn] ? players[cn] : (players[cn] = newdynent());
		neterr("clientnum");
		return NULL;
	};
	while (cn >= players.length())
		players.add(NULL);
	return players[cn] ? players[cn] : (players[cn] = newdynent());
};

void
void initclient()
initclient()
{
    clientmap[0] = 0;
    initclientnet();
	clientmap[0] = 0;
	initclientnet();
};

void
void startmap(char *name)   // called just after a map load
startmap(char *name) // called just after a map load
{
	if (netmapstart() && m_sp) {
		gamemode = 0;
    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();
    strcpy_s(clientmap, name);
    if(editmode) toggleedit();
    setvar("gamespeed", 100);
		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();
	strcpy_s(clientmap, name);
	if (editmode)
		toggleedit();
	setvar("gamespeed", 100);
	setvar("fog", 180);
	setvar("fogcolour", 0x8099B3);
    showscores(false);
    intermission = false;
    framesinmap = 0;
    conoutf("game mode is %s", modestr(gamemode));
}; 
	showscores(false);
	intermission = false;
	framesinmap = 0;
	conoutf("game mode is %s", modestr(gamemode));
};

COMMANDN(map, changemap, ARG_1STR);

// client processing of the incoming network stream

#include "cube.h"

extern int clientnum;
extern bool c2sinit, senditemstoserver;
extern string toservermap;
extern string clientpassword;

void
void neterr(char *s)
neterr(char *s)
{
    conoutf("illegal network message (%s)", s);
    disconnect();
	conoutf("illegal network message (%s)", s);
	disconnect();
};

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

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

// update the position of other clients in the game in our world
// don't care if he's in the scenery or other players,
// just don't overlap with our client

void
void updatepos(dynent *d)
updatepos(dynent *d)
{
    const float r = player1->radius+d->radius;
    const float dx = player1->o.x-d->o.x;
    const float dy = player1->o.y-d->o.y;
    const float dz = player1->o.z-d->o.z;
    const float rz = player1->aboveeye+d->eyeheight;
    const float fx = (float)fabs(dx), fy = (float)fabs(dy), fz = (float)fabs(dz);
    if(fx<r && fy<r && fz<rz && d->state!=CS_DEAD)
	const float r = player1->radius + d->radius;
	const float dx = player1->o.x - d->o.x;
	const float dy = player1->o.y - d->o.y;
	const float dz = player1->o.z - d->o.z;
	const float rz = player1->aboveeye + d->eyeheight;
	const float fx = (float)fabs(dx), fy = (float)fabs(dy),
	            fz = (float)fabs(dz);
	if (fx < r && fy < r && fz < rz && d->state != CS_DEAD) {
    {
        if(fx<fy) d->o.y += dy<0 ? r-fy : -(r-fy);  // push aside
        else      d->o.x += dx<0 ? r-fx : -(r-fx);
    };
    int lagtime = lastmillis-d->lastupdate;
    if(lagtime)
		if (fx < fy)
			d->o.y += dy < 0 ? r - fy : -(r - fy); // push aside
		else
			d->o.x += dx < 0 ? r - fx : -(r - fx);
	};
	int lagtime = lastmillis - d->lastupdate;
	if (lagtime) {
    {
        d->plag = (d->plag*5+lagtime)/6;
        d->lastupdate = lastmillis;
    };
		d->plag = (d->plag * 5 + lagtime) / 6;
		d->lastupdate = lastmillis;
	};
};

void
localservertoclient(
void localservertoclient(uchar *buf, int len)   // processes any updates from the server
    uchar *buf, int len) // processes any updates from the server
{
    if(ENET_NET_TO_HOST_16(*(ushort *)buf)!=len) neterr("packet length");
    incomingdemodata(buf, len);
    
    uchar *end = buf+len;
    uchar *p = buf+2;
    char text[MAXTRANS];
    int cn = -1, type;
    dynent *d = NULL;
    bool mapchanged = false;
	if (ENET_NET_TO_HOST_16(*(ushort *)buf) != len)
		neterr("packet length");
	incomingdemodata(buf, len);

	uchar *end = buf + len;
	uchar *p = buf + 2;
	char text[MAXTRANS];
	int cn = -1, type;
	dynent *d = NULL;
	bool mapchanged = false;

	while (p < end)
    while(p<end) switch(type = getint(p))
		switch (type = getint(p)) {
    {
        case SV_INITS2C:                    // welcome messsage from the server
        {
            cn = getint(p);
            int prot = getint(p);
            if(prot!=PROTOCOL_VERSION)
		case SV_INITS2C: // welcome messsage from the server
		{
			cn = getint(p);
			int prot = getint(p);
			if (prot != PROTOCOL_VERSION) {
            {
                conoutf("you are using a different game protocol (you: %d, server: %d)", PROTOCOL_VERSION, prot);
                disconnect();
                return;
            };
            toservermap[0] = 0;
            clientnum = cn;                 // we are now fully connected
            if(!getint(p)) strcpy_s(toservermap, getclientmap());   // we are the first client on this server, set map
            sgetstr();
            if(text[0] && strcmp(text, clientpassword))
				conoutf("you are using a different game "
				        "protocol (you: %d, server: %d)",
				    PROTOCOL_VERSION, prot);
				disconnect();
				return;
			};
			toservermap[0] = 0;
			clientnum = cn; // we are now fully connected
			if (!getint(p))
				strcpy_s(toservermap,
				    getclientmap()); // we are the first client
				                     // on this server, set map
			sgetstr();
			if (text[0] && strcmp(text, clientpassword)) {
            {
                conoutf("you need to set the correct password to join this server!");
                disconnect();
                return;
            };
            if(getint(p)==1)
				conoutf("you need to set the correct password "
				        "to join this server!");
				disconnect();
				return;
			};
			if (getint(p) == 1) {
            {
                conoutf("server is FULL, disconnecting..");
            };
            break;
        };
				conoutf("server is FULL, disconnecting..");
			};
			break;
		};

        case SV_POS:                        // position of another client
        {
            cn = getint(p);
            d = getclient(cn);
            if(!d) return;
            d->o.x   = getint(p)/DMF;
            d->o.y   = getint(p)/DMF;
            d->o.z   = getint(p)/DMF;
            d->yaw   = getint(p)/DAF;
            d->pitch = getint(p)/DAF;
            d->roll  = getint(p)/DAF;
            d->vel.x = getint(p)/DVF;
            d->vel.y = getint(p)/DVF;
            d->vel.z = getint(p)/DVF;
            int f = getint(p);
            d->strafe = (f&3)==3 ? -1 : f&3;
            f >>= 2; 
            d->move = (f&3)==3 ? -1 : f&3;
            d->onfloor = (f>>2)&1;
            int state = f>>3;
            if(state==CS_DEAD && d->state!=CS_DEAD) d->lastaction = lastmillis;
            d->state = state;
            if(!demoplayback) updatepos(d);
            break;
        };
		case SV_POS: // position of another client
		{
			cn = getint(p);
			d = getclient(cn);
			if (!d)
				return;
			d->o.x = getint(p) / DMF;
			d->o.y = getint(p) / DMF;
			d->o.z = getint(p) / DMF;
			d->yaw = getint(p) / DAF;
			d->pitch = getint(p) / DAF;
			d->roll = getint(p) / DAF;
			d->vel.x = getint(p) / DVF;
			d->vel.y = getint(p) / DVF;
			d->vel.z = getint(p) / DVF;
			int f = getint(p);
			d->strafe = (f & 3) == 3 ? -1 : f & 3;
			f >>= 2;
			d->move = (f & 3) == 3 ? -1 : f & 3;
			d->onfloor = (f >> 2) & 1;
			int state = f >> 3;
			if (state == CS_DEAD && d->state != CS_DEAD)
				d->lastaction = lastmillis;
			d->state = state;
			if (!demoplayback)
				updatepos(d);
			break;
		};

        case SV_SOUND:
            playsound(getint(p), &d->o);
            break;
		case SV_SOUND:
			playsound(getint(p), &d->o);
			break;

        case SV_TEXT:
            sgetstr();
            conoutf("%s:\f %s", d->name, text); 
            break;
		case SV_TEXT:
			sgetstr();
			conoutf("%s:\f %s", d->name, text);
			break;

        case SV_MAPCHANGE:     
            sgetstr();
            changemapserv(text, getint(p));
            mapchanged = true;
            break;
        
        case SV_ITEMLIST:
		case SV_MAPCHANGE:
			sgetstr();
			changemapserv(text, getint(p));
			mapchanged = true;
			break;

		case SV_ITEMLIST: {
        {
            int n;
            if(mapchanged) { senditemstoserver = false; resetspawns(); };
            while((n = getint(p))!=-1) if(mapchanged) setspawn(n, true);
            break;
        };
			int n;
			if (mapchanged) {
				senditemstoserver = false;
				resetspawns();
			};
			while ((n = getint(p)) != -1)
				if (mapchanged)
					setspawn(n, true);
			break;
		};

        case SV_MAPRELOAD:          // server requests next map
        {
            getint(p);
            sprintf_sd(nextmapalias)("nextmap_%s", getclientmap());
            char *map = getalias(nextmapalias);     // look up map in the cycle
            changemap(map ? map : getclientmap());
            break;
        };
		case SV_MAPRELOAD: // server requests next map
		{
			getint(p);
			sprintf_sd(nextmapalias)("nextmap_%s", getclientmap());
			char *map =
			    getalias(nextmapalias); // look up map in the cycle
			changemap(map ? map : getclientmap());
			break;
		};

        case SV_INITC2S:            // another client either connected or changed name/team
        {
            sgetstr();
            if(d->name[0])          // already connected
            {
                if(strcmp(d->name, text))
                    conoutf("%s is now known as %s", d->name, text);
		case SV_INITC2S: // another client either connected or changed
		                 // name/team
		{
			sgetstr();
			if (d->name[0]) // already connected
			{
				if (strcmp(d->name, text))
					conoutf("%s is now known as %s",
            }
            else                    // new client
            {
                c2sinit = false;    // send new players my info again 
                conoutf("connected: %s", text);
            }; 
            strcpy_s(d->name, text);
            sgetstr();
            strcpy_s(d->team, text);
            d->lifesequence = getint(p);
            break;
        };
					    d->name, text);
			} else // new client
			{
				c2sinit =
				    false; // send new players my info again
				conoutf("connected: %s", text);
			};
			strcpy_s(d->name, text);
			sgetstr();
			strcpy_s(d->team, text);
			d->lifesequence = getint(p);
			break;
		};

        case SV_CDIS:
            cn = getint(p);
            if(!(d = getclient(cn))) break;
			conoutf("player %s disconnected", d->name[0] ? d->name : "[incompatible client]"); 
            zapdynent(players[cn]);
            break;
		case SV_CDIS:
			cn = getint(p);
			if (!(d = getclient(cn)))
				break;
			conoutf("player %s disconnected",
			    d->name[0] ? d->name : "[incompatible client]");
			zapdynent(players[cn]);
			break;

        case SV_SHOT:
		case SV_SHOT: {
        {
            int gun = getint(p);
            vec s, e;
            s.x = getint(p)/DMF;
            s.y = getint(p)/DMF;
            s.z = getint(p)/DMF;
            e.x = getint(p)/DMF;
            e.y = getint(p)/DMF;
            e.z = getint(p)/DMF;
            if(gun==GUN_SG) createrays(s, e);
            shootv(gun, s, e, d);
            break;
        };
			int gun = getint(p);
			vec s, e;
			s.x = getint(p) / DMF;
			s.y = getint(p) / DMF;
			s.z = getint(p) / DMF;
			e.x = getint(p) / DMF;
			e.y = getint(p) / DMF;
			e.z = getint(p) / DMF;
			if (gun == GUN_SG)
				createrays(s, e);
			shootv(gun, s, e, d);
			break;
		};

        case SV_DAMAGE:             
		case SV_DAMAGE: {
        {
            int target = getint(p);
            int damage = getint(p);
            int ls = getint(p);
            if(target==clientnum) { if(ls==player1->lifesequence) selfdamage(damage, cn, d); }
            else playsound(S_PAIN1+rnd(5), &getclient(target)->o);
            break;
        };
			int target = getint(p);
			int damage = getint(p);
			int ls = getint(p);
			if (target == clientnum) {
				if (ls == player1->lifesequence)
					selfdamage(damage, cn, d);
			} else
				playsound(
				    S_PAIN1 + rnd(5), &getclient(target)->o);
			break;
		};

        case SV_DIED:
        {
            int actor = getint(p);
            if(actor==cn)
            {
                conoutf("%s suicided", d->name);

		case SV_DIED: {
			int actor = getint(p);
			if (actor == cn) {
				conoutf("%s suicided", d->name);
            }
            else if(actor==clientnum)
			} else if (actor == clientnum) {
            {
                int frags;
                if(isteam(player1->team, d->team))
				int frags;
				if (isteam(player1->team, d->team)) {
                {
                    frags = -1;
                    conoutf("you fragged a teammate (%s)", d->name);
					frags = -1;
					conoutf("you fragged a teammate (%s)",
                }
                else
					    d->name);
				} else {
                {
                    frags = 1;
                    conoutf("you fragged %s", d->name);
                };
                addmsg(1, 2, SV_FRAGS, player1->frags += frags);
					frags = 1;
					conoutf("you fragged %s", d->name);
				};
				addmsg(1, 2, SV_FRAGS, player1->frags += frags);
            }
            else
			} else {
            {
                dynent *a = getclient(actor);
                if(a)
				dynent *a = getclient(actor);
				if (a) {
                {
                    if(isteam(a->team, d->name))
					if (isteam(a->team, d->name)) {
                    {
                        conoutf("%s fragged his teammate (%s)", a->name, d->name);
						conoutf("%s fragged his "
                    }
                    else
						        "teammate (%s)",
						    a->name, d->name);
					} else {
                    {
                        conoutf("%s fragged %s", a->name, d->name);
                    };
                };
            };
            playsound(S_DIE1+rnd(2), &d->o);
            d->lifesequence++;
            break;
        };
						conoutf("%s fragged %s",
						    a->name, d->name);
					};
				};
			};
			playsound(S_DIE1 + rnd(2), &d->o);
			d->lifesequence++;
			break;
		};

        case SV_FRAGS:
            players[cn]->frags = getint(p);
            break;
		case SV_FRAGS:
			players[cn]->frags = getint(p);
			break;

        case SV_ITEMPICKUP:
            setspawn(getint(p), false);
            getint(p);
            break;
		case SV_ITEMPICKUP:
			setspawn(getint(p), false);
			getint(p);
			break;

        case SV_ITEMSPAWN:
		case SV_ITEMSPAWN: {
        {
            uint i = getint(p);
            setspawn(i, true);
            if(i>=(uint)ents.length()) break;
            vec v = { ents[i].x, ents[i].y, ents[i].z };
            playsound(S_ITEMSPAWN, &v); 
            break;
        };
			uint i = getint(p);
			setspawn(i, true);
			if (i >= (uint)ents.length())
				break;
			vec v = {ents[i].x, ents[i].y, ents[i].z};
			playsound(S_ITEMSPAWN, &v);
			break;
		};

        case SV_ITEMACC:            // server acknowledges that I picked up this item
            realpickup(getint(p), player1);
            break;
		case SV_ITEMACC: // server acknowledges that I picked up this
		                 // item
			realpickup(getint(p), player1);
			break;

        case SV_EDITH:              // coop editing messages, should be extended to include all possible editing ops
        case SV_EDITT:
        case SV_EDITS:
        case SV_EDITD:
        case SV_EDITE:
		case SV_EDITH: // coop editing messages, should be extended to
		               // include all possible editing ops
		case SV_EDITT:
		case SV_EDITS:
		case SV_EDITD:
		case SV_EDITE: {
        {
            int x  = getint(p);
            int y  = getint(p);
            int xs = getint(p);
            int ys = getint(p);
            int v  = getint(p);
            block b = { x, y, xs, ys };
            switch(type)
			int x = getint(p);
			int y = getint(p);
			int xs = getint(p);
			int ys = getint(p);
			int v = getint(p);
			block b = {x, y, xs, ys};
			switch (type) {
            {
                case SV_EDITH: editheightxy(v!=0, getint(p), b); break;
                case SV_EDITT: edittexxy(v, getint(p), b); break;
                case SV_EDITS: edittypexy(v, b); break;
                case SV_EDITD: setvdeltaxy(v, b); break;
                case SV_EDITE: editequalisexy(v!=0, b); break;
            };
            break;
        };
			case SV_EDITH:
				editheightxy(v != 0, getint(p), b);
				break;
			case SV_EDITT:
				edittexxy(v, getint(p), b);
				break;
			case SV_EDITS:
				edittypexy(v, b);
				break;
			case SV_EDITD:
				setvdeltaxy(v, b);
				break;
			case SV_EDITE:
				editequalisexy(v != 0, b);
				break;
			};
			break;
		};

        case SV_EDITENT:            // coop edit of ent
        {
            uint i = getint(p);
            while((uint)ents.length()<=i) ents.add().type = NOTUSED;
            int to = ents[i].type;
            ents[i].type = getint(p);
            ents[i].x = getint(p);
            ents[i].y = getint(p);
            ents[i].z = getint(p);
            ents[i].attr1 = getint(p);
            ents[i].attr2 = getint(p);
            ents[i].attr3 = getint(p);
            ents[i].attr4 = getint(p);
            ents[i].spawned = false;
            if(ents[i].type==LIGHT || to==LIGHT) calclight();
            break;
        };
		case SV_EDITENT: // coop edit of ent
		{
			uint i = getint(p);
			while ((uint)ents.length() <= i)
				ents.add().type = NOTUSED;
			int to = ents[i].type;
			ents[i].type = getint(p);
			ents[i].x = getint(p);
			ents[i].y = getint(p);
			ents[i].z = getint(p);
			ents[i].attr1 = getint(p);
			ents[i].attr2 = getint(p);
			ents[i].attr3 = getint(p);
			ents[i].attr4 = getint(p);
			ents[i].spawned = false;
			if (ents[i].type == LIGHT || to == LIGHT)
				calclight();
			break;
		};

        case SV_PING:
            getint(p);
            break;
		case SV_PING:
			getint(p);
			break;

        case SV_PONG: 
            addmsg(0, 2, SV_CLIENTPING, player1->ping = (player1->ping*5+lastmillis-getint(p))/6);
            break;
		case SV_PONG:
			addmsg(0, 2, SV_CLIENTPING,
			    player1->ping =
			        (player1->ping * 5 + lastmillis - getint(p)) /
			        6);
			break;

        case SV_CLIENTPING:
            players[cn]->ping = getint(p);
            break;
		case SV_CLIENTPING:
			players[cn]->ping = getint(p);
			break;

        case SV_GAMEMODE:
            nextmode = getint(p);
            break;
		case SV_GAMEMODE:
			nextmode = getint(p);
			break;

        case SV_TIMEUP:
            timeupdate(getint(p));
            break;
		case SV_TIMEUP:
			timeupdate(getint(p));
			break;

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

		case SV_SERVMSG:
			sgetstr();
			conoutf("%s", text);
			break;

        case SV_EXT:        // so we can messages without breaking previous clients/servers, if necessary
        {
            for(int n = getint(p); n; n--) getint(p);
            break;
        };
		case SV_EXT: // so we can messages without breaking previous
		             // clients/servers, if necessary
		{
			for (int n = getint(p); n; n--)
				getint(p);
			break;
		};

        default:
            neterr("type");
            return;
    };
		default:
			neterr("type");
			return;
		};
};

// command.cpp: implements the parsing and execution of a tiny script language which
// is largely backwards compatible with the quake console language.
// command.cpp: implements the parsing and execution of a tiny script language
// which is largely backwards compatible with the quake console language.

#include "cube.h"

enum { ID_VAR, ID_COMMAND, ID_ALIAS };

struct ident
struct ident {
{
    int type;           // one of ID_* above
    char *name;
    int min, max;       // ID_VAR
    int *storage;       // ID_VAR
    void (*fun)();      // ID_VAR, ID_COMMAND
    int narg;           // ID_VAR, ID_COMMAND
    char *action;       // ID_ALIAS
    bool persist;
	int type; // one of ID_* above
	char *name;
	int min, max;  // ID_VAR
	int *storage;  // ID_VAR
	void (*fun)(); // ID_VAR, ID_COMMAND
	int narg;      // ID_VAR, ID_COMMAND
	char *action;  // ID_ALIAS
	bool persist;
};

void
void itoa(char *s, int i) { sprintf_s(s)("%d", i); };
itoa(char *s, int i)
char *exchangestr(char *o, char *n) { gp()->deallocstr(o); return newstring(n); };

{
hashtable<ident> *idents = NULL;        // contains ALL vars/commands/aliases

void alias(char *name, char *action)
	sprintf_s(s)("%d", i);
};
char *
exchangestr(char *o, char *n)
{
    ident *b = idents->access(name);
	gp()->deallocstr(o);
    if(!b)
    {
        name = newstring(name);
        ident b = { ID_ALIAS, name, 0, 0, 0, 0, 0, newstring(action), true };
        idents->access(name, &b);
	return newstring(n);
};

hashtable<ident> *idents = NULL; // contains ALL vars/commands/aliases

void
alias(char *name, char *action)
{
	ident *b = idents->access(name);
	if (!b) {
		name = newstring(name);
		ident b = {
		    ID_ALIAS, name, 0, 0, 0, 0, 0, newstring(action), true};
		idents->access(name, &b);
    }
    else
	} else {
    {
        if(b->type==ID_ALIAS) b->action = exchangestr(b->action, action);
        else conoutf("cannot redefine builtin %s with an alias", name);
    };
		if (b->type == ID_ALIAS)
			b->action = exchangestr(b->action, action);
		else
			conoutf(
			    "cannot redefine builtin %s with an alias", name);
	};
};

COMMAND(alias, ARG_2STR);

// variable's and commands are registered through globals, see cube.h

int
int variable(char *name, int min, int cur, int max, int *storage, void (*fun)(), bool persist)
variable(char *name, int min, int cur, int max, int *storage, void (*fun)(),
    bool persist)
{
	if (!idents)
    if(!idents) idents = new hashtable<ident>;
    ident v = { ID_VAR, name, min, max, storage, fun, 0, 0, persist };
    idents->access(name, &v);
    return cur;
		idents = new hashtable<ident>;
	ident v = {ID_VAR, name, min, max, storage, fun, 0, 0, persist};
	idents->access(name, &v);
	return cur;
};

void
setvar(char *name, int i)
{
void setvar(char *name, int i) { *idents->access(name)->storage = i; };
int getvar(char *name) { return *idents->access(name)->storage; };
bool identexists(char *name) { return idents->access(name)!=NULL; };
	*idents->access(name)->storage = i;
};
int
getvar(char *name)
{
	return *idents->access(name)->storage;
};
bool
identexists(char *name)
{
	return idents->access(name) != NULL;
};

char *
char *getalias(char *name)
getalias(char *name)
{
    ident *i = idents->access(name);
    return i && i->type==ID_ALIAS ? i->action : NULL;
	ident *i = idents->access(name);
	return i && i->type == ID_ALIAS ? i->action : NULL;
};


bool addcommand(char *name, void (*fun)(), int narg)
bool
addcommand(char *name, void (*fun)(), int narg)
{
	if (!idents)
    if(!idents) idents = new hashtable<ident>;
    ident c = { ID_COMMAND, name, 0, 0, 0, fun, narg, 0, false };
    idents->access(name, &c);
    return false;
		idents = new hashtable<ident>;
	ident c = {ID_COMMAND, name, 0, 0, 0, fun, narg, 0, false};
	idents->access(name, &c);
	return false;
};

char *
char *parseexp(char *&p, int right)             // parse any nested set of () or []
parseexp(char *&p, int right) // parse any nested set of () or []
{
    int left = *p++;
    char *word = p;
    for(int brak = 1; brak; )
	int left = *p++;
	char *word = p;
	for (int brak = 1; brak;) {
    {
        int c = *p++;
        if(c=='\r') *(p-1) = ' ';               // hack
        if(c==left) brak++;
        else if(c==right) brak--;
        else if(!c) { p--; conoutf("missing \"%c\"", right); return NULL; };
    };
    char *s = newstring(word, p-word-1);
    if(left=='(')
		int c = *p++;
		if (c == '\r')
			*(p - 1) = ' '; // hack
		if (c == left)
			brak++;
		else if (c == right)
			brak--;
		else if (!c) {
			p--;
			conoutf("missing \"%c\"", right);
			return NULL;
		};
	};
	char *s = newstring(word, p - word - 1);
	if (left == '(') {
    {
        string t;
        itoa(t, execute(s));                    // evaluate () exps directly, and substitute result
        s = exchangestr(s, t);
    };
    return s;
		string t;
		itoa(t,
		    execute(
		        s)); // evaluate () exps directly, and substitute result
		s = exchangestr(s, t);
	};
	return s;
};

char *
char *parseword(char *&p)                       // parse single argument, including expressions
parseword(char *&p) // parse single argument, including expressions
{
    p += strspn(p, " \t\r");
    if(p[0]=='/' && p[1]=='/') p += strcspn(p, "\n\0");  
    if(*p=='\"')
	p += strspn(p, " \t\r");
	if (p[0] == '/' && p[1] == '/')
		p += strcspn(p, "\n\0");
	if (*p == '\"') {
    {
        p++;
        char *word = p;
        p += strcspn(p, "\"\r\n\0");
        char *s = newstring(word, p-word);
        if(*p=='\"') p++;
        return s;
    };
    if(*p=='(') return parseexp(p, ')');
    if(*p=='[') return parseexp(p, ']');
    char *word = p;
    p += strcspn(p, "; \t\r\n\0");
    if(p-word==0) return NULL;
    return newstring(word, p-word);
		p++;
		char *word = p;
		p += strcspn(p, "\"\r\n\0");
		char *s = newstring(word, p - word);
		if (*p == '\"')
			p++;
		return s;
	};
	if (*p == '(')
		return parseexp(p, ')');
	if (*p == '[')
		return parseexp(p, ']');
	char *word = p;
	p += strcspn(p, "; \t\r\n\0");
	if (p - word == 0)
		return NULL;
	return newstring(word, p - word);
};

char *
lookup(char *n) // find value of ident referenced with $ in exp
{
	ident *id = idents->access(n + 1);
	if (id)

char *lookup(char *n)                           // find value of ident referenced with $ in exp
		switch (id->type) {
		case ID_VAR:
{
    ident *id = idents->access(n+1);
    if(id) switch(id->type)
			string t;
			itoa(t, *(id->storage));
    {
        case ID_VAR: string t; itoa(t, *(id->storage)); return exchangestr(n, t);
        case ID_ALIAS: return exchangestr(n, id->action);
    };
    conoutf("unknown alias lookup: %s", n+1);
    return n;
			return exchangestr(n, t);
		case ID_ALIAS:
			return exchangestr(n, id->action);
		};
	conoutf("unknown alias lookup: %s", n + 1);
	return n;
};

int
execute(char *p, bool isdown) // all evaluation happens here, recursively
{
	const int MAXWORDS = 25; // limit, remove
	char *w[MAXWORDS];
	int val = 0;
	for (bool cont = true; cont;) // for each ; seperated statement
	{
		int numargs = MAXWORDS;
		loopi(MAXWORDS) // collect all argument values
		{
			w[i] = "";
			if (i > numargs)
				continue;
			char *s = parseword(p); // parse and evaluate exps
			if (!s) {
				numargs = i;
				s = "";
			};

int execute(char *p, bool isdown)               // all evaluation happens here, recursively
{
			if (*s == '$')
				s = lookup(s); // substitute variables
			w[i] = s;
		};

    const int MAXWORDS = 25;                    // limit, remove
    char *w[MAXWORDS];
    int val = 0;
    for(bool cont = true; cont;)                // for each ; seperated statement
    {
        int numargs = MAXWORDS;
		p += strcspn(p, ";\n\0");
		cont = *p++ !=
		       0; // more statements if this isn't the end of the string
		char *c = w[0];
		if (*c == '/')
			c++; // strip irc-style command prefix
		if (!*c)
			continue; // empty statement

		ident *id = idents->access(c);
		if (!id) {
			val = ATOI(c);
        loopi(MAXWORDS)                         // collect all argument values
        {
			if (!val && *c != '0')
				conoutf("unknown command: %s", c);
		} else
			switch (id->type) {
			case ID_COMMAND:          // game defined commands
				switch (id->narg) // use very ad-hoc function
				                  // signature, and just call it
				{
            w[i] = "";
            if(i>numargs) continue;
				case ARG_1INT:
					if (isdown)
            char *s = parseword(p);             // parse and evaluate exps
            if(!s) { numargs = i; s = ""; };
            if(*s=='$') s = lookup(s);          // substitute variables
            w[i] = s;
						((void(__cdecl *)(int))id->fun)(
						    ATOI(w[1]));
        };
        
        p += strcspn(p, ";\n\0");
        cont = *p++!=0;                         // more statements if this isn't the end of the string
        char *c = w[0];
					break;
				case ARG_2INT:
					if (isdown)
						((void(__cdecl *)(
						    int, int))id->fun)(
						    ATOI(w[1]), ATOI(w[2]));
					break;
				case ARG_3INT:
					if (isdown)
						((void(__cdecl *)(int, int,
						    int))id->fun)(ATOI(w[1]),
						    ATOI(w[2]), ATOI(w[3]));
					break;
				case ARG_4INT:
					if (isdown)
						((void(__cdecl *)(int, int, int,
						    int))id->fun)(ATOI(w[1]),
						    ATOI(w[2]), ATOI(w[3]),
						    ATOI(w[4]));
					break;
				case ARG_NONE:
					if (isdown)
						((void(__cdecl *)())id->fun)();
					break;
				case ARG_1STR:
					if (isdown)
						((void(__cdecl *)(
						    char *))id->fun)(w[1]);
        if(*c=='/') c++;                        // strip irc-style command prefix
        if(!*c) continue;                       // empty statement
        
        ident *id = idents->access(c);
        if(!id)
					break;
				case ARG_2STR:
					if (isdown)
						((void(__cdecl *)(
						    char *, char *))id->fun)(
						    w[1], w[2]);
					break;
				case ARG_3STR:
					if (isdown)
        {
            val = ATOI(c);
						((void(__cdecl *)(char *,
            if(!val && *c!='0') conoutf("unknown command: %s", c);
        }
        else switch(id->type)
						    char *, char *))id->fun)(
        {
            case ID_COMMAND:                    // game defined commands       
                switch(id->narg)                // use very ad-hoc function signature, and just call it
						    w[1], w[2], w[3]);
					break;
				case ARG_5STR:
					if (isdown)
						((void(__cdecl *)(char *,
                { 
                    case ARG_1INT: if(isdown) ((void (__cdecl *)(int))id->fun)(ATOI(w[1])); break;
                    case ARG_2INT: if(isdown) ((void (__cdecl *)(int, int))id->fun)(ATOI(w[1]), ATOI(w[2])); break;
                    case ARG_3INT: if(isdown) ((void (__cdecl *)(int, int, int))id->fun)(ATOI(w[1]), ATOI(w[2]), ATOI(w[3])); break;
                    case ARG_4INT: if(isdown) ((void (__cdecl *)(int, int, int, int))id->fun)(ATOI(w[1]), ATOI(w[2]), ATOI(w[3]), ATOI(w[4])); break;
                    case ARG_NONE: if(isdown) ((void (__cdecl *)())id->fun)(); break;
                    case ARG_1STR: if(isdown) ((void (__cdecl *)(char *))id->fun)(w[1]); break;
                    case ARG_2STR: if(isdown) ((void (__cdecl *)(char *, char *))id->fun)(w[1], w[2]); break;
                    case ARG_3STR: if(isdown) ((void (__cdecl *)(char *, char *, char*))id->fun)(w[1], w[2], w[3]); break;
                    case ARG_5STR: if(isdown) ((void (__cdecl *)(char *, char *, char*, char*, char*))id->fun)(w[1], w[2], w[3], w[4], w[5]); break;
                    case ARG_DOWN: ((void (__cdecl *)(bool))id->fun)(isdown); break;
                    case ARG_DWN1: ((void (__cdecl *)(bool, char *))id->fun)(isdown, w[1]); break;
                    case ARG_1EXP: if(isdown) val = ((int (__cdecl *)(int))id->fun)(execute(w[1])); break;
                    case ARG_2EXP: if(isdown) val = ((int (__cdecl *)(int, int))id->fun)(execute(w[1]), execute(w[2])); break;
                    case ARG_1EST: if(isdown) val = ((int (__cdecl *)(char *))id->fun)(w[1]); break;
                    case ARG_2EST: if(isdown) val = ((int (__cdecl *)(char *, char *))id->fun)(w[1], w[2]); break;
                    case ARG_VARI: if(isdown)
						    char *, char *, char *,
						    char *))id->fun)(w[1], w[2],
						    w[3], w[4], w[5]);
					break;
				case ARG_DOWN:
					((void(__cdecl *)(bool))id->fun)(
					    isdown);
					break;
				case ARG_DWN1:
					((void(__cdecl *)(bool,
					    char *))id->fun)(isdown, w[1]);
					break;
				case ARG_1EXP:
					if (isdown)
						val = ((int(__cdecl *)(
						    int))id->fun)(
						    execute(w[1]));
					break;
				case ARG_2EXP:
					if (isdown)
						val = ((int(__cdecl *)(int,
						    int))id->fun)(execute(w[1]),
						    execute(w[2]));
					break;
				case ARG_1EST:
					if (isdown)
						val = ((int(__cdecl *)(
						    char *))id->fun)(w[1]);
					break;
				case ARG_2EST:
					if (isdown)
						val = ((int(__cdecl *)(
						    char *, char *))id->fun)(
						    w[1], w[2]);
					break;
				case ARG_VARI:
                    {
                        string r;               // limit, remove
                        r[0] = 0;
                        for(int i = 1; i<numargs; i++)       
					if (isdown) {
						string r; // limit, remove
						r[0] = 0;
						for (int i = 1; i < numargs;
                        {
                            strcat_s(r, w[i]);  // make string-list out of all arguments
                            if(i==numargs-1) break;
                            strcat_s(r, " ");
                        };
                        ((void (__cdecl *)(char *))id->fun)(r);
                        break;
                    }
                };
                break;
       
            case ID_VAR:                        // game defined variabled 
                if(isdown)
						     i++) {
							strcat_s(r,
							    w[i]); // make
							           // string-list
							           // out of all
							           // arguments
							if (i == numargs - 1)
								break;
							strcat_s(r, " ");
						};
						((void(__cdecl *)(
						    char *))id->fun)(r);
						break;
					}
				};
				break;

			case ID_VAR: // game defined variabled
				if (isdown) {
                {
                    if(!w[1][0]) conoutf("%s = %d", c, *id->storage);      // var with no value just prints its current value
                    else
					if (!w[1][0])
						conoutf("%s = %d", c,
						    *id->storage); // var with
						                   // no value
						                   // just
						                   // prints its
						                   // current
						                   // value
					else {
                    {
                        if(id->min>id->max)
						if (id->min > id->max) {
                        {
                            conoutf("variable is read-only");
							conoutf("variable is "
                        }
                        else
							        "read-only");
						} else {
                        {
                            int i1 = ATOI(w[1]);
                            if(i1<id->min || i1>id->max)
							int i1 = ATOI(w[1]);
							if (i1 < id->min ||
							    i1 > id->max) {
								i1 =
								    i1 < id->min
								        ? id->min
								        : id->max; // clamp to valid range
								conoutf(
								    "valid "
								    "range for "
								    "%s is "
								    "%d..%d",
								    c, id->min,
                            {
                                i1 = i1<id->min ? id->min : id->max;                // clamp to valid range
                                conoutf("valid range for %s is %d..%d", c, id->min, id->max);
                            }
                            *id->storage = i1;
                        };
                        if(id->fun) ((void (__cdecl *)())id->fun)();            // call trigger function if available
                    };
                };
                break;
                
            case ID_ALIAS:                              // alias, also used as functions and (global) variables
                for(int i = 1; i<numargs; i++)
								    id->max);
							}
							*id->storage = i1;
						};
						if (id->fun)
							((void(__cdecl *)())id
							        ->fun)(); // call
							                  // trigger
							                  // function
							                  // if
							                  // available
					};
				};
				break;

			case ID_ALIAS: // alias, also used as functions and
			               // (global) variables
				for (int i = 1; i < numargs; i++) {
                {
                    sprintf_sd(t)("arg%d", i);          // set any arguments as (global) arg values so functions can access them
                    alias(t, w[i]);
                };
                char *action = newstring(id->action);   // create new string here because alias could rebind itself
                val = execute(action, isdown);
                gp()->deallocstr(action);
                break;
        };
        loopj(numargs) gp()->deallocstr(w[j]);
    };
    return val;
					sprintf_sd(t)("arg%d",
					    i); // set any arguments as (global)
					        // arg values so functions can
					        // access them
					alias(t, w[i]);
				};
				char *action = newstring(
				    id->action); // create new string here
				                 // because alias could rebind
				                 // itself
				val = execute(action, isdown);
				gp()->deallocstr(action);
				break;
			};
		loopj(numargs) gp()->deallocstr(w[j]);
	};
	return val;
};

// tab-completion of all idents

int completesize = 0, completeidx = 0;

void
void resetcomplete() { completesize = 0; };

void complete(char *s)
{
    if(*s!='/')
    {
        string t;
        strcpy_s(t, s);
        strcpy_s(s, "/");
        strcat_s(s, t);
    };
    if(!s[1]) return;
    if(!completesize) { completesize = (int)strlen(s)-1; completeidx = 0; };
    int idx = 0;
    enumerate(idents, ident *, id,
        if(strncmp(id->name, s+1, completesize)==0 && idx++==completeidx)
resetcomplete()
{
	completesize = 0;
};

void
complete(char *s)
{
	if (*s != '/') {
		string t;
		strcpy_s(t, s);
		strcpy_s(s, "/");
		strcat_s(s, t);
	};
	if (!s[1])
		return;
	if (!completesize) {
		completesize = (int)strlen(s) - 1;
		completeidx = 0;
	};
	int idx = 0;
	enumerate(
	    idents, ident *, id,
	    if (strncmp(id->name, s + 1, completesize) == 0 &&
        {
            strcpy_s(s, "/");
            strcat_s(s, id->name);
        };
	        idx++ == completeidx) {
		    strcpy_s(s, "/");
		    strcat_s(s, id->name);
	    };);
    );
    completeidx++;
    if(completeidx>=idx) completeidx = 0;
	completeidx++;
	if (completeidx >= idx)
		completeidx = 0;
};

bool
bool execfile(char *cfgfile)
execfile(char *cfgfile)
{
    string s;
    strcpy_s(s, cfgfile);
    char *buf = loadfile(path(s), NULL);
    if(!buf) return false;
    execute(buf);
    free(buf);
    return true;
	string s;
	strcpy_s(s, cfgfile);
	char *buf = loadfile(path(s), NULL);
	if (!buf)
		return false;
	execute(buf);
	free(buf);
	return true;
};

void
void exec(char *cfgfile)
exec(char *cfgfile)
{
	if (!execfile(cfgfile))
    if(!execfile(cfgfile)) conoutf("could not read \"%s\"", cfgfile);
		conoutf("could not read \"%s\"", cfgfile);
};

void
void writecfg()
writecfg()
{
    FILE *f = fopen("config.cfg", "w");
    if(!f) return;
    fprintf(f, "// automatically written on exit, do not modify\n// delete this file to have defaults.cfg overwrite these settings\n// modify settings in game, or put settings in autoexec.cfg to override anything\n\n");
    writeclientinfo(f);
    fprintf(f, "\n");
    enumerate(idents, ident *, id,
        if(id->type==ID_VAR && id->persist)
	FILE *f = fopen("config.cfg", "w");
	if (!f)
		return;
	fprintf(f, "// automatically written on exit, do not modify\n// delete "
	           "this file to have defaults.cfg overwrite these "
	           "settings\n// modify settings in game, or put settings in "
	           "autoexec.cfg to override anything\n\n");
	writeclientinfo(f);
	fprintf(f, "\n");
	enumerate(
	    idents, ident *, id, if (id->type == ID_VAR && id->persist) {
        {
            fprintf(f, "%s %d\n", id->name, *id->storage);
        };
		    fprintf(f, "%s %d\n", id->name, *id->storage);
	    };);
    );
    fprintf(f, "\n");
    writebinds(f);
    fprintf(f, "\n");
    enumerate(idents, ident *, id,
        if(id->type==ID_ALIAS && !strstr(id->name, "nextmap_"))
	fprintf(f, "\n");
	writebinds(f);
	fprintf(f, "\n");
	enumerate(
	    idents, ident *, id,
	    if (id->type == ID_ALIAS && !strstr(id->name, "nextmap_")) {
        {
            fprintf(f, "alias \"%s\" [%s]\n", id->name, id->action);
        };
		    fprintf(f, "alias \"%s\" [%s]\n", id->name, id->action);
	    };);
    );
    fclose(f);
	fclose(f);
};

COMMAND(writecfg, ARG_NONE);

// below the commands that implement a small imperative language. thanks to the semantics of
// below the commands that implement a small imperative language. thanks to the
// semantics of
// () and [] expressions, any control construct can be defined trivially.

void
void intset(char *name, int v) { string b; itoa(b, v); alias(name, b); };

void ifthen(char *cond, char *thenp, char *elsep) { execute(cond[0]!='0' ? thenp : elsep); };
intset(char *name, int v)
{
	string b;
	itoa(b, v);
	alias(name, b);
};

void
ifthen(char *cond, char *thenp, char *elsep)
void loopa(char *times, char *body) { int t = atoi(times); loopi(t) { intset("i", i); execute(body); }; };
void whilea(char *cond, char *body) { while(execute(cond)) execute(body); };    // can't get any simpler than this :)
void onrelease(bool on, char *body) { if(!on) execute(body); };

void concat(char *s) { alias("s", s); };

{
	execute(cond[0] != '0' ? thenp : elsep);
};
void
loopa(char *times, char *body)
{
void concatword(char *s)
{
	int t = atoi(times);
	loopi(t)
	{
    for(char *a = s, *b = s; *a = *b; b++) if(*a!=' ') a++;   
    concat(s);
};
		intset("i", i);
		execute(body);
	};
};
void
whilea(char *cond, char *body)
{
	while (execute(cond))
		execute(body);
}; // can't get any simpler than this :)
void
onrelease(bool on, char *body)
{
	if (!on)
		execute(body);
};

void
concat(char *s)
{
	alias("s", s);
};

void
concatword(char *s)
{
	for (char *a = s, *b = s; *a = *b; b++)
		if (*a != ' ')
			a++;
	concat(s);
};

int
int listlen(char *a)
listlen(char *a)
{
	if (!*a)
    if(!*a) return 0;
    int n = 0;
    while(*a) if(*a++==' ') n++;
    return n+1;
		return 0;
	int n = 0;
	while (*a)
		if (*a++ == ' ')
			n++;
	return n + 1;
};

void
void at(char *s, char *pos)
at(char *s, char *pos)
{
    int n = atoi(pos);
    loopi(n) s += strspn(s += strcspn(s, " \0"), " ");
    s[strcspn(s, " \0")] = 0;
    concat(s);
	int n = atoi(pos);
	loopi(n) s += strspn(s += strcspn(s, " \0"), " ");
	s[strcspn(s, " \0")] = 0;
	concat(s);
};

COMMANDN(loop, loopa, ARG_2STR);
COMMANDN(while, whilea, ARG_2STR);
COMMANDN(if, ifthen, ARG_3STR); 
COMMANDN(if, ifthen, ARG_3STR);
COMMAND(onrelease, ARG_DWN1);
COMMAND(exec, ARG_1STR);
COMMAND(concat, ARG_VARI);
COMMAND(concatword, ARG_VARI);
COMMAND(at, ARG_2STR);
COMMAND(listlen, ARG_1EST);

int
add(int a, int b)
{
	return a + b;
};
int add(int a, int b)   { return a+b; };         COMMANDN(+, add, ARG_2EXP);
int mul(int a, int b)   { return a*b; };         COMMANDN(*, mul, ARG_2EXP);
int sub(int a, int b)   { return a-b; };         COMMANDN(-, sub, ARG_2EXP);
int divi(int a, int b)  { return b ? a/b : 0; }; COMMANDN(div, divi, ARG_2EXP);
int mod(int a, int b)   { return b ? a%b : 0; }; COMMAND(mod, ARG_2EXP);
int equal(int a, int b) { return (int)(a==b); }; COMMANDN(=, equal, ARG_2EXP);
int lt(int a, int b)    { return (int)(a<b); };  COMMANDN(<, lt, ARG_2EXP);
int gt(int a, int b)    { return (int)(a>b); };  COMMANDN(>, gt, ARG_2EXP);
COMMANDN(+, add, ARG_2EXP);
int
mul(int a, int b)
{
	return a * b;
};
COMMANDN(*, mul, ARG_2EXP);
int
sub(int a, int b)
{
	return a - b;
};
COMMANDN(-, sub, ARG_2EXP);
int
divi(int a, int b)
{
	return b ? a / b : 0;
};
COMMANDN(div, divi, ARG_2EXP);
int
mod(int a, int b)
{
	return b ? a % b : 0;
};
COMMAND(mod, ARG_2EXP);
int
equal(int a, int b)
{
	return (int)(a == b);
};
COMMANDN(=, equal, ARG_2EXP);
int
lt(int a, int b)
{
	return (int)(a < b);
};
COMMANDN(<, lt, ARG_2EXP);
int
gt(int a, int b)
{
	return (int)(a > b);
};
COMMANDN(>, gt, ARG_2EXP);

int
strcmpa(char *a, char *b)
{
	return strcmp(a, b) == 0;
};
int strcmpa(char *a, char *b) { return strcmp(a,b)==0; };  COMMANDN(strcmp, strcmpa, ARG_2EST);
COMMANDN(strcmp, strcmpa, ARG_2EST);

int
rndn(int a)
{
	return a > 0 ? rnd(a) : 0;
};
int rndn(int a)    { return a>0 ? rnd(a) : 0; };  COMMANDN(rnd, rndn, ARG_1EXP);
COMMANDN(rnd, rndn, ARG_1EXP);

int
int explastmillis() { return lastmillis; };  COMMANDN(millis, explastmillis, ARG_1EXP);

explastmillis()
{
	return lastmillis;
};
COMMANDN(millis, explastmillis, ARG_1EXP);

// console.cpp: the console buffer, its display, and command line control

#include "cube.h"
#include <ctype.h>

struct cline { char *cref; int outtime; };
struct cline {
	char *cref;
	int outtime;
};
vector<cline> conlines;

const int ndraw = 5;
const int WORDWRAP = 80;
int conskip = 0;

bool saycommandon = false;
string commandbuf;

void
void setconskip(int n)
setconskip(int n)
{
    conskip += n;
    if(conskip<0) conskip = 0;
	conskip += n;
	if (conskip < 0)
		conskip = 0;
};

COMMANDN(conskip, setconskip, ARG_1INT);

void
void conline(const char *sf, bool highlight)        // add a line to the console buffer
conline(const char *sf, bool highlight) // add a line to the console buffer
{
    cline cl;
    cl.cref = conlines.length()>100 ? conlines.pop().cref : newstringbuf("");   // constrain the buffer size
    cl.outtime = lastmillis;                        // for how long to keep line on screen
    conlines.insert(0,cl);
    if(highlight)                                   // show line in a different colour, for chat etc.
    {
        cl.cref[0] = '\f';
        cl.cref[1] = 0;
        strcat_s(cl.cref, sf);
	cline cl;
	cl.cref = conlines.length() > 100
	              ? conlines.pop().cref
	              : newstringbuf(""); // constrain the buffer size
	cl.outtime = lastmillis;          // for how long to keep line on screen
	conlines.insert(0, cl);
	if (highlight) // show line in a different colour, for chat etc.
	{
		cl.cref[0] = '\f';
		cl.cref[1] = 0;
		strcat_s(cl.cref, sf);
    }
    else
	} else {
    {
        strcpy_s(cl.cref, sf);
    };
    puts(cl.cref);
    #ifndef _WIN32
        fflush(stdout);
    #endif
		strcpy_s(cl.cref, sf);
	};
	puts(cl.cref);
#ifndef _WIN32
	fflush(stdout);
#endif
};

void
void conoutf(const char *s, ...)
conoutf(const char *s, ...)
{
    sprintf_sdv(sf, s);
    s = sf;
    int n = 0;
    while(strlen(s)>WORDWRAP)                       // cut strings to fit on screen
    {
        string t;
        strn0cpy(t, s, WORDWRAP+1);
        conline(t, n++!=0);
        s += WORDWRAP;
    };
    conline(s, n!=0);
	sprintf_sdv(sf, s);
	s = sf;
	int n = 0;
	while (strlen(s) > WORDWRAP) // cut strings to fit on screen
	{
		string t;
		strn0cpy(t, s, WORDWRAP + 1);
		conline(t, n++ != 0);
		s += WORDWRAP;
	};
	conline(s, n != 0);
};

void
void renderconsole()                                // render buffer taking into account time & scrolling
renderconsole() // render buffer taking into account time & scrolling
{
    int nd = 0;
    char *refs[ndraw];
    loopv(conlines) if(conskip ? i>=conskip-1 || i>=conlines.length()-ndraw : lastmillis-conlines[i].outtime<20000)
    {
        refs[nd++] = conlines[i].cref;
        if(nd==ndraw) break;
    };
    loopj(nd)
    {
        draw_text(refs[j], FONTH/3, (FONTH/4*5)*(nd-j-1)+FONTH/3, 2);
    };
	int nd = 0;
	char *refs[ndraw];
	loopv(conlines) if (conskip ? i >= conskip - 1 ||
	                                  i >= conlines.length() - ndraw
	                            : lastmillis - conlines[i].outtime < 20000)
	{
		refs[nd++] = conlines[i].cref;
		if (nd == ndraw)
			break;
	};
	loopj(nd)
	{
		draw_text(refs[j], FONTH / 3,
		    (FONTH / 4 * 5) * (nd - j - 1) + FONTH / 3, 2);
	};
};

// keymap is defined externally in keymap.cfg

struct keym { int code; char *name; char *action; } keyms[256];
int numkm = 0;                                     
struct keym {
	int code;
	char *name;
	char *action;
} keyms[256];
int numkm = 0;

void
void keymap(char *code, char *key, char *action)
keymap(char *code, char *key, char *action)
{
    keyms[numkm].code = atoi(code);
    keyms[numkm].name = newstring(key);
    keyms[numkm++].action = newstringbuf(action);
	keyms[numkm].code = atoi(code);
	keyms[numkm].name = newstring(key);
	keyms[numkm++].action = newstringbuf(action);
};

COMMAND(keymap, ARG_3STR);

void
void bindkey(char *key, char *action)
bindkey(char *key, char *action)
{
    for(char *x = key; *x; x++) *x = toupper(*x);
    loopi(numkm) if(strcmp(keyms[i].name, key)==0)
    {
        strcpy_s(keyms[i].action, action);
        return;
    };
    conoutf("unknown key \"%s\"", key);   
	for (char *x = key; *x; x++)
		*x = toupper(*x);
	loopi(numkm) if (strcmp(keyms[i].name, key) == 0)
	{
		strcpy_s(keyms[i].action, action);
		return;
	};
	conoutf("unknown key \"%s\"", key);
};

COMMANDN(bind, bindkey, ARG_2STR);

void
void saycommand(char *init)                         // turns input to the command line on or off
saycommand(char *init) // turns input to the command line on or off
{
    SDL_EnableUNICODE(saycommandon = (init!=NULL));
    if(!editmode) keyrepeat(saycommandon);
    if(!init) init = "";
    strcpy_s(commandbuf, init);
	SDL_EnableUNICODE(saycommandon = (init != NULL));
	if (!editmode)
		keyrepeat(saycommandon);
	if (!init)
		init = "";
	strcpy_s(commandbuf, init);
};

void
mapmsg(char *s)
{
void mapmsg(char *s) { strn0cpy(hdr.maptitle, s, 128); };
	strn0cpy(hdr.maptitle, s, 128);
};

COMMAND(saycommand, ARG_VARI);
COMMAND(mapmsg, ARG_1STR);

#ifndef _WIN32
#include <X11/Xlib.h>
#include <SDL_syswm.h>
#include <X11/Xlib.h>
#endif

void
void pasteconsole()
pasteconsole()
{
    #ifdef _WIN32
    if(!IsClipboardFormatAvailable(CF_TEXT)) return; 
    if(!OpenClipboard(NULL)) return;
    char *cb = (char *)GlobalLock(GetClipboardData(CF_TEXT));
    strcat_s(commandbuf, cb);
    GlobalUnlock(cb);
    CloseClipboard();
    #else
    SDL_SysWMinfo wminfo;
    SDL_VERSION(&wminfo.version); 
    wminfo.subsystem = SDL_SYSWM_X11;
    if(!SDL_GetWMInfo(&wminfo)) return;
    int cbsize;
    char *cb = XFetchBytes(wminfo.info.x11.display, &cbsize);
    if(!cb || !cbsize) return;
    int commandlen = strlen(commandbuf);
    for(char *cbline = cb, *cbend; commandlen + 1 < _MAXDEFSTR && cbline < &cb[cbsize]; cbline = cbend + 1)
#ifdef _WIN32
	if (!IsClipboardFormatAvailable(CF_TEXT))
		return;
	if (!OpenClipboard(NULL))
		return;
	char *cb = (char *)GlobalLock(GetClipboardData(CF_TEXT));
	strcat_s(commandbuf, cb);
	GlobalUnlock(cb);
	CloseClipboard();
#else
	SDL_SysWMinfo wminfo;
	SDL_VERSION(&wminfo.version);
	wminfo.subsystem = SDL_SYSWM_X11;
	if (!SDL_GetWMInfo(&wminfo))
		return;
	int cbsize;
	char *cb = XFetchBytes(wminfo.info.x11.display, &cbsize);
	if (!cb || !cbsize)
		return;
	int commandlen = strlen(commandbuf);
	for (char *cbline = cb, *cbend;
	     commandlen + 1 < _MAXDEFSTR && cbline < &cb[cbsize];
    {
        cbend = (char *)memchr(cbline, '\0', &cb[cbsize] - cbline);
        if(!cbend) cbend = &cb[cbsize];
        if(commandlen + cbend - cbline + 1 > _MAXDEFSTR) cbend = cbline + _MAXDEFSTR - commandlen - 1;
        memcpy(&commandbuf[commandlen], cbline, cbend - cbline);
        commandlen += cbend - cbline;
        commandbuf[commandlen] = '\n';
        if(commandlen + 1 < _MAXDEFSTR && cbend < &cb[cbsize]) ++commandlen;
        commandbuf[commandlen] = '\0';
    };
    XFree(cb);
    #endif
	     cbline = cbend + 1) {
		cbend = (char *)memchr(cbline, '\0', &cb[cbsize] - cbline);
		if (!cbend)
			cbend = &cb[cbsize];
		if (commandlen + cbend - cbline + 1 > _MAXDEFSTR)
			cbend = cbline + _MAXDEFSTR - commandlen - 1;
		memcpy(&commandbuf[commandlen], cbline, cbend - cbline);
		commandlen += cbend - cbline;
		commandbuf[commandlen] = '\n';
		if (commandlen + 1 < _MAXDEFSTR && cbend < &cb[cbsize])
			++commandlen;
		commandbuf[commandlen] = '\0';
	};
	XFree(cb);
#endif
};

cvector vhistory;
int histpos = 0;

void
void history(int n)
history(int n)
{
    static bool rec = false;
    if(!rec && n>=0 && n<vhistory.length())
	static bool rec = false;
	if (!rec && n >= 0 && n < vhistory.length()) {
    {
        rec = true;
        execute(vhistory[vhistory.length()-n-1]);
        rec = false;
    };
		rec = true;
		execute(vhistory[vhistory.length() - n - 1]);
		rec = false;
	};
};

COMMAND(history, ARG_1INT);

void
void keypress(int code, bool isdown, int cooked)
keypress(int code, bool isdown, int cooked)
{
    if(saycommandon)                                // keystrokes go to commandline
    {
        if(isdown)
	if (saycommandon) // keystrokes go to commandline
	{
		if (isdown) {
        {
            switch(code)
			switch (code) {
            {
                case SDLK_RETURN:
                    break;
			case SDLK_RETURN:
				break;

                case SDLK_BACKSPACE:
                case SDLK_LEFT:
			case SDLK_BACKSPACE:
			case SDLK_LEFT: {
                {
                    for(int i = 0; commandbuf[i]; i++) if(!commandbuf[i+1]) commandbuf[i] = 0;
                    resetcomplete();
                    break;
                };
                    
                case SDLK_UP:
                    if(histpos) strcpy_s(commandbuf, vhistory[--histpos]);
                    break;
                
                case SDLK_DOWN:
                    if(histpos<vhistory.length()) strcpy_s(commandbuf, vhistory[histpos++]);
                    break;
                    
                case SDLK_TAB:
                    complete(commandbuf);
                    break;
				for (int i = 0; commandbuf[i]; i++)
					if (!commandbuf[i + 1])
						commandbuf[i] = 0;
				resetcomplete();
				break;
			};

			case SDLK_UP:
				if (histpos)
					strcpy_s(
					    commandbuf, vhistory[--histpos]);
				break;

			case SDLK_DOWN:
				if (histpos < vhistory.length())
					strcpy_s(
					    commandbuf, vhistory[histpos++]);
				break;

			case SDLK_TAB:
				complete(commandbuf);
				break;

                case SDLK_v:
                    if(SDL_GetModState()&(KMOD_LCTRL|KMOD_RCTRL)) { pasteconsole(); return; };
			case SDLK_v:
				if (SDL_GetModState() &
				    (KMOD_LCTRL | KMOD_RCTRL)) {
					pasteconsole();
					return;
				};

                default:
                    resetcomplete();
                    if(cooked) { char add[] = { cooked, 0 }; strcat_s(commandbuf, add); };
            };
        }
        else
			default:
				resetcomplete();
				if (cooked) {
					char add[] = {cooked, 0};
					strcat_s(commandbuf, add);
				};
			};
		} else {
        {
            if(code==SDLK_RETURN)
			if (code == SDLK_RETURN) {
            {
                if(commandbuf[0])
				if (commandbuf[0]) {
                {
                    if(vhistory.empty() || strcmp(vhistory.last(), commandbuf))
					if (vhistory.empty() ||
					    strcmp(
					        vhistory.last(), commandbuf)) {
                    {
                        vhistory.add(newstring(commandbuf));  // cap this?
                    };
                    histpos = vhistory.length();
                    if(commandbuf[0]=='/') execute(commandbuf, true);
                    else toserver(commandbuf);
                };
                saycommand(NULL);
						vhistory.add(newstring(
						    commandbuf)); // cap this?
					};
					histpos = vhistory.length();
					if (commandbuf[0] == '/')
						execute(commandbuf, true);
					else
						toserver(commandbuf);
				};
				saycommand(NULL);
            }
            else if(code==SDLK_ESCAPE)
			} else if (code == SDLK_ESCAPE) {
            {
                saycommand(NULL);
            };
        };
				saycommand(NULL);
			};
		};
    }
    else if(!menukey(code, isdown))                 // keystrokes go to menu
    {
        loopi(numkm) if(keyms[i].code==code)        // keystrokes go to game, lookup in keymap and execute
        {
            string temp;
            strcpy_s(temp, keyms[i].action);
            execute(temp, isdown); 
            return;
        };
    };
	} else if (!menukey(code, isdown)) // keystrokes go to menu
	{
		loopi(numkm) if (keyms[i].code ==
		                 code) // keystrokes go to game, lookup in
		                       // keymap and execute
		{
			string temp;
			strcpy_s(temp, keyms[i].action);
			execute(temp, isdown);
			return;
		};
	};
};

char *
char *getcurcommand()
getcurcommand()
{
    return saycommandon ? commandbuf : NULL;
	return saycommandon ? commandbuf : NULL;
};

void
void writebinds(FILE *f)
writebinds(FILE *f)
{
    loopi(numkm)
    {
        if(*keyms[i].action) fprintf(f, "bind \"%s\" [%s]\n", keyms[i].name, keyms[i].action);
    };
	loopi(numkm)
	{
		if (*keyms[i].action)
			fprintf(f, "bind \"%s\" [%s]\n", keyms[i].name,
			    keyms[i].action);
	};
};

// one big bad include file for the whole engine... nasty!

#include "tools.h"			
#include "tools.h"

enum                            // block types, order matters!
enum // block types, order matters!
{
    SOLID = 0,                  // entirely solid cube [only specifies wtex]
    CORNER,                     // half full corner of a wall
    FHF,                        // floor heightfield using neighbour vdelta values
    CHF,                        // idem ceiling
    SPACE,                      // entirely empty cube
    SEMISOLID,                  // generated by mipmapping
    MAXTYPE
	SOLID = 0, // entirely solid cube [only specifies wtex]
	CORNER,    // half full corner of a wall
	FHF,       // floor heightfield using neighbour vdelta values
	CHF,       // idem ceiling
	SPACE,     // entirely empty cube
	SEMISOLID, // generated by mipmapping
	MAXTYPE
};
 
struct sqr

struct sqr {
{
    uchar type;                 // one of the above
    char floor, ceil;           // height, in cubes
    uchar wtex, ftex, ctex;     // wall/floor/ceil texture ids
    uchar r, g, b;              // light value at upper left vertex
    uchar vdelta;               // vertex delta, used for heightfield cubes
    char defer;                 // used in mipmapping, when true this cube is not a perfect mip
    char occluded;              // true when occluded
    uchar utex;                 // upper wall tex id
    uchar tag;                  // used by triggers
	uchar type;             // one of the above
	char floor, ceil;       // height, in cubes
	uchar wtex, ftex, ctex; // wall/floor/ceil texture ids
	uchar r, g, b;          // light value at upper left vertex
	uchar vdelta;           // vertex delta, used for heightfield cubes
	char defer; // used in mipmapping, when true this cube is not a perfect
	            // mip
	char occluded; // true when occluded
	uchar utex;    // upper wall tex id
	uchar tag;     // used by triggers
};

enum                            // hardcoded texture numbers
enum // hardcoded texture numbers
{
    DEFAULT_SKY = 0,
    DEFAULT_LIQUID,
    DEFAULT_WALL,
    DEFAULT_FLOOR,
    DEFAULT_CEIL
	DEFAULT_SKY = 0,
	DEFAULT_LIQUID,
	DEFAULT_WALL,
	DEFAULT_FLOOR,
	DEFAULT_CEIL
};

enum                            // static entity types
enum // static entity types
{
    NOTUSED = 0,                // entity slot not in use in map
    LIGHT,                      // lightsource, attr1 = radius, attr2 = intensity
    PLAYERSTART,                // attr1 = angle
    I_SHELLS, I_BULLETS, I_ROCKETS, I_ROUNDS,
    I_HEALTH, I_BOOST,
    I_GREENARMOUR, I_YELLOWARMOUR,
    I_QUAD,
    TELEPORT,                   // attr1 = idx
    TELEDEST,                   // attr1 = angle, attr2 = idx
    MAPMODEL,                   // attr1 = angle, attr2 = idx
    MONSTER,                    // attr1 = angle, attr2 = monstertype
    CARROT,                     // attr1 = tag, attr2 = type
    JUMPPAD,                    // attr1 = zpush, attr2 = ypush, attr3 = xpush
    MAXENTTYPES
	NOTUSED = 0, // entity slot not in use in map
	LIGHT,       // lightsource, attr1 = radius, attr2 = intensity
	PLAYERSTART, // attr1 = angle
	I_SHELLS,
	I_BULLETS,
	I_ROCKETS,
	I_ROUNDS,
	I_HEALTH,
	I_BOOST,
	I_GREENARMOUR,
	I_YELLOWARMOUR,
	I_QUAD,
	TELEPORT, // attr1 = idx
	TELEDEST, // attr1 = angle, attr2 = idx
	MAPMODEL, // attr1 = angle, attr2 = idx
	MONSTER,  // attr1 = angle, attr2 = monstertype
	CARROT,   // attr1 = tag, attr2 = type
	JUMPPAD,  // attr1 = zpush, attr2 = ypush, attr3 = xpush
	MAXENTTYPES
};

struct persistent_entity        // map entity
struct persistent_entity // map entity
{
    short x, y, z;              // cube aligned position
    short attr1;
    uchar type;                 // type is one of the above
    uchar attr2, attr3, attr4;        
	short x, y, z; // cube aligned position
	short attr1;
	uchar type; // type is one of the above
	uchar attr2, attr3, attr4;
};

struct entity : public persistent_entity    
struct entity : public persistent_entity {
{
    bool spawned;               // the only dynamic state of a map entity
	bool spawned; // the only dynamic state of a map entity
};

#define MAPVERSION 5            // bump if map format changes, see worldio.cpp
#define MAPVERSION 5 // bump if map format changes, see worldio.cpp

struct header                   // map file format header
struct header // map file format header
{
    char head[4];               // "CUBE"
    int version;                // any >8bit quantity is a little indian
    int headersize;             // sizeof(header)
    int sfactor;                // in bits
    int numents;
    char maptitle[128];
    uchar texlists[3][256];
    int waterlevel;
    int reserved[15];
	char head[4];   // "CUBE"
	int version;    // any >8bit quantity is a little indian
	int headersize; // sizeof(header)
	int sfactor;    // in bits
	int numents;
	char maptitle[128];
	uchar texlists[3][256];
	int waterlevel;
	int reserved[15];
};

#define SWS(w,x,y,s) (&(w)[(y)*(s)+(x)])
#define SW(w,x,y) SWS(w,x,y,ssize)
#define S(x,y) SW(world,x,y)            // convenient lookup of a lowest mip cube
#define SMALLEST_FACTOR 6               // determines number of mips there can be
#define SWS(w, x, y, s) (&(w)[(y) * (s) + (x)])
#define SW(w, x, y) SWS(w, x, y, ssize)
#define S(x, y) SW(world, x, y) // convenient lookup of a lowest mip cube
#define SMALLEST_FACTOR 6       // determines number of mips there can be
#define DEFAULT_FACTOR 8
#define LARGEST_FACTOR 11               // 10 is already insane
#define SOLID(x) ((x)->type==SOLID)
#define MINBORD 2                       // 2 cubes from the edge of the world are always solid
#define OUTBORD(x,y) ((x)<MINBORD || (y)<MINBORD || (x)>=ssize-MINBORD || (y)>=ssize-MINBORD)
#define LARGEST_FACTOR 11 // 10 is already insane
#define SOLID(x) ((x)->type == SOLID)
#define MINBORD 2 // 2 cubes from the edge of the world are always solid
#define OUTBORD(x, y)                                                          \
	((x) < MINBORD || (y) < MINBORD || (x) >= ssize - MINBORD ||           \
	    (y) >= ssize - MINBORD)

struct vec { float x, y, z; };
struct block { int x, y, xs, ys; };
struct mapmodelinfo { int rad, h, zoff, snap; char *name; };
struct vec {
	float x, y, z;
};
struct block {
	int x, y, xs, ys;
};
struct mapmodelinfo {
	int rad, h, zoff, snap;
	char *name;
};

enum {
	GUN_FIST = 0,
	GUN_SG,
	GUN_CG,
	GUN_RL,
	GUN_RIFLE,
	GUN_FIREBALL,
	GUN_ICEBALL,
enum { GUN_FIST = 0, GUN_SG, GUN_CG, GUN_RL, GUN_RIFLE, GUN_FIREBALL, GUN_ICEBALL, GUN_SLIMEBALL, GUN_BITE, NUMGUNS };
	GUN_SLIMEBALL,
	GUN_BITE,
	NUMGUNS
};

struct dynent                           // players & monsters
struct dynent // players & monsters
{
    vec o, vel;                         // origin, velocity
    float yaw, pitch, roll;             // used as vec in one place
    float maxspeed;                     // cubes per second, 24 for player
    bool outsidemap;                    // from his eyes
    bool inwater;
    bool onfloor, jumpnext;
    int move, strafe;
    bool k_left, k_right, k_up, k_down; // see input code  
    int timeinair;                      // used for fake gravity
    float radius, eyeheight, aboveeye;  // bounding box size
    int lastupdate, plag, ping;
    int lifesequence;                   // sequence id for each respawn, used in damage test
    int state;                          // one of CS_* below
    int frags;
    int health, armour, armourtype, quadmillis;
    int gunselect, gunwait;
    int lastaction, lastattackgun, lastmove;
    bool attacking;
    int ammo[NUMGUNS];
    int monsterstate;                   // one of M_* below, M_NONE means human
    int mtype;                          // see monster.cpp
    dynent *enemy;                      // monster wants to kill this entity
    float targetyaw;                    // monster wants to look in this direction
    bool blocked, moving;               // used by physics to signal ai
    int trigger;                        // millis at which transition to another monsterstate takes place
    vec attacktarget;                   // delayed attacks
    int anger;                          // how many times already hit by fellow monster
    string name, team;
	vec o, vel;             // origin, velocity
	float yaw, pitch, roll; // used as vec in one place
	float maxspeed;         // cubes per second, 24 for player
	bool outsidemap;        // from his eyes
	bool inwater;
	bool onfloor, jumpnext;
	int move, strafe;
	bool k_left, k_right, k_up, k_down; // see input code
	int timeinair;                      // used for fake gravity
	float radius, eyeheight, aboveeye;  // bounding box size
	int lastupdate, plag, ping;
	int lifesequence; // sequence id for each respawn, used in damage test
	int state;        // one of CS_* below
	int frags;
	int health, armour, armourtype, quadmillis;
	int gunselect, gunwait;
	int lastaction, lastattackgun, lastmove;
	bool attacking;
	int ammo[NUMGUNS];
	int monsterstate;     // one of M_* below, M_NONE means human
	int mtype;            // see monster.cpp
	dynent *enemy;        // monster wants to kill this entity
	float targetyaw;      // monster wants to look in this direction
	bool blocked, moving; // used by physics to signal ai
	int trigger; // millis at which transition to another monsterstate takes
	             // place
	vec attacktarget; // delayed attacks
	int anger;        // how many times already hit by fellow monster
	string name, team;
};

#define SAVEGAMEVERSION                                                        \
#define SAVEGAMEVERSION 4               // bump if dynent/netprotocol changes or any other savegame/demo data
	4 // bump if dynent/netprotocol changes or any other savegame/demo data

enum { A_BLUE, A_GREEN, A_YELLOW };     // armour types... take 20/40/60 % off
enum { M_NONE = 0, M_SEARCH, M_HOME, M_ATTACKING, M_PAIN, M_SLEEP, M_AIMING };  // monster states
enum { A_BLUE, A_GREEN, A_YELLOW }; // armour types... take 20/40/60 % off
enum {
	M_NONE = 0,
	M_SEARCH,
	M_HOME,
	M_ATTACKING,
	M_PAIN,
	M_SLEEP,
	M_AIMING
}; // monster states

#define MAXCLIENTS 256                  // in a multiplayer game, can be arbitrarily changed
#define MAXTRANS 5000                   // max amount of data to swallow in 1 go
#define MAXCLIENTS 256 // in a multiplayer game, can be arbitrarily changed
#define MAXTRANS 5000  // max amount of data to swallow in 1 go
#define CUBE_SERVER_PORT 28765
#define CUBE_SERVINFO_PORT 28766
#define PROTOCOL_VERSION 122            // bump when protocol changes
#define PROTOCOL_VERSION 122 // bump when protocol changes

// network messages codes, c2s, c2c, s2c
enum
enum {
{
    SV_INITS2C, SV_INITC2S, SV_POS, SV_TEXT, SV_SOUND, SV_CDIS,
    SV_DIED, SV_DAMAGE, SV_SHOT, SV_FRAGS,
    SV_TIMEUP, SV_EDITENT, SV_MAPRELOAD, SV_ITEMACC,
    SV_MAPCHANGE, SV_ITEMSPAWN, SV_ITEMPICKUP, SV_DENIED,
    SV_PING, SV_PONG, SV_CLIENTPING, SV_GAMEMODE,
    SV_EDITH, SV_EDITT, SV_EDITS, SV_EDITD, SV_EDITE,
    SV_SENDMAP, SV_RECVMAP, SV_SERVMSG, SV_ITEMLIST,
    SV_EXT,
};     
	SV_INITS2C,
	SV_INITC2S,
	SV_POS,
	SV_TEXT,
	SV_SOUND,
	SV_CDIS,
	SV_DIED,
	SV_DAMAGE,
	SV_SHOT,
	SV_FRAGS,
	SV_TIMEUP,
	SV_EDITENT,
	SV_MAPRELOAD,
	SV_ITEMACC,
	SV_MAPCHANGE,
	SV_ITEMSPAWN,
	SV_ITEMPICKUP,
	SV_DENIED,
	SV_PING,
	SV_PONG,
	SV_CLIENTPING,
	SV_GAMEMODE,
	SV_EDITH,
	SV_EDITT,
	SV_EDITS,
	SV_EDITD,
	SV_EDITE,
	SV_SENDMAP,
	SV_RECVMAP,
	SV_SERVMSG,
	SV_ITEMLIST,
	SV_EXT,
};

enum { CS_ALIVE = 0, CS_DEAD, CS_LAGGED, CS_EDITING };

// hardcoded sounds, defined in sounds.cfg
enum
enum {
{
    S_JUMP = 0, S_LAND, S_RIFLE, S_PUNCH1, S_SG, S_CG,
    S_RLFIRE, S_RLHIT, S_WEAPLOAD, S_ITEMAMMO, S_ITEMHEALTH,
    S_ITEMARMOUR, S_ITEMPUP, S_ITEMSPAWN, S_TELEPORT, S_NOAMMO, S_PUPOUT,
    S_PAIN1, S_PAIN2, S_PAIN3, S_PAIN4, S_PAIN5, S_PAIN6,
    S_DIE1, S_DIE2,
    S_FLAUNCH, S_FEXPLODE,
    S_SPLASH1, S_SPLASH2,
    S_GRUNT1, S_GRUNT2, S_RUMBLE,
    S_PAINO,
    S_PAINR, S_DEATHR, 
    S_PAINE, S_DEATHE, 
    S_PAINS, S_DEATHS,
    S_PAINB, S_DEATHB, 
    S_PAINP, S_PIGGR2, 
    S_PAINH, S_DEATHH,
    S_PAIND, S_DEATHD,
    S_PIGR1, S_ICEBALL, S_SLIMEBALL,
    S_JUMPPAD,
	S_JUMP = 0,
	S_LAND,
	S_RIFLE,
	S_PUNCH1,
	S_SG,
	S_CG,
	S_RLFIRE,
	S_RLHIT,
	S_WEAPLOAD,
	S_ITEMAMMO,
	S_ITEMHEALTH,
	S_ITEMARMOUR,
	S_ITEMPUP,
	S_ITEMSPAWN,
	S_TELEPORT,
	S_NOAMMO,
	S_PUPOUT,
	S_PAIN1,
	S_PAIN2,
	S_PAIN3,
	S_PAIN4,
	S_PAIN5,
	S_PAIN6,
	S_DIE1,
	S_DIE2,
	S_FLAUNCH,
	S_FEXPLODE,
	S_SPLASH1,
	S_SPLASH2,
	S_GRUNT1,
	S_GRUNT2,
	S_RUMBLE,
	S_PAINO,
	S_PAINR,
	S_DEATHR,
	S_PAINE,
	S_DEATHE,
	S_PAINS,
	S_DEATHS,
	S_PAINB,
	S_DEATHB,
	S_PAINP,
	S_PIGGR2,
	S_PAINH,
	S_DEATHH,
	S_PAIND,
	S_DEATHD,
	S_PIGR1,
	S_ICEBALL,
	S_SLIMEBALL,
	S_JUMPPAD,
};

// vertex array format

struct vertex { float u, v, x, y, z; uchar r, g, b, a; }; 
struct vertex {
	float u, v, x, y, z;
	uchar r, g, b, a;
};

typedef vector<dynent *> dvector;
typedef vector<char *> cvector;
typedef vector<int> ivector;

// globals ooh naughty

extern sqr *world,
extern sqr *world, *wmip[];             // map data, the mips are sequential 2D arrays in memory
extern header hdr;                      // current map header
extern int sfactor, ssize;              // ssize = 2^sfactor
extern int cubicsize, mipsize;          // cubicsize = ssize^2
extern dynent *player1;                 // special client ent that receives input and acts as camera
extern dvector players;                 // all the other clients (in multiplayer)
    *wmip[];       // map data, the mips are sequential 2D arrays in memory
extern header hdr; // current map header
extern int sfactor, ssize;     // ssize = 2^sfactor
extern int cubicsize, mipsize; // cubicsize = ssize^2
extern dynent
    *player1; // special client ent that receives input and acts as camera
extern dvector players; // all the other clients (in multiplayer)
extern bool editmode;
extern vector<entity> ents;             // map entities
extern vec worldpos;                    // current target of the crosshair in the world
extern int lastmillis;                  // last time
extern int curtime;                     // current frame time
extern vector<entity> ents; // map entities
extern vec worldpos;        // current target of the crosshair in the world
extern int lastmillis;      // last time
extern int curtime;         // current frame time
extern int gamemode, nextmode;
extern int xtraverts;
extern bool demoplayback;


#define DMF 16.0f 
#define DAF 1.0f 
#define DMF 16.0f
#define DAF 1.0f
#define DVF 100.0f

#define VIRTW 2400                      // virtual screen size for text & HUD
#define VIRTW 2400 // virtual screen size for text & HUD
#define VIRTH 1800
#define FONTH 64
#define PIXELTAB (VIRTW/12)
#define PIXELTAB (VIRTW / 12)

#define PI  (3.1415927f)
#define PI2 (2*PI)
#define PI (3.1415927f)
#define PI2 (2 * PI)

// simplistic vector ops
#define dotprod(u,v) ((u).x * (v).x + (u).y * (v).y + (u).z * (v).z)
#define vmul(u,f)    { (u).x *= (f); (u).y *= (f); (u).z *= (f); }
#define vdiv(u,f)    { (u).x /= (f); (u).y /= (f); (u).z /= (f); }
#define vadd(u,v)    { (u).x += (v).x; (u).y += (v).y; (u).z += (v).z; };
#define vsub(u,v)    { (u).x -= (v).x; (u).y -= (v).y; (u).z -= (v).z; };
#define vdist(d,v,e,s) vec v = s; vsub(v,e); float d = (float)sqrt(dotprod(v,v));
#define vreject(v,u,max) ((v).x>(u).x+(max) || (v).x<(u).x-(max) || (v).y>(u).y+(max) || (v).y<(u).y-(max))
#define vlinterp(v,f,u,g) { (v).x = (v).x*f+(u).x*g; (v).y = (v).y*f+(u).y*g; (v).z = (v).z*f+(u).z*g; }

#define sgetstr() { char *t = text; do { *t = getint(p); } while(*t++); }   // used by networking
#define dotprod(u, v) ((u).x * (v).x + (u).y * (v).y + (u).z * (v).z)
#define vmul(u, f)                                                             \
	{                                                                      \
		(u).x *= (f);                                                  \
		(u).y *= (f);                                                  \
		(u).z *= (f);                                                  \
	}
#define vdiv(u, f)                                                             \
	{                                                                      \
		(u).x /= (f);                                                  \
		(u).y /= (f);                                                  \
		(u).z /= (f);                                                  \
	}
#define vadd(u, v)                                                             \
	{                                                                      \
		(u).x += (v).x;                                                \
		(u).y += (v).y;                                                \
		(u).z += (v).z;                                                \
	};
#define vsub(u, v)                                                             \
	{                                                                      \
		(u).x -= (v).x;                                                \
		(u).y -= (v).y;                                                \
		(u).z -= (v).z;                                                \
	};
#define vdist(d, v, e, s)                                                      \
	vec v = s;                                                             \
	vsub(v, e);                                                            \
	float d = (float)sqrt(dotprod(v, v));
#define vreject(v, u, max)                                                     \
	((v).x > (u).x + (max) || (v).x < (u).x - (max) ||                     \
	    (v).y > (u).y + (max) || (v).y < (u).y - (max))
#define vlinterp(v, f, u, g)                                                   \
	{                                                                      \
		(v).x = (v).x * f + (u).x * g;                                 \
		(v).y = (v).y * f + (u).y * g;                                 \
		(v).z = (v).z * f + (u).z * g;                                 \
	}

#define sgetstr()                                                              \
	{                                                                      \
		char *t = text;                                                \
		do {                                                           \
			*t = getint(p);                                        \
		} while (*t++);                                                \
	} // used by networking

#define m_noitems     (gamemode>=4)
#define m_noitemsrail (gamemode<=5)
#define m_arena       (gamemode>=8)
#define m_tarena      (gamemode>=10)
#define m_teammode    (gamemode&1 && gamemode>2)
#define m_sp          (gamemode<0)
#define m_dmsp        (gamemode==-1)
#define m_classicsp   (gamemode==-2)
#define isteam(a,b)   (m_teammode && strcmp(a, b)==0)
#define m_noitems (gamemode >= 4)
#define m_noitemsrail (gamemode <= 5)
#define m_arena (gamemode >= 8)
#define m_tarena (gamemode >= 10)
#define m_teammode (gamemode & 1 && gamemode > 2)
#define m_sp (gamemode < 0)
#define m_dmsp (gamemode == -1)
#define m_classicsp (gamemode == -2)
#define isteam(a, b) (m_teammode && strcmp(a, b) == 0)

enum    // function signatures for script functions, see command.cpp
enum // function signatures for script functions, see command.cpp
{
    ARG_1INT, ARG_2INT, ARG_3INT, ARG_4INT,
    ARG_NONE,
    ARG_1STR, ARG_2STR, ARG_3STR, ARG_5STR,
    ARG_DOWN, ARG_DWN1,
    ARG_1EXP, ARG_2EXP,
    ARG_1EST, ARG_2EST,
    ARG_VARI
}; 
	ARG_1INT,
	ARG_2INT,
	ARG_3INT,
	ARG_4INT,
	ARG_NONE,
	ARG_1STR,
	ARG_2STR,
	ARG_3STR,
	ARG_5STR,
	ARG_DOWN,
	ARG_DWN1,
	ARG_1EXP,
	ARG_2EXP,
	ARG_1EST,
	ARG_2EST,
	ARG_VARI
};

// nasty macros for registering script functions, abuses globals to avoid excessive infrastructure
#define COMMANDN(name, fun, nargs) static bool __dummy_##fun = addcommand(#name, (void (*)())fun, nargs)
// nasty macros for registering script functions, abuses globals to avoid
// excessive infrastructure
#define COMMANDN(name, fun, nargs)                                             \
	static bool __dummy_##fun = addcommand(#name, (void (*)())fun, nargs)
#define COMMAND(name, nargs) COMMANDN(name, name, nargs)
#define VARP(name, min, cur, max)                                              \
#define VARP(name, min, cur, max) int name = variable(#name, min, cur, max, &name, NULL, true)
#define VAR(name, min, cur, max)  int name = variable(#name, min, cur, max, &name, NULL, false)
#define VARF(name, min, cur, max, body)  void var_##name(); static int name = variable(#name, min, cur, max, &name, var_##name, false); void var_##name() { body; }
#define VARFP(name, min, cur, max, body) void var_##name(); static int name = variable(#name, min, cur, max, &name, var_##name, true); void var_##name() { body; }
	int name = variable(#name, min, cur, max, &name, NULL, true)
#define VAR(name, min, cur, max)                                               \
	int name = variable(#name, min, cur, max, &name, NULL, false)
#define VARF(name, min, cur, max, body)                                        \
	void var_##name();                                                     \
	static int name =                                                      \
	    variable(#name, min, cur, max, &name, var_##name, false);          \
	void var_##name() { body; }
#define VARFP(name, min, cur, max, body)                                       \
	void var_##name();                                                     \
	static int name =                                                      \
	    variable(#name, min, cur, max, &name, var_##name, true);           \
	void var_##name() { body; }

#define ATOI(s) strtol(s, NULL, 0)		// supports hexadecimal numbers
#define ATOI(s) strtol(s, NULL, 0) // supports hexadecimal numbers

#ifdef WIN32
	#define WIN32_LEAN_AND_MEAN
	#include "windows.h"
	#define _WINDOWS
	#define ZLIB_DLL
#define WIN32_LEAN_AND_MEAN
#include "windows.h"
#define _WINDOWS
#define ZLIB_DLL
#else
	#include <dlfcn.h>
#include <dlfcn.h>
#endif

#include <time.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glext.h>
#include <GL/glext.h>
#include <GL/glu.h>

#include <SDL.h>
#include <SDL_image.h>

#include <enet/enet.h>

#include <zlib.h>

#include "protos.h"				// external function decls
#include "protos.h" // external function decls

// editing.cpp: most map editing commands go here, entity editing commands are in world.cpp
// editing.cpp: most map editing commands go here, entity editing commands are
// in world.cpp

#include "cube.h"

bool editmode = false; 
bool editmode = false;

// the current selection, used by almost all editing commands
// invariant: all code assumes that these are kept inside MINBORD distance of the edge of the map
// invariant: all code assumes that these are kept inside MINBORD distance of
// the edge of the map

block sel =
block sel = {
{
    variable("selx",  0, 0, 4096, &sel.x,  NULL, false),
    variable("sely",  0, 0, 4096, &sel.y,  NULL, false),
    variable("selx", 0, 0, 4096, &sel.x, NULL, false),
    variable("sely", 0, 0, 4096, &sel.y, NULL, false),
    variable("selxs", 0, 0, 4096, &sel.xs, NULL, false),
    variable("selys", 0, 0, 4096, &sel.ys, NULL, false),
};

int selh = 0;
bool selset = false;

#define loopselxy(b) { makeundo(); loop(x,sel.xs) loop(y,sel.ys) { sqr *s = S(sel.x+x, sel.y+y); b; }; remip(sel); }
#define loopselxy(b)                                                           \
	{                                                                      \
		makeundo();                                                    \
		loop(x, sel.xs) loop(y, sel.ys)                                \
		{                                                              \
			sqr *s = S(sel.x + x, sel.y + y);                      \
			b;                                                     \
		};                                                             \
		remip(sel);                                                    \
	}

int cx, cy, ch;

int curedittex[] = { -1, -1, -1 };
int curedittex[] = {-1, -1, -1};

bool dragging = false;
int lastx, lasty, lasth;

int lasttype = 0, lasttex = 0;
sqr rtex;

VAR(editing,0,0,1);
VAR(editing, 0, 0, 1);

void
void toggleedit()
toggleedit()
{
	if (player1->state == CS_DEAD)
    if(player1->state==CS_DEAD) return;                 // do not allow dead players to edit to avoid state confusion
    if(!editmode && !allowedittoggle()) return;         // not in most multiplayer modes
    if(!(editmode = !editmode))
		return; // do not allow dead players to edit to avoid state
		        // confusion
	if (!editmode && !allowedittoggle())
		return; // not in most multiplayer modes
	if (!(editmode = !editmode)) {
    {
        settagareas();                                  // reset triggers to allow quick playtesting
        entinmap(player1);                              // find spawn closest to current floating pos
		settagareas();     // reset triggers to allow quick playtesting
		entinmap(player1); // find spawn closest to current floating pos
    }
    else
	} else {
    {
        resettagareas();                                // clear trigger areas to allow them to be edited
        player1->health = 100;
        if(m_classicsp) monsterclear();                 // all monsters back at their spawns for editing
        projreset();
    };
    keyrepeat(editmode);
    selset = false;
    editing = editmode;
		resettagareas(); // clear trigger areas to allow them to be
		                 // edited
		player1->health = 100;
		if (m_classicsp)
			monsterclear(); // all monsters back at their spawns for
			                // editing
		projreset();
	};
	keyrepeat(editmode);
	selset = false;
	editing = editmode;
};

COMMANDN(edittoggle, toggleedit, ARG_NONE);

void
void correctsel()                                       // ensures above invariant
correctsel() // ensures above invariant
{
    selset = !OUTBORD(sel.x, sel.y);
    int bsize = ssize-MINBORD;
    if(sel.xs+sel.x>bsize) sel.xs = bsize-sel.x;
    if(sel.ys+sel.y>bsize) sel.ys = bsize-sel.y;
    if(sel.xs<=0 || sel.ys<=0) selset = false;
	selset = !OUTBORD(sel.x, sel.y);
	int bsize = ssize - MINBORD;
	if (sel.xs + sel.x > bsize)
		sel.xs = bsize - sel.x;
	if (sel.ys + sel.y > bsize)
		sel.ys = bsize - sel.y;
	if (sel.xs <= 0 || sel.ys <= 0)
		selset = false;
};

bool
bool noteditmode()
noteditmode()
{
    correctsel();
    if(!editmode) conoutf("this function is only allowed in edit mode");
    return !editmode;
	correctsel();
	if (!editmode)
		conoutf("this function is only allowed in edit mode");
	return !editmode;
};

bool
bool noselection()
noselection()
{
	if (!selset)
    if(!selset) conoutf("no selection");
    return !selset;
		conoutf("no selection");
	return !selset;
};

#define EDITSEL                                                                \
#define EDITSEL   if(noteditmode() || noselection()) return;
#define EDITSELMP if(noteditmode() || noselection() || multiplayer()) return;
#define EDITMP    if(noteditmode() || multiplayer()) return;
	if (noteditmode() || noselection())                                    \
		return;
#define EDITSELMP                                                              \
	if (noteditmode() || noselection() || multiplayer())                   \
		return;
#define EDITMP                                                                 \
	if (noteditmode() || multiplayer())                                    \
		return;

void
void selectpos(int x, int y, int xs, int ys)
selectpos(int x, int y, int xs, int ys)
{
    block s = { x, y, xs, ys };
    sel = s;
    selh = 0;
    correctsel();
	block s = {x, y, xs, ys};
	sel = s;
	selh = 0;
	correctsel();
};

void
void makesel()
makesel()
{
    block s = { min(lastx,cx), min(lasty,cy), abs(lastx-cx)+1, abs(lasty-cy)+1 };
    sel = s;
    selh = max(lasth,ch);
    correctsel();
    if(selset) rtex = *S(sel.x, sel.y);
	block s = {min(lastx, cx), min(lasty, cy), abs(lastx - cx) + 1,
	    abs(lasty - cy) + 1};
	sel = s;
	selh = max(lasth, ch);
	correctsel();
	if (selset)
		rtex = *S(sel.x, sel.y);
};

VAR(flrceil,0,0,2);
VAR(flrceil, 0, 0, 2);

float
sheight(
float sheight(sqr *s, sqr *t, float z)                  // finds out z height when cursor points at wall
    sqr *s, sqr *t, float z) // finds out z height when cursor points at wall
{
    return !flrceil //z-s->floor<s->ceil-z
        ? (s->type==FHF ? s->floor-t->vdelta/4.0f : (float)s->floor)
        : (s->type==CHF ? s->ceil+t->vdelta/4.0f : (float)s->ceil);
	return !flrceil // z-s->floor<s->ceil-z
	           ? (s->type == FHF ? s->floor - t->vdelta / 4.0f
	                             : (float)s->floor)
	           : (s->type == CHF ? s->ceil + t->vdelta / 4.0f
	                             : (float)s->ceil);
};

void
void cursorupdate()                                     // called every frame from hud
cursorupdate() // called every frame from hud
{
    flrceil = ((int)(player1->pitch>=0))*2;
	flrceil = ((int)(player1->pitch >= 0)) * 2;

	volatile float x =
    volatile float x = worldpos.x;                      // volatile needed to prevent msvc7 optimizer bug?
    volatile float y = worldpos.y;
    volatile float z = worldpos.z;
    
    cx = (int)x;
    cy = (int)y;
	    worldpos.x; // volatile needed to prevent msvc7 optimizer bug?
	volatile float y = worldpos.y;
	volatile float z = worldpos.z;

	cx = (int)x;
	cy = (int)y;

    if(OUTBORD(cx, cy)) return;
    sqr *s = S(cx,cy);
    
    if(fabs(sheight(s,s,z)-z)>1)                        // selected wall
    {
        x += x>player1->o.x ? 0.5f : -0.5f;             // find right wall cube
        y += y>player1->o.y ? 0.5f : -0.5f;
	if (OUTBORD(cx, cy))
		return;
	sqr *s = S(cx, cy);

	if (fabs(sheight(s, s, z) - z) > 1) // selected wall
	{
		x += x > player1->o.x ? 0.5f : -0.5f; // find right wall cube
		y += y > player1->o.y ? 0.5f : -0.5f;

        cx = (int)x;
        cy = (int)y;
		cx = (int)x;
		cy = (int)y;

        if(OUTBORD(cx, cy)) return;
    };
        
    if(dragging) makesel();
		if (OUTBORD(cx, cy))
			return;
	};

	if (dragging)
		makesel();

    const int GRIDSIZE = 5;
    const float GRIDW = 0.5f;
    const float GRID8 = 2.0f;
    const float GRIDS = 2.0f;
    const int GRIDM = 0x7;
    
    // render editing grid
	const int GRIDSIZE = 5;
	const float GRIDW = 0.5f;
	const float GRID8 = 2.0f;
	const float GRIDS = 2.0f;
	const int GRIDM = 0x7;

	// render editing grid

    for(int ix = cx-GRIDSIZE; ix<=cx+GRIDSIZE; ix++) for(int iy = cy-GRIDSIZE; iy<=cy+GRIDSIZE; iy++)
	for (int ix = cx - GRIDSIZE; ix <= cx + GRIDSIZE; ix++)
    {
        if(OUTBORD(ix, iy)) continue;
        sqr *s = S(ix,iy);
        if(SOLID(s)) continue;
        float h1 = sheight(s, s, z);
        float h2 = sheight(s, SWS(s,1,0,ssize), z);
        float h3 = sheight(s, SWS(s,1,1,ssize), z);
        float h4 = sheight(s, SWS(s,0,1,ssize), z);
        if(s->tag) linestyle(GRIDW, 0xFF, 0x40, 0x40);
        else if(s->type==FHF || s->type==CHF) linestyle(GRIDW, 0x80, 0xFF, 0x80);
        else linestyle(GRIDW, 0x80, 0x80, 0x80);
        block b = { ix, iy, 1, 1 };
        box(b, h1, h2, h3, h4);
        linestyle(GRID8, 0x40, 0x40, 0xFF);
        if(!(ix&GRIDM))   line(ix,   iy,   h1, ix,   iy+1, h4);
        if(!(ix+1&GRIDM)) line(ix+1, iy,   h2, ix+1, iy+1, h3);
        if(!(iy&GRIDM))   line(ix,   iy,   h1, ix+1, iy,   h2);
        if(!(iy+1&GRIDM)) line(ix,   iy+1, h4, ix+1, iy+1, h3);
    };
		for (int iy = cy - GRIDSIZE; iy <= cy + GRIDSIZE; iy++) {
			if (OUTBORD(ix, iy))
				continue;
			sqr *s = S(ix, iy);
			if (SOLID(s))
				continue;
			float h1 = sheight(s, s, z);
			float h2 = sheight(s, SWS(s, 1, 0, ssize), z);
			float h3 = sheight(s, SWS(s, 1, 1, ssize), z);
			float h4 = sheight(s, SWS(s, 0, 1, ssize), z);
			if (s->tag)
				linestyle(GRIDW, 0xFF, 0x40, 0x40);
			else if (s->type == FHF || s->type == CHF)
				linestyle(GRIDW, 0x80, 0xFF, 0x80);
			else
				linestyle(GRIDW, 0x80, 0x80, 0x80);
			block b = {ix, iy, 1, 1};
			box(b, h1, h2, h3, h4);
			linestyle(GRID8, 0x40, 0x40, 0xFF);
			if (!(ix & GRIDM))
				line(ix, iy, h1, ix, iy + 1, h4);
			if (!(ix + 1 & GRIDM))
				line(ix + 1, iy, h2, ix + 1, iy + 1, h3);
			if (!(iy & GRIDM))
				line(ix, iy, h1, ix + 1, iy, h2);
			if (!(iy + 1 & GRIDM))
				line(ix, iy + 1, h4, ix + 1, iy + 1, h3);
		};

    if(!SOLID(s))
	if (!SOLID(s)) {
    {
        float ih = sheight(s, s, z);
        linestyle(GRIDS, 0xFF, 0xFF, 0xFF);
        block b = { cx, cy, 1, 1 };
        box(b, ih, sheight(s, SWS(s,1,0,ssize), z), sheight(s, SWS(s,1,1,ssize), z), sheight(s, SWS(s,0,1,ssize), z));
        linestyle(GRIDS, 0xFF, 0x00, 0x00);
        dot(cx, cy, ih);
        ch = (int)ih;
    };
		float ih = sheight(s, s, z);
		linestyle(GRIDS, 0xFF, 0xFF, 0xFF);
		block b = {cx, cy, 1, 1};
		box(b, ih, sheight(s, SWS(s, 1, 0, ssize), z),
		    sheight(s, SWS(s, 1, 1, ssize), z),
		    sheight(s, SWS(s, 0, 1, ssize), z));
		linestyle(GRIDS, 0xFF, 0x00, 0x00);
		dot(cx, cy, ih);
		ch = (int)ih;
	};

    if(selset)
	if (selset) {
    {
        linestyle(GRIDS, 0xFF, 0x40, 0x40);
        box(sel, (float)selh, (float)selh, (float)selh, (float)selh);
    };
		linestyle(GRIDS, 0xFF, 0x40, 0x40);
		box(sel, (float)selh, (float)selh, (float)selh, (float)selh);
	};
};

vector<block *> undos;                                  // unlimited undo
VARP(undomegs, 0, 1, 10);                                // bounded by n megs
vector<block *> undos;    // unlimited undo
VARP(undomegs, 0, 1, 10); // bounded by n megs

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

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

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

block *copybuf = NULL;

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

void
void paste()
paste()
{
    EDITMP;
    if(!copybuf) { conoutf("nothing to paste"); return; };
    sel.xs = copybuf->xs;
    sel.ys = copybuf->ys;
    correctsel();
    if(!selset || sel.xs!=copybuf->xs || sel.ys!=copybuf->ys) { conoutf("incorrect selection"); return; };
    makeundo();
    copybuf->x = sel.x;
    copybuf->y = sel.y;
    blockpaste(*copybuf);
	EDITMP;
	if (!copybuf) {
		conoutf("nothing to paste");
		return;
	};
	sel.xs = copybuf->xs;
	sel.ys = copybuf->ys;
	correctsel();
	if (!selset || sel.xs != copybuf->xs || sel.ys != copybuf->ys) {
		conoutf("incorrect selection");
		return;
	};
	makeundo();
	copybuf->x = sel.x;
	copybuf->y = sel.y;
	blockpaste(*copybuf);
};

void
void tofronttex()                                       // maintain most recently used of the texture lists when applying texture
tofronttex() // maintain most recently used of the texture lists when applying
             // texture
{
    loopi(3)
    {
        int c = curedittex[i];
        if(c>=0)
	loopi(3)
	{
		int c = curedittex[i];
		if (c >= 0) {
        {
            uchar *p = hdr.texlists[i];
            int t = p[c];
            for(int a = c-1; a>=0; a--) p[a+1] = p[a];
            p[0] = t;
            curedittex[i] = -1;
        };
    };
			uchar *p = hdr.texlists[i];
			int t = p[c];
			for (int a = c - 1; a >= 0; a--)
				p[a + 1] = p[a];
			p[0] = t;
			curedittex[i] = -1;
		};
	};
};

void
void editdrag(bool isdown)
editdrag(bool isdown)
{
    if(dragging = isdown)
	if (dragging = isdown) {
    {
        lastx = cx;
        lasty = cy;
        lasth = ch;
        selset = false;
        tofronttex();
    };
    makesel();
		lastx = cx;
		lasty = cy;
		lasth = ch;
		selset = false;
		tofronttex();
	};
	makesel();
};

// the core editing function. all the *xy functions perform the core operations
// and are also called directly from the network, the function below it is strictly
// triggered locally. They all have very similar structure.
// and are also called directly from the network, the function below it is
// strictly triggered locally. They all have very similar structure.

void
void editheightxy(bool isfloor, int amount, block &sel)
editheightxy(bool isfloor, int amount, block &sel)
{
    loopselxy(if(isfloor)
	loopselxy(
    {
        s->floor += amount;
        if(s->floor>=s->ceil) s->floor = s->ceil-1;
	    if (isfloor) {
		    s->floor += amount;
		    if (s->floor >= s->ceil)
			    s->floor = s->ceil - 1;
    }
    else
	    } else {
    {
        s->ceil += amount;
        if(s->ceil<=s->floor) s->ceil = s->floor+1;
    });
		    s->ceil += amount;
		    if (s->ceil <= s->floor)
			    s->ceil = s->floor + 1;
	    });
};

void
void editheight(int flr, int amount)
editheight(int flr, int amount)
{
    EDITSEL;
    bool isfloor = flr==0;
    editheightxy(isfloor, amount, sel);
    addmsg(1, 7, SV_EDITH, sel.x, sel.y, sel.xs, sel.ys, isfloor, amount);
	EDITSEL;
	bool isfloor = flr == 0;
	editheightxy(isfloor, amount, sel);
	addmsg(1, 7, SV_EDITH, sel.x, sel.y, sel.xs, sel.ys, isfloor, amount);
};

COMMAND(editheight, ARG_2INT);

void
void edittexxy(int type, int t, block &sel)            
edittexxy(int type, int t, block &sel)
{
    loopselxy(switch(type)
	loopselxy(switch (type) {
    {
        case 0: s->ftex = t; break;
        case 1: s->wtex = t; break;
        case 2: s->ctex = t; break;
        case 3: s->utex = t; break;
    });
	        case 0:
		        s->ftex = t;
		        break;
	        case 1:
		        s->wtex = t;
		        break;
	        case 2:
		        s->ctex = t;
		        break;
	        case 3:
		        s->utex = t;
		        break;
	});
};

void
void edittex(int type, int dir)
edittex(int type, int dir)
{
    EDITSEL;
    if(type<0 || type>3) return;
    if(type!=lasttype) { tofronttex(); lasttype = type; };
    int atype = type==3 ? 1 : type;
    int i = curedittex[atype];
    i = i<0 ? 0 : i+dir;
    curedittex[atype] = i = min(max(i, 0), 255);
    int t = lasttex = hdr.texlists[atype][i];
    edittexxy(type, t, sel);
    addmsg(1, 7, SV_EDITT, sel.x, sel.y, sel.xs, sel.ys, type, t);
	EDITSEL;
	if (type < 0 || type > 3)
		return;
	if (type != lasttype) {
		tofronttex();
		lasttype = type;
	};
	int atype = type == 3 ? 1 : type;
	int i = curedittex[atype];
	i = i < 0 ? 0 : i + dir;
	curedittex[atype] = i = min(max(i, 0), 255);
	int t = lasttex = hdr.texlists[atype][i];
	edittexxy(type, t, sel);
	addmsg(1, 7, SV_EDITT, sel.x, sel.y, sel.xs, sel.ys, type, t);
};

void
void replace()
replace()
{
    EDITSELMP;
    loop(x,ssize) loop(y,ssize)
    {
        sqr *s = S(x, y);
        switch(lasttype)
	EDITSELMP;
	loop(x, ssize) loop(y, ssize)
	{
		sqr *s = S(x, y);
		switch (lasttype) {
        {
            case 0: if(s->ftex == rtex.ftex) s->ftex = lasttex; break;
            case 1: if(s->wtex == rtex.wtex) s->wtex = lasttex; break;
            case 2: if(s->ctex == rtex.ctex) s->ctex = lasttex; break;
            case 3: if(s->utex == rtex.utex) s->utex = lasttex; break;
        };
    };
    block b = { 0, 0, ssize, ssize }; 
    remip(b);
		case 0:
			if (s->ftex == rtex.ftex)
				s->ftex = lasttex;
			break;
		case 1:
			if (s->wtex == rtex.wtex)
				s->wtex = lasttex;
			break;
		case 2:
			if (s->ctex == rtex.ctex)
				s->ctex = lasttex;
			break;
		case 3:
			if (s->utex == rtex.utex)
				s->utex = lasttex;
			break;
		};
	};
	block b = {0, 0, ssize, ssize};
	remip(b);
};

void
edittypexy(int type, block &sel)

{
void edittypexy(int type, block &sel)
{
    loopselxy(s->type = type);
	loopselxy(s->type = type);
};

void
void edittype(int type)
edittype(int type)
{
    EDITSEL;
    if(type==CORNER && (sel.xs!=sel.ys || sel.xs==3 || sel.xs>4 && sel.xs!=8
                   || sel.x&~-sel.xs || sel.y&~-sel.ys))
                   { conoutf("corner selection must be power of 2 aligned"); return; };
    edittypexy(type, sel);
    addmsg(1, 6, SV_EDITS, sel.x, sel.y, sel.xs, sel.ys, type);
	EDITSEL;
	if (type == CORNER &&
	    (sel.xs != sel.ys || sel.xs == 3 || sel.xs > 4 && sel.xs != 8 ||
	        sel.x & ~-sel.xs || sel.y & ~-sel.ys)) {
		conoutf("corner selection must be power of 2 aligned");
		return;
	};
	edittypexy(type, sel);
	addmsg(1, 6, SV_EDITS, sel.x, sel.y, sel.xs, sel.ys, type);
};

void
void heightfield(int t) { edittype(t==0 ? FHF : CHF); };
void solid(int t)       { edittype(t==0 ? SPACE : SOLID); };
void corner()           { edittype(CORNER); };
heightfield(int t)
{
	edittype(t == 0 ? FHF : CHF);
};
void
solid(int t)
{
	edittype(t == 0 ? SPACE : SOLID);
};
void
corner()
{
	edittype(CORNER);
};

COMMAND(heightfield, ARG_1INT);
COMMAND(solid, ARG_1INT);
COMMAND(corner, ARG_NONE);

void
void editequalisexy(bool isfloor, block &sel)
editequalisexy(bool isfloor, block &sel)
{
    int low = 127, hi = -128;
    loopselxy(
	int low = 127, hi = -128;
	loopselxy({
    {
        if(s->floor<low) low = s->floor;
        if(s->ceil>hi) hi = s->ceil;
    });
    loopselxy(
		if (s->floor < low)
			low = s->floor;
		if (s->ceil > hi)
			hi = s->ceil;
	});
	loopselxy({
    {
        if(isfloor) s->floor = low; else s->ceil = hi;
        if(s->floor>=s->ceil) s->floor = s->ceil-1;
    });
		if (isfloor)
			s->floor = low;
		else
			s->ceil = hi;
		if (s->floor >= s->ceil)
			s->floor = s->ceil - 1;
	});
};

void
void equalize(int flr)
equalize(int flr)
{
    bool isfloor = flr==0;
    EDITSEL;
    editequalisexy(isfloor, sel);
    addmsg(1, 6, SV_EDITE, sel.x, sel.y, sel.xs, sel.ys, isfloor);
	bool isfloor = flr == 0;
	EDITSEL;
	editequalisexy(isfloor, sel);
	addmsg(1, 6, SV_EDITE, sel.x, sel.y, sel.xs, sel.ys, isfloor);
};

COMMAND(equalize, ARG_1INT);

void
void setvdeltaxy(int delta, block &sel)
setvdeltaxy(int delta, block &sel)
{
    loopselxy(s->vdelta = max(s->vdelta+delta, 0));
    remipmore(sel);    
	loopselxy(s->vdelta = max(s->vdelta + delta, 0));
	remipmore(sel);
};

void
void setvdelta(int delta)
setvdelta(int delta)
{
    EDITSEL;
    setvdeltaxy(delta, sel);
    addmsg(1, 6, SV_EDITD, sel.x, sel.y, sel.xs, sel.ys, delta);
	EDITSEL;
	setvdeltaxy(delta, sel);
	addmsg(1, 6, SV_EDITD, sel.x, sel.y, sel.xs, sel.ys, delta);
};

const int MAXARCHVERT = 50;
int archverts[MAXARCHVERT][MAXARCHVERT];
bool archvinit = false;

void
void archvertex(int span, int vert, int delta)
archvertex(int span, int vert, int delta)
{
    if(!archvinit)
	if (!archvinit) {
    {
        archvinit = true;
        loop(s,MAXARCHVERT) loop(v,MAXARCHVERT) archverts[s][v] = 0;
    };
    if(span>=MAXARCHVERT || vert>=MAXARCHVERT || span<0 || vert<0) return;
    archverts[span][vert] = delta;
		archvinit = true;
		loop(s, MAXARCHVERT) loop(v, MAXARCHVERT) archverts[s][v] = 0;
	};
	if (span >= MAXARCHVERT || vert >= MAXARCHVERT || span < 0 || vert < 0)
		return;
	archverts[span][vert] = delta;
};

void
void arch(int sidedelta, int _a)
arch(int sidedelta, int _a)
{
    EDITSELMP;
    sel.xs++;
    sel.ys++;
    if(sel.xs>MAXARCHVERT) sel.xs = MAXARCHVERT;
    if(sel.ys>MAXARCHVERT) sel.ys = MAXARCHVERT;
    loopselxy(s->vdelta =
        sel.xs>sel.ys
            ? (archverts[sel.xs-1][x] + (y==0 || y==sel.ys-1 ? sidedelta : 0))
            : (archverts[sel.ys-1][y] + (x==0 || x==sel.xs-1 ? sidedelta : 0)));
    remipmore(sel);
	EDITSELMP;
	sel.xs++;
	sel.ys++;
	if (sel.xs > MAXARCHVERT)
		sel.xs = MAXARCHVERT;
	if (sel.ys > MAXARCHVERT)
		sel.ys = MAXARCHVERT;
	loopselxy(
	    s->vdelta = sel.xs > sel.ys
	                    ? (archverts[sel.xs - 1][x] +
	                          (y == 0 || y == sel.ys - 1 ? sidedelta : 0))
	                    : (archverts[sel.ys - 1][y] +
	                          (x == 0 || x == sel.xs - 1 ? sidedelta : 0)));
	remipmore(sel);
};

void
void slope(int xd, int yd)
slope(int xd, int yd)
{
    EDITSELMP;
    int off = 0;
    if(xd<0) off -= xd*sel.xs;
    if(yd<0) off -= yd*sel.ys;
    sel.xs++;
    sel.ys++;
    loopselxy(s->vdelta = xd*x+yd*y+off);
    remipmore(sel);
	EDITSELMP;
	int off = 0;
	if (xd < 0)
		off -= xd * sel.xs;
	if (yd < 0)
		off -= yd * sel.ys;
	sel.xs++;
	sel.ys++;
	loopselxy(s->vdelta = xd * x + yd * y + off);
	remipmore(sel);
};

void
void perlin(int scale, int seed, int psize)
perlin(int scale, int seed, int psize)
{
    EDITSELMP;
    sel.xs++;
    sel.ys++;
    makeundo();
    sel.xs--;
    sel.ys--;
    perlinarea(sel, scale, seed, psize);
    sel.xs++;
    sel.ys++;
    remipmore(sel);
    sel.xs--;
    sel.ys--;
	EDITSELMP;
	sel.xs++;
	sel.ys++;
	makeundo();
	sel.xs--;
	sel.ys--;
	perlinarea(sel, scale, seed, psize);
	sel.xs++;
	sel.ys++;
	remipmore(sel);
	sel.xs--;
	sel.ys--;
};

VARF(fullbright, 0, 0, 1,
    if(fullbright)
VARF(
    fullbright, 0, 0, 1, if (fullbright) {
    {
        if(noteditmode()) return;
        loopi(mipsize) world[i].r = world[i].g = world[i].b = 176;
    };
	    if (noteditmode())
		    return;
	    loopi(mipsize) world[i].r = world[i].g = world[i].b = 176;
    };);
);

void
void edittag(int tag)
edittag(int tag)
{
    EDITSELMP;
    loopselxy(s->tag = tag);
	EDITSELMP;
	loopselxy(s->tag = tag);
};

void
void newent(char *what, char *a1, char *a2, char *a3, char *a4)
newent(char *what, char *a1, char *a2, char *a3, char *a4)
{
    EDITSEL;
    newentity(sel.x, sel.y, (int)player1->o.z, what, ATOI(a1), ATOI(a2), ATOI(a3), ATOI(a4));
	EDITSEL;
	newentity(sel.x, sel.y, (int)player1->o.z, what, ATOI(a1), ATOI(a2),
	    ATOI(a3), ATOI(a4));
};

COMMANDN(select, selectpos, ARG_4INT);
COMMAND(edittag, ARG_1INT);
COMMAND(replace, ARG_NONE);
COMMAND(archvertex, ARG_3INT);
COMMAND(arch, ARG_2INT);
COMMAND(slope, ARG_2INT);
COMMANDN(vdelta, setvdelta, ARG_1INT);
COMMANDN(undo, editundo, ARG_NONE);
COMMAND(copy, ARG_NONE);
COMMAND(paste, ARG_NONE);
COMMAND(edittex, ARG_2INT);
COMMAND(newent, ARG_5STR);
COMMAND(perlin, ARG_3INT);