Cube  Check-in [fa4b03aaca]

Overview
Comment:Migrate more strings
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: fa4b03aacafc3bab0a52c144241ab665332f7e8e789eb17fff63f76e02e2d5c9
User & Date: js on 2025-03-08 00:48:42
Other Links: manifest | tags
Context
2025-03-08
00:58
More string migration check-in: 245efe8045 user: js tags: trunk
00:48
Migrate more strings check-in: fa4b03aaca user: js tags: trunk
2025-03-07
23:33
Fix newent accepting hex check-in: 291f7a7146 user: js tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified src/Cube.mm from [b09eeb8e8f] to [aeae4b6df1].

︙
86
87
88
89
90
91
92
93

94
95
96
97
98
99
100
101

86
87
88
89
90
91
92

93

94
95
96
97
98
99
100








-
+
-









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

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

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

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

Modified src/client.mm from [e93d114d64] to [2cc0559143].

︙
289
290
291
292
293
294
295
296

297
298
299
300
301
302
303

289
290
291
292
293
294
295

296
297
298
299
300
301
302
303








-
+








		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.UTF8String, p);
			sendstring(toservermap, p);
			toservermap = @"";
			putint(p, nextmode);
		} else {
			putint(p, SV_POS);
			putint(p, clientnum);
			putint(
			    p, (int)(d->o.x *
︙
330
331
332
333
334
335
336
337

338
339
340
341
342
343
344
345
346


347
348
349
350
351
352
353

330
331
332
333
334
335
336

337
338
339
340
341
342
343
344


345
346
347
348
349
350
351
352
353








-
+







-
-
+
+








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

Modified src/clientextras.mm from [55a0200404] to [45d297fe4b].

︙
187
188
189
190
191
192
193
194

195
196
197
198
199
200
201

187
188
189
190
191
192
193

194
195
196
197
198
199
200
201








-
+








		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.UTF8String, p);
		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);
︙

Modified src/clientgame.mm from [e005695b56] to [ce2ec26dd6].

︙
506
507
508
509
510
511
512
513

514
515
516

506
507
508
509
510
511
512

513
514
515
516








-
+




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

COMMANDN(map, changemap, ARG_1STR)

Modified src/clients2c.mm from [e48be73a93] to [a718bd08e4].

︙
11
12
13
14
15
16
17
18

19
20
21
22

23
24
25
26
27
28
29
30

11
12
13
14
15
16
17

18
19
20


21

22
23
24
25
26
27
28








-
+


-
-
+
-








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

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

void
changemap(OFString *name) // request map change, server may ignore
{
	toservermap = name;
}
︙
96
97
98
99
100
101
102
103

104
105
106
107
108
109
110

94
95
96
97
98
99
100

101
102
103
104
105
106
107
108








-
+








				        @"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;
︙
125
126
127
128
129
130
131
132

133
134
135
136
137
138
139
140
141
142
143
144

145


146
147
148
149
150
151
152
153
154

155
156
157
158
159
160
161

123
124
125
126
127
128
129

130
131
132
133
134
135
136
137
138
139
140
141
142
143

144
145
146
147
148
149
150
151
152
153

154
155
156
157
158
159
160
161








-
+












+
-
+
+








-
+








			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));
				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
︙
363
364
365
366
367
368
369

370

371
372
373



374
375
376
377
378
379
380

363
364
365
366
367
368
369
370

371



372
373
374
375
376
377
378
379
380
381








+
-
+
-
-
-
+
+
+









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

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

Modified src/commands.mm from [5c63a6ff95] to [ac6583caf8].

︙
341
342
343
344
345
346
347
348
349
350

351
352
353
354
355
356
357
358
359
360
361
362
363
364
365

341
342
343
344
345
346
347

348

349
350
351
352
353




354
355
356
357
358
359
360








-

-
+




-
-
-
-








	}
}

bool
execfile(OFString *cfgfile)
{
	@autoreleasepool {
		OFMutableData *data;
		@try {
			data = [OFMutableData dataWithContentsOfFile:cfgfile];
			execute([OFString stringWithContentsOfFile:cfgfile]);
		} @catch (id e) {
			return false;
		}

		// Ensure \0 termination.
		[data addItem:""];

		execute(@((char *)data.mutableItems));
		return true;
	}
}

void
exec(OFString *cfgfile)
{
︙

Modified src/menus.mm from [27b088d99d] to [8be4b9144c].

︙
152
153
154
155
156
157
158
159

160
161
162
163
164
165
166

152
153
154
155
156
157
158

159
160
161
162
163
164
165
166








-
+








			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)));
					connects(getservername(menusel));
				}
			}

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

			[menuStack addObject:@(vmenu)];
︙

Modified src/protos.h from [cecc5f4a0e] to [dbbc22637c].

︙
33
34
35
36
37
38
39
40

41
42
43
44
45
46
47

33
34
35
36
37
38
39

40
41
42
43
44
45
46
47








-
+








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 char *getservername(int n);
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);
︙
78
79
80
81
82
83
84
85

86
87
88
89
90
91
92
93
94
95
96
97
98

99
100
101
102
103
104
105

78
79
80
81
82
83
84

85
86
87
88
89
90
91
92
93
94
95
96
97

98
99
100
101
102
103
104
105








-
+












-
+








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(char *name, int mode);
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 const char *modestr(int n);
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
︙
211
212
213
214
215
216
217
218
219


220
221
222
223
224
225
226
227

228
229
230
231
232
233
234
235




236
237
238
239
240
241
242
243
244
245
246

247
248
249
250
251
252
253

211
212
213
214
215
216
217


218
219
220
221
222
223
224
225
226

227
228
229
230
231




232
233
234
235
236
237
238
239
240
241
242
243
244
245

246
247
248
249
250
251
252
253








-
-
+
+







-
+




-
-
-
-
+
+
+
+










-
+








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, const char *sdesc,
    const char *ip, const char *master, OFString *passwd, int maxcl);
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(const char *t, 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, char *smapname,
    int seconds, bool isfull);
extern void servermsinit(const char *master, const char *sdesc, bool listen);
extern void sendmaps(int n, string mapname, int mapsize, uchar *mapdata);
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 char *playerincrosshair();
extern OFString *playerincrosshair();
extern int reloadtime(int gun);

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

Modified src/renderextras.mm from [a953917ec3] to [2f71e0ae26].

︙
363
364
365
366
367
368
369
370

371
372
373
374
375
376
377


378
379
380
381
382
383
384

363
364
365
366
367
368
369

370
371
372
373
374
375


376
377
378
379
380
381
382
383
384








-
+





-
-
+
+








			dblend = 0;
	}

	glEnable(GL_TEXTURE_2D);

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

		if (command)
			draw_textf(@"> %@_", 20, 1570, 2, command);
		else if (closeent[0])
			draw_text(@(closeent), 20, 1570, 2);
		else if (player)
			draw_text(@(player), 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);
︙

Modified src/server.mm from [9821265b10] to [133bbad38c].

︙
14
15
16
17
18
19
20
21

22
23
24
25
26
27
28

14
15
16
17
18
19
20

21
22
23
24
25
26
27
28








-
+








	string name;
	int modevote;
};

vector<client> clients;

int maxclients = 8;
string smapname;
static OFString *smapname;

struct server_entity // server side version of "entity" type
{
	bool spawned;
	int spawnsecs;
};
︙
92
93
94
95
96
97
98
99

100
101
102
103
104
105
106
107
108
109
110
111
112

113
114
115
116
117
118
119

92
93
94
95
96
97
98

99
100
101
102
103
104
105
106
107
108
109
110
111

112
113
114
115
116
117
118
119








-
+












-
+








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

void
sendservmsg(char *msg)
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;
︙
161
162
163
164
165
166
167



168
169
170




171
172
173

174
175
176
177
178
179
180

161
162
163
164
165
166
167
168
169
170



171
172
173
174
175
176

177
178
179
180
181
182
183
184








+
+
+
-
-
-
+
+
+
+


-
+








			else
				no++;
		} else
			no++;
	};
	if (yes == 1 && no == 0)
		return true; // single player
	@autoreleasepool {
		OFString *msg =
		    [OFString stringWithFormat:
	sprintf_sd(msg)("%s suggests %s on map %s (set map to vote)",
	    clients[sender].name, modestr(reqmode), map);
	sendservmsg(msg);
		                  @"%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");
	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)
︙
207
208
209
210
211
212
213
214

215
216
217
218
219
220
221

222


223
224
225
226

227
228
229
230
231
232
233
234
235
236
237
238
239

240
241
242
243
244
245

246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262

263
264
265
266

267


268
269
270
271
272
273
274

211
212
213
214
215
216
217

218
219
220
221
222
223
224
225
226

227
228
229
230
231

232
233
234
235
236
237
238
239
240
241
242
243
244

245
246
247
248
249
250

251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267

268
269
270
271
272
273

274
275
276
277
278
279
280
281
282








-
+







+
-
+
+



-
+












-
+





-
+
















-
+




+
-
+
+








			break;

		case SV_MAPCHANGE: {
			sgetstr();
			int reqmode = getint(p);
			if (reqmode < 0)
				reqmode = 0;
			if (smapname[0] && !mapreload &&
			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 {
			strcpy_s(smapname, text);
				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);
				sendmaps(sender, @(text), mapsize, p);
			}
			return;
		}

		case SV_RECVMAP:
			send(sender, recvmap(sender));
			return;
︙
303
304
305
306
307
308
309

310
311



312
313

314
315
316
317
318
319
320

321
322
323
324

325
326
327
328
329
330
331

311
312
313
314
315
316
317
318


319
320
321
322

323
324
325
326
327
328
329

330
331
332
333

334
335
336
337
338
339
340
341








+
-
-
+
+
+

-
+






-
+



-
+








	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[0]);
	sendstring(serverpassword.UTF8String, p);
		putint(p, *smapname.UTF8String);
	}
	sendstring(serverpassword, p);
	putint(p, clients.length() > maxclients);
	if (smapname[0]) {
	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)
︙
367
368
369
370
371
372
373
374

375
376
377
378
379
380
381
382

383
384
385
386
387
388
389

377
378
379
380
381
382
383

384
385
386
387
388
389
390
391

392
393
394
395
396
397
398
399








-
+







-
+








};

void
resetserverifempty()
{
	loopv(clients) if (clients[i].type != ST_EMPTY) return;
	clients.setsize(0);
	smapname[0] = 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
︙
505
506
507
508
509
510
511
512
513


514
515
516
517

518
519
520
521


522
523



524
525
526
527
528
529
530

515
516
517
518
519
520
521


522
523
524
525
526

527
528
529
530
531
532
533


534
535
536
537
538
539
540
541
542
543








-
-
+
+



-
+




+
+
-
-
+
+
+








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

void
initserver(bool dedicated, int uprate, const char *sdesc, const char *ip,
    const char *master, OFString *passwd, int maxcl)
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/",
	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 &&
		if (*ip && enet_address_set_host(&address, ip) < 0)
			printf("WARNING: server ip not resolved");
			    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();
︙

Modified src/serverbrowser.mm from [23e77d6100] to [c6e27aadf2].

︙
141
142
143
144
145
146
147
148

149
150

151


152
153
154
155
156
157
158

141
142
143
144
145
146
147

148
149
150
151

152
153
154
155
156
157
158
159
160








-
+


+
-
+
+








	ENetAddress address;
};

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

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

void
addserver(OFString *servername_)
{
	@autoreleasepool {
		const char *servername = servername_.UTF8String;
︙
268
269
270
271
272
273
274
275
276
277
278
279










280
281
282
283
284
285
286

270
271
272
273
274
275
276





277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293








-
-
-
-
-
+
+
+
+
+
+
+
+
+
+








	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
				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), si.name, si.sdesc);
			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);
		}
︙

Modified src/serverms.mm from [67a9f7fd73] to [063897f679].

︙
8
9
10
11
12
13
14
15

16
17
18
19
20
21
22

23
24
25
26

27
28
29
30
31
32
33
34
35

36
37
38
39
40
41
42

8
9
10
11
12
13
14

15
16
17
18
19
20
21

22
23
24
25

26
27
28
29
30
31
32
33
34

35
36
37
38
39
40
41
42








-
+






-
+



-
+








-
+








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;
︙
106
107
108
109
110
111
112
113

114
115
116
117


118
119
120
121
122
123
124

106
107
108
109
110
111
112

113
114
115


116
117
118
119
120
121
122
123
124








-
+


-
-
+
+








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

ENetSocket pongsock = ENET_SOCKET_NULL;
string serverdesc;
static OFString *serverdesc;

void
serverms(int mode, int numplayers, int minremain, char *smapname, int seconds,
    bool isfull)
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;
︙
132
133
134
135
136
137
138
139
140
141



142
143
144
145
146
147
148
149
150

151


152
153
154
155
156
157






158
159
160
161
162
163
164
165
166











132
133
134
135
136
137
138



139
140
141
142
143
144
145
146
147
148
149

150
151
152
153






154
155
156
157
158
159
160








161
162
163
164
165
166
167
168
169
170








-
-
-
+
+
+








-
+

+
+
-
-
-
-
-
-
+
+
+
+
+
+

-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+

		if (len < 0)
			return;
		p = &pong[len];
		putint(p, PROTOCOL_VERSION);
		putint(p, mode);
		putint(p, numplayers);
		putint(p, minremain);
		string mname;
		strcpy_s(mname, isfull ? "[FULL] " : "");
		strcat_s(mname, smapname);
		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(const char *master, const char *sdesc, bool listen)
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);
	strcpy_s(serverdesc, sdesc);
		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");
	}
}
		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");
		}
	}
}

Modified src/serverutil.mm from [b2c8903da8] to [e5f6cbf888].

︙
36
37
38
39
40
41
42
43
44


45
46

47


48
49
50



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


















68
69
70

71
72
73

74

75
76
77
78
79
80
81

36
37
38
39
40
41
42


43
44
45

46
47
48
49



50
51
52

















53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

73
74
75

76

77
78
79
80
81
82
83
84








-
-
+
+

-
+

+
+
-
-
-
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+


-
+


-
+
-
+








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

}

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

const char *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",
	}
}

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",
};

const char *
OFString *
modestr(int n)
{
	return (n >= -2 && n < 12) ? modenames[n + 2] : "unknown";
	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,
︙
90
91
92
93
94
95
96
97

98
99
100
101
102

103
104
105
106

107
108
109
110
111
112
113

93
94
95
96
97
98
99

100
101
102
103
104

105
106
107
108

109
110
111
112
113
114
115
116








-
+




-
+



-
+








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

// sending of maps between clients

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

void
sendmaps(int n, string mapname, int mapsize, uchar *mapdata)
sendmaps(int n, OFString *mapname, int mapsize, uchar *mapdata)
{
	if (mapsize <= 0 || mapsize > 256 * 256)
		return;
	strcpy_s(copyname, mapname);
	copyname = mapname;
	copysize = mapsize;
	if (copydata)
		free(copydata);
	copydata = (uchar *)alloc(mapsize);
	memcpy(copydata, mapdata, mapsize);
}
︙
185
186
187
188
189
190
191
192

193
194
195

188
189
190
191
192
193
194

195
196
197
198








-
+




			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);
	initserver(true, uprate, @(sdesc), @(ip), @(master), @(passwd), maxcl);
	return 0;
}
#endif

Modified src/tools.h from [257c91a25c] to [217eb7d86e].

︙
44
45
46
47
48
49
50
51

52
53
54
55
56
57
58
59
60
61
62
63
64
65

44
45
46
47
48
49
50

51




52
53

54
55
56
57
58
59
60








-
+
-
-
-
-


-








	}
#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)

#ifdef WIN32
#ifndef OF_WINDOWS
# pragma warning(3 : 4189)
// #pragma comment(linker,"/OPT:NOWIN98")
# define PATHDIV '\\'
#else
# define __cdecl
# define _vsnprintf vsnprintf
# define PATHDIV '/'
#endif

// easy safe strings

#define _MAXDEFSTR 260
typedef char string[_MAXDEFSTR];
︙

Modified src/weapon.mm from [efed2ffe54] to [f70bf0b290].

︙
107
108
109
110
111
112
113
114

115
116
117
118
119
120
121
122
123
124
125





126
127
128
129
130
131
132

107
108
109
110
111
112
113

114
115
116
117
118
119
120
121
122
123


124
125
126
127
128
129
130
131
132
133
134
135








-
+









-
-
+
+
+
+
+








	}

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

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

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

Fossil 2.25 [8f798279d5] 2024-11-06 12:59:09
This page was generated in about 0.047s