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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.24 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.34 by root, Tue Sep 12 01:09:53 2006 UTC

…		…
1
2	/*
3	* static char *rcsid_object_c =
4	* "$Id: object.C,v 1.24 2006/09/10 16:00:23 root Exp $";
5	*/
6		1
7	/*	2	/*
8	CrossFire, A Multiplayer game for X-windows	3	CrossFire, A Multiplayer game for X-windows
9		4
10	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	Copyright (C) 2001 Mark Wedel & Crossfire Development Team
29		24
30	/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.	25	/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
31	sub/add_weight will transcend the environment updating the carrying	26	sub/add_weight will transcend the environment updating the carrying
32	variable. */	27	variable. */
33	#include <global.h>	28	#include <global.h>
34	#ifndef WIN32 /* ---win32 exclude headers */
35	# include <stdio.h>	29	#include <stdio.h>
36	# include <sys/types.h>	30	#include <sys/types.h>
37	# include <sys/uio.h>	31	#include <sys/uio.h>
38	#endif /* win32 */
39	#include <object.h>	32	#include <object.h>
40	#include <funcpoint.h>	33	#include <funcpoint.h>
41	#include <skills.h>
42	#include <loader.h>	34	#include <loader.h>
		35
43	int nrofallocobjects = 0;	36	int nrofallocobjects = 0;
44		37
45	object objects; / Pointer to the list of used objects */	38	object objects; / Pointer to the list of used objects */
46	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 */
47		40
…		…
214	if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)	207	if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
215	return 0;	208	return 0;
216		209
217	switch (ob1->type)	210	switch (ob1->type)
218	{	211	{
219	case SCROLL:	212	case SCROLL:
220	if (ob1->level != ob2->level)	213	if (ob1->level != ob2->level)
221	return 0;	214	return 0;
222	break;	215	break;
223	}	216	}
224		217
225	if (ob1->key_values != NULL \|\| ob2->key_values != NULL)	218	if (ob1->key_values != NULL \|\| ob2->key_values != NULL)
226	{	219	{
227	/* At least one of these has key_values. */	220	/* At least one of these has key_values. */
…		…
249	/*	242	/*
250	* sum_weight() is a recursive function which calculates the weight	243	* sum_weight() is a recursive function which calculates the weight
251	* an object is carrying. It goes through in figures out how much	244	* an object is carrying. It goes through in figures out how much
252	* containers are carrying, and sums it up.	245	* containers are carrying, and sums it up.
253	*/	246	*/
254	signed long	247	long
255	sum_weight (object *op)	248	sum_weight (object *op)
256	{	249	{
257	signed long sum;	250	long sum;
258	object *inv;	251	object *inv;
259		252
260	for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)	253	for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
261	{	254	{
262	if (inv->inv)	255	if (inv->inv)
…		…
449	* Changed 2004-02-12 - if the player is setting at the play again	442	* Changed 2004-02-12 - if the player is setting at the play again
450	* prompt, he is removed, and we don't want to treat him as an owner of	443	* prompt, he is removed, and we don't want to treat him as an owner of
451	* anything, so check removed flag. I don't expect that this should break	444	* anything, so check removed flag. I don't expect that this should break
452	* anything - once an object is removed, it is basically dead anyways.	445	* anything - once an object is removed, it is basically dead anyways.
453	*/	446	*/
454
455	object *	447	object *
456	get_owner (object *op)	448	object::get_owner ()
457	{	449	{
458	if (op->owner == NULL)	450	if (!owner
459	return NULL;	451	\|\| QUERY_FLAG (owner, FLAG_FREED)
		452	\|\| QUERY_FLAG (owner, FLAG_REMOVED))
		453	owner = 0;
460		454
461	if (!QUERY_FLAG (op->owner, FLAG_FREED) && !QUERY_FLAG (op->owner, FLAG_REMOVED) && op->owner->count == op->ownercount)
462	return op->owner;	455	return owner;
463
464	op->owner = NULL;
465	op->ownercount = 0;
466	return NULL;
467	}
468
469	void
470	clear_owner (object *op)
471	{
472	if (!op)
473	return;
474
475	if (op->owner && op->ownercount == op->owner->count)
476	op->owner->refcount--;
477
478	op->owner = NULL;
479	op->ownercount = 0;
480	}	456	}
481		457
482	/*	458	/*
483	* Sets the owner and sets the skill and exp pointers to owner's current	459	* Sets the owner and sets the skill and exp pointers to owner's current
484	* skill and experience objects.	460	* skill and experience objects.
485	*/	461	*/
486	void	462	void
487	set_owner (object op, object owner)	463	object::set_owner (object *owner)
488	{	464	{
489	if (owner == NULL \|\| op == NULL)	465	if (!owner)
490	return;	466	return;
491		467
492	/* next line added to allow objects which own objects */	468	/* next line added to allow objects which own objects */
493	/* Add a check for ownercounts in here, as I got into an endless loop	469	/* Add a check for ownercounts in here, as I got into an endless loop
494	* with the fireball owning a poison cloud which then owned the	470	* with the fireball owning a poison cloud which then owned the
495	* fireball. I believe that was caused by one of the objects getting	471	* fireball. I believe that was caused by one of the objects getting
496	* freed and then another object replacing it. Since the ownercounts	472	* freed and then another object replacing it. Since the ownercounts
497	* didn't match, this check is valid and I believe that cause is valid.	473	* didn't match, this check is valid and I believe that cause is valid.
498	*/	474	*/
499	while (owner->owner && owner != owner->owner && owner->ownercount == owner->owner->count)	475	while (owner->owner)
500	owner = owner->owner;	476	owner = owner->owner;
501		477
502	/* IF the owner still has an owner, we did not resolve to a final owner.
503	* so lets not add to that.
504	*/
505	if (owner->owner)
506	return;
507
508	op->owner = owner;	478	this->owner = owner;
509
510	op->ownercount = owner->count;
511	owner->refcount++;
512
513	}
514
515	/* Set the owner to clone's current owner and set the skill and experience
516	* objects to clone's objects (typically those objects that where the owner's
517	* current skill and experience objects at the time when clone's owner was
518	* set - not the owner's current skill and experience objects).
519	*
520	* Use this function if player created an object (e.g. fire bullet, swarm
521	* spell), and this object creates further objects whose kills should be
522	* accounted for the player's original skill, even if player has changed
523	* skills meanwhile.
524	*/
525	void
526	copy_owner (object op, object clone)
527	{
528	object *owner = get_owner (clone);
529
530	if (owner == NULL)
531	{
532	/* players don't have owners - they own themselves. Update
533	* as appropriate.
534	*/
535	if (clone->type == PLAYER)
536	owner = clone;
537	else
538	return;
539	}
540	set_owner (op, owner);
541
542	}	479	}
543		480
544	/* Zero the key_values on op, decrementing the shared-string	481	/* Zero the key_values on op, decrementing the shared-string
545	* refcounts and freeing the links.	482	* refcounts and freeing the links.
546	*/	483	*/
…		…
562	{	499	{
563	attachable_base::clear ();	500	attachable_base::clear ();
564		501
565	free_key_values (this);	502	free_key_values (this);
566		503
		504	owner = 0;
567	name = 0;	505	name = 0;
568	name_pl = 0;	506	name_pl = 0;
569	title = 0;	507	title = 0;
570	race = 0;	508	race = 0;
571	slaying = 0;	509	slaying = 0;
572	skill = 0;	510	skill = 0;
573	msg = 0;	511	msg = 0;
574	lore = 0;	512	lore = 0;
575	custom_name = 0;	513	custom_name = 0;
576	materialname = 0;	514	materialname = 0;
		515	contr = 0;
		516	below = 0;
		517	above = 0;
		518	inv = 0;
		519	container = 0;
		520	env = 0;
		521	more = 0;
		522	head = 0;
		523	map = 0;
		524	active_next = 0;
		525	active_prev = 0;
577		526
578	memset (static_cast < object_pod * >(this), 0, sizeof (object_pod));	527	memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
579		528
580	SET_FLAG (this, FLAG_REMOVED);	529	SET_FLAG (this, FLAG_REMOVED);
		530
		531	/* What is not cleared is next, prev, and count */
		532
		533	expmul = 1.0;
		534	face = blank_face;
		535	attacked_by_count = -1;
		536
		537	if (settings.casting_time)
		538	casting_time = -1;
581	}	539	}
582		540
583	void object::clone (object *destination)	541	void object::clone (object *destination)
584	{	542	{
585	(object_copy ) destination = *this;	543	(object_copy )destination = *this;
586	(object_pod ) destination = *this;	544	(object_pod )destination = *this;
587		545
588	if (self \|\| cb)	546	if (self \|\| cb)
589	INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination));	547	INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination));
590	}
591
592	/*
593	* clear_object() frees everything allocated by an object, and also
594	* clears all variables and flags to default settings.
595	*/
596
597	void
598	clear_object (object *op)
599	{
600	op->clear ();
601
602	op->contr = NULL;
603	op->below = NULL;
604	op->above = NULL;
605	op->inv = NULL;
606	op->container = NULL;
607	op->env = NULL;
608	op->more = NULL;
609	op->head = NULL;
610	op->map = NULL;
611	op->refcount = 0;
612	op->active_next = NULL;
613	op->active_prev = NULL;
614	/* What is not cleared is next, prev, and count */
615
616	op->expmul = 1.0;
617	op->face = blank_face;
618	op->attacked_by_count = -1;
619
620	if (settings.casting_time)
621	op->casting_time = -1;
622	}	548	}
623		549
624	/*	550	/*
625	* copy object first frees everything allocated by the second object,	551	* copy object first frees everything allocated by the second object,
626	* and then copies the contends of the first object into the second	552	* and then copies the contends of the first object into the second
627	* object, allocating what needs to be allocated. Basically, any	553	* object, allocating what needs to be allocated. Basically, any
628	* data that is malloc'd needs to be re-malloc/copied. Otherwise,	554	* data that is malloc'd needs to be re-malloc/copied. Otherwise,
629	* if the first object is freed, the pointers in the new object	555	* if the first object is freed, the pointers in the new object
630	* will point at garbage.	556	* will point at garbage.
631	*/	557	*/
632
633	void	558	void
634	copy_object (object op2, object op)	559	copy_object (object op2, object op)
635	{	560	{
636	bool is_freed = QUERY_FLAG (op, FLAG_FREED);	561	bool is_freed = QUERY_FLAG (op, FLAG_FREED);
637	bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);	562	bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
…		…
697	/*	622	/*
698	* Updates the speed of an object. If the speed changes from 0 to another	623	* Updates the speed of an object. If the speed changes from 0 to another
699	* value, or vice versa, then add/remove the object from the active list.	624	* value, or vice versa, then add/remove the object from the active list.
700	* This function needs to be called whenever the speed of an object changes.	625	* This function needs to be called whenever the speed of an object changes.
701	*/	626	*/
702
703	void	627	void
704	update_ob_speed (object *op)	628	update_ob_speed (object *op)
705	{	629	{
706	extern int arch_init;	630	extern int arch_init;
707		631
…		…
716	abort ();	640	abort ();
717	#else	641	#else
718	op->speed = 0;	642	op->speed = 0;
719	#endif	643	#endif
720	}	644	}
		645
721	if (arch_init)	646	if (arch_init)
722	{
723	return;	647	return;
724	}	648
725	if (FABS (op->speed) > MIN_ACTIVE_SPEED)	649	if (FABS (op->speed) > MIN_ACTIVE_SPEED)
726	{	650	{
727	/* If already on active list, don't do anything */	651	/* If already on active list, don't do anything */
728	if (op->active_next \|\| op->active_prev \|\| op == active_objects)	652	if (op->active_next \|\| op->active_prev \|\| op == active_objects)
729	return;	653	return;
730		654
731	/* process_events() expects us to insert the object at the beginning	655	/* process_events() expects us to insert the object at the beginning
732	* of the list. */	656	* of the list. */
733	op->active_next = active_objects;	657	op->active_next = active_objects;
		658
734	if (op->active_next != NULL)	659	if (op->active_next != NULL)
735	op->active_next->active_prev = op;	660	op->active_next->active_prev = op;
		661
736	active_objects = op;	662	active_objects = op;
737	}	663	}
738	else	664	else
739	{	665	{
740	/* If not on the active list, nothing needs to be done */	666	/* If not on the active list, nothing needs to be done */
…		…
742	return;	668	return;
743		669
744	if (op->active_prev == NULL)	670	if (op->active_prev == NULL)
745	{	671	{
746	active_objects = op->active_next;	672	active_objects = op->active_next;
		673
747	if (op->active_next != NULL)	674	if (op->active_next != NULL)
748	op->active_next->active_prev = NULL;	675	op->active_next->active_prev = NULL;
749	}	676	}
750	else	677	else
751	{	678	{
752	op->active_prev->active_next = op->active_next;	679	op->active_prev->active_next = op->active_next;
		680
753	if (op->active_next)	681	if (op->active_next)
754	op->active_next->active_prev = op->active_prev;	682	op->active_next->active_prev = op->active_prev;
755	}	683	}
		684
756	op->active_next = NULL;	685	op->active_next = NULL;
757	op->active_prev = NULL;	686	op->active_prev = NULL;
758	}	687	}
759	}	688	}
760		689
…		…
890	/* if the object is being removed, we can't make intelligent	819	/* if the object is being removed, we can't make intelligent
891	* decisions, because remove_ob can't really pass the object	820	* decisions, because remove_ob can't really pass the object
892	* that is being removed.	821	* that is being removed.
893	*/	822	*/
894	else if (action == UP_OBJ_CHANGE \|\| action == UP_OBJ_REMOVE)	823	else if (action == UP_OBJ_CHANGE \|\| action == UP_OBJ_REMOVE)
895	{
896	update_now = 1;	824	update_now = 1;
897	}
898	else if (action == UP_OBJ_FACE)	825	else if (action == UP_OBJ_FACE)
899	{
900	/* Nothing to do for that case */	826	/* Nothing to do for that case */ ;
901	}
902	else	827	else
903	{
904	LOG (llevError, "update_object called with invalid action: %d\n", action);	828	LOG (llevError, "update_object called with invalid action: %d\n", action);
905	}
906		829
907	if (update_now)	830	if (update_now)
908	{	831	{
909	SET_MAP_FLAGS (op->map, op->x, op->y, flags \| P_NO_ERROR \| P_NEED_UPDATE);	832	SET_MAP_FLAGS (op->map, op->x, op->y, flags \| P_NO_ERROR \| P_NEED_UPDATE);
910	update_position (op->map, op->x, op->y);	833	update_position (op->map, op->x, op->y);
…		…
912		835
913	if (op->more != NULL)	836	if (op->more != NULL)
914	update_object (op->more, action);	837	update_object (op->more, action);
915	}	838	}
916		839
917	static	840	static unordered_vector<object *> mortals;
918	std::vector < object *>	841	static std::vector<object *> freed;
919	mortals;
920		842
921	void object::free_mortals ()	843	void object::free_mortals ()
922	{	844	{
923	for (std::vector < object *>::iterator i = mortals.begin (); i != mortals.end (); ++i)	845	for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end ();)
924	delete *	846	if ((*i)->refcnt)
		847	++i; // further delay freeing
		848	else
925	i;	849	{
		850	freed.push_back (*i);//D
		851	//delete *i;
		852	mortals.erase (i);
		853	}
926		854
927	mortals.clear ();	855	if (mortals.size())//D
		856	LOG (llevDebug, "%d objects in mortal queue\n", mortals.size());//D
928	}	857	}
929		858
930	object::object ()	859	object::object ()
931	{	860	{
932	SET_FLAG (this, FLAG_REMOVED);	861	SET_FLAG (this, FLAG_REMOVED);
…		…
958	{	887	{
959	count = 0;	888	count = 0;
960		889
961	/* Remove this object from the list of used objects */	890	/* Remove this object from the list of used objects */
962	if (prev)	891	if (prev)
		892	{
963	prev->next = next;	893	prev->next = next;
		894	prev = 0;
		895	}
		896
964	if (next)	897	if (next)
		898	{
965	next->prev = prev;	899	next->prev = prev;
		900	next = 0;
		901	}
		902
966	if (this == objects)	903	if (this == objects)
967	objects = next;	904	objects = next;
968	}	905	}
969		906
970	object *object::create ()	907	object *object::create ()
971	{	908	{
972	object *	909	object *op;
		910
		911	if (freed.empty ())
973	op = new object;	912	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	}
974		921
975	op->link ();	922	op->link ();
976	return op;	923	return op;
977	}	924	}
978		925
…		…
986	* If free_inventory is set, free inventory as well. Else drop items in	933	* If free_inventory is set, free inventory as well. Else drop items in
987	* inventory to the ground.	934	* inventory to the ground.
988	*/	935	*/
989	void object::free (bool free_inventory)	936	void object::free (bool free_inventory)
990	{	937	{
		938	if (QUERY_FLAG (this, FLAG_FREED))
		939	return;
		940
		941	if (QUERY_FLAG (this, FLAG_FRIENDLY))
		942	remove_friendly_object (this);
		943
991	if (!QUERY_FLAG (this, FLAG_REMOVED))	944	if (!QUERY_FLAG (this, FLAG_REMOVED))
992	{	945	remove_ob (this);
993	LOG (llevDebug, "Free object called with non removed object\n");
994	dump_object (this);
995	#ifdef MANY_CORES
996	abort ();
997	#endif
998	}
999		946
1000	if (QUERY_FLAG (this, FLAG_FRIENDLY))
1001	{
1002	LOG (llevMonster, "Warning: tried to free friendly object.\n");
1003	remove_friendly_object (this);
1004	}
1005
1006	if (QUERY_FLAG (this, FLAG_FREED))	947	SET_FLAG (this, FLAG_FREED);
1007	{
1008	dump_object (this);
1009	LOG (llevError, "Trying to free freed object.\n%s\n", errmsg);
1010	return;
1011	}
1012		948
1013	if (more)	949	if (more)
1014	{	950	{
1015	more->free (free_inventory);	951	more->free (free_inventory);
1016	more = 0;	952	more = 0;
…		…
1020	{	956	{
1021	/* Only if the space blocks everything do we not process -	957	/* Only if the space blocks everything do we not process -
1022	* if some form of movement is allowed, let objects	958	* if some form of movement is allowed, let objects
1023	* drop on that space.	959	* drop on that space.
1024	*/	960	*/
1025	if (free_inventory \|\| !map \|\| map->in_memory != MAP_IN_MEMORY \|\| (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL))	961	if (free_inventory \|\| !map \|\| map->in_memory != MAP_IN_MEMORY \|\| GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
1026	{	962	{
1027	object *	963	object *op = inv;
1028	op = inv;
1029		964
1030	while (op)	965	while (op)
1031	{	966	{
1032	object *
1033	tmp = op->below;	967	object *tmp = op->below;
1034
1035	remove_ob (op);
1036	op->free (free_inventory);	968	op->free (free_inventory);
1037	op = tmp;	969	op = tmp;
1038	}	970	}
1039	}	971	}
1040	else	972	else
1041	{ /* Put objects in inventory onto this space */	973	{ /* Put objects in inventory onto this space */
1042	object *	974	object *op = inv;
1043	op = inv;
1044		975
1045	while (op)	976	while (op)
1046	{	977	{
1047	object *
1048	tmp = op->below;	978	object *tmp = op->below;
1049		979
1050	remove_ob (op);	980	remove_ob (op);
1051		981
1052	if (QUERY_FLAG (op, FLAG_STARTEQUIP)	982	if (QUERY_FLAG (op, FLAG_STARTEQUIP)
1053	\|\| QUERY_FLAG (op, FLAG_NO_DROP) \|\| op->type == RUNE \|\| op->type == TRAP \|\| QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	983	\|\| QUERY_FLAG (op, FLAG_NO_DROP) \|\| op->type == RUNE \|\| op->type == TRAP \|\| QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
…		…
1062	op = tmp;	992	op = tmp;
1063	}	993	}
1064	}	994	}
1065	}	995	}
1066		996
		997	owner = 0;
		998
1067	/* Remove object from the active list */	999	/* Remove object from the active list */
1068	speed = 0;	1000	speed = 0;
1069	update_ob_speed (this);	1001	update_ob_speed (this);
1070		1002
1071	unlink ();	1003	unlink ();
1072
1073	SET_FLAG (this, FLAG_FREED);
1074		1004
1075	mortals.push_back (this);	1005	mortals.push_back (this);
1076	}	1006	}
1077		1007
1078	/*	1008	/*
…		…
1109	object *	1039	object *
1110	tmp, *	1040	tmp, *
1111	last = NULL;	1041	last = NULL;
1112	object *	1042	object *
1113	otmp;	1043	otmp;
		1044
1114	tag_t	1045	tag_t
1115	tag;	1046	tag;
1116	int	1047	int
1117	check_walk_off;	1048	check_walk_off;
1118	mapstruct *	1049	mapstruct *
1119	m;	1050	m;
		1051
1120	sint16	1052	sint16
1121	x,	1053	x,
1122	y;	1054	y;
1123		1055
1124
1125	if (QUERY_FLAG (op, FLAG_REMOVED))	1056	if (QUERY_FLAG (op, FLAG_REMOVED))
1126	{	1057	return;
1127	dump_object (op);
1128	LOG (llevError, "Trying to remove removed object.\n%s\n", errmsg);
1129		1058
1130	/* Changed it to always dump core in this case. As has been learned	1059	SET_FLAG (op, FLAG_REMOVED);
1131	* in the past, trying to recover from errors almost always	1060
1132	* make things worse, and this is a real error here - something
1133	* that should not happen.
1134	* Yes, if this was a mission critical app, trying to do something
1135	* to recover may make sense, but that is because failure of the app
1136	* may have other disastrous problems. Cf runs out of a script
1137	* so is easily enough restarted without any real problems.
1138	* MSW 2001-07-01
1139	*/
1140	abort ();
1141	}
1142	if (op->more != NULL)	1061	if (op->more != NULL)
1143	remove_ob (op->more);	1062	remove_ob (op->more);
1144
1145	SET_FLAG (op, FLAG_REMOVED);
1146		1063
1147	/*	1064	/*
1148	* In this case, the object to be removed is in someones	1065	* In this case, the object to be removed is in someones
1149	* inventory.	1066	* inventory.
1150	*/	1067	*/
…		…
1176	*/	1093	*/
1177	op->x = op->env->x, op->y = op->env->y;	1094	op->x = op->env->x, op->y = op->env->y;
1178	op->map = op->env->map;	1095	op->map = op->env->map;
1179	op->above = NULL, op->below = NULL;	1096	op->above = NULL, op->below = NULL;
1180	op->env = NULL;	1097	op->env = NULL;
1181	return;	1098	}
		1099	else if (op->map)
1182	}	1100	{
1183
1184	/* If we get here, we are removing it from a map */
1185	if (op->map == NULL)
1186	return;
1187
1188	x = op->x;	1101	x = op->x;
1189	y = op->y;	1102	y = op->y;
1190	m = get_map_from_coord (op->map, &x, &y);	1103	m = get_map_from_coord (op->map, &x, &y);
1191		1104
1192	if (!m)	1105	if (!m)
1193	{	1106	{
1194	LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",	1107	LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1195	op->map->path, op->x, op->y);	1108	op->map->path, op->x, op->y);
1196	/* in old days, we used to set x and y to 0 and continue.	1109	/* in old days, we used to set x and y to 0 and continue.
1197	* it seems if we get into this case, something is probablye	1110	* it seems if we get into this case, something is probablye
1198	* screwed up and should be fixed.	1111	* screwed up and should be fixed.
		1112	*/
		1113	abort ();
		1114	}
		1115
		1116	if (op->map != m)
		1117	LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
		1118	op->map->path, m->path, op->x, op->y, x, y);
		1119
		1120	/* Re did the following section of code - it looks like it had
		1121	* lots of logic for things we no longer care about
1199	*/	1122	*/
1200	abort ();
1201	}
1202	if (op->map != m)
1203	{
1204	LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1205	op->map->path, m->path, op->x, op->y, x, y);
1206	}
1207		1123
1208	/* Re did the following section of code - it looks like it had
1209	* lots of logic for things we no longer care about
1210	*/
1211
1212	/* link the object above us */	1124	/* link the object above us */
1213	if (op->above)	1125	if (op->above)
1214	op->above->below = op->below;	1126	op->above->below = op->below;
1215	else	1127	else
1216	SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */	1128	SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1217		1129
1218	/* Relink the object below us, if there is one */	1130	/* Relink the object below us, if there is one */
1219	if (op->below)	1131	if (op->below)
1220	{
1221	op->below->above = op->above;	1132	op->below->above = op->above;
1222	}
1223	else	1133	else
1224	{	1134	{
1225	/* Nothing below, which means we need to relink map object for this space	1135	/* Nothing below, which means we need to relink map object for this space
1226	* use translated coordinates in case some oddness with map tiling is	1136	* use translated coordinates in case some oddness with map tiling is
1227	* evident	1137	* evident
1228	*/
1229	if (GET_MAP_OB (m, x, y) != op)
1230	{
1231	dump_object (op);
1232	LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n",
1233	errmsg);
1234	dump_object (GET_MAP_OB (m, x, y));
1235	LOG (llevError, "%s\n", errmsg);
1236	}
1237	SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1238	}
1239	op->above = NULL;
1240	op->below = NULL;
1241
1242	if (op->map->in_memory == MAP_SAVING)
1243	return;
1244
1245	tag = op->count;
1246	check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1247	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1248	{
1249	/* No point updating the players look faces if he is the object
1250	* being removed.
1251	*/
1252
1253	if (tmp->type == PLAYER && tmp != op)
1254	{
1255	/* If a container that the player is currently using somehow gets
1256	* removed (most likely destroyed), update the player view
1257	* appropriately.
1258	*/	1138	*/
1259	if (tmp->container == op)	1139	if (GET_MAP_OB (m, x, y) != op)
1260	{	1140	{
1261	CLEAR_FLAG (op, FLAG_APPLIED);	1141	dump_object (op);
1262	tmp->container = NULL;	1142	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);
		1144	dump_object (GET_MAP_OB (m, x, y));
		1145	LOG (llevError, "%s\n", errmsg);
1263	}	1146	}
1264	tmp->contr->socket.update_look = 1;	1147
1265	}	1148	SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1266	/* See if player moving off should effect something */
1267	if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1268	{	1149	}
1269		1150
1270	move_apply (tmp, op, NULL);	1151	op->above = 0;
1271	if (was_destroyed (op, tag))	1152	op->below = 0;
		1153
		1154	if (op->map->in_memory == MAP_SAVING)
		1155	return;
		1156
		1157	tag = op->count;
		1158	check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
		1159
		1160	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
		1161	{
		1162	/* No point updating the players look faces if he is the object
		1163	* being removed.
		1164	*/
		1165
		1166	if (tmp->type == PLAYER && tmp != op)
1272	{	1167	{
1273	LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);	1168	/* If a container that the player is currently using somehow gets
		1169	* removed (most likely destroyed), update the player view
		1170	* appropriately.
		1171	*/
		1172	if (tmp->container == op)
		1173	{
		1174	CLEAR_FLAG (op, FLAG_APPLIED);
		1175	tmp->container = NULL;
		1176	}
		1177
		1178	tmp->contr->socket.update_look = 1;
1274	}	1179	}
		1180
		1181	/* 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))
		1183	{
		1184	move_apply (tmp, op, NULL);
		1185
		1186	if (was_destroyed (op, tag))
		1187	{
		1188	LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);
		1189	}
1275	}	1190	}
1276		1191
1277	/* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */	1192	/* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1278		1193
1279	if (tmp->above == tmp)	1194	if (tmp->above == tmp)
1280	tmp->above = NULL;	1195	tmp->above = NULL;
		1196
1281	last = tmp;	1197	last = tmp;
1282	}	1198	}
		1199
1283	/* last == NULL of there are no objects on this space */	1200	/* last == NULL of there are no objects on this space */
1284	if (last == NULL)	1201	if (last == NULL)
1285	{	1202	{
1286	/* set P_NEED_UPDATE, otherwise update_position will complain. In theory,	1203	/* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1287	* we could preserve the flags (GET_MAP_FLAGS), but update_position figures	1204	* we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1288	* those out anyways, and if there are any flags set right now, they won't	1205	* those out anyways, and if there are any flags set right now, they won't
1289	* be correct anyways.	1206	* be correct anyways.
1290	*/	1207	*/
1291	SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);	1208	SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1292	update_position (op->map, op->x, op->y);	1209	update_position (op->map, op->x, op->y);
1293	}	1210	}
1294	else	1211	else
1295	update_object (last, UP_OBJ_REMOVE);	1212	update_object (last, UP_OBJ_REMOVE);
1296		1213
1297	if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) \|\| (op->glow_radius != 0))	1214	if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) \|\| (op->glow_radius != 0))
1298	update_all_los (op->map, op->x, op->y);	1215	update_all_los (op->map, op->x, op->y);
1299		1216	}
1300	}	1217	}
1301		1218
1302	/*	1219	/*
1303	* merge_ob(op,top):	1220	* merge_ob(op,top):
1304	*	1221	*
…		…
1311	object *	1228	object *
1312	merge_ob (object op, object top)	1229	merge_ob (object op, object top)
1313	{	1230	{
1314	if (!op->nrof)	1231	if (!op->nrof)
1315	return 0;	1232	return 0;
		1233
1316	if (top == NULL)	1234	if (top == NULL)
1317	for (top = op; top != NULL && top->above != NULL; top = top->above);	1235	for (top = op; top != NULL && top->above != NULL; top = top->above);
		1236
1318	for (; top != NULL; top = top->below)	1237	for (; top != NULL; top = top->below)
1319	{	1238	{
1320	if (top == op)	1239	if (top == op)
1321	continue;	1240	continue;
1322	if (CAN_MERGE (op, top))	1241	if (CAN_MERGE (op, top))
…		…
1328	remove_ob (op);	1247	remove_ob (op);
1329	free_object (op);	1248	free_object (op);
1330	return top;	1249	return top;
1331	}	1250	}
1332	}	1251	}
		1252
1333	return NULL;	1253	return NULL;
1334	}	1254	}
1335		1255
1336	/*	1256	/*
1337	* same as insert_ob_in_map except it handle separate coordinates and do a clean	1257	* same as insert_ob_in_map except it handle separate coordinates and do a clean
1338	* job preparing multi-part monsters	1258	* job preparing multi-part monsters
1339	*/	1259	*/
1340	object *	1260	object *
1341	insert_ob_in_map_at (object op, mapstruct m, object *originator, int flag, int x, int y)	1261	insert_ob_in_map_at (object op, mapstruct m, object *originator, int flag, int x, int y)
1342	{	1262	{
1343	object *	1263	object *tmp;
1344	tmp;
1345		1264
1346	if (op->head)	1265	if (op->head)
1347	op = op->head;	1266	op = op->head;
		1267
1348	for (tmp = op; tmp; tmp = tmp->more)	1268	for (tmp = op; tmp; tmp = tmp->more)
1349	{	1269	{
1350	tmp->x = x + tmp->arch->clone.x;	1270	tmp->x = x + tmp->arch->clone.x;
1351	tmp->y = y + tmp->arch->clone.y;	1271	tmp->y = y + tmp->arch->clone.y;
1352	}	1272	}
		1273
1353	return insert_ob_in_map (op, m, originator, flag);	1274	return insert_ob_in_map (op, m, originator, flag);
1354	}	1275	}
1355		1276
1356	/*	1277	/*
1357	* insert_ob_in_map (op, map, originator, flag):	1278	* insert_ob_in_map (op, map, originator, flag):
…		…
1375	*/	1296	*/
1376		1297
1377	object *	1298	object *
1378	insert_ob_in_map (object op, mapstruct m, object *originator, int flag)	1299	insert_ob_in_map (object op, mapstruct m, object *originator, int flag)
1379	{	1300	{
1380	object *	1301	object tmp, top, *floor = NULL;
1381	tmp, *	1302	sint16 x, y;
1382	top, *
1383	floor = NULL;
1384	sint16
1385	x,
1386	y;
1387		1303
1388	if (QUERY_FLAG (op, FLAG_FREED))	1304	if (QUERY_FLAG (op, FLAG_FREED))
1389	{	1305	{
1390	LOG (llevError, "Trying to insert freed object!\n");	1306	LOG (llevError, "Trying to insert freed object!\n");
1391	return NULL;	1307	return NULL;
1392	}	1308	}
		1309
1393	if (m == NULL)	1310	if (m == NULL)
1394	{	1311	{
1395	dump_object (op);	1312	dump_object (op);
1396	LOG (llevError, "Trying to insert in null-map!\n%s\n", errmsg);	1313	LOG (llevError, "Trying to insert in null-map!\n%s\n", errmsg);
1397	return op;	1314	return op;
1398	}	1315	}
		1316
1399	if (out_of_map (m, op->x, op->y))	1317	if (out_of_map (m, op->x, op->y))
1400	{	1318	{
1401	dump_object (op);	1319	dump_object (op);
1402	LOG (llevError, "Trying to insert object outside the map.\n%s\n", errmsg);	1320	LOG (llevError, "Trying to insert object outside the map.\n%s\n", errmsg);
1403	#ifdef MANY_CORES	1321	#ifdef MANY_CORES
…		…
1407	*/	1325	*/
1408	abort ();	1326	abort ();
1409	#endif	1327	#endif
1410	return op;	1328	return op;
1411	}	1329	}
		1330
1412	if (!QUERY_FLAG (op, FLAG_REMOVED))	1331	if (!QUERY_FLAG (op, FLAG_REMOVED))
1413	{	1332	{
1414	dump_object (op);	1333	dump_object (op);
1415	LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", errmsg);	1334	LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", errmsg);
1416	return op;	1335	return op;
1417	}	1336	}
		1337
1418	if (op->more != NULL)	1338	if (op->more != NULL)
1419	{	1339	{
1420	/* The part may be on a different map. */	1340	/* The part may be on a different map. */
1421		1341
1422	object *
1423	more = op->more;	1342	object *more = op->more;
1424		1343
1425	/* We really need the caller to normalize coordinates - if	1344	/* We really need the caller to normalize coordinates - if
1426	* we set the map, that doesn't work if the location is within	1345	* we set the map, that doesn't work if the location is within
1427	* a map and this is straddling an edge. So only if coordinate	1346	* a map and this is straddling an edge. So only if coordinate
1428	* is clear wrong do we normalize it.	1347	* is clear wrong do we normalize it.
1429	*/	1348	*/
1430	if (OUT_OF_REAL_MAP (more->map, more->x, more->y))	1349	if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
1431	{
1432	more->map = get_map_from_coord (m, &more->x, &more->y);	1350	more->map = get_map_from_coord (m, &more->x, &more->y);
1433	}
1434	else if (!more->map)	1351	else if (!more->map)
1435	{	1352	{
1436	/* For backwards compatibility - when not dealing with tiled maps,	1353	/* For backwards compatibility - when not dealing with tiled maps,
1437	* more->map should always point to the parent.	1354	* more->map should always point to the parent.
1438	*/	1355	*/
…		…
1441		1358
1442	if (insert_ob_in_map (more, more->map, originator, flag) == NULL)	1359	if (insert_ob_in_map (more, more->map, originator, flag) == NULL)
1443	{	1360	{
1444	if (!op->head)	1361	if (!op->head)
1445	LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");	1362	LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
		1363
1446	return NULL;	1364	return NULL;
1447	}	1365	}
1448	}	1366	}
		1367
1449	CLEAR_FLAG (op, FLAG_REMOVED);	1368	CLEAR_FLAG (op, FLAG_REMOVED);
1450		1369
1451	/* Ideally, the caller figures this out. However, it complicates a lot	1370	/* Ideally, the caller figures this out. However, it complicates a lot
1452	* of areas of callers (eg, anything that uses find_free_spot would now	1371	* of areas of callers (eg, anything that uses find_free_spot would now
1453	* need extra work	1372	* need extra work
…		…
1457	y = op->y;	1376	y = op->y;
1458		1377
1459	/* this has to be done after we translate the coordinates.	1378	/* this has to be done after we translate the coordinates.
1460	*/	1379	*/
1461	if (op->nrof && !(flag & INS_NO_MERGE))	1380	if (op->nrof && !(flag & INS_NO_MERGE))
1462	{
1463	for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)	1381	for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)
1464	if (CAN_MERGE (op, tmp))	1382	if (CAN_MERGE (op, tmp))
1465	{	1383	{
1466	op->nrof += tmp->nrof;	1384	op->nrof += tmp->nrof;
1467	remove_ob (tmp);	1385	remove_ob (tmp);
1468	free_object (tmp);	1386	free_object (tmp);
1469	}	1387	}
1470	}
1471		1388
1472	CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */	1389	CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1473	CLEAR_FLAG (op, FLAG_INV_LOCKED);	1390	CLEAR_FLAG (op, FLAG_INV_LOCKED);
		1391
1474	if (!QUERY_FLAG (op, FLAG_ALIVE))	1392	if (!QUERY_FLAG (op, FLAG_ALIVE))
1475	CLEAR_FLAG (op, FLAG_NO_STEAL);	1393	CLEAR_FLAG (op, FLAG_NO_STEAL);
1476		1394
1477	if (flag & INS_BELOW_ORIGINATOR)	1395	if (flag & INS_BELOW_ORIGINATOR)
1478	{	1396	{
1479	if (originator->map != op->map \|\| originator->x != op->x \|\| originator->y != op->y)	1397	if (originator->map != op->map \|\| originator->x != op->x \|\| originator->y != op->y)
1480	{	1398	{
1481	LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");	1399	LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1482	abort ();	1400	abort ();
1483	}	1401	}
		1402
1484	op->above = originator;	1403	op->above = originator;
1485	op->below = originator->below;	1404	op->below = originator->below;
		1405
1486	if (op->below)	1406	if (op->below)
1487	op->below->above = op;	1407	op->below->above = op;
1488	else	1408	else
1489	SET_MAP_OB (op->map, op->x, op->y, op);	1409	SET_MAP_OB (op->map, op->x, op->y, op);
		1410
1490	/* since below originator, no need to update top */	1411	/* since below originator, no need to update top */
1491	originator->below = op;	1412	originator->below = op;
1492	}	1413	}
1493	else	1414	else
1494	{	1415	{
1495	/* If there are other objects, then */	1416	/* If there are other objects, then */
1496	if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))	1417	if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
1497	{	1418	{
1498	object *
1499	last = NULL;	1419	object *last = NULL;
1500		1420
1501	/*	1421	/*
1502	* If there are multiple objects on this space, we do some trickier handling.	1422	* If there are multiple objects on this space, we do some trickier handling.
1503	* We've already dealt with merging if appropriate.	1423	* We've already dealt with merging if appropriate.
1504	* Generally, we want to put the new object on top. But if	1424	* Generally, we want to put the new object on top. But if
…		…
1513		1433
1514	while (top != NULL)	1434	while (top != NULL)
1515	{	1435	{
1516	if (QUERY_FLAG (top, FLAG_IS_FLOOR) \|\| QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))	1436	if (QUERY_FLAG (top, FLAG_IS_FLOOR) \|\| QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
1517	floor = top;	1437	floor = top;
		1438
1518	if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW \| MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))	1439	if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW \| MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))
1519	{	1440	{
1520	/* We insert above top, so we want this object below this */	1441	/* We insert above top, so we want this object below this */
1521	top = top->below;	1442	top = top->below;
1522	break;	1443	break;
1523	}	1444	}
		1445
1524	last = top;	1446	last = top;
1525	top = top->above;	1447	top = top->above;
1526	}	1448	}
		1449
1527	/* Don't want top to be NULL, so set it to the last valid object */	1450	/* Don't want top to be NULL, so set it to the last valid object */
1528	top = last;	1451	top = last;
1529		1452
1530	/* We let update_position deal with figuring out what the space	1453	/* We let update_position deal with figuring out what the space
1531	* looks like instead of lots of conditions here.	1454	* looks like instead of lots of conditions here.
…		…
1551	*/	1474	*/
1552	if (last && last->below && last != floor)	1475	if (last && last->below && last != floor)
1553	top = last->below;	1476	top = last->below;
1554	}	1477	}
1555	} /* If objects on this space */	1478	} /* If objects on this space */
		1479
1556	if (flag & INS_MAP_LOAD)	1480	if (flag & INS_MAP_LOAD)
1557	top = GET_MAP_TOP (op->map, op->x, op->y);	1481	top = GET_MAP_TOP (op->map, op->x, op->y);
		1482
1558	if (flag & INS_ABOVE_FLOOR_ONLY)	1483	if (flag & INS_ABOVE_FLOOR_ONLY)
1559	top = floor;	1484	top = floor;
1560		1485
1561	/* Top is the object that our object (op) is going to get inserted above.	1486	/* Top is the object that our object (op) is going to get inserted above.
1562	*/	1487	*/
1563		1488
1564	/* First object on this space */	1489	/* First object on this space */
1565	if (!top)	1490	if (!top)
1566	{	1491	{
1567	op->above = GET_MAP_OB (op->map, op->x, op->y);	1492	op->above = GET_MAP_OB (op->map, op->x, op->y);
		1493
1568	if (op->above)	1494	if (op->above)
1569	op->above->below = op;	1495	op->above->below = op;
		1496
1570	op->below = NULL;	1497	op->below = NULL;
1571	SET_MAP_OB (op->map, op->x, op->y, op);	1498	SET_MAP_OB (op->map, op->x, op->y, op);
1572	}	1499	}
1573	else	1500	else
1574	{ /* get inserted into the stack above top */	1501	{ /* get inserted into the stack above top */
1575	op->above = top->above;	1502	op->above = top->above;
		1503
1576	if (op->above)	1504	if (op->above)
1577	op->above->below = op;	1505	op->above->below = op;
		1506
1578	op->below = top;	1507	op->below = top;
1579	top->above = op;	1508	top->above = op;
1580	}	1509	}
		1510
1581	if (op->above == NULL)	1511	if (op->above == NULL)
1582	SET_MAP_TOP (op->map, op->x, op->y, op);	1512	SET_MAP_TOP (op->map, op->x, op->y, op);
1583	} /* else not INS_BELOW_ORIGINATOR */	1513	} /* else not INS_BELOW_ORIGINATOR */
1584		1514
1585	if (op->type == PLAYER)	1515	if (op->type == PLAYER)
…		…
1588	/* If we have a floor, we know the player, if any, will be above	1518	/* If we have a floor, we know the player, if any, will be above
1589	* it, so save a few ticks and start from there.	1519	* it, so save a few ticks and start from there.
1590	*/	1520	*/
1591	if (!(flag & INS_MAP_LOAD))	1521	if (!(flag & INS_MAP_LOAD))
1592	for (tmp = floor ? floor : GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1522	for (tmp = floor ? floor : GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1593	{
1594	if (tmp->type == PLAYER)	1523	if (tmp->type == PLAYER)
1595	tmp->contr->socket.update_look = 1;	1524	tmp->contr->socket.update_look = 1;
1596	}
1597		1525
1598	/* If this object glows, it may affect lighting conditions that are	1526	/* If this object glows, it may affect lighting conditions that are
1599	* visible to others on this map. But update_all_los is really	1527	* visible to others on this map. But update_all_los is really
1600	* an inefficient way to do this, as it means los for all players	1528	* an inefficient way to do this, as it means los for all players
1601	* on the map will get recalculated. The players could very well	1529	* on the map will get recalculated. The players could very well
…		…
1605	* of effect may be sufficient.	1533	* of effect may be sufficient.
1606	*/	1534	*/
1607	if (MAP_DARKNESS (op->map) && (op->glow_radius != 0))	1535	if (MAP_DARKNESS (op->map) && (op->glow_radius != 0))
1608	update_all_los (op->map, op->x, op->y);	1536	update_all_los (op->map, op->x, op->y);
1609		1537
1610
1611	/* updates flags (blocked, alive, no magic, etc) for this map space */	1538	/* updates flags (blocked, alive, no magic, etc) for this map space */
1612	update_object (op, UP_OBJ_INSERT);	1539	update_object (op, UP_OBJ_INSERT);
1613
1614		1540
1615	/* Don't know if moving this to the end will break anything. However,	1541	/* Don't know if moving this to the end will break anything. However,
1616	* we want to have update_look set above before calling this.	1542	* we want to have update_look set above before calling this.
1617	*	1543	*
1618	* check_move_on() must be after this because code called from	1544	* check_move_on() must be after this because code called from
…		…
1620	* blocked() and wall() work properly), and these flags are updated by	1546	* blocked() and wall() work properly), and these flags are updated by
1621	* update_object().	1547	* update_object().
1622	*/	1548	*/
1623		1549
1624	/* if this is not the head or flag has been passed, don't check walk on status */	1550	/* if this is not the head or flag has been passed, don't check walk on status */
1625
1626	if (!(flag & INS_NO_WALK_ON) && !op->head)	1551	if (!(flag & INS_NO_WALK_ON) && !op->head)
1627	{	1552	{
1628	if (check_move_on (op, originator))	1553	if (check_move_on (op, originator))
1629	return NULL;	1554	return NULL;
1630		1555
…		…
1633	*/	1558	*/
1634	for (tmp = op->more; tmp != NULL; tmp = tmp->more)	1559	for (tmp = op->more; tmp != NULL; tmp = tmp->more)
1635	if (check_move_on (tmp, originator))	1560	if (check_move_on (tmp, originator))
1636	return NULL;	1561	return NULL;
1637	}	1562	}
		1563
1638	return op;	1564	return op;
1639	}	1565	}
1640		1566
1641	/* this function inserts an object in the map, but if it	1567	/* this function inserts an object in the map, but if it
1642	* finds an object of its own type, it'll remove that one first.	1568	* finds an object of its own type, it'll remove that one first.
…		…
1660	free_object (tmp);	1586	free_object (tmp);
1661	}	1587	}
1662	}	1588	}
1663		1589
1664	tmp1 = arch_to_object (find_archetype (arch_string));	1590	tmp1 = arch_to_object (find_archetype (arch_string));
1665
1666		1591
1667	tmp1->x = op->x;	1592	tmp1->x = op->x;
1668	tmp1->y = op->y;	1593	tmp1->y = op->y;
1669	insert_ob_in_map (tmp1, op->map, op, 0);	1594	insert_ob_in_map (tmp1, op->map, op, 0);
1670	}	1595	}
…		…
1688	if (orig_ob->nrof < nr)	1613	if (orig_ob->nrof < nr)
1689	{	1614	{
1690	sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);	1615	sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1691	return NULL;	1616	return NULL;
1692	}	1617	}
		1618
1693	newob = object_create_clone (orig_ob);	1619	newob = object_create_clone (orig_ob);
		1620
1694	if ((orig_ob->nrof -= nr) < 1)	1621	if ((orig_ob->nrof -= nr) < 1)
1695	{	1622	{
1696	if (!is_removed)	1623	if (!is_removed)
1697	remove_ob (orig_ob);	1624	remove_ob (orig_ob);
1698	free_object2 (orig_ob, 1);	1625	free_object2 (orig_ob, 1);
…		…
1706	strcpy (errmsg, "Tried to split object whose map is not in memory.");	1633	strcpy (errmsg, "Tried to split object whose map is not in memory.");
1707	LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");	1634	LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1708	return NULL;	1635	return NULL;
1709	}	1636	}
1710	}	1637	}
		1638
1711	newob->nrof = nr;	1639	newob->nrof = nr;
1712		1640
1713	return newob;	1641	return newob;
1714	}	1642	}
1715		1643
…		…
1722	*/	1650	*/
1723		1651
1724	object *	1652	object *
1725	decrease_ob_nr (object *op, uint32 i)	1653	decrease_ob_nr (object *op, uint32 i)
1726	{	1654	{
1727	object *	1655	object *tmp;
1728	tmp;
1729	player *	1656	player *pl;
1730	pl;
1731		1657
1732	if (i == 0) /* objects with op->nrof require this check */	1658	if (i == 0) /* objects with op->nrof require this check */
1733	return op;	1659	return op;
1734		1660
1735	if (i > op->nrof)	1661	if (i > op->nrof)
1736	i = op->nrof;	1662	i = op->nrof;
1737		1663
1738	if (QUERY_FLAG (op, FLAG_REMOVED))	1664	if (QUERY_FLAG (op, FLAG_REMOVED))
1739	{
1740	op->nrof -= i;	1665	op->nrof -= i;
1741	}
1742	else if (op->env != NULL)	1666	else if (op->env != NULL)
1743	{	1667	{
1744	/* is this object in the players inventory, or sub container	1668	/* is this object in the players inventory, or sub container
1745	* therein?	1669	* therein?
1746	*/	1670	*/
…		…
1781	}	1705	}
1782	}	1706	}
1783	}	1707	}
1784	else	1708	else
1785	{	1709	{
1786	object *
1787	above = op->above;	1710	object *above = op->above;
1788		1711
1789	if (i < op->nrof)	1712	if (i < op->nrof)
1790	{
1791	op->nrof -= i;	1713	op->nrof -= i;
1792	}
1793	else	1714	else
1794	{	1715	{
1795	remove_ob (op);	1716	remove_ob (op);
1796	op->nrof = 0;	1717	op->nrof = 0;
1797	}	1718	}
		1719
1798	/* Since we just removed op, op->above is null */	1720	/* Since we just removed op, op->above is null */
1799	for (tmp = above; tmp != NULL; tmp = tmp->above)	1721	for (tmp = above; tmp != NULL; tmp = tmp->above)
1800	if (tmp->type == PLAYER)	1722	if (tmp->type == PLAYER)
1801	{	1723	{
1802	if (op->nrof)	1724	if (op->nrof)
…		…
1805	esrv_del_item (tmp->contr, op->count);	1727	esrv_del_item (tmp->contr, op->count);
1806	}	1728	}
1807	}	1729	}
1808		1730
1809	if (op->nrof)	1731	if (op->nrof)
1810	{
1811	return op;	1732	return op;
1812	}
1813	else	1733	else
1814	{	1734	{
1815	free_object (op);	1735	free_object (op);
1816	return NULL;	1736	return NULL;
1817	}	1737	}
…		…
1826	add_weight (object *op, signed long weight)	1746	add_weight (object *op, signed long weight)
1827	{	1747	{
1828	while (op != NULL)	1748	while (op != NULL)
1829	{	1749	{
1830	if (op->type == CONTAINER)	1750	if (op->type == CONTAINER)
1831	{
1832	weight = (signed long) (weight * (100 - op->stats.Str) / 100);	1751	weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1833	}	1752
1834	op->carrying += weight;	1753	op->carrying += weight;
1835	op = op->env;	1754	op = op->env;
1836	}	1755	}
1837	}	1756	}
1838		1757
…		…
1861	{	1780	{
1862	dump_object (op);	1781	dump_object (op);
1863	LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);	1782	LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);
1864	return op;	1783	return op;
1865	}	1784	}
		1785
1866	if (where == NULL)	1786	if (where == NULL)
1867	{	1787	{
1868	dump_object (op);	1788	dump_object (op);
1869	LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);	1789	LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);
1870	return op;	1790	return op;
1871	}	1791	}
		1792
1872	if (where->head)	1793	if (where->head)
1873	{	1794	{
1874	LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");	1795	LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1875	where = where->head;	1796	where = where->head;
1876	}	1797	}
		1798
1877	if (op->more)	1799	if (op->more)
1878	{	1800	{
1879	LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);	1801	LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1880	return op;	1802	return op;
1881	}	1803	}
		1804
1882	CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);	1805	CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1883	CLEAR_FLAG (op, FLAG_REMOVED);	1806	CLEAR_FLAG (op, FLAG_REMOVED);
1884	if (op->nrof)	1807	if (op->nrof)
1885	{	1808	{
1886	for (tmp = where->inv; tmp != NULL; tmp = tmp->below)	1809	for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
…		…
1979	tag;	1902	tag;
1980	mapstruct *	1903	mapstruct *
1981	m = op->map;	1904	m = op->map;
1982	int	1905	int
1983	x = op->x, y = op->y;	1906	x = op->x, y = op->y;
		1907
1984	MoveType	1908	MoveType
1985	move_on,	1909	move_on,
1986	move_slow,	1910	move_slow,
1987	move_block;	1911	move_block;
1988		1912
…		…
2022	* we don't need to check all of them.	1946	* we don't need to check all of them.
2023	*/	1947	*/
2024	if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK))	1948	if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK))
2025	break;	1949	break;
2026	}	1950	}
		1951
2027	for (; tmp != NULL; tmp = tmp->below)	1952	for (; tmp; tmp = tmp->below)
2028	{	1953	{
2029	if (tmp == op)	1954	if (tmp == op)
2030	continue; /* Can't apply yourself */	1955	continue; /* Can't apply yourself */
2031		1956
2032	/* Check to see if one of the movement types should be slowed down.	1957	/* Check to see if one of the movement types should be slowed down.
…		…
2040	if ((!op->move_type && tmp->move_slow & MOVE_WALK) \|\|	1965	if ((!op->move_type && tmp->move_slow & MOVE_WALK) \|\|
2041	((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))	1966	((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
2042	{	1967	{
2043		1968
2044	float	1969	float
2045	diff;
2046
2047	diff = tmp->move_slow_penalty * FABS (op->speed);	1970	diff = tmp->move_slow_penalty * FABS (op->speed);
		1971
2048	if (op->type == PLAYER)	1972	if (op->type == PLAYER)
2049	{
2050	if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) \|\|	1973	if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) \|\|
2051	(QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))	1974	(QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2052	{
2053	diff /= 4.0;	1975	diff /= 4.0;
2054	}	1976
2055	}
2056	op->speed_left -= diff;	1977	op->speed_left -= diff;
2057	}	1978	}
2058	}	1979	}
2059		1980
2060	/* Basically same logic as above, except now for actual apply. */	1981	/* Basically same logic as above, except now for actual apply. */
2061	if ((!op->move_type && tmp->move_on & MOVE_WALK) \|\|	1982	if ((!op->move_type && tmp->move_on & MOVE_WALK) \|\|
2062	((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))	1983	((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
2063	{	1984	{
2064
2065	move_apply (tmp, op, originator);	1985	move_apply (tmp, op, originator);
		1986
2066	if (was_destroyed (op, tag))	1987	if (was_destroyed (op, tag))
2067	return 1;	1988	return 1;
2068		1989
2069	/* what the person/creature stepped onto has moved the object	1990	/* what the person/creature stepped onto has moved the object
2070	* someplace new. Don't process any further - if we did,	1991	* someplace new. Don't process any further - if we did,
…		…
2072	*/	1993	*/
2073	if (op->map != m \|\| op->x != x \|\| op->y != y)	1994	if (op->map != m \|\| op->x != x \|\| op->y != y)
2074	return 0;	1995	return 0;
2075	}	1996	}
2076	}	1997	}
		1998
2077	return 0;	1999	return 0;
2078	}	2000	}
2079		2001
2080	/*	2002	/*
2081	* present_arch(arch, map, x, y) searches for any objects with	2003	* present_arch(arch, map, x, y) searches for any objects with
…		…
2372	find_dir (mapstruct m, int x, int y, object exclude)	2294	find_dir (mapstruct m, int x, int y, object exclude)
2373	{	2295	{
2374	int	2296	int
2375	i,	2297	i,
2376	max = SIZEOFFREE, mflags;	2298	max = SIZEOFFREE, mflags;
2377	sint16	2299
2378	nx,	2300	sint16 nx, ny;
2379	ny;
2380	object *	2301	object *
2381	tmp;	2302	tmp;
2382	mapstruct *	2303	mapstruct *
2383	mp;	2304	mp;
2384	MoveType	2305
2385	blocked,	2306	MoveType blocked, move_type;
2386	move_type;
2387		2307
2388	if (exclude && exclude->head)	2308	if (exclude && exclude->head)
2389	{	2309	{
2390	exclude = exclude->head;	2310	exclude = exclude->head;
2391	move_type = exclude->move_type;	2311	move_type = exclude->move_type;
…		…
2598		2518
2599		2519
2600	int	2520	int
2601	can_see_monsterP (mapstruct *m, int x, int y, int dir)	2521	can_see_monsterP (mapstruct *m, int x, int y, int dir)
2602	{	2522	{
2603	sint16	2523	sint16 dx, dy;
2604	dx,
2605	dy;
2606	int	2524	int
2607	mflags;	2525	mflags;
2608		2526
2609	if (dir < 0)	2527	if (dir < 0)
2610	return 0; /* exit condition: invalid direction */	2528	return 0; /* exit condition: invalid direction */
…		…
2741	fprintf (tempfile, obstr);	2659	fprintf (tempfile, obstr);
2742	fclose (tempfile);	2660	fclose (tempfile);
2743		2661
2744	op = get_object ();	2662	op = get_object ();
2745		2663
2746	object_thawer	2664	object_thawer thawer (filename);
2747	thawer (filename);
2748		2665
2749	if (thawer)	2666	if (thawer)
2750	load_object (thawer, op, 0);	2667	load_object (thawer, op, 0);
2751		2668
2752	LOG (llevDebug, " load str completed, object=%s\n", &op->name);	2669	LOG (llevDebug, " load str completed, object=%s\n", &op->name);
…		…
2876	if (last)	2793	if (last)
2877	last->next = field->next;	2794	last->next = field->next;
2878	else	2795	else
2879	op->key_values = field->next;	2796	op->key_values = field->next;
2880		2797
2881	delete
2882	field;	2798	delete field;
2883	}	2799	}
2884	}	2800	}
2885	return TRUE;	2801	return TRUE;
2886	}	2802	}
2887	/* IF we get here, key doesn't exist */	2803	/* IF we get here, key doesn't exist */
…		…
2922	* Returns TRUE on success.	2838	* Returns TRUE on success.
2923	*/	2839	*/
2924	int	2840	int
2925	set_ob_key_value (object op, const char key, const char *value, int add_key)	2841	set_ob_key_value (object op, const char key, const char *value, int add_key)
2926	{	2842	{
2927	shstr
2928	key_ (key);	2843	shstr key_ (key);
2929		2844
2930	return set_ob_key_value_s (op, key_, value, add_key);	2845	return set_ob_key_value_s (op, key_, value, add_key);
2931	}	2846	}
		2847
		2848	object::depth_iterator::depth_iterator (object *container)
		2849	: iterator_base (container)
		2850	{
		2851	while (item->inv)
		2852	item = item->inv;
		2853	}
		2854
		2855	void
		2856	object::depth_iterator::next ()
		2857	{
		2858	if (item->below)
		2859	{
		2860	item = item->below;
		2861
		2862	while (item->inv)
		2863	item = item->inv;
		2864	}
		2865	else
		2866	item = item->env;
		2867	}
		2868

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.24 by root, Sun Sep 10 16:00:23 2006 UTC vs. Revision 1.34 by root, Tue Sep 12 01:09:53 2006 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.24 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.34 by root, Tue Sep 12 01:09:53 2006 UTC