Cube  Check-in [5bbd6d8ddd]

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

// collect c2s messages conveniently

static OFMutableArray<OFData *> *messages;

void
addmsg(int rel, int num, int type, ...)
{
	if (demoplayback)
		return;
	if (num != msgsizelookup(type)) {
		fatal([OFString
		    stringWithFormat:@"inconsistant msg size for %d (%d != %d)",
		    type, num, msgsizelookup(type)]);
	}
	if (messages.count == 100) {
		conoutf(@"command flood protection (type %d)", type);
		return;
	}

	OFMutableData *msg = [OFMutableData dataWithItemSize:sizeof(int)
	                                            capacity:num + 2];
	[msg addItem:&num];
	[msg addItem:&rel];
	[msg addItem:&type];

	va_list marker;
	va_start(marker, type);
	loopi(num - 1)
	{
		int tmp = va_arg(marker, int);
		[msg addItem:&tmp];
	}
	va_end(marker);
	[msg makeImmutable];

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

	[messages addObject:msg];
}

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

				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);

			}
			for (OFData *msg in messages) {
				// send messages collected during the previous
				// frames


				if (*(int *)[msg itemAtIndex:1])
					packet->flags =
					    ENET_PACKET_FLAG_RELIABLE;
				loopi(*(int *)[msg itemAtIndex:0])
				    putint(p, *(int *)[msg itemAtIndex:i + 2]);

			}
			[messages removeAllObjects];
			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

void
pasteconsole()
{
	char *cb = SDL_GetClipboardText();
	strcat_s(commandbuf, cb);
}

static OFMutableArray<OFString *> *vhistory;
int histpos = 0;

void
history(int n)
{
	static bool rec = false;

	if (!rec && n >= 0 && n < vhistory.count) {
		rec = true;
		OFString *cmd = vhistory[vhistory.count - n - 1];
		std::unique_ptr<char> copy(strdup(cmd.UTF8String));
		execute(copy.get());
		rec = false;
	}
}
COMMAND(history, ARG_1INT)

void
keypress(int code, bool isdown, int cooked)

			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) {
					@autoreleasepool {
						strcpy_s(commandbuf,
						    vhistory[--histpos]
						        .UTF8String);
					}
				}
				break;

			case SDLK_DOWN:
				if (histpos < vhistory.count) {
					@autoreleasepool {
						strcpy_s(commandbuf,
						    vhistory[histpos++]
						        .UTF8String);
					}
				}
				break;

			case SDLK_TAB:
				complete(commandbuf);
				break;

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

			default:
				resetcomplete();
				if (cooked) {
					char add[] = {(char)cooked, 0};
					strcat_s(commandbuf, add);


				}
			}
		} else {
			if (code == SDLK_RETURN) {
				if (commandbuf[0]) {
					@autoreleasepool {
						OFString *cmdbuf =
						    @(commandbuf);

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

						if (vhistory.count == 0 ||
						    ![vhistory.lastObject
						        isEqual:cmdbuf]) {
							// cap this?

							[vhistory
							    addObject:cmdbuf];
						}
					}
					histpos = vhistory.count;
					if (commandbuf[0] == '/')
						execute(commandbuf, true);
					else
						toserver(commandbuf);

				}
				saycommand(NULL);
			} else if (code == SDLK_ESCAPE) {
				saycommand(NULL);


			}
		}
	} else if (!menukey(code, isdown)) {
		// keystrokes go to menu

		for (KeyMapping *mapping in keyMappings) {
			if (mapping.code == code) {
				// keystrokes go to game, lookup in keymap and
				// execute

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

typedef vector<dynent *> dvector;



// globals ooh naughty

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

#ifdef USE_MIXER
vector<Mix_Chunk *> samples;
#else
vector<FSOUND_SAMPLE *> samples;
#endif

static OFMutableArray<OFString *> *snames;

int
registersound(char *name_)
{
	@autoreleasepool {
		OFString *name = @(name_);

		int i = 0;
		for (OFString *iter in snames) {
			if ([iter isEqual:name])
				return i;

			i++;
		}

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

		[snames addObject:name];
		samples.add(NULL);
		return samples.length() - 1;
	}
}
COMMAND(registersound, ARG_1EST)

void
cleansound()
{
	if (nosound)

	if (n < 0 || n >= samples.length()) {
		conoutf(@"unregistered sound: %d", n);
		return;
	}

	if (!samples[n]) {
		OFString *path = [OFString
		    stringWithFormat:@"packages/sounds/%@.wav", snames[n]];
		OFIRI *IRI = [Cube.sharedInstance.gameDataIRI
		    IRIByAppendingPathComponent:path];

#ifdef USE_MIXER
		samples[n] =
		    Mix_LoadWAV(IRI.fileSystemRepresentation.UTF8String);
#else