[ViewVC] Diff of: cvs/deliantra/server/socket/request.C

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.71 by root, Mon Mar 12 01:13:10 2007 UTC vs.
Revision 1.78 by root, Thu Mar 15 14:59:43 2007 UTC

…		…
459	char tmpbuf[20];	459	char tmpbuf[20];
460	int q = atoi (param);	460	int q = atoi (param);
461		461
462	if (is_valid_faceset (q))	462	if (is_valid_faceset (q))
463	ns->faceset = q;	463	ns->faceset = q;
		464
464	sprintf (tmpbuf, "%d", ns->faceset);	465	sprintf (tmpbuf, "%d", ns->faceset);
465	safe_strcat (cmdback, tmpbuf, &slen, HUGE_BUF);	466	safe_strcat (cmdback, tmpbuf, &slen, HUGE_BUF);
466	/* if the client is using faceset, it knows about image2 command */	467	/* if the client is using faceset, it knows about image2 command */
467	ns->image2 = 1;	468	ns->image2 = 1;
468	}	469	}
…		…
561	* This is what takes care of it. We tell the client how things worked out.	562	* This is what takes care of it. We tell the client how things worked out.
562	* I am not sure if this file is the best place for this function. however,	563	* I am not sure if this file is the best place for this function. however,
563	* it either has to be here or init_sockets needs to be exported.	564	* it either has to be here or init_sockets needs to be exported.
564	*/	565	*/
565	void	566	void
566	AddMeCmd (char buf, int len, client ns)	567	AddMeCmd (char buf, int len, client ns)
567	{	568	{
		569	// face caching is mandatory
		570	if (!ns->facecache)
		571	{
		572	ns->send_drawinfo (
		573	"\n"
		574	"\n"
		575	"***\n"
		576	"*** WARNING:\n"
		577	"*** Your client does not support face/image caching,\n"
		578	"*** or it has been disabled. Face caching is mandatory\n"
		579	"*** so please enable it or use a newer client.\n"
		580	"***\n"
		581	"*** Look at your client preferences:\n"
		582	"***\n"
		583	"*** CFPlus: all known versions automatically enable the facecache.\n"
		584	"*** cfclient: use the -cache commandline option.\n"
		585	"*** cfclient: map will not redraw automatically (bug).\n"
		586	"*** gcfclient: use -cache commandline option, or enable\n"
		587	"*** gcfclient: Client=>Configure=>Map & Image=>Cache Images.\n"
		588	"*** jcrossclient: your client is broken, use CFPlus or gcfclient.\n"
		589	"***\n"
		590	"***\n",
		591	NDI_RED
		592	);
		593
		594	if (strstr (ns->version, "jcrossclient"))
		595	/* let them, for now*/;
		596	else
		597	{
		598	ns->flush ();
		599	//ns->destroy ();
		600	}
		601	//ns->facecache = true;
		602	}
		603
568	INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));	604	INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
569	}	605	}
570		606
571	/** Reply to ExtendedInfos command */	607	/** Reply to ExtendedInfos command */
572	void	608	void
…		…
683		719
684	ns->send_packet (cmdback);	720	ns->send_packet (cmdback);
685	}	721	}
686		722
687	/**	723	/**
688	* A lot like the old AskSmooth (in fact, now called by AskSmooth).	724	* client requested an image. send it rate-limited
689	* Basically, it makes no sense to wait for the client to request a	725	* before flushing.
690	* a piece of data from us that we know the client wants. So
691	* if we know the client wants it, might as well push it to the
692	* client.
693	*/
694	static void
695	SendSmooth (client *ns, uint16 face)
696	{
697	uint16 smoothface;
698
699	/* If we can't find a face, return and set it so we won't try to send this
700	* again.
701	*/	726	*/
702	if (!FindSmooth (face, &smoothface))	727	void
703	{	728	AskFaceCmd (char buf, int len, client ns)
704		729	{
705	LOG (llevError, "could not findsmooth for %d.\n", face);	730	ns->askface.push_back (atoi (buf));
706	ns->faces_sent[face] \|= NS_FACESENT_SMOOTH;
707	return;
708	}
709
710	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))
711	esrv_send_face (ns, smoothface, 0);
712
713	ns->faces_sent[face] \|= NS_FACESENT_SMOOTH;
714
715	packet sl ("smooth");
716
717	sl << uint16 (face)
718	<< uint16 (smoothface);
719
720	ns->send_packet (sl);
721	}	731	}
722		732
723	/**	733	/**
724	* Tells client the picture it has to use	734	* Tells client the picture it has to use
725	* to smooth a picture number given as argument.	735	* to smooth a picture number given as argument.
726	*/	736	*/
727	void	737	void
728	AskSmooth (char buf, int len, client ns)	738	AskSmooth (char buf, int len, client ns)
729	{	739	{
730	SendSmooth (ns, atoi (buf));	740	ns->send_face (atoi (buf));
731	}	741	}
732		742
733	/**	743	/**
734	* This handles the general commands from the client (ie, north, fire, cast,	744	* This handles the general commands from the client (ie, north, fire, cast,
735	* etc.)	745	* etc.)
…		…
1107	pl->ns->last_weight = weight;	1117	pl->ns->last_weight = weight;
1108	pl->ns->send_packet (sl);	1118	pl->ns->send_packet (sl);
1109	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);	1119	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1110	}	1120	}
1111		1121
1112	/**
1113	* Need to send an animation sequence to the client.
1114	* We will send appropriate face commands to the client if we haven't
1115	* sent them the face yet (this can become quite costly in terms of
1116	* how much we are sending - on the other hand, this should only happen
1117	* when the player logs in and picks stuff up.
1118	*/
1119	void
1120	esrv_send_animation (client * ns, short anim_num)
1121	{
1122	/* Do some checking on the anim_num we got. Note that the animations
1123	* are added in contigous order, so if the number is in the valid
1124	* range, it must be a valid animation.
1125	*/
1126	if (anim_num < 0 \|\| anim_num > num_animations)
1127	{
1128	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
1129	return;
1130	}
1131
1132	packet sl ("anim");
1133
1134	sl << uint16 (anim_num)
1135	<< uint16 (0); /* flags - not used right now */
1136
1137	/* Build up the list of faces. Also, send any information (ie, the
1138	* the face itself) down to the client.
1139	*/
1140	for (int i = 0; i < animations[anim_num].num_animations; i++)
1141	{
1142	if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))
1143	esrv_send_face (ns, animations[anim_num].faces[i], 0);
1144
1145	sl << uint16 (animations[anim_num].faces[i]); /* flags - not used right now */
1146	}
1147
1148	ns->send_packet (sl);
1149
1150	ns->anims_sent[anim_num] = 1;
1151	}
1152
1153
1154	/******************************************************************************	1122	/******************************************************************************
1155	*	1123	*
1156	* Start of map related commands.	1124	* Start of map related commands.
1157	*	1125	*
1158	******************************************************************************/	1126	******************************************************************************/
1159		1127
1160	/** Clears a map cell */	1128	/** Clears a map cell */
1161	static void	1129	static void
1162	map_clearcell (struct MapCell *cell, int count)	1130	map_clearcell (struct MapCell *cell, int count)
1163	{	1131	{
1164	cell->faces[0] = 0;	1132	cell->faces[0] = 0;
1165	cell->faces[1] = 0;	1133	cell->faces[1] = 0;
1166	cell->faces[2] = 0;	1134	cell->faces[2] = 0;
		1135	cell->smooth[0] = 0;
		1136	cell->smooth[1] = 0;
		1137	cell->smooth[2] = 0;
1167	cell->count = count;	1138	cell->count = count;
1168	cell->stat_hp = 0;	1139	cell->stat_hp = 0;
1169	cell->flags = 0;	1140	cell->flags = 0;
1170	cell->player = 0;	1141	cell->player = 0;
1171	}	1142	}
1172		1143
1173	#define MAX_LAYERS 3	1144	#define MAX_LAYERS 3
1174		1145
1175	/**	1146	/**
…		…
1178	* it was.	1149	* it was.
1179	* sl is the socklist this data is going into.	1150	* sl is the socklist this data is going into.
1180	* ns is the socket we are working on - all the info we care	1151	* ns is the socket we are working on - all the info we care
1181	* about is in this socket structure, so now need not pass the	1152	* about is in this socket structure, so now need not pass the
1182	* entire player object.	1153	* entire player object.
1183	* mx and my are map coordinate offsets for map mp
1184	* sx and sy are the offsets into the socket structure that
1185	* holds the old values.
1186	* layer is the layer to update, with 2 being the floor and 0 the	1154	* layer is the layer to update, with 2 being the floor and 0 the
1187	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ)	1155	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ)
1188	* take. Interesting to note that before this function, the map1 function	1156	* take. Interesting to note that before this function, the map1 function
1189	* numbers the spaces differently - I think this was a leftover from	1157	* numbers the spaces differently - I think this was a leftover from
1190	* the map command, where the faces stack up. Sinces that is no longer	1158	* the map command, where the faces stack up. Sinces that is no longer
1191	* the case, it seems to make more sense to have these layer values	1159	* the case, it seems to make more sense to have these layer values
1192	* actually match.	1160	* actually match.
1193	*/	1161	*/
1194	static int	1162	static int
1195	update_space (packet &sl, client &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)	1163	update_space (packet &sl, client &ns, mapspace &ms, MapCell &lastcell, int layer)
1196	{	1164	{
1197	uint16 face_num;	1165	object *ob = ms.faces_obj [layer];
1198	int bx, by, i;
1199
1200	object *ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
1201		1166
1202	/* If there is no object for this space, or if the face for the object	1167	/* If there is no object for this space, or if the face for the object
1203	* is the blank face, set the face number to zero.	1168	* is the blank face, set the face number to zero.
1204	* else if we have the stored head object for this space, that takes	1169	* else if we have the stored head object for this space, that takes
1205	* precedence over the other object for this space.	1170	* precedence over the other object for this space.
1206	* otherwise, we do special head processing	1171	* otherwise, we do special head processing
1207	*/	1172	*/
1208	if (!ob \|\| ob->face == blank_face)	1173	uint16 face_num = ob && ob->face != blank_face ? ob->face : 0;
1209	face_num = 0;
1210	else
1211	/* In this case, we are already at the lower right or single part object,
1212	* so nothing special
1213	*/
1214	face_num = ob->face;
1215		1174
1216	/* We've gotten what face we want to use for the object. Now see if	1175	/* We've gotten what face we want to use for the object. Now see if
1217	* if it has changed since we last sent it to the client.	1176	* if it has changed since we last sent it to the client.
1218	*/	1177	*/
1219	if (ns.lastmap.cells[sx][sy].faces[layer] != face_num)	1178	if (lastcell.faces[layer] != face_num)
1220	{	1179	{
1221	ns.lastmap.cells[sx][sy].faces[layer] = face_num;	1180	lastcell.faces[layer] = face_num;
		1181
1222	if (!(ns.faces_sent[face_num] & NS_FACESENT_FACE))	1182	if (!ns.faces_sent[face_num])
		1183	if (ob)
		1184	ns.send_faces (ob);
		1185	else
1223	esrv_send_face (&ns, face_num, 0);	1186	ns.send_face (face_num);
1224		1187
1225	sl << uint16 (face_num);	1188	sl << uint16 (face_num);
1226	return 1;
1227	}
1228
1229	/* Nothing changed */
1230	return 0;
1231	}
1232
1233	/**
1234	* This function is mainly a copy of update_space,
1235	* except it handles update of the smoothing updates,
1236	* not the face updates.
1237	* Removes the need to replicate the same code for each layer.
1238	* this returns true if this smooth is now in fact different
1239	* than it was.
1240	* sl is the socklist this data is going into.
1241	* ns is the socket we are working on - all the info we care
1242	* about is in this socket structure, so know need to pass the
1243	* entire player object.
1244	* mx and my are map coordinate offsets for map mp
1245	* sx and sy are the offsets into the socket structure that
1246	* holds the old values.
1247	* layer is the layer to update, with 2 being the floor and 0 the
1248	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
1249	* take.
1250	*/
1251	static inline int
1252	update_smooth (packet &sl, client &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1253	{
1254	object *ob;
1255	int smoothlevel; /* old face_num; */
1256
1257	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
1258
1259	/* If there is no object for this space, or if the face for the object
1260	* is the blank face, set the smoothlevel to zero.
1261	*/
1262	if (!ob \|\| ob->face == blank_face)
1263	smoothlevel = 0;
1264	else
1265	{
1266	smoothlevel = ob->smoothlevel;
1267	if (smoothlevel && !(ns.faces_sent[ob->face] & NS_FACESENT_SMOOTH))
1268	SendSmooth (&ns, ob->face);
1269	} /* else not already head object or blank face */
1270
1271	/* We've gotten what face we want to use for the object. Now see if
1272	* if it has changed since we last sent it to the client.
1273	*/
1274	if (smoothlevel > 255)
1275	smoothlevel = 255;
1276	else if (smoothlevel < 0)
1277	smoothlevel = 0;
1278
1279	if (ns.lastmap.cells[sx][sy].smooth[layer] != smoothlevel)
1280	{
1281	ns.lastmap.cells[sx][sy].smooth[layer] = smoothlevel;
1282	sl << uint8 (smoothlevel);
1283	return 1;	1189	return 1;
1284	}	1190	}
1285		1191
1286	/* Nothing changed */	1192	/* Nothing changed */
1287	return 0;	1193	return 0;
…		…
1351	* look like.	1257	* look like.
1352	*/	1258	*/
1353	void	1259	void
1354	draw_client_map1 (object *pl)	1260	draw_client_map1 (object *pl)
1355	{	1261	{
1356	int x, y, ax, ay, d, startlen, max_x, max_y, oldlen;	1262	int x, y, ax, ay, startlen, max_x, max_y, oldlen;
1357	sint16 nx, ny;	1263	sint16 nx, ny;
1358	int estartlen, eoldlen;	1264	int estartlen, eoldlen;
1359	uint16 mask, emask;
1360	uint8 eentrysize;	1265	uint8 eentrysize;
1361	uint16 ewhatstart, ewhatflag;	1266	uint16 ewhatstart, ewhatflag;
1362	uint8 extendedinfos;	1267	uint8 extendedinfos;
1363	maptile *m;	1268	maptile *m;
1364		1269
…		…
1391	<< uint8 (extendedinfos)	1296	<< uint8 (extendedinfos)
1392	<< uint8 (eentrysize);	1297	<< uint8 (eentrysize);
1393		1298
1394	estartlen = esl.length ();	1299	estartlen = esl.length ();
1395	}	1300	}
1396	else
1397	{
1398	/* suppress compiler warnings */
1399	ewhatstart = 0;
1400	ewhatflag = 0;
1401	estartlen = 0;
1402	}
1403		1301
1404	/* x,y are the real map locations. ax, ay are viewport relative	1302	/* x,y are the real map locations. ax, ay are viewport relative
1405	* locations.	1303	* locations.
1406	*/	1304	*/
1407	ay = 0;	1305	ay = 0;
…		…
1410	* but that started to get a bit messy to look at.	1308	* but that started to get a bit messy to look at.
1411	*/	1309	*/
1412	max_x = pl->x + (socket.mapx + 1) / 2;	1310	max_x = pl->x + (socket.mapx + 1) / 2;
1413	max_y = pl->y + (socket.mapy + 1) / 2;	1311	max_y = pl->y + (socket.mapy + 1) / 2;
1414		1312
		1313	maptile *plmap = pl->map;
		1314
1415	for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++)	1315	for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++)
1416	{	1316	{
1417	ax = 0;	1317	ax = 0;
1418	for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++)	1318	for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++)
1419	{	1319	{
		1320	int emask, mask;
1420	emask = mask = (ax & 0x3f) << 10 \| (ay & 0x3f) << 4;	1321	emask = mask = (ax & 0x3f) << 10 \| (ay & 0x3f) << 4;
1421		1322
1422	MapCell &lastcell = socket.lastmap.cells[ax][ay];	1323	MapCell &lastcell = socket.lastmap.cells[ax][ay];
1423
1424	d = pl->contr->blocked_los[ax][ay];
1425		1324
1426	/* If the coordinates are not valid, or it is too dark to see,	1325	/* If the coordinates are not valid, or it is too dark to see,
1427	* we tell the client as such	1326	* we tell the client as such
1428	*/	1327	*/
1429	nx = x;	1328	nx = x;
1430	ny = y;	1329	ny = y;
1431	m = get_map_from_coord (pl->map, &nx, &ny);	1330	m = get_map_from_coord (plmap, &nx, &ny);
1432		1331
1433	if (!m)	1332	if (!m)
1434	{	1333	{
1435	/* space is out of map. Update space and clear values	1334	/* space is out of map. Update space and clear values
1436	* if this hasn't already been done. If the space is out	1335	* if this hasn't already been done. If the space is out
…		…
1439	if (lastcell.count != -1)	1338	if (lastcell.count != -1)
1440	{	1339	{
1441	sl << uint16 (mask);	1340	sl << uint16 (mask);
1442	map_clearcell (&lastcell, -1);	1341	map_clearcell (&lastcell, -1);
1443	}	1342	}
		1343
		1344	continue;
1444	}	1345	}
		1346
		1347	m->touch ();
		1348
		1349	int d = pl->contr->blocked_los[ax][ay];
		1350
1445	else if (d > 3)	1351	if (d > 3)
1446	{	1352	{
1447	m->touch ();
1448		1353
1449	int need_send = 0, count;	1354	int need_send = 0, count;
1450		1355
1451	/* This block deals with spaces that are not visible for whatever	1356	/* This block deals with spaces that are not visible for whatever
1452	* reason. Still may need to send the head for this space.	1357	* reason. Still may need to send the head for this space.
…		…
1460	need_send = 1;	1365	need_send = 1;
1461		1366
1462	count = -1;	1367	count = -1;
1463		1368
1464	/* properly clear a previously sent big face */	1369	/* properly clear a previously sent big face */
1465	if (lastcell.faces[0] != 0 \|\| lastcell.faces[1] != 0 \|\| lastcell.faces[2] != 0	1370	if (lastcell.faces[0] \|\| lastcell.faces[1] \|\| lastcell.faces[2]
1466	\|\| lastcell.stat_hp \|\| lastcell.flags \|\| lastcell.player)	1371	\|\| lastcell.stat_hp \|\| lastcell.flags \|\| lastcell.player)
1467	need_send = 1;	1372	need_send = 1;
1468		1373
1469	map_clearcell (&lastcell, count);	1374	map_clearcell (&lastcell, count);
1470		1375
…		…
1473	else	1378	else
1474	sl.reset (oldlen);	1379	sl.reset (oldlen);
1475	}	1380	}
1476	else	1381	else
1477	{	1382	{
1478	m->touch ();
1479
1480	/* In this block, the space is visible.	1383	/* In this block, the space is visible.
1481	*/	1384	*/
1482		1385
1483	/* Rather than try to figure out what everything that we might	1386	/* Rather than try to figure out what everything that we might
1484	* need to send is, then form the packet after that,	1387	* need to send is, then form the packet after that,
…		…
1488	* is done.	1391	* is done.
1489	* I think this is simpler than doing a bunch of checks to see	1392	* I think this is simpler than doing a bunch of checks to see
1490	* what if anything we need to send, setting the bits, then	1393	* what if anything we need to send, setting the bits, then
1491	* doing those checks again to add the real data.	1394	* doing those checks again to add the real data.
1492	*/	1395	*/
1493	oldlen = sl.length ();	1396	oldlen = sl.length ();
1494	mask = (ax & 0x3f) << 10 \| (ay & 0x3f) << 4;
1495	eoldlen = esl.length ();	1397	eoldlen = esl.length ();
1496	emask = (ax & 0x3f) << 10 \| (ay & 0x3f) << 4;	1398
1497	sl << uint16 (mask);	1399	sl << uint16 (mask);
1498
1499	if (socket.ext_mapinfos)
1500	esl << uint16 (emask);
1501		1400
1502	unsigned char dummy;	1401	unsigned char dummy;
1503	unsigned char *last_ext = &dummy;	1402	unsigned char *last_ext = &dummy;
1504		1403
1505	/* Darkness changed */	1404	/* Darkness changed */
…		…
1517	sl << uint8 (255 - 64 * d);	1416	sl << uint8 (255 - 64 * d);
1518	}	1417	}
1519		1418
1520	lastcell.count = d;	1419	lastcell.count = d;
1521		1420
		1421	mapspace &ms = m->at (nx, ny);
		1422
1522	if (socket.extmap)	1423	if (socket.extmap)
1523	{	1424	{
1524	uint8 stat_hp = 0;	1425	uint8 stat_hp = 0;
1525	uint8 stat_width = 0;	1426	uint8 stat_width = 0;
1526	uint8 flags = 0;	1427	uint8 flags = 0;
1527	UUID player = 0;	1428	UUID player = 0;
1528		1429
1529	// send hp information, if applicable	1430	// send hp information, if applicable
1530	if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))	1431	if (object *op = ms.faces_obj [0])
1531	{	1432	{
1532	if (op->head \|\| op->invisible)	1433	if (op->head \|\| op->invisible)
1533	; // do not show	1434	; // do not show
1534	else if (op->type == PLAYER	1435	else if (op->type == PLAYER
1535	\|\| QUERY_FLAG (op, FLAG_MONSTER) \|\| QUERY_FLAG (op, FLAG_ALIVE) \|\| QUERY_FLAG (op, FLAG_GENERATOR))	1436	\|\| QUERY_FLAG (op, FLAG_MONSTER) \|\| QUERY_FLAG (op, FLAG_ALIVE) \|\| QUERY_FLAG (op, FLAG_GENERATOR))
…		…
1589	sl << uint8 (8) << uint8 (flags);	1490	sl << uint8 (8) << uint8 (flags);
1590	}	1491	}
1591	}	1492	}
1592		1493
1593	/* Floor face */	1494	/* Floor face */
1594	if (update_space (sl, socket, m, nx, ny, ax, ay, 2))	1495	if (update_space (sl, socket, ms, lastcell, 2))
1595	mask \|= 0x4;	1496	mask \|= 0x4;
1596		1497
1597	if (socket.EMI_smooth)
1598	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 2))
1599	emask \|= 0x4;
1600
1601	/* Middle face */	1498	/* Middle face */
1602	if (update_space (sl, socket, m, nx, ny, ax, ay, 1))	1499	if (update_space (sl, socket, ms, lastcell, 1))
1603	mask \|= 0x2;	1500	mask \|= 0x2;
1604		1501
1605	if (socket.EMI_smooth)	1502	if (ms.player () == pl
1606	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 1))	1503	&& (pl->invisible & (pl->invisible < 50 ? 1 : 7)))
1607	emask \|= 0x2;
1608
1609	if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))
1610	{	1504	{
		1505	// force player to be visible to himself if invisible
1611	if (lastcell.faces[0] != pl->face)	1506	if (lastcell.faces[0] != pl->face)
1612	{	1507	{
1613	lastcell.faces[0] = pl->face;	1508	lastcell.faces[0] = pl->face;
		1509
1614	mask \|= 0x1;	1510	mask \|= 0x1;
1615
1616	if (!(socket.faces_sent[pl->face] & NS_FACESENT_FACE))
1617	esrv_send_face (&socket, pl->face, 0);
1618
1619	sl << uint16 (pl->face);	1511	sl << uint16 (pl->face);
		1512
		1513	socket.send_faces (pl);
1620	}	1514	}
1621	}	1515	}
1622	else
1623	{
1624	/* Top face */	1516	/* Top face */
1625	if (update_space (sl, socket, m, nx, ny, ax, ay, 0))	1517	else if (update_space (sl, socket, ms, lastcell, 0))
1626	mask \|= 0x1;	1518	mask \|= 0x1;
1627
1628	if (socket.EMI_smooth)
1629	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 0))
1630	emask \|= 0x1;
1631	}	1519
1632		1520
1633	/* Check to see if we are in fact sending anything for this	1521	/* Check to see if we are in fact sending anything for this
1634	* space by checking the mask. If so, update the mask.	1522	* space by checking the mask. If so, update the mask.
1635	* if not, reset the len to that from before adding the mask	1523	* if not, reset the len to that from before adding the mask
1636	* value, so we don't send those bits.	1524	* value, so we don't send those bits.
…		…
1638	if (mask & 0xf)	1526	if (mask & 0xf)
1639	sl[oldlen + 1] = mask & 0xff;	1527	sl[oldlen + 1] = mask & 0xff;
1640	else	1528	else
1641	sl.reset (oldlen);	1529	sl.reset (oldlen);
1642		1530
		1531	if (socket.ext_mapinfos)
		1532	esl << uint16 (emask);
		1533
		1534	if (socket.EMI_smooth)
		1535	{
		1536	for (int layer = 2+1; layer--; )
		1537	{
		1538	object *ob = ms.faces_obj [layer];
		1539
		1540	// If there is no object for this space, or if the face for the object
		1541	// is the blank face, set the smoothlevel to zero.
		1542	int smoothlevel = ob && ob->face != blank_face ? ob->smoothlevel : 0;
		1543
		1544	// We've gotten what face we want to use for the object. Now see if
		1545	// if it has changed since we last sent it to the client.
		1546	if (lastcell.smooth[layer] != smoothlevel)
		1547	{
		1548	lastcell.smooth[layer] = smoothlevel;
		1549	esl << uint8 (smoothlevel);
		1550	emask \|= 1 << layer;
		1551	}
		1552	}
		1553
1643	if (emask & 0xf)	1554	if (emask & 0xf)
1644	esl[eoldlen + 1] = emask & 0xff;	1555	esl[eoldlen + 1] = emask & 0xff;
1645	else	1556	else
1646	esl.reset (eoldlen);	1557	esl.reset (eoldlen);
		1558	}
1647	} /* else this is a viewable space */	1559	} /* else this is a viewable space */
1648	} /* for x loop */	1560	} /* for x loop */
1649	} /* for y loop */	1561	} /* for y loop */
1650		1562
1651	/* Verify that we in fact do need to send this */	1563	/* Verify that we in fact do need to send this */
…		…
1654	if (!(sl.length () > startlen \|\| socket.sent_scroll))	1566	if (!(sl.length () > startlen \|\| socket.sent_scroll))
1655	{	1567	{
1656	/* No map data will follow, so don't say the client	1568	/* No map data will follow, so don't say the client
1657	* it doesn't need draw!	1569	* it doesn't need draw!
1658	*/	1570	*/
1659	ewhatflag &= (~EMI_NOREDRAW);	1571	ewhatflag &= ~EMI_NOREDRAW;
1660	esl[ewhatstart + 1] = ewhatflag & 0xff;	1572	esl[ewhatstart + 1] = ewhatflag & 0xff;
1661	}	1573	}
1662		1574
1663	if (esl.length () > estartlen)	1575	if (esl.length () > estartlen)
1664	socket.send_packet (esl);	1576	socket.send_packet (esl);

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/socket/request.C (file contents): Revision 1.71 by root, Mon Mar 12 01:13:10 2007 UTC vs. Revision 1.78 by root, Thu Mar 15 14:59:43 2007 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.71 by root, Mon Mar 12 01:13:10 2007 UTC vs.
Revision 1.78 by root, Thu Mar 15 14:59:43 2007 UTC