[ViewVC] Diff of: cvs/deliantra/server/common/object.C

Comparing deliantra/server/common/object.C (file contents):
Revision 1.64 by root, Tue Dec 12 21:39:56 2006 UTC vs.
Revision 1.75 by root, Wed Dec 20 11:36:38 2006 UTC

…		…
29	#include <sys/types.h>	29	#include <sys/types.h>
30	#include <sys/uio.h>	30	#include <sys/uio.h>
31	#include <object.h>	31	#include <object.h>
32	#include <funcpoint.h>	32	#include <funcpoint.h>
33	#include <loader.h>	33	#include <loader.h>
		34
		35	#include <bitset>
34		36
35	int nrofallocobjects = 0;	37	int nrofallocobjects = 0;
36	static UUID uuid;	38	static UUID uuid;
37	const uint64 UUID_SKIP = 1<<19;	39	const uint64 UUID_SKIP = 1<<19;
38		40
…		…
183	*	185	*
184	* Note that this function appears a lot longer than the macro it	186	* Note that this function appears a lot longer than the macro it
185	* replaces - this is mostly for clarity - a decent compiler should hopefully	187	* replaces - this is mostly for clarity - a decent compiler should hopefully
186	* reduce this to the same efficiency.	188	* reduce this to the same efficiency.
187	*	189	*
188	* Check nrof variable before calling CAN_MERGE()	190	* Check nrof variable before calling can_merge()
189	*	191	*
190	* Improvements made with merge: Better checking on potion, and also	192	* Improvements made with merge: Better checking on potion, and also
191	* check weight	193	* check weight
192	*/	194	*/
193		195
194	bool object::can_merge (object ob1, object ob2)	196	bool object::can_merge_slow (object ob1, object ob2)
195	{	197	{
196	/* A couple quicksanity checks */	198	/* A couple quicksanity checks */
197	if ((ob1 == ob2) \|\| (ob1->type != ob2->type))	199	if (ob1 == ob2
		200	\|\| ob1->type != ob2->type
		201	\|\| ob1->speed != ob2->speed
		202	\|\| ob1->value != ob2->value
		203	\|\| ob1->name != ob2->name)
198	return 0;	204	return 0;
199		205
200	if (ob1->speed != ob2->speed)	206	//TODO: this ain't working well, use nicer and correct overflow check
201	return 0;
202
203	/* Do not merge objects if nrof would overflow. We use 1UL<<31 since that	207	/* Do not merge objects if nrof would overflow. We use 1UL<<31 since that
204	* value could not be stored in a sint32 (which unfortunately sometimes is	208	* value could not be stored in a sint32 (which unfortunately sometimes is
205	* used to store nrof).	209	* used to store nrof).
206	*/	210	*/
207	if (ob1->nrof + ob2->nrof >= 1UL << 31)	211	if (ob1->nrof + ob2->nrof >= 1UL << 31)
…		…
217	SET_FLAG (ob1, FLAG_BEEN_APPLIED);	221	SET_FLAG (ob1, FLAG_BEEN_APPLIED);
218		222
219	if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))	223	if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
220	SET_FLAG (ob2, FLAG_BEEN_APPLIED);	224	SET_FLAG (ob2, FLAG_BEEN_APPLIED);
221		225
222		226	if ((ob1->flags ^ ob2->flags).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any ()
223	/* the 0x400000 on flags2 is FLAG_INV_LOCK. I don't think something	227	\|\| ob1->arch != ob2->arch
224	* being locked in inventory should prevent merging.
225	* 0x4 in flags3 is CLIENT_SENT
226	*/
227	if ((ob1->arch != ob2->arch) \|\|
228	(ob1->flags[0] != ob2->flags[0]) \|\|
229	(ob1->flags[1] != ob2->flags[1]) \|\|
230	((ob1->flags[2] & ~0x400000) != (ob2->flags[2] & ~0x400000)) \|\|
231	((ob1->flags[3] & ~0x4) != (ob2->flags[3] & ~0x4)) \|\|
232	(ob1->name != ob2->name) \|\|	228	\|\| ob1->name != ob2->name
233	(ob1->title != ob2->title) \|\|	229	\|\| ob1->title != ob2->title
234	(ob1->msg != ob2->msg) \|\|	230	\|\| ob1->msg != ob2->msg
235	(ob1->weight != ob2->weight) \|\|	231	\|\| ob1->weight != ob2->weight
236	(memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist)) != 0) \|\|	232	\|\| memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
237	(memcmp (&ob1->stats, &ob2->stats, sizeof (ob1->stats)) != 0) \|\|	233	\|\| memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats) )
238	(ob1->attacktype != ob2->attacktype) \|\|	234	\|\| ob1->attacktype != ob2->attacktype
239	(ob1->magic != ob2->magic) \|\|	235	\|\| ob1->magic != ob2->magic
240	(ob1->slaying != ob2->slaying) \|\|	236	\|\| ob1->slaying != ob2->slaying
241	(ob1->skill != ob2->skill) \|\|	237	\|\| ob1->skill != ob2->skill
242	(ob1->value != ob2->value) \|\|	238	\|\| ob1->value != ob2->value
243	(ob1->animation_id != ob2->animation_id) \|\|	239	\|\| ob1->animation_id != ob2->animation_id
244	(ob1->client_type != ob2->client_type) \|\|	240	\|\| ob1->client_type != ob2->client_type
245	(ob1->materialname != ob2->materialname) \|\|	241	\|\| ob1->materialname != ob2->materialname
246	(ob1->lore != ob2->lore) \|\|	242	\|\| ob1->lore != ob2->lore
247	(ob1->subtype != ob2->subtype) \|\|	243	\|\| ob1->subtype != ob2->subtype
248	(ob1->move_type != ob2->move_type) \|\|	244	\|\| ob1->move_type != ob2->move_type
249	(ob1->move_block != ob2->move_block) \|\|	245	\|\| ob1->move_block != ob2->move_block
250	(ob1->move_allow != ob2->move_allow) \|\|	246	\|\| ob1->move_allow != ob2->move_allow
251	(ob1->move_on != ob2->move_on) \|\|	247	\|\| ob1->move_on != ob2->move_on
252	(ob1->move_off != ob2->move_off) \|\| (ob1->move_slow != ob2->move_slow) \|\| (ob1->move_slow_penalty != ob2->move_slow_penalty))	248	\|\| ob1->move_off != ob2->move_off
		249	\|\| ob1->move_slow != ob2->move_slow
		250	\|\| ob1->move_slow_penalty != ob2->move_slow_penalty)
253	return 0;	251	return 0;
254		252
255	/* This is really a spellbook check - really, we should	253	/* This is really a spellbook check - really, we should
256	* check all objects in the inventory.	254	* check all objects in the inventory.
257	*/	255	*/
…		…
260	/* if one object has inventory but the other doesn't, not equiv */	258	/* if one object has inventory but the other doesn't, not equiv */
261	if ((ob1->inv && !ob2->inv) \|\| (ob2->inv && !ob1->inv))	259	if ((ob1->inv && !ob2->inv) \|\| (ob2->inv && !ob1->inv))
262	return 0;	260	return 0;
263		261
264	/* Now check to see if the two inventory objects could merge */	262	/* Now check to see if the two inventory objects could merge */
265	if (!CAN_MERGE (ob1->inv, ob2->inv))	263	if (!object::can_merge (ob1->inv, ob2->inv))
266	return 0;	264	return 0;
267		265
268	/* inventory ok - still need to check rest of this object to see	266	/* inventory ok - still need to check rest of this object to see
269	* if it is valid.	267	* if it is valid.
270	*/	268	*/
…		…
350	object *	348	object *
351	object_get_env_recursive (object *op)	349	object_get_env_recursive (object *op)
352	{	350	{
353	while (op->env != NULL)	351	while (op->env != NULL)
354	op = op->env;	352	op = op->env;
355	return op;
356	}
357
358	/*
359	* Eneq(@csd.uu.se): Since we can have items buried in a character we need
360	* a better check. We basically keeping traversing up until we can't
361	* or find a player.
362	*/
363
364	object *
365	is_player_inv (object *op)
366	{
367	for (; op != NULL && op->type != PLAYER; op = op->env)
368	if (op->env == op)
369	op->env = NULL;
370	return op;	353	return op;
371	}	354	}
372		355
373	/*	356	/*
374	* Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.	357	* Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
…		…
588	}	571	}
589		572
590	update_ob_speed (dst);	573	update_ob_speed (dst);
591	}	574	}
592		575
		576	object *
		577	object::clone ()
		578	{
		579	object *neu = create ();
		580	copy_to (neu);
		581	return neu;
		582	}
		583
593	/*	584	/*
594	* If an object with the IS_TURNABLE() flag needs to be turned due	585	* If an object with the IS_TURNABLE() flag needs to be turned due
595	* to the closest player being on the other side, this function can	586	* to the closest player being on the other side, this function can
596	* be called to update the face variable, _and_ how it looks on the map.	587	* be called to update the face variable, _and_ how it looks on the map.
597	*/	588	*/
…		…
703	op->active_next = NULL;	694	op->active_next = NULL;
704	op->active_prev = NULL;	695	op->active_prev = NULL;
705	}	696	}
706		697
707	/*	698	/*
708	* update_object() updates the array which represents the map.	699	* update_object() updates the the map.
709	* It takes into account invisible objects (and represent squares covered	700	* It takes into account invisible objects (and represent squares covered
710	* by invisible objects by whatever is below them (unless it's another	701	* by invisible objects by whatever is below them (unless it's another
711	* invisible object, etc...)	702	* invisible object, etc...)
712	* If the object being updated is beneath a player, the look-window	703	* If the object being updated is beneath a player, the look-window
713	* of that player is updated (this might be a suboptimal way of	704	* of that player is updated (this might be a suboptimal way of
714	* updating that window, though, since update_object() is called _often_)	705	* updating that window, though, since update_object() is called _often_)
715	*	706	*
716	* action is a hint of what the caller believes need to be done.	707	* action is a hint of what the caller believes need to be done.
717	* For example, if the only thing that has changed is the face (due to
718	* an animation), we don't need to call update_position until that actually
719	* comes into view of a player. OTOH, many other things, like addition/removal
720	* of walls or living creatures may need us to update the flags now.
721	* current action are:	708	* current action are:
722	* UP_OBJ_INSERT: op was inserted	709	* UP_OBJ_INSERT: op was inserted
723	* UP_OBJ_REMOVE: op was removed	710	* UP_OBJ_REMOVE: op was removed
724	* UP_OBJ_CHANGE: object has somehow changed. In this case, we always update	711	* UP_OBJ_CHANGE: object has somehow changed. In this case, we always update
725	* as that is easier than trying to look at what may have changed.	712	* as that is easier than trying to look at what may have changed.
726	* UP_OBJ_FACE: only the objects face has changed.	713	* UP_OBJ_FACE: only the objects face has changed.
727	*/	714	*/
728
729	void	715	void
730	update_object (object *op, int action)	716	update_object (object *op, int action)
731	{	717	{
732	int update_now = 0, flags;
733	MoveType move_on, move_off, move_block, move_slow;	718	MoveType move_on, move_off, move_block, move_slow;
734		719
735	if (op == NULL)	720	if (op == NULL)
736	{	721	{
737	/* this should never happen */	722	/* this should never happen */
738	LOG (llevDebug, "update_object() called for NULL object.\n");	723	LOG (llevDebug, "update_object() called for NULL object.\n");
739	return;	724	return;
740	}	725	}
741		726
742	if (op->env != NULL)	727	if (op->env)
743	{	728	{
744	/* Animation is currently handled by client, so nothing	729	/* Animation is currently handled by client, so nothing
745	* to do in this case.	730	* to do in this case.
746	*/	731	*/
747	return;	732	return;
…		…
761	abort ();	746	abort ();
762	#endif	747	#endif
763	return;	748	return;
764	}	749	}
765		750
766	flags = GET_MAP_FLAGS (op->map, op->x, op->y);	751	mapspace &m = op->map->at (op->x, op->y);
767	SET_MAP_FLAGS (op->map, op->x, op->y, flags \| P_NEED_UPDATE);
768	move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
769	move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
770	move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
771	move_off = GET_MAP_MOVE_OFF (op->map, op->x, op->y);
772		752
		753	if (m.flags_ & P_NEED_UPDATE)
		754	/* nop */;
773	if (action == UP_OBJ_INSERT)	755	else if (action == UP_OBJ_INSERT)
774	{	756	{
		757	// this is likely overkill, TODO: revisit (schmorp)
775	if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(flags & P_BLOCKSVIEW))	758	if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW))
776	update_now = 1;
777
778	if (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(flags & P_NO_MAGIC))	759	\|\| (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC))
779	update_now = 1;	760	\|\| (op->type == PLAYER && !(m.flags_ & P_PLAYER))
780		761	\|\| (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE))
		762	\|\| (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE))
781	if (QUERY_FLAG (op, FLAG_DAMNED) && !(flags & P_NO_CLERIC))	763	\|\| (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
782	update_now = 1;
783
784	if (QUERY_FLAG (op, FLAG_ALIVE) && !(flags & P_IS_ALIVE))
785	update_now = 1;
786
787	if (op->type == SAFE_GROUND && !(flags & P_SAFE))
788	update_now = 1;
789
790	if ((move_on \| op->move_on) != move_on)	764	\|\| (m.move_on \| op->move_on ) != m.move_on
791	update_now = 1;
792
793	if ((move_off \| op->move_off) != move_off)	765	\|\| (m.move_off \| op->move_off ) != m.move_off
794	update_now = 1;	766	\|\| (m.move_slow \| op->move_slow) != m.move_slow
795
796	/* This isn't perfect, but I don't expect a lot of objects to	767	/* This isn't perfect, but I don't expect a lot of objects to
797	* to have move_allow right now.	768	* to have move_allow right now.
798	*/	769	*/
799	if (((move_block \| op->move_block) & ~op->move_allow) != move_block)	770	\|\| ((m.move_block \| op->move_block) & ~op->move_allow) != m.move_block
800	update_now = 1;	771	\|\| 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
801		772	m.flags_ = P_NEED_UPDATE;
802	if ((move_slow \| op->move_slow) != move_slow)
803	update_now = 1;
804	}	773	}
805
806	/* if the object is being removed, we can't make intelligent	774	/* if the object is being removed, we can't make intelligent
807	* decisions, because remove_ob can't really pass the object	775	* decisions, because remove_ob can't really pass the object
808	* that is being removed.	776	* that is being removed.
809	*/	777	*/
810	else if (action == UP_OBJ_CHANGE \|\| action == UP_OBJ_REMOVE)	778	else if (action == UP_OBJ_CHANGE \|\| action == UP_OBJ_REMOVE)
811	update_now = 1;	779	m.flags_ = P_NEED_UPDATE;
812	else if (action == UP_OBJ_FACE)	780	else if (action == UP_OBJ_FACE)
813	/* Nothing to do for that case */ ;	781	/* Nothing to do for that case */ ;
814	else	782	else
815	LOG (llevError, "update_object called with invalid action: %d\n", action);	783	LOG (llevError, "update_object called with invalid action: %d\n", action);
816		784
817	if (update_now)
818	{
819	SET_MAP_FLAGS (op->map, op->x, op->y, flags \| P_NO_ERROR \| P_NEED_UPDATE);
820	update_position (op->map, op->x, op->y);
821	}
822
823	if (op->more != NULL)	785	if (op->more)
824	update_object (op->more, action);	786	update_object (op->more, action);
825	}	787	}
826		788
827	object::vector object::mortals;	789	object::vector object::mortals;
828	object::vector object::objects; // not yet used	790	object::vector object::objects; // not yet used
…		…
1049		1011
1050	/* NO_FIX_PLAYER is set when a great many changes are being	1012	/* NO_FIX_PLAYER is set when a great many changes are being
1051	* made to players inventory. If set, avoiding the call	1013	* made to players inventory. If set, avoiding the call
1052	* to save cpu time.	1014	* to save cpu time.
1053	*/	1015	*/
1054	if ((otmp = is_player_inv (env)) != NULL && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))	1016	if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1055	fix_player (otmp);	1017	fix_player (otmp);
1056		1018
1057	if (above != NULL)	1019	if (above != NULL)
1058	above->below = below;	1020	above->below = below;
1059	else	1021	else
…		…
1079		1041
1080	/* link the object above us */	1042	/* link the object above us */
1081	if (above)	1043	if (above)
1082	above->below = below;	1044	above->below = below;
1083	else	1045	else
1084	SET_MAP_TOP (map, x, y, below); /* we were top, set new top */	1046	map->at (x, y).top = below; /* we were top, set new top */
1085		1047
1086	/* Relink the object below us, if there is one */	1048	/* Relink the object below us, if there is one */
1087	if (below)	1049	if (below)
1088	below->above = above;	1050	below->above = above;
1089	else	1051	else
…		…
1101	dump = dump_object (GET_MAP_OB (map, x, y));	1063	dump = dump_object (GET_MAP_OB (map, x, y));
1102	LOG (llevError, "%s\n", dump);	1064	LOG (llevError, "%s\n", dump);
1103	free (dump);	1065	free (dump);
1104	}	1066	}
1105		1067
1106	SET_MAP_OB (map, x, y, above); /* goes on above it. */	1068	map->at (x, y).bottom = above; /* goes on above it. */
1107	}	1069	}
1108		1070
1109	above = 0;	1071	above = 0;
1110	below = 0;	1072	below = 0;
1111		1073
…		…
1130	{	1092	{
1131	CLEAR_FLAG (this, FLAG_APPLIED);	1093	CLEAR_FLAG (this, FLAG_APPLIED);
1132	tmp->container = 0;	1094	tmp->container = 0;
1133	}	1095	}
1134		1096
1135	tmp->contr->socket.update_look = 1;	1097	tmp->contr->socket->floorbox_update ();
1136	}	1098	}
1137		1099
1138	/* See if player moving off should effect something */	1100	/* See if player moving off should effect something */
1139	if (check_walk_off	1101	if (check_walk_off
1140	&& ((move_type & tmp->move_off)	1102	&& ((move_type & tmp->move_off)
…		…
1154	last = tmp;	1116	last = tmp;
1155	}	1117	}
1156		1118
1157	/* last == NULL of there are no objects on this space */	1119	/* last == NULL of there are no objects on this space */
1158	if (!last)	1120	if (!last)
1159	{	1121	map->at (x, y).flags_ = P_NEED_UPDATE;
1160	/* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1161	* we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1162	* those out anyways, and if there are any flags set right now, they won't
1163	* be correct anyways.
1164	*/
1165	SET_MAP_FLAGS (map, x, y, P_NEED_UPDATE);
1166	update_position (map, x, y);
1167	}
1168	else	1122	else
1169	update_object (last, UP_OBJ_REMOVE);	1123	update_object (last, UP_OBJ_REMOVE);
1170		1124
1171	if (QUERY_FLAG (this, FLAG_BLOCKSVIEW) \|\| glow_radius)	1125	if (QUERY_FLAG (this, FLAG_BLOCKSVIEW) \|\| glow_radius)
1172	update_all_los (map, x, y);	1126	update_all_los (map, x, y);
…		…
1192		1146
1193	for (; top != NULL; top = top->below)	1147	for (; top != NULL; top = top->below)
1194	{	1148	{
1195	if (top == op)	1149	if (top == op)
1196	continue;	1150	continue;
1197	if (CAN_MERGE (op, top))	1151
		1152	if (object::can_merge (op, top))
1198	{	1153	{
1199	top->nrof += op->nrof;	1154	top->nrof += op->nrof;
1200		1155
1201	/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/	1156	/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/
1202	op->weight = 0; /* Don't want any adjustements now */	1157	op->weight = 0; /* Don't want any adjustements now */
…		…
1335		1290
1336	/* this has to be done after we translate the coordinates.	1291	/* this has to be done after we translate the coordinates.
1337	*/	1292	*/
1338	if (op->nrof && !(flag & INS_NO_MERGE))	1293	if (op->nrof && !(flag & INS_NO_MERGE))
1339	for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)	1294	for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)
1340	if (CAN_MERGE (op, tmp))	1295	if (object::can_merge (op, tmp))
1341	{	1296	{
1342	op->nrof += tmp->nrof;	1297	op->nrof += tmp->nrof;
1343	tmp->destroy ();	1298	tmp->destroy ();
1344	}	1299	}
1345		1300
…		…
1361	op->below = originator->below;	1316	op->below = originator->below;
1362		1317
1363	if (op->below)	1318	if (op->below)
1364	op->below->above = op;	1319	op->below->above = op;
1365	else	1320	else
1366	SET_MAP_OB (op->map, op->x, op->y, op);	1321	op->map->at (op->x, op->y).bottom = op;
1367		1322
1368	/* since below originator, no need to update top */	1323	/* since below originator, no need to update top */
1369	originator->below = op;	1324	originator->below = op;
1370	}	1325	}
1371	else	1326	else
…		…
1417	* If INS_ON_TOP is used, don't do this processing	1372	* If INS_ON_TOP is used, don't do this processing
1418	* Need to find the object that in fact blocks view, otherwise	1373	* Need to find the object that in fact blocks view, otherwise
1419	* stacking is a bit odd.	1374	* stacking is a bit odd.
1420	*/	1375	*/
1421	if (!(flag & INS_ON_TOP) &&	1376	if (!(flag & INS_ON_TOP) &&
1422	(get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))	1377	(get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
1423	{	1378	{
1424	for (last = top; last != floor; last = last->below)	1379	for (last = top; last != floor; last = last->below)
1425	if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))	1380	if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1426	break;	1381	break;
1427	/* Check to see if we found the object that blocks view,	1382	/* Check to see if we found the object that blocks view,
…		…
1450		1405
1451	if (op->above)	1406	if (op->above)
1452	op->above->below = op;	1407	op->above->below = op;
1453		1408
1454	op->below = NULL;	1409	op->below = NULL;
1455	SET_MAP_OB (op->map, op->x, op->y, op);	1410	op->map->at (op->x, op->y).bottom = op;
1456	}	1411	}
1457	else	1412	else
1458	{ /* get inserted into the stack above top */	1413	{ /* get inserted into the stack above top */
1459	op->above = top->above;	1414	op->above = top->above;
1460		1415
…		…
1464	op->below = top;	1419	op->below = top;
1465	top->above = op;	1420	top->above = op;
1466	}	1421	}
1467		1422
1468	if (op->above == NULL)	1423	if (op->above == NULL)
1469	SET_MAP_TOP (op->map, op->x, op->y, op);	1424	op->map->at (op->x, op->y).top = op;
1470	} /* else not INS_BELOW_ORIGINATOR */	1425	} /* else not INS_BELOW_ORIGINATOR */
1471		1426
1472	if (op->type == PLAYER)	1427	if (op->type == PLAYER)
1473	op->contr->do_los = 1;	1428	op->contr->do_los = 1;
1474		1429
1475	/* If we have a floor, we know the player, if any, will be above	1430	/* If we have a floor, we know the player, if any, will be above
1476	* it, so save a few ticks and start from there.	1431	* it, so save a few ticks and start from there.
1477	*/	1432	*/
1478	if (!(flag & INS_MAP_LOAD))	1433	if (!(flag & INS_MAP_LOAD))
1479	for (tmp = floor ? floor : GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1434	if (object *pl = op->map->at (op->x, op->y).player ())
1480	if (tmp->type == PLAYER)	1435	pl->contr->socket->floorbox_update ();
1481	tmp->contr->socket.update_look = 1;
1482		1436
1483	/* If this object glows, it may affect lighting conditions that are	1437	/* If this object glows, it may affect lighting conditions that are
1484	* visible to others on this map. But update_all_los is really	1438	* visible to others on this map. But update_all_los is really
1485	* an inefficient way to do this, as it means los for all players	1439	* an inefficient way to do this, as it means los for all players
1486	* on the map will get recalculated. The players could very well	1440	* on the map will get recalculated. The players could very well
…		…
1494		1448
1495	/* updates flags (blocked, alive, no magic, etc) for this map space */	1449	/* updates flags (blocked, alive, no magic, etc) for this map space */
1496	update_object (op, UP_OBJ_INSERT);	1450	update_object (op, UP_OBJ_INSERT);
1497		1451
1498	/* Don't know if moving this to the end will break anything. However,	1452	/* Don't know if moving this to the end will break anything. However,
1499	* we want to have update_look set above before calling this.	1453	* we want to have floorbox_update called before calling this.
1500	*	1454	*
1501	* check_move_on() must be after this because code called from	1455	* check_move_on() must be after this because code called from
1502	* check_move_on() depends on correct map flags (so functions like	1456	* check_move_on() depends on correct map flags (so functions like
1503	* blocked() and wall() work properly), and these flags are updated by	1457	* blocked() and wall() work properly), and these flags are updated by
1504	* update_object().	1458	* update_object().
…		…
1520		1474
1521	return op;	1475	return op;
1522	}	1476	}
1523		1477
1524	/* this function inserts an object in the map, but if it	1478	/* this function inserts an object in the map, but if it
1525	* finds an object of its own type, it'll remove that one first.	1479	* finds an object of its own type, it'll remove that one first.
1526	* op is the object to insert it under: supplies x and the map.	1480	* op is the object to insert it under: supplies x and the map.
1527	*/	1481	*/
1528	void	1482	void
1529	replace_insert_ob_in_map (const char arch_string, object op)	1483	replace_insert_ob_in_map (const char arch_string, object op)
1530	{	1484	{
1531	object *	1485	object tmp, tmp1;
1532	tmp;
1533	object *
1534	tmp1;
1535		1486
1536	/* first search for itself and remove any old instances */	1487	/* first search for itself and remove any old instances */
1537		1488
1538	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1489	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1539	if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */	1490	if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */
…		…
1607	if (i > op->nrof)	1558	if (i > op->nrof)
1608	i = op->nrof;	1559	i = op->nrof;
1609		1560
1610	if (QUERY_FLAG (op, FLAG_REMOVED))	1561	if (QUERY_FLAG (op, FLAG_REMOVED))
1611	op->nrof -= i;	1562	op->nrof -= i;
1612	else if (op->env != NULL)	1563	else if (op->env)
1613	{	1564	{
1614	/* is this object in the players inventory, or sub container	1565	/* is this object in the players inventory, or sub container
1615	* therein?	1566	* therein?
1616	*/	1567	*/
1617	tmp = is_player_inv (op->env);	1568	tmp = op->in_player ();
1618	/* nope. Is this a container the player has opened?	1569	/* nope. Is this a container the player has opened?
1619	* If so, set tmp to that player.	1570	* If so, set tmp to that player.
1620	* IMO, searching through all the players will mostly	1571	* IMO, searching through all the players will mostly
1621	* likely be quicker than following op->env to the map,	1572	* likely be quicker than following op->env to the map,
1622	* and then searching the map for a player.	1573	* and then searching the map for a player.
1623	*/	1574	*/
1624	if (!tmp)	1575	if (!tmp)
1625	{	1576	{
1626	for (pl = first_player; pl; pl = pl->next)	1577	for (pl = first_player; pl; pl = pl->next)
1627	if (pl->ob->container == op->env)	1578	if (pl->ob->container == op->env)
		1579	{
		1580	tmp = pl->ob;
1628	break;	1581	break;
1629	if (pl)	1582	}
1630	tmp = pl->ob;
1631	else
1632	tmp = NULL;
1633	}	1583	}
1634		1584
1635	if (i < op->nrof)	1585	if (i < op->nrof)
1636	{	1586	{
1637	sub_weight (op->env, op->weight * i);	1587	sub_weight (op->env, op->weight * i);
1638	op->nrof -= i;	1588	op->nrof -= i;
1639	if (tmp)	1589	if (tmp)
1640	{
1641	esrv_send_item (tmp, op);	1590	esrv_send_item (tmp, op);
1642	}
1643	}	1591	}
1644	else	1592	else
1645	{	1593	{
1646	op->remove ();	1594	op->remove ();
1647	op->nrof = 0;	1595	op->nrof = 0;
1648	if (tmp)	1596	if (tmp)
1649	{
1650	esrv_del_item (tmp->contr, op->count);	1597	esrv_del_item (tmp->contr, op->count);
1651	}
1652	}	1598	}
1653	}	1599	}
1654	else	1600	else
1655	{	1601	{
1656	object *above = op->above;	1602	object *above = op->above;
…		…
1662	op->remove ();	1608	op->remove ();
1663	op->nrof = 0;	1609	op->nrof = 0;
1664	}	1610	}
1665		1611
1666	/* Since we just removed op, op->above is null */	1612	/* Since we just removed op, op->above is null */
1667	for (tmp = above; tmp != NULL; tmp = tmp->above)	1613	for (tmp = above; tmp; tmp = tmp->above)
1668	if (tmp->type == PLAYER)	1614	if (tmp->type == PLAYER)
1669	{	1615	{
1670	if (op->nrof)	1616	if (op->nrof)
1671	esrv_send_item (tmp, op);	1617	esrv_send_item (tmp, op);
1672	else	1618	else
…		…
1677	if (op->nrof)	1623	if (op->nrof)
1678	return op;	1624	return op;
1679	else	1625	else
1680	{	1626	{
1681	op->destroy ();	1627	op->destroy ();
1682	return NULL;	1628	return 0;
1683	}	1629	}
1684	}	1630	}
1685		1631
1686	/*	1632	/*
1687	* add_weight(object, weight) adds the specified weight to an object,	1633	* add_weight(object, weight) adds the specified weight to an object,
…		…
1747	CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);	1693	CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1748	CLEAR_FLAG (op, FLAG_REMOVED);	1694	CLEAR_FLAG (op, FLAG_REMOVED);
1749	if (op->nrof)	1695	if (op->nrof)
1750	{	1696	{
1751	for (tmp = inv; tmp != NULL; tmp = tmp->below)	1697	for (tmp = inv; tmp != NULL; tmp = tmp->below)
1752	if (CAN_MERGE (tmp, op))	1698	if (object::can_merge (tmp, op))
1753	{	1699	{
1754	/* return the original object and remove inserted object	1700	/* return the original object and remove inserted object
1755	(client needs the original object) */	1701	(client needs the original object) */
1756	tmp->nrof += op->nrof;	1702	tmp->nrof += op->nrof;
1757	/* Weight handling gets pretty funky. Since we are adding to	1703	/* Weight handling gets pretty funky. Since we are adding to
…		…
1775	add_weight (this, op->weight * op->nrof);	1721	add_weight (this, op->weight * op->nrof);
1776	}	1722	}
1777	else	1723	else
1778	add_weight (this, (op->weight + op->carrying));	1724	add_weight (this, (op->weight + op->carrying));
1779		1725
1780	otmp = is_player_inv (this);	1726	otmp = this->in_player ();
1781	if (otmp && otmp->contr)	1727	if (otmp && otmp->contr)
1782	if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))	1728	if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1783	fix_player (otmp);	1729	fix_player (otmp);
1784		1730
1785	op->map = NULL;	1731	op->map = 0;
1786	op->env = this;	1732	op->env = this;
1787	op->above = NULL;	1733	op->above = 0;
1788	op->below = NULL;	1734	op->below = 0;
1789	op->x = 0, op->y = 0;	1735	op->x = 0, op->y = 0;
1790		1736
1791	/* reset the light list and los of the players on the map */	1737	/* reset the light list and los of the players on the map */
1792	if ((op->glow_radius != 0) && map)	1738	if ((op->glow_radius != 0) && map)
1793	{	1739	{
…		…
2130	* if the space being examined only has a wall to the north and empty	2076	* if the space being examined only has a wall to the north and empty
2131	* spaces in all the other directions, this will reduce the search space	2077	* spaces in all the other directions, this will reduce the search space
2132	* to only the spaces immediately surrounding the target area, and	2078	* to only the spaces immediately surrounding the target area, and
2133	* won't look 2 spaces south of the target space.	2079	* won't look 2 spaces south of the target space.
2134	*/	2080	*/
2135	else if ((flag & AB_NO_PASS) && maxfree[i] < stop)	2081	else if ((flag & P_NO_PASS) && maxfree[i] < stop)
2136	stop = maxfree[i];	2082	stop = maxfree[i];
2137	}	2083	}
		2084
2138	if (!index)	2085	if (!index)
2139	return -1;	2086	return -1;
		2087
2140	return altern[RANDOM () % index];	2088	return altern[RANDOM () % index];
2141	}	2089	}
2142		2090
2143	/*	2091	/*
2144	* find_first_free_spot(archetype, maptile, x, y) works like	2092	* find_first_free_spot(archetype, maptile, x, y) works like
…		…
2252	mp = m;	2200	mp = m;
2253	nx = x + freearr_x[i];	2201	nx = x + freearr_x[i];
2254	ny = y + freearr_y[i];	2202	ny = y + freearr_y[i];
2255		2203
2256	mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);	2204	mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
		2205
2257	if (mflags & P_OUT_OF_MAP)	2206	if (mflags & P_OUT_OF_MAP)
2258	{
2259	max = maxfree[i];	2207	max = maxfree[i];
2260	}
2261	else	2208	else
2262	{	2209	{
2263	blocked = GET_MAP_MOVE_BLOCK (mp, nx, ny);	2210	blocked = GET_MAP_MOVE_BLOCK (mp, nx, ny);
2264		2211
2265	if ((move_type & blocked) == move_type)	2212	if ((move_type & blocked) == move_type)
2266	{
2267	max = maxfree[i];	2213	max = maxfree[i];
2268	}
2269	else if (mflags & P_IS_ALIVE)	2214	else if (mflags & P_IS_ALIVE)
2270	{	2215	{
2271	for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = tmp->above)	2216	for (tmp = GET_MAP_OB (mp, nx, ny); tmp; tmp = tmp->above)
2272	{
2273	if ((QUERY_FLAG (tmp, FLAG_MONSTER) \|\| tmp->type == PLAYER) && (tmp != exclude \|\| (tmp->head && tmp->head != exclude)))	2217	if ((QUERY_FLAG (tmp, FLAG_MONSTER) \|\| tmp->type == PLAYER) && (tmp != exclude \|\| (tmp->head && tmp->head != exclude)))
2274	{
2275	break;	2218	break;
2276	}	2219
2277	}
2278	if (tmp)	2220	if (tmp)
2279	{
2280	return freedir[i];	2221	return freedir[i];
2281	}
2282	}	2222	}
2283	}	2223	}
2284	}	2224	}
		2225
2285	return 0;	2226	return 0;
2286	}	2227	}
2287		2228
2288	/*	2229	/*
2289	* distance(object 1, object 2) will return the square of the	2230	* distance(object 1, object 2) will return the square of the
…		…
2291	*/	2232	*/
2292		2233
2293	int	2234	int
2294	distance (const object ob1, const object ob2)	2235	distance (const object ob1, const object ob2)
2295	{	2236	{
2296	int	2237	int i;
2297	i;
2298		2238
2299	i = (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);	2239	i = (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);
2300	return i;	2240	return i;
2301	}	2241	}
2302		2242
…		…
2307	*/	2247	*/
2308		2248
2309	int	2249	int
2310	find_dir_2 (int x, int y)	2250	find_dir_2 (int x, int y)
2311	{	2251	{
2312	int	2252	int q;
2313	q;
2314		2253
2315	if (y)	2254	if (y)
2316	q = x * 100 / y;	2255	q = x * 100 / y;
2317	else if (x)	2256	else if (x)
2318	q = -300 * x;	2257	q = -300 * x;
…		…
2444	* find a path to that monster that we found. If not,	2383	* find a path to that monster that we found. If not,
2445	* we don't bother going toward it. Returns 1 if we	2384	* we don't bother going toward it. Returns 1 if we
2446	* can see a direct way to get it	2385	* can see a direct way to get it
2447	* Modified to be map tile aware -.MSW	2386	* Modified to be map tile aware -.MSW
2448	*/	2387	*/
2449
2450
2451	int	2388	int
2452	can_see_monsterP (maptile *m, int x, int y, int dir)	2389	can_see_monsterP (maptile *m, int x, int y, int dir)
2453	{	2390	{
2454	sint16 dx, dy;	2391	sint16 dx, dy;
2455	int
2456	mflags;	2392	int mflags;
2457		2393
2458	if (dir < 0)	2394	if (dir < 0)
2459	return 0; /* exit condition: invalid direction */	2395	return 0; /* exit condition: invalid direction */
2460		2396
2461	dx = x + freearr_x[dir];	2397	dx = x + freearr_x[dir];
…		…
2474	return 0;	2410	return 0;
2475		2411
2476	/* yes, can see. */	2412	/* yes, can see. */
2477	if (dir < 9)	2413	if (dir < 9)
2478	return 1;	2414	return 1;
		2415
2479	return can_see_monsterP (m, x, y, reduction_dir[dir][0]) \|	2416	return can_see_monsterP (m, x, y, reduction_dir[dir][0])
2480	can_see_monsterP (m, x, y, reduction_dir[dir][1]) \| can_see_monsterP (m, x, y, reduction_dir[dir][2]);	2417	\| can_see_monsterP (m, x, y, reduction_dir[dir][1])
		2418	\| can_see_monsterP (m, x, y, reduction_dir[dir][2]);
2481	}	2419	}
2482
2483
2484		2420
2485	/*	2421	/*
2486	* can_pick(picker, item): finds out if an object is possible to be	2422	* can_pick(picker, item): finds out if an object is possible to be
2487	* picked up by the picker. Returnes 1 if it can be	2423	* picked up by the picker. Returnes 1 if it can be
2488	* picked up, otherwise 0.	2424	* picked up, otherwise 0.
…		…
2499	return /QUERY_FLAG(who,FLAG_WIZ)\|\| /	2435	return /QUERY_FLAG(who,FLAG_WIZ)\|\| /
2500	(item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&	2436	(item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
2501	!QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER \|\| item->weight < who->weight / 3));	2437	!QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER \|\| item->weight < who->weight / 3));
2502	}	2438	}
2503		2439
2504
2505	/*	2440	/*
2506	* create clone from object to another	2441	* create clone from object to another
2507	*/	2442	*/
2508	object *	2443	object *
2509	object_create_clone (object *asrc)	2444	object_create_clone (object *asrc)
…		…
2518	src = src->head;	2453	src = src->head;
2519		2454
2520	prev = 0;	2455	prev = 0;
2521	for (part = src; part; part = part->more)	2456	for (part = src; part; part = part->more)
2522	{	2457	{
2523	tmp = object::create ();	2458	tmp = part->clone ();
2524	part->copy_to (tmp);
2525	tmp->x -= src->x;	2459	tmp->x -= src->x;
2526	tmp->y -= src->y;	2460	tmp->y -= src->y;
2527		2461
2528	if (!part->head)	2462	if (!part->head)
2529	{	2463	{
2530	dst = tmp;	2464	dst = tmp;
2531	tmp->head = 0;	2465	tmp->head = 0;
2532	}	2466	}
2533	else	2467	else
2534	{
2535	tmp->head = dst;	2468	tmp->head = dst;
2536	}
2537		2469
2538	tmp->more = 0;	2470	tmp->more = 0;
2539		2471
2540	if (prev)	2472	if (prev)
2541	prev->more = tmp;	2473	prev->more = tmp;

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.64 by root, Tue Dec 12 21:39:56 2006 UTC vs. Revision 1.75 by root, Wed Dec 20 11:36:38 2006 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.64 by root, Tue Dec 12 21:39:56 2006 UTC vs.
Revision 1.75 by root, Wed Dec 20 11:36:38 2006 UTC