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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.35 by root, Tue Sep 12 18:15:34 2006 UTC vs.
Revision 1.53 by root, Tue Nov 7 16:30:54 2006 UTC

…		…
1
2	/*	1	/*
3	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
4		3
5	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	4	Copyright (C) 2001 Mark Wedel & Crossfire Development Team
6	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
17		16
18	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
19	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21		20
22	The authors can be reached via e-mail at crossfire-devel@real-time.com	21	The authors can be reached via e-mail at <crossfire@schmorp.de>
23	*/	22	*/
24		23
25	/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.	24	/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
26	sub/add_weight will transcend the environment updating the carrying	25	sub/add_weight will transcend the environment updating the carrying
27	variable. */	26	variable. */
…		…
32	#include <object.h>	31	#include <object.h>
33	#include <funcpoint.h>	32	#include <funcpoint.h>
34	#include <loader.h>	33	#include <loader.h>
35		34
36	int nrofallocobjects = 0;	35	int nrofallocobjects = 0;
		36	static UUID uuid;
		37	const uint64 UUID_SKIP = 1<<19;
37		38
38	object objects; / Pointer to the list of used objects */
39	object active_objects; / List of active objects that need to be processed */	39	object active_objects; / List of active objects that need to be processed */
40		40
41	short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,	41	short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,
42	0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1	42	0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
43	};	43	};
…		…
49	};	49	};
50	int freedir[SIZEOFFREE] = {	50	int freedir[SIZEOFFREE] = {
51	0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8,	51	0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8,
52	1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8	52	1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8
53	};	53	};
		54
		55	static void
		56	write_uuid (void)
		57	{
		58	char filename1[MAX_BUF], filename2[MAX_BUF];
		59
		60	sprintf (filename1, "%s/uuid", settings.localdir);
		61	sprintf (filename2, "%s/uuid~", settings.localdir);
		62
		63	FILE *fp;
		64
		65	if (!(fp = fopen (filename2, "w")))
		66	{
		67	LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
		68	return;
		69	}
		70
		71	fprintf (fp, "<1,%llx>\n", (unsigned long long)uuid.seq + UUID_SKIP * 2);
		72	fclose (fp);
		73	rename (filename2, filename1);
		74	}
		75
		76	static void
		77	read_uuid (void)
		78	{
		79	char filename[MAX_BUF];
		80
		81	sprintf (filename, "%s/uuid", settings.localdir);
		82
		83	FILE *fp;
		84
		85	if (!(fp = fopen (filename, "r")))
		86	{
		87	if (errno == ENOENT)
		88	{
		89	LOG (llevInfo, "RESET uid to 1\n");
		90	uuid.seq = 0;
		91	write_uuid ();
		92	return;
		93	}
		94
		95	LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
		96	_exit (1);
		97	}
		98
		99	int version;
		100	unsigned long long uid;
		101	if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) \|\| version != 1)
		102	{
		103	LOG (llevError, "FATAL: error reading uid from %s!\n", filename);
		104	_exit (1);
		105	}
		106
		107	uuid.seq = uid;
		108	write_uuid ();
		109	LOG (llevDebug, "read UID: %lld\n", uid);
		110	fclose (fp);
		111	}
		112
		113	UUID
		114	gen_uuid ()
		115	{
		116	UUID uid;
		117
		118	uid.seq = ++uuid.seq;
		119
		120	if (!(uuid.seq & (UUID_SKIP - 1)))
		121	write_uuid ();
		122
		123	return uid;
		124	}
		125
		126	void
		127	init_uuid ()
		128	{
		129	read_uuid ();
		130	}
54		131
55	/* Returns TRUE if every key_values in wants has a partner with the same value in has. */	132	/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
56	static int	133	static int
57	compare_ob_value_lists_one (const object wants, const object has)	134	compare_ob_value_lists_one (const object wants, const object has)
58	{	135	{
…		…
254	{	331	{
255	if (inv->inv)	332	if (inv->inv)
256	sum_weight (inv);	333	sum_weight (inv);
257	sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);	334	sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
258	}	335	}
		336
259	if (op->type == CONTAINER && op->stats.Str)	337	if (op->type == CONTAINER && op->stats.Str)
260	sum = (sum * (100 - op->stats.Str)) / 100;	338	sum = (sum * (100 - op->stats.Str)) / 100;
		339
261	if (op->carrying != sum)	340	if (op->carrying != sum)
262	op->carrying = sum;	341	op->carrying = sum;
		342
263	return sum;	343	return sum;
264	}	344	}
265		345
266	/**	346	/**
267	* Return the outermost environment object for a given object.	347	* Return the outermost environment object for a given object.
…		…
294	* Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.	374	* Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
295	* Some error messages.	375	* Some error messages.
296	* The result of the dump is stored in the static global errmsg array.	376	* The result of the dump is stored in the static global errmsg array.
297	*/	377	*/
298		378
299	void	379	char *
300	dump_object2 (object *op)
301	{
302	errmsg[0] = 0;
303	return;
304	//TODO//D#d#
305	#if 0
306	char *cp;
307
308	/* object tmp;/
309
310	if (op->arch != NULL)
311	{
312	strcat (errmsg, "arch ");
313	strcat (errmsg, op->arch->name ? op->arch->name : "(null)");
314	strcat (errmsg, "\n");
315	if ((cp = get_ob_diff (op, &empty_archetype->clone)) != NULL)
316	strcat (errmsg, cp);
317	# if 0
318	/* Don't dump player diffs - they are too long, mostly meaningless, and
319	* will overflow the buffer.
320	* Changed so that we don't dump inventory either. This may
321	* also overflow the buffer.
322	*/
323	if (op->type != PLAYER && (cp = get_ob_diff (op, &empty_archetype->clone)) != NULL)
324	strcat (errmsg, cp);
325	for (tmp = op->inv; tmp; tmp = tmp->below)
326	dump_object2 (tmp);
327	# endif
328	strcat (errmsg, "end\n");
329	}
330	else
331	{
332	strcat (errmsg, "Object ");
333	if (op->name == NULL)
334	strcat (errmsg, "(null)");
335	else
336	strcat (errmsg, op->name);
337	strcat (errmsg, "\n");
338	# if 0
339	if ((cp = get_ob_diff (op, &empty_archetype->clone)) != NULL)
340	strcat (errmsg, cp);
341	for (tmp = op->inv; tmp; tmp = tmp->below)
342	dump_object2 (tmp);
343	# endif
344	strcat (errmsg, "end\n");
345	}
346	#endif
347	}
348
349	/*
350	* Dumps an object. Returns output in the static global errmsg array.
351	*/
352
353	void
354	dump_object (object *op)	380	dump_object (object *op)
355	{	381	{
356	if (op == NULL)	382	if (!op)
357	{	383	return strdup ("[NULLOBJ]");
358	strcpy (errmsg, "[NULL pointer]");
359	return;
360	}
361	errmsg[0] = '\0';
362	dump_object2 (op);
363	}
364		384
365	void	385	object_freezer freezer;
366	dump_all_objects (void)	386	save_object (freezer, op, 3);
367	{	387	return freezer.as_string ();
368	object *op;
369
370	for (op = objects; op != NULL; op = op->next)
371	{
372	dump_object (op);
373	fprintf (logfile, "Object %d\n:%s\n", op->count, errmsg);
374	}
375	}	388	}
376		389
377	/*	390	/*
378	* get_nearest_part(multi-object, object 2) returns the part of the	391	* get_nearest_part(multi-object, object 2) returns the part of the
379	* multi-object 1 which is closest to the second object.	392	* multi-object 1 which is closest to the second object.
…		…
401	object *	414	object *
402	find_object (tag_t i)	415	find_object (tag_t i)
403	{	416	{
404	object *op;	417	object *op;
405		418
406	for (op = objects; op != NULL; op = op->next)	419	for (op = object::first; op != NULL; op = op->next)
407	if (op->count == i)	420	if (op->count == i)
408	break;	421	break;
		422
409	return op;	423	return op;
410	}	424	}
411		425
412	/*	426	/*
413	* Returns the first object which has a name equal to the argument.	427	* Returns the first object which has a name equal to the argument.
…		…
419	find_object_name (const char *str)	433	find_object_name (const char *str)
420	{	434	{
421	shstr_cmp str_ (str);	435	shstr_cmp str_ (str);
422	object *op;	436	object *op;
423		437
424	for (op = objects; op != NULL; op = op->next)	438	for (op = object::first; op != NULL; op = op->next)
425	if (op->name == str_)	439	if (op->name == str_)
426	break;	440	break;
427		441
428	return op;	442	return op;
429	}	443	}
430		444
431	void	445	void
432	free_all_object_data ()	446	free_all_object_data ()
433	{	447	{
434	LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);	448	LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);
435	}
436
437	/*
438	* Returns the object which this object marks as being the owner.
439	* A id-scheme is used to avoid pointing to objects which have been
440	* freed and are now reused. If this is detected, the owner is
441	* set to NULL, and NULL is returned.
442	* Changed 2004-02-12 - if the player is setting at the play again
443	* prompt, he is removed, and we don't want to treat him as an owner of
444	* anything, so check removed flag. I don't expect that this should break
445	* anything - once an object is removed, it is basically dead anyways.
446	*/
447	object *
448	object::get_owner ()
449	{
450	if (!owner
451	\|\| QUERY_FLAG (owner, FLAG_FREED)
452	\|\| QUERY_FLAG (owner, FLAG_REMOVED))
453	owner = 0;
454
455	return owner;
456	}	449	}
457		450
458	/*	451	/*
459	* Sets the owner and sets the skill and exp pointers to owner's current	452	* Sets the owner and sets the skill and exp pointers to owner's current
460	* skill and experience objects.	453	* skill and experience objects.
…		…
530		523
531	/* What is not cleared is next, prev, and count */	524	/* What is not cleared is next, prev, and count */
532		525
533	expmul = 1.0;	526	expmul = 1.0;
534	face = blank_face;	527	face = blank_face;
535	attacked_by_count = -1;
536		528
537	if (settings.casting_time)	529	if (settings.casting_time)
538	casting_time = -1;	530	casting_time = -1;
539	}	531	}
540		532
…		…
835		827
836	if (op->more != NULL)	828	if (op->more != NULL)
837	update_object (op->more, action);	829	update_object (op->more, action);
838	}	830	}
839		831
840	static unordered_vector<object *> mortals;	832	object::vector object::mortals;
841	static std::vector<object *> freed;	833	object::vector object::objects; // not yet used
		834	object *object::first;
842		835
843	void object::free_mortals ()	836	void object::free_mortals ()
844	{	837	{
845	for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end ();)	838	for (AUTODECL (i, mortals.begin ()); i != mortals.end ();)
846	if ((*i)->refcnt)	839	if ((*i)->refcnt)
847	++i; // further delay freeing	840	++i; // further delay freeing
848	else	841	else
849	{	842	{
850	freed.push_back (*i);//D
851	//delete *i;	843	delete *i;
852	mortals.erase (i);	844	mortals.erase (i);
853	}	845	}
854		846
855	if (mortals.size() && 0)//D	847	static int lastmortals = 0;//D
		848
		849	if (mortals.size() != lastmortals && lastmortals > 100)//D
		850	{
		851	lastmortals = mortals.size ();//D
856	LOG (llevDebug, "%d objects in mortal queue\n", mortals.size());//D	852	LOG (llevDebug, "%d objects in mortal queue\n", lastmortals);//D
		853	}
857	}	854	}
858		855
859	object::object ()	856	object::object ()
860	{	857	{
861	SET_FLAG (this, FLAG_REMOVED);	858	SET_FLAG (this, FLAG_REMOVED);
862		859
863	expmul = 1.0;	860	expmul = 1.0;
864	face = blank_face;	861	face = blank_face;
865	attacked_by_count = -1;
866	}	862	}
867		863
868	object::~object ()	864	object::~object ()
869	{	865	{
870	free_key_values (this);	866	free_key_values (this);
871	}	867	}
872		868
873	void object::link ()	869	void object::link ()
874	{	870	{
875	count = ++ob_count;	871	count = ++ob_count;
		872	uuid = gen_uuid ();
876		873
877	prev = 0;	874	prev = 0;
878	next = objects;	875	next = object::first;
879		876
880	if (objects)	877	if (object::first)
881	objects->prev = this;	878	object::first->prev = this;
882		879
883	objects = this;	880	object::first = this;
884	}	881	}
885		882
886	void object::unlink ()	883	void object::unlink ()
887	{	884	{
888	count = 0;	885	if (this == object::first)
		886	object::first = next;
889		887
890	/* Remove this object from the list of used objects */	888	/* Remove this object from the list of used objects */
891	if (prev)
892	{
893	prev->next = next;	889	if (prev) prev->next = next;
		890	if (next) next->prev = prev;
		891
894	prev = 0;	892	prev = 0;
895	}
896
897	if (next)
898	{
899	next->prev = prev;
900	next = 0;	893	next = 0;
901	}
902
903	if (this == objects)
904	objects = next;
905	}	894	}
906		895
907	object *object::create ()	896	object *object::create ()
908	{	897	{
909	object *op;
910
911	if (freed.empty ())
912	op = new object;	898	object *op = new object;
913	else
914	{
915	// highly annoying, but the only way to get it stable right now
916	op = freed.back ();
917	freed.pop_back ();
918	op->~object ();
919	new ((void *) op) object;
920	}
921
922	op->link ();	899	op->link ();
923	return op;	900	return op;
924	}	901	}
925		902
926	/*	903	/*
…		…
928	* it from the list of used objects, and puts it on the list of	905	* it from the list of used objects, and puts it on the list of
929	* free objects. The IS_FREED() flag is set in the object.	906	* free objects. The IS_FREED() flag is set in the object.
930	* The object must have been removed by remove_ob() first for	907	* The object must have been removed by remove_ob() first for
931	* this function to succeed.	908	* this function to succeed.
932	*	909	*
933	* If free_inventory is set, free inventory as well. Else drop items in	910	* If destroy_inventory is set, free inventory as well. Else drop items in
934	* inventory to the ground.	911	* inventory to the ground.
935	*/	912	*/
936	void object::free (bool free_inventory)	913	void object::destroy (bool destroy_inventory)
937	{	914	{
938	if (QUERY_FLAG (this, FLAG_FREED))	915	if (QUERY_FLAG (this, FLAG_FREED))
939	return;	916	return;
940		917
941	if (QUERY_FLAG (this, FLAG_FRIENDLY))	918	if (QUERY_FLAG (this, FLAG_FRIENDLY))
…		…
946		923
947	SET_FLAG (this, FLAG_FREED);	924	SET_FLAG (this, FLAG_FREED);
948		925
949	if (more)	926	if (more)
950	{	927	{
951	more->free (free_inventory);	928	more->destroy (destroy_inventory);
952	more = 0;	929	more = 0;
953	}	930	}
954		931
955	if (inv)	932	if (inv)
956	{	933	{
957	/* Only if the space blocks everything do we not process -	934	/* Only if the space blocks everything do we not process -
958	* if some form of movement is allowed, let objects	935	* if some form of movement is allowed, let objects
959	* drop on that space.	936	* drop on that space.
960	*/	937	*/
961	if (free_inventory \|\| !map \|\| map->in_memory != MAP_IN_MEMORY \|\| GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)	938	if (destroy_inventory \|\| !map \|\| map->in_memory != MAP_IN_MEMORY \|\| GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
962	{	939	{
963	object *op = inv;	940	object *op = inv;
964		941
965	while (op)	942	while (op)
966	{	943	{
967	object *tmp = op->below;	944	object *tmp = op->below;
968	op->free (free_inventory);	945	op->destroy (destroy_inventory);
969	op = tmp;	946	op = tmp;
970	}	947	}
971	}	948	}
972	else	949	else
973	{ /* Put objects in inventory onto this space */	950	{ /* Put objects in inventory onto this space */
…		…
992	op = tmp;	969	op = tmp;
993	}	970	}
994	}	971	}
995	}	972	}
996		973
		974	// clear those pointers that likely might have circular references to us
997	owner = 0;	975	owner = 0;
		976	enemy = 0;
		977	attacked_by = 0;
		978
		979	// only relevant for players(?), but make sure of it anyways
		980	contr = 0;
998		981
999	/* Remove object from the active list */	982	/* Remove object from the active list */
1000	speed = 0;	983	speed = 0;
1001	update_ob_speed (this);	984	update_ob_speed (this);
1002		985
…		…
1014	sub_weight (object *op, signed long weight)	997	sub_weight (object *op, signed long weight)
1015	{	998	{
1016	while (op != NULL)	999	while (op != NULL)
1017	{	1000	{
1018	if (op->type == CONTAINER)	1001	if (op->type == CONTAINER)
1019	{
1020	weight = (signed long) (weight * (100 - op->stats.Str) / 100);	1002	weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1021	}	1003
1022	op->carrying -= weight;	1004	op->carrying -= weight;
1023	op = op->env;	1005	op = op->env;
1024	}	1006	}
1025	}	1007	}
1026		1008
…		…
1034	*/	1016	*/
1035		1017
1036	void	1018	void
1037	remove_ob (object *op)	1019	remove_ob (object *op)
1038	{	1020	{
		1021	object tmp, last = 0;
1039	object *	1022	object *otmp;
1040	tmp, *
1041	last = NULL;
1042	object *
1043	otmp;
1044		1023
1045	tag_t
1046	tag;
1047	int
1048	check_walk_off;	1024	int check_walk_off;
1049	mapstruct *	1025	maptile *m;
1050	m;
1051		1026
1052	sint16	1027	sint16 x, y;
1053	x,
1054	y;
1055		1028
1056	if (QUERY_FLAG (op, FLAG_REMOVED))	1029	if (QUERY_FLAG (op, FLAG_REMOVED))
1057	return;	1030	return;
1058		1031
1059	SET_FLAG (op, FLAG_REMOVED);	1032	SET_FLAG (op, FLAG_REMOVED);
…		…
1136	* use translated coordinates in case some oddness with map tiling is	1109	* use translated coordinates in case some oddness with map tiling is
1137	* evident	1110	* evident
1138	*/	1111	*/
1139	if (GET_MAP_OB (m, x, y) != op)	1112	if (GET_MAP_OB (m, x, y) != op)
1140	{	1113	{
1141	dump_object (op);	1114	char *dump = dump_object (op);
1142	LOG (llevError,	1115	LOG (llevError,
1143	"remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", errmsg);	1116	"remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", dump);
		1117	free (dump);
1144	dump_object (GET_MAP_OB (m, x, y));	1118	dump = dump_object (GET_MAP_OB (m, x, y));
1145	LOG (llevError, "%s\n", errmsg);	1119	LOG (llevError, "%s\n", dump);
		1120	free (dump);
1146	}	1121	}
1147		1122
1148	SET_MAP_OB (m, x, y, op->above); /* goes on above it. */	1123	SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1149	}	1124	}
1150		1125
…		…
1152	op->below = 0;	1127	op->below = 0;
1153		1128
1154	if (op->map->in_memory == MAP_SAVING)	1129	if (op->map->in_memory == MAP_SAVING)
1155	return;	1130	return;
1156		1131
1157	tag = op->count;
1158	check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);	1132	check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1159		1133
1160	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	1134	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1161	{	1135	{
1162	/* No point updating the players look faces if he is the object	1136	/* No point updating the players look faces if he is the object
…		…
1177		1151
1178	tmp->contr->socket.update_look = 1;	1152	tmp->contr->socket.update_look = 1;
1179	}	1153	}
1180		1154
1181	/* See if player moving off should effect something */	1155	/* See if player moving off should effect something */
1182	if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))	1156	if (check_walk_off
		1157	&& ((op->move_type & tmp->move_off)
		1158	&& (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1183	{	1159	{
1184	move_apply (tmp, op, NULL);	1160	move_apply (tmp, op, NULL);
1185		1161
1186	if (was_destroyed (op, tag))	1162	if (op->destroyed ())
1187	{
1188	LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);	1163	LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1189	}
1190	}	1164	}
1191		1165
1192	/* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */	1166	/* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1193		1167
1194	if (tmp->above == tmp)	1168	if (tmp->above == tmp)
…		…
1222	* This function goes through all objects below and including top, and	1196	* This function goes through all objects below and including top, and
1223	* merges op to the first matching object.	1197	* merges op to the first matching object.
1224	* If top is NULL, it is calculated.	1198	* If top is NULL, it is calculated.
1225	* Returns pointer to object if it succeded in the merge, otherwise NULL	1199	* Returns pointer to object if it succeded in the merge, otherwise NULL
1226	*/	1200	*/
1227
1228	object *	1201	object *
1229	merge_ob (object op, object top)	1202	merge_ob (object op, object top)
1230	{	1203	{
1231	if (!op->nrof)	1204	if (!op->nrof)
1232	return 0;	1205	return 0;
…		…
1248	free_object (op);	1221	free_object (op);
1249	return top;	1222	return top;
1250	}	1223	}
1251	}	1224	}
1252		1225
1253	return NULL;	1226	return 0;
1254	}	1227	}
1255		1228
1256	/*	1229	/*
1257	* same as insert_ob_in_map except it handle separate coordinates and do a clean	1230	* same as insert_ob_in_map except it handle separate coordinates and do a clean
1258	* job preparing multi-part monsters	1231	* job preparing multi-part monsters
1259	*/	1232	*/
1260	object *	1233	object *
1261	insert_ob_in_map_at (object op, mapstruct m, object *originator, int flag, int x, int y)	1234	insert_ob_in_map_at (object op, maptile m, object *originator, int flag, int x, int y)
1262	{	1235	{
1263	object *tmp;	1236	object *tmp;
1264		1237
1265	if (op->head)	1238	if (op->head)
1266	op = op->head;	1239	op = op->head;
…		…
1294	* NULL if 'op' was destroyed	1267	* NULL if 'op' was destroyed
1295	* just 'op' otherwise	1268	* just 'op' otherwise
1296	*/	1269	*/
1297		1270
1298	object *	1271	object *
1299	insert_ob_in_map (object op, mapstruct m, object *originator, int flag)	1272	insert_ob_in_map (object op, maptile m, object *originator, int flag)
1300	{	1273	{
1301	object tmp, top, *floor = NULL;	1274	object tmp, top, *floor = NULL;
1302	sint16 x, y;	1275	sint16 x, y;
1303		1276
1304	if (QUERY_FLAG (op, FLAG_FREED))	1277	if (QUERY_FLAG (op, FLAG_FREED))
…		…
1307	return NULL;	1280	return NULL;
1308	}	1281	}
1309		1282
1310	if (m == NULL)	1283	if (m == NULL)
1311	{	1284	{
1312	dump_object (op);	1285	char *dump = dump_object (op);
1313	LOG (llevError, "Trying to insert in null-map!\n%s\n", errmsg);	1286	LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
		1287	free (dump);
1314	return op;	1288	return op;
1315	}	1289	}
1316		1290
1317	if (out_of_map (m, op->x, op->y))	1291	if (out_of_map (m, op->x, op->y))
1318	{	1292	{
1319	dump_object (op);	1293	char *dump = dump_object (op);
1320	LOG (llevError, "Trying to insert object outside the map.\n%s\n", errmsg);	1294	LOG (llevError, "Trying to insert object outside the map.\n%s\n", dump);
1321	#ifdef MANY_CORES	1295	#ifdef MANY_CORES
1322	/* Better to catch this here, as otherwise the next use of this object	1296	/* Better to catch this here, as otherwise the next use of this object
1323	* is likely to cause a crash. Better to find out where it is getting	1297	* is likely to cause a crash. Better to find out where it is getting
1324	* improperly inserted.	1298	* improperly inserted.
1325	*/	1299	*/
1326	abort ();	1300	abort ();
1327	#endif	1301	#endif
		1302	free (dump);
1328	return op;	1303	return op;
1329	}	1304	}
1330		1305
1331	if (!QUERY_FLAG (op, FLAG_REMOVED))	1306	if (!QUERY_FLAG (op, FLAG_REMOVED))
1332	{	1307	{
1333	dump_object (op);	1308	char *dump = dump_object (op);
1334	LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", errmsg);	1309	LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
		1310	free (dump);
1335	return op;	1311	return op;
1336	}	1312	}
1337		1313
1338	if (op->more != NULL)	1314	if (op->more != NULL)
1339	{	1315	{
…		…
1585	remove_ob (tmp);	1561	remove_ob (tmp);
1586	free_object (tmp);	1562	free_object (tmp);
1587	}	1563	}
1588	}	1564	}
1589		1565
1590	tmp1 = arch_to_object (find_archetype (arch_string));	1566	tmp1 = arch_to_object (archetype::find (arch_string));
1591		1567
1592	tmp1->x = op->x;	1568	tmp1->x = op->x;
1593	tmp1->y = op->y;	1569	tmp1->y = op->y;
1594	insert_ob_in_map (tmp1, op->map, op, 0);	1570	insert_ob_in_map (tmp1, op->map, op, 0);
1595	}	1571	}
…		…
1776	tmp, *	1752	tmp, *
1777	otmp;	1753	otmp;
1778		1754
1779	if (!QUERY_FLAG (op, FLAG_REMOVED))	1755	if (!QUERY_FLAG (op, FLAG_REMOVED))
1780	{	1756	{
1781	dump_object (op);	1757	char *dump = dump_object (op);
1782	LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);	1758	LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", dump);
		1759	free (dump);
1783	return op;	1760	return op;
1784	}	1761	}
1785		1762
1786	if (where == NULL)	1763	if (where == NULL)
1787	{	1764	{
1788	dump_object (op);	1765	char *dump = dump_object (op);
1789	LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);	1766	LOG (llevError, "Trying to put object in NULL.\n%s\n", dump);
		1767	free (dump);
1790	return op;	1768	return op;
1791	}	1769	}
1792		1770
1793	if (where->head)	1771	if (where->head)
1794	{	1772	{
…		…
1894	*/	1872	*/
1895		1873
1896	int	1874	int
1897	check_move_on (object op, object originator)	1875	check_move_on (object op, object originator)
1898	{	1876	{
1899	object *	1877	object *tmp;
1900	tmp;	1878	maptile *m = op->map;
1901	tag_t
1902	tag;
1903	mapstruct *
1904	m = op->map;
1905	int
1906	x = op->x, y = op->y;	1879	int x = op->x, y = op->y;
1907		1880
1908	MoveType	1881	MoveType move_on, move_slow, move_block;
1909	move_on,
1910	move_slow,
1911	move_block;
1912		1882
1913	if (QUERY_FLAG (op, FLAG_NO_APPLY))	1883	if (QUERY_FLAG (op, FLAG_NO_APPLY))
1914	return 0;	1884	return 0;
1915
1916	tag = op->count;
1917		1885
1918	move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);	1886	move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
1919	move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);	1887	move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
1920	move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);	1888	move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
1921		1889
…		…
1982	if ((!op->move_type && tmp->move_on & MOVE_WALK) \|\|	1950	if ((!op->move_type && tmp->move_on & MOVE_WALK) \|\|
1983	((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))	1951	((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
1984	{	1952	{
1985	move_apply (tmp, op, originator);	1953	move_apply (tmp, op, originator);
1986		1954
1987	if (was_destroyed (op, tag))	1955	if (op->destroyed ())
1988	return 1;	1956	return 1;
1989		1957
1990	/* what the person/creature stepped onto has moved the object	1958	/* what the person/creature stepped onto has moved the object
1991	* someplace new. Don't process any further - if we did,	1959	* someplace new. Don't process any further - if we did,
1992	* have a feeling strange problems would result.	1960	* have a feeling strange problems would result.
…		…
2004	* a matching archetype at the given map and coordinates.	1972	* a matching archetype at the given map and coordinates.
2005	* The first matching object is returned, or NULL if none.	1973	* The first matching object is returned, or NULL if none.
2006	*/	1974	*/
2007		1975
2008	object *	1976	object *
2009	present_arch (const archetype at, mapstruct m, int x, int y)	1977	present_arch (const archetype at, maptile m, int x, int y)
2010	{	1978	{
2011	object *	1979	object *
2012	tmp;	1980	tmp;
2013		1981
2014	if (m == NULL \|\| out_of_map (m, x, y))	1982	if (m == NULL \|\| out_of_map (m, x, y))
…		…
2027	* a matching type variable at the given map and coordinates.	1995	* a matching type variable at the given map and coordinates.
2028	* The first matching object is returned, or NULL if none.	1996	* The first matching object is returned, or NULL if none.
2029	*/	1997	*/
2030		1998
2031	object *	1999	object *
2032	present (unsigned char type, mapstruct *m, int x, int y)	2000	present (unsigned char type, maptile *m, int x, int y)
2033	{	2001	{
2034	object *	2002	object *
2035	tmp;	2003	tmp;
2036		2004
2037	if (out_of_map (m, x, y))	2005	if (out_of_map (m, x, y))
…		…
2177	* the archetype because that isn't correct if the monster has been	2145	* the archetype because that isn't correct if the monster has been
2178	* customized, changed states, etc.	2146	* customized, changed states, etc.
2179	*/	2147	*/
2180		2148
2181	int	2149	int
2182	find_free_spot (const object ob, mapstruct m, int x, int y, int start, int stop)	2150	find_free_spot (const object ob, maptile m, int x, int y, int start, int stop)
2183	{	2151	{
2184	int	2152	int
2185	i,	2153	i,
2186	index = 0, flag;	2154	index = 0, flag;
2187	static int	2155	static int
…		…
2208	return -1;	2176	return -1;
2209	return altern[RANDOM () % index];	2177	return altern[RANDOM () % index];
2210	}	2178	}
2211		2179
2212	/*	2180	/*
2213	* find_first_free_spot(archetype, mapstruct, x, y) works like	2181	* find_first_free_spot(archetype, maptile, x, y) works like
2214	* find_free_spot(), but it will search max number of squares.	2182	* find_free_spot(), but it will search max number of squares.
2215	* But it will return the first available spot, not a random choice.	2183	* But it will return the first available spot, not a random choice.
2216	* Changed 0.93.2: Have it return -1 if there is no free spot available.	2184	* Changed 0.93.2: Have it return -1 if there is no free spot available.
2217	*/	2185	*/
2218		2186
2219	int	2187	int
2220	find_first_free_spot (const object ob, mapstruct m, int x, int y)	2188	find_first_free_spot (const object ob, maptile m, int x, int y)
2221	{	2189	{
2222	int	2190	int
2223	i;	2191	i;
2224		2192
2225	for (i = 0; i < SIZEOFFREE; i++)	2193	for (i = 0; i < SIZEOFFREE; i++)
…		…
2289	* because we have to know what movement the thing looking to move	2257	* because we have to know what movement the thing looking to move
2290	* there is capable of.	2258	* there is capable of.
2291	*/	2259	*/
2292		2260
2293	int	2261	int
2294	find_dir (mapstruct m, int x, int y, object exclude)	2262	find_dir (maptile m, int x, int y, object exclude)
2295	{	2263	{
2296	int	2264	int
2297	i,	2265	i,
2298	max = SIZEOFFREE, mflags;	2266	max = SIZEOFFREE, mflags;
2299		2267
2300	sint16 nx, ny;	2268	sint16 nx, ny;
2301	object *	2269	object *
2302	tmp;	2270	tmp;
2303	mapstruct *	2271	maptile *
2304	mp;	2272	mp;
2305		2273
2306	MoveType blocked, move_type;	2274	MoveType blocked, move_type;
2307		2275
2308	if (exclude && exclude->head)	2276	if (exclude && exclude->head)
…		…
2516	* Modified to be map tile aware -.MSW	2484	* Modified to be map tile aware -.MSW
2517	*/	2485	*/
2518		2486
2519		2487
2520	int	2488	int
2521	can_see_monsterP (mapstruct *m, int x, int y, int dir)	2489	can_see_monsterP (maptile *m, int x, int y, int dir)
2522	{	2490	{
2523	sint16 dx, dy;	2491	sint16 dx, dy;
2524	int	2492	int
2525	mflags;	2493	mflags;
2526		2494
…		…
2606	if (prev)	2574	if (prev)
2607	prev->more = tmp;	2575	prev->more = tmp;
2608	prev = tmp;	2576	prev = tmp;
2609	}	2577	}
2610		2578
2611	/* copy inventory */
2612	for (item = src->inv; item; item = item->below)	2579	for (item = src->inv; item; item = item->below)
2613	{
2614	(void) insert_ob_in_ob (object_create_clone (item), dst);	2580	insert_ob_in_ob (object_create_clone (item), dst);
2615	}
2616		2581
2617	return dst;	2582	return dst;
2618	}	2583	}
2619		2584
2620	/* return true if the object was destroyed, 0 otherwise */
2621	int
2622	was_destroyed (const object *op, tag_t old_tag)
2623	{
2624	/* checking for FLAG_FREED isn't necessary, but makes this function more
2625	* robust */
2626	return op->count != old_tag \|\| QUERY_FLAG (op, FLAG_FREED);
2627	}
2628
2629	/* GROS - Creates an object using a string representing its content. */	2585	/* GROS - Creates an object using a string representing its content. */
2630
2631	/* Basically, we save the content of the string to a temp file, then call */	2586	/* Basically, we save the content of the string to a temp file, then call */
2632
2633	/* load_object on it. I admit it is a highly inefficient way to make things, */	2587	/* load_object on it. I admit it is a highly inefficient way to make things, */
2634
2635	/* but it was simple to make and allows reusing the load_object function. */	2588	/* but it was simple to make and allows reusing the load_object function. */
2636
2637	/* Remember not to use load_object_str in a time-critical situation. */	2589	/* Remember not to use load_object_str in a time-critical situation. */
2638
2639	/* Also remember that multiparts objects are not supported for now. */	2590	/* Also remember that multiparts objects are not supported for now. */
2640		2591
2641	object *	2592	object *
2642	load_object_str (const char *obstr)	2593	load_object_str (const char *obstr)
2643	{	2594	{
2644	object *	2595	object *op;
2645	op;
2646	char
2647	filename[MAX_BUF];	2596	char filename[MAX_BUF];
2648		2597
2649	sprintf (filename, "%s/cfloadobstr2044", settings.tmpdir);	2598	sprintf (filename, "%s/cfloadobstr2044", settings.tmpdir);
2650		2599
2651	FILE *
2652	tempfile = fopen (filename, "w");	2600	FILE *tempfile = fopen (filename, "w");
2653		2601
2654	if (tempfile == NULL)	2602	if (tempfile == NULL)
2655	{	2603	{
2656	LOG (llevError, "Error - Unable to access load object temp file\n");	2604	LOG (llevError, "Error - Unable to access load object temp file\n");
2657	return NULL;	2605	return NULL;
2658	};	2606	}
		2607
2659	fprintf (tempfile, obstr);	2608	fprintf (tempfile, obstr);
2660	fclose (tempfile);	2609	fclose (tempfile);
2661		2610
2662	op = get_object ();	2611	op = get_object ();
2663		2612
…		…
2677	* returns NULL if no match.	2626	* returns NULL if no match.
2678	*/	2627	*/
2679	object *	2628	object *
2680	find_obj_by_type_subtype (const object *who, int type, int subtype)	2629	find_obj_by_type_subtype (const object *who, int type, int subtype)
2681	{	2630	{
2682	object *	2631	object *tmp;
2683	tmp;
2684		2632
2685	for (tmp = who->inv; tmp; tmp = tmp->below)	2633	for (tmp = who->inv; tmp; tmp = tmp->below)
2686	if (tmp->type == type && tmp->subtype == subtype)	2634	if (tmp->type == type && tmp->subtype == subtype)
2687	return tmp;	2635	return tmp;
2688		2636
…		…
2696	* do the desired thing.	2644	* do the desired thing.
2697	*/	2645	*/
2698	key_value *	2646	key_value *
2699	get_ob_key_link (const object ob, const char key)	2647	get_ob_key_link (const object ob, const char key)
2700	{	2648	{
2701	key_value *	2649	key_value *link;
2702	link;
2703		2650
2704	for (link = ob->key_values; link != NULL; link = link->next)	2651	for (link = ob->key_values; link != NULL; link = link->next)
2705	{
2706	if (link->key == key)	2652	if (link->key == key)
2707	{
2708	return link;	2653	return link;
2709	}
2710	}
2711		2654
2712	return NULL;	2655	return NULL;
2713	}	2656	}
2714		2657
2715	/*	2658	/*
…		…
2857	}	2800	}
2858	else	2801	else
2859	item = item->env;	2802	item = item->env;
2860	}	2803	}
2861		2804
		2805	// return a suitable string describing an objetc in enough detail to find it
		2806	const char *
		2807	object::debug_desc (char *info) const
		2808	{
		2809	char info2[256 * 3];
		2810	char *p = info;
		2811
		2812	p += snprintf (p, 256, "%d=\"%s%s%s\"",
		2813	count,
		2814	&name,
		2815	title ? " " : "",
		2816	title ? (const char *)title : "");
		2817
		2818	if (env)
		2819	p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
		2820
		2821	if (map)
		2822	p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);
		2823
		2824	return info;
		2825	}
		2826
		2827	const char *
		2828	object::debug_desc () const
		2829	{
		2830	static char info[256 * 3];
		2831	return debug_desc (info);
		2832	}
		2833

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.35 by root, Tue Sep 12 18:15:34 2006 UTC vs. Revision 1.53 by root, Tue Nov 7 16:30:54 2006 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.35 by root, Tue Sep 12 18:15:34 2006 UTC vs.
Revision 1.53 by root, Tue Nov 7 16:30:54 2006 UTC