Cube  Check-in [fa4b03aaca]

	log(@"net");
	if (enet_initialize() < 0)
		fatal(@"Unable to initialise network module");

	initclient();
	// never returns if dedicated
	initserver(dedicated, uprate, sdesc, ip, master, passwd, maxcl);


	log(@"world");
	empty_world(7, true);

	log(@"video: sdl");
	if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
		fatal(@"Unable to initialize SDL Video");

		uchar *p = start + 2;
		bool serveriteminitdone = false;
		if (toservermap.length > 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 = @"";
			putint(p, nextmode);
		} else {
			putint(p, SV_POS);
			putint(p, clientnum);
			putint(
			    p, (int)(d->o.x *

				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);
			}
			for (OFData *msg in messages) {
				// send messages collected during the previous
				// frames
				if (*(int *)[msg itemAtIndex:1])
					packet->flags =

		if (mapdata == nil)
			return;
		ENetPacket *packet = enet_packet_create(
		    NULL, MAXTRANS + mapdata.count, ENET_PACKET_FLAG_RELIABLE);
		uchar *start = packet->data;
		uchar *p = start + 2;
		putint(p, SV_SENDMAP);
		sendstring(mapname, p);
		putint(p, mapdata.count);
		if (65535 - (p - start) < mapdata.count) {
			conoutf(@"map %@ is too large to send", mapname);
			enet_packet_destroy(packet);
			return;
		}
		memcpy(p, mapdata.items, mapdata.count);

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

COMMANDN(map, changemap, ARG_1STR)

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

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

	load_world(name);

}

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

				        @"to join this server!");
				disconnect();
				return;
			}
			if (getint(p) == 1)
				conoutf(@"server is FULL, disconnecting..");
			break;

		}

		case SV_POS: // position of another client
		{
			cn = getint(p);
			d = getclient(cn);
			if (!d)
				return;

			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_TEXT:
			sgetstr();
			conoutf(@"%s:\f %s", d->name, text);
			break;

		case SV_MAPCHANGE:
			sgetstr();
			@autoreleasepool {
				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;
		}

		case SV_MAPRELOAD: // server requests next map

		case SV_RECVMAP: {
			sgetstr();
			conoutf(@"received map \"%s\" from server, reloading..",
			    text);
			int mapsize = getint(p);
			@autoreleasepool {
				OFString *string = @(text);
				writemap(string, mapsize, p);

				p += mapsize;
				changemapserv(string, gamemode);
			}
			break;
		}

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

	}
}

bool
execfile(OFString *cfgfile)
{
	@autoreleasepool {

		@try {
			execute([OFString stringWithContentsOfFile:cfgfile]);
		} @catch (id e) {
			return false;
		}





		return true;
	}
}

void
exec(OFString *cfgfile)
{

			menusel = 0;
		menus[vmenu].menusel = menusel;
	} else {
		if (code == SDLK_RETURN || code == -2) {
			OFString *action = menus[vmenu].items[menusel].action;
			if (vmenu == 1) {
				@autoreleasepool {
					connects(getservername(menusel));
				}
			}

			if (menuStack == nil)
				menuStack = [[OFMutableArray alloc] init];

			[menuStack addObject:@(vmenu)];

extern void menumanual(int m, int n, OFString *text);
extern void sortmenu();
extern bool menukey(int code, bool isdown);
extern void newmenu(OFString *name);

// serverbrowser
extern void addserver(OFString *servername);
extern OFString *getservername(int n);
extern void writeservercfg();

// rendergl
extern void gl_init(int w, int h);
extern void cleangl();
extern void gl_drawframe(int w, int h, float curfps);
extern bool installtex(int tnum, OFIRI *IRI, int *xs, int *ys, bool clamp);

extern void sendpackettoserv(void *packet);
extern void gets2c();
extern void c2sinfo(dynent *d);
extern void neterr(OFString *s);
extern void initclientnet();
extern bool netmapstart();
extern int getclientnum();
extern void changemapserv(OFString *name, int mode);
extern void writeclientinfo(OFStream *stream);

// clientgame
extern void mousemove(int dx, int dy);
extern void updateworld(int millis);
extern void startmap(OFString *name);
extern void changemap(OFString *name);
extern void initclient();
extern void spawnplayer(dynent *d);
extern void selfdamage(int damage, int actor, dynent *act);
extern dynent *newdynent();
extern OFString *getclientmap();
extern OFString *modestr(int n);
extern void zapdynent(dynent *&d);
extern dynent *getclient(int cn);
extern void timeupdate(int timeremain);
extern void resetmovement(dynent *d);
extern void fixplayer1range();

// clientextras

extern void rendermodel(OFString *mdl, int frame, int range, int tex, float rad,
    float x, float y, float z, float yaw, float pitch, bool teammate,
    float scale, float speed, int snap = 0, int basetime = 0);
@class MapModelInfo;
extern MapModelInfo *getmminfo(int i);

// server
extern void initserver(bool dedicated, int uprate, OFString *sdesc,
    OFString *ip, OFString *master, OFString *passwd, int maxcl);
extern void cleanupserver();
extern void localconnect();
extern void localdisconnect();
extern void localclienttoserver(struct _ENetPacket *);
extern void serverslice(int seconds, unsigned int timeout);
extern void putint(uchar *&p, int n);
extern int getint(uchar *&p);
extern void sendstring(OFString *t, uchar *&p);
extern void startintermission();
extern void restoreserverstate(vector<entity> &ents);
extern uchar *retrieveservers(uchar *buf, int buflen);
extern char msgsizelookup(int msg);
extern void serverms(int mode, int numplayers, int minremain,
    OFString *smapname, int seconds, bool isfull);
extern void servermsinit(OFString *master, OFString *sdesc, bool listen);
extern void sendmaps(int n, OFString *mapname, int mapsize, uchar *mapdata);
extern ENetPacket *recvmap(int n);

// weapon
extern void selectgun(int a = -1, int b = -1, int c = -1);
extern void shoot(dynent *d, OFVector3D &to);
extern void shootv(int gun, OFVector3D &from, OFVector3D &to, dynent *d = 0,
    bool local = false);
extern void createrays(OFVector3D &from, OFVector3D &to);
extern void moveprojectiles(float time);
extern void projreset();
extern OFString *playerincrosshair();
extern int reloadtime(int gun);

// monster
extern void monsterclear();
extern void restoremonsterstate();
extern void monsterthink();
extern void monsterrender();

			dblend = 0;
	}

	glEnable(GL_TEXTURE_2D);

	@autoreleasepool {
		OFString *command = getcurcommand();
		OFString *player = playerincrosshair();

		if (command)
			draw_textf(@"> %@_", 20, 1570, 2, command);
		else if (closeent[0])
			draw_text(@(closeent), 20, 1570, 2);
		else if (player != nil)
			draw_text(player, 20, 1570, 2);
	}

	renderscores();
	if (!rendermenu()) {
		glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA);
		glBindTexture(GL_TEXTURE_2D, 1);
		glBegin(GL_QUADS);

	string name;
	int modevote;
};

vector<client> clients;

int maxclients = 8;
static OFString *smapname;

struct server_entity // server side version of "entity" type
{
	bool spawned;
	int spawnsecs;
};

	else
		send(cn, packet);
	if (packet->referenceCount == 0)
		enet_packet_destroy(packet);
};

void
sendservmsg(OFString *msg)
{
	ENetPacket *packet = enet_packet_create(
	    NULL, _MAXDEFSTR + 10, ENET_PACKET_FLAG_RELIABLE);
	uchar *start = packet->data;
	uchar *p = start + 2;
	putint(p, SV_SERVMSG);
	sendstring(msg, p);
	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	multicast(packet, -1);
	if (packet->referenceCount == 0)
		enet_packet_destroy(packet);

}

void
disconnect_client(int n, char *reason)
{
	printf("disconnecting client (%s) [%s]\n", clients[n].hostname, reason);
	enet_peer_disconnect(clients[n].peer);
	clients[n].type = ST_EMPTY;

			else
				no++;
		} else
			no++;
	};
	if (yes == 1 && no == 0)
		return true; // single player
	@autoreleasepool {
		OFString *msg =
		    [OFString stringWithFormat:
		                  @"%s suggests %@ on map %s (set map to vote)",
		              clients[sender].name, modestr(reqmode), map];
		sendservmsg(msg);
	}
	if (yes / (float)(yes + no) <= 0.5f)
		return false;
	sendservmsg(@"vote passed");
	resetvotes();
	return true;
};

// server side processing of updates: does very little and most state is tracked
// client only could be extended to move more gameplay to server (at expense of
// lag)

			break;

		case SV_MAPCHANGE: {
			sgetstr();
			int reqmode = getint(p);
			if (reqmode < 0)
				reqmode = 0;
			if (smapname.length > 0 && !mapreload &&
			    !vote(text, reqmode, sender))
				return;
			mapreload = false;
			mode = reqmode;
			minremain = mode & 1 ? 15 : 10;
			mapend = lastsec + minremain * 60;
			interm = 0;
			@autoreleasepool {
				smapname = @(text);
			}
			resetitems();
			sender = -1;
			break;

		}

		case SV_ITEMLIST: {
			int n;
			while ((n = getint(p)) != -1)
				if (notgotitems) {
					server_entity se = {false, 0};
					while (sents.length() <= n)
						sents.add(se);
					sents[n].spawned = true;
				};
			notgotitems = false;
			break;

		}

		case SV_ITEMPICKUP: {
			int n = getint(p);
			pickup(n, getint(p), sender);
			break;

		}

		case SV_PING:
			send2(false, cn, SV_PONG, getint(p));
			break;

		case SV_POS: {
			cn = getint(p);
			if (cn < 0 || cn >= clients.length() ||
			    clients[cn].type == ST_EMPTY) {
				disconnect_client(sender, "client num");
				return;
			};
			int size = msgsizelookup(type);
			assert(size != -1);
			loopi(size - 2) getint(p);
			break;

		}

		case SV_SENDMAP: {
			sgetstr();
			int mapsize = getint(p);
			@autoreleasepool {
				sendmaps(sender, @(text), mapsize, p);
			}
			return;
		}

		case SV_RECVMAP:
			send(sender, recvmap(sender));
			return;

	ENetPacket *packet =
	    enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
	uchar *start = packet->data;
	uchar *p = start + 2;
	putint(p, SV_INITS2C);
	putint(p, n);
	putint(p, PROTOCOL_VERSION);
	@autoreleasepool {
		putint(p, *smapname.UTF8String);
	}
	sendstring(serverpassword, p);
	putint(p, clients.length() > maxclients);
	if (smapname.length > 0) {
		putint(p, SV_MAPCHANGE);
		sendstring(smapname, p);
		putint(p, mode);
		putint(p, SV_ITEMLIST);
		loopv(sents) if (sents[i].spawned) putint(p, i);
		putint(p, -1);

	}
	*(ushort *)start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	send(n, packet);

}

void
multicast(ENetPacket *packet, int sender)
{
	loopv(clients)
	{
		if (i == sender)

};

void
resetserverifempty()
{
	loopv(clients) if (clients[i].type != ST_EMPTY) return;
	clients.setsize(0);
	smapname = @"";
	resetvotes();
	resetitems();
	mode = 0;
	mapreload = false;
	minremain = 10;
	mapend = lastsec + minremain * 60;
	interm = 0;

}

int nonlocalclients = 0;
int lastconnect = 0;

void
serverslice(int seconds,
    unsigned int timeout) // main server update, called from cube main loop in

	client &c = addclient();
	c.type = ST_LOCAL;
	strcpy_s(c.hostname, "local");
	send_welcome(&c - &clients[0]);
};

void
initserver(bool dedicated, int uprate, OFString *sdesc, OFString *ip,
    OFString *master, OFString *passwd, int maxcl)
{
	serverpassword = passwd;
	maxclients = maxcl;
	servermsinit(master ? master : @"wouter.fov120.com/cube/masterserver/",
	    sdesc, dedicated);

	if (isdedicated = dedicated) {
		ENetAddress address = {ENET_HOST_ANY, CUBE_SERVER_PORT};
		@autoreleasepool {
			if (ip.length > 0 &&
			    enet_address_set_host(&address, ip.UTF8String) < 0)
				printf("WARNING: server ip not resolved");
		}
		serverhost = enet_host_create(&address, MAXCLIENTS, 0, uprate);
		if (!serverhost)
			fatal(@"could not create server host\n");
		loopi(MAXCLIENTS) serverhost->peers[i].data = (void *)-1;
	}

	resetserverifempty();

	ENetAddress address;
};

vector<serverinfo> servers;
ENetSocket pingsock = ENET_SOCKET_NULL;
int lastinfo = 0;

OFString *
getservername(int n)
{
	@autoreleasepool {
		return @(servers[n].name);
	}
}

void
addserver(OFString *servername_)
{
	@autoreleasepool {
		const char *servername = servername_.UTF8String;

	loopv(servers)
	{
		serverinfo &si = servers[i];
		if (si.address.host != ENET_HOST_ANY && si.ping != 9999) {
			if (si.protocol != PROTOCOL_VERSION)
				sprintf_s(si.full)(
				    "%s [different cube protocol]", si.name);
			else {
				@autoreleasepool {
					sprintf_s(si.full)(
					    "%d\t%d\t%s, %s: %s %s", si.ping,
					    si.numplayers,
					    si.map[0] ? si.map : "[unknown]",
					    modestr(si.mode).UTF8String,
					    si.name, si.sdesc);
				}
			}
		} else {
			sprintf_s(si.full)(
			    si.address.host != ENET_HOST_ANY
			        ? "%s [waiting for server response]"
			        : "%s [unknown host]\t",
			    si.name);
		}

httpgetsend(ENetAddress &ad, char *hostname, char *req, char *ref, char *agent)
{
	if (ad.host == ENET_HOST_ANY) {
		printf("looking up %s...\n", hostname);
		enet_address_set_host(&ad, hostname);
		if (ad.host == ENET_HOST_ANY)
			return;

	}
	if (mssock != ENET_SOCKET_NULL)
		enet_socket_destroy(mssock);
	mssock = enet_socket_create(ENET_SOCKET_TYPE_STREAM, NULL);
	if (mssock == ENET_SOCKET_NULL) {
		printf("could not open socket\n");
		return;

	}
	if (enet_socket_connect(mssock, &ad) < 0) {
		printf("could not connect\n");
		return;

	}
	ENetBuffer buf;
	sprintf_sd(httpget)(
	    "GET %s HTTP/1.0\nHost: %s\nReferer: %s\nUser-Agent: %s\n\n", req,
	    hostname, ref, agent);
	buf.data = httpget;
	buf.dataLength = strlen((char *)buf.data);
	printf("sending request to %s...\n", hostname);
	enet_socket_send(mssock, NULL, &buf, 1);

}

void
httpgetrecieve(ENetBuffer &buf)
{
	if (mssock == ENET_SOCKET_NULL)
		return;
	enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;

	eb.dataLength = buflen - 1;
	while (mssock != ENET_SOCKET_NULL)
		httpgetrecieve(eb);
	return stripheader(buf);
};

ENetSocket pongsock = ENET_SOCKET_NULL;
static OFString *serverdesc;

void
serverms(int mode, int numplayers, int minremain, OFString *smapname,
    int seconds, bool isfull)
{
	checkmasterreply();
	updatemasterserver(seconds);

	// reply all server info requests
	ENetBuffer buf;
	ENetAddress addr;

		if (len < 0)
			return;
		p = &pong[len];
		putint(p, PROTOCOL_VERSION);
		putint(p, mode);
		putint(p, numplayers);
		putint(p, minremain);
		OFString *mname =
		    [OFString stringWithFormat:@"%@%@",
		              (isfull ? @"[FULL] " : @""), smapname];
		sendstring(mname, p);
		sendstring(serverdesc, p);
		buf.dataLength = p - pong;
		enet_socket_send(pongsock, &addr, &buf, 1);
	}
}

void
servermsinit(OFString *master_, OFString *sdesc, bool listen)
{
	@autoreleasepool {
		const char *master = master_.UTF8String;
		const char *mid = strstr(master, "/");
		if (!mid)
			mid = master;
		strcpy_s(masterpath, mid);
		strn0cpy(masterbase, master, mid - master + 1);
		serverdesc = sdesc;

		if (listen) {
			ENetAddress address = {
			    ENET_HOST_ANY, CUBE_SERVINFO_PORT};
			pongsock = enet_socket_create(
			    ENET_SOCKET_TYPE_DATAGRAM, &address);
			if (pongsock == ENET_SOCKET_NULL)
				fatal(@"could not create server info socket\n");
		}
	}
}

	} else if (c == -127) {
		int n = *p++;
		n |= *p++ << 8;
		n |= *p++ << 16;
		return n | (*p++ << 24);
	} else
		return c;

}

void
sendstring(OFString *t_, uchar *&p)
{
	@autoreleasepool {
		const char *t = t_.UTF8String;
		while (*t)
			putint(p, *t++);
		putint(p, 0);

	}
}

static const OFString *modenames[] = {
    @"SP",
    @"DMSP",
    @"ffa/default",
    @"coopedit",
    @"ffa/duel",
    @"teamplay",
    @"instagib",
    @"instagib team",
    @"efficiency",
    @"efficiency team",
    @"insta arena",
    @"insta clan arena",
    @"tactics arena",
    @"tactics clan arena",
};


OFString *
modestr(int n)
{
	return (n >= -2 && n < 12) ? modenames[n + 2] : @"unknown";

}

char msgsizesl[] = // size inclusive message token, 0 for variable or
                   // not-checked sizes
    {SV_INITS2C, 4, SV_INITC2S, 0, SV_POS, 12, SV_TEXT, 0, SV_SOUND, 2, SV_CDIS,
        2, SV_EDITH, 7, SV_EDITT, 7, SV_EDITS, 6, SV_EDITD, 6, SV_EDITE, 6,
        SV_DIED, 2, SV_DAMAGE, 4, SV_SHOT, 8, SV_FRAGS, 2, SV_MAPCHANGE, 0,
        SV_ITEMSPAWN, 2, SV_ITEMPICKUP, 3, SV_DENIED, 2, SV_PING, 2, SV_PONG, 2,

		if (*p == msg)
			return p[1];
	return -1;
};

// sending of maps between clients

static OFString *copyname;
int copysize;
uchar *copydata = NULL;

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

			default:
				printf("WARNING: unknown commandline option\n");
			};
	};

	if (enet_initialize() < 0)
		fatal(@"Unable to initialise network module");
	initserver(true, uprate, @(sdesc), @(ip), @(master), @(passwd), maxcl);
	return 0;
}
#endif

	}
#define loop(v, m) for (int v = 0; v < (m); v++)
#define loopi(m) loop(i, m)
#define loopj(m) loop(j, m)
#define loopk(m) loop(k, m)
#define loopl(m) loop(l, m)

#ifndef OF_WINDOWS




# define __cdecl
# define _vsnprintf vsnprintf

#endif

// easy safe strings

#define _MAXDEFSTR 260
typedef char string[_MAXDEFSTR];

	}

	return (p->x <= d->o.x + d->radius && p->x >= d->o.x - d->radius &&
	        p->y <= d->o.y + d->radius && p->y >= d->o.y - d->radius &&
	        p->z <= d->o.z + d->aboveeye && p->z >= d->o.z - d->eyeheight);
}

OFString *
playerincrosshair()
{
	if (demoplayback)
		return NULL;
	loopv(players)
	{
		dynent *o = players[i];
		if (!o)
			continue;
		if (intersect(o, player1->o, worldpos)) {
			@autoreleasepool {
				return @(o->name);
			}
		}
	}
	return NULL;
}

const int MAXPROJ = 100;
struct projectile {
	OFVector3D o, to;