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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.87 by root, Tue Dec 26 08:54:59 2006 UTC vs.
Revision 1.105 by pippijn, Wed Jan 3 00:21:35 2007 UTC

…		…
190	* Check nrof variable before calling can_merge()	190	* Check nrof variable before calling can_merge()
191	*	191	*
192	* Improvements made with merge: Better checking on potion, and also	192	* Improvements made with merge: Better checking on potion, and also
193	* check weight	193	* check weight
194	*/	194	*/
195
196	bool object::can_merge_slow (object ob1, object ob2)	195	bool object::can_merge_slow (object ob1, object ob2)
197	{	196	{
198	/* A couple quicksanity checks */	197	/* A couple quicksanity checks */
199	if (ob1 == ob2	198	if (ob1 == ob2
200	\|\| ob1->type != ob2->type	199	\|\| ob1->type != ob2->type
…		…
277		276
278	/* Note sure why the following is the case - either the object has to	277	/* Note sure why the following is the case - either the object has to
279	* be animated or have a very low speed. Is this an attempted monster	278	* be animated or have a very low speed. Is this an attempted monster
280	* check?	279	* check?
281	*/	280	*/
282	if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)	281	if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ())
283	return 0;	282	return 0;
284		283
285	switch (ob1->type)	284	switch (ob1->type)
286	{	285	{
287	case SCROLL:	286	case SCROLL:
…		…
538	/*	537	/*
539	* If an object with the IS_TURNABLE() flag needs to be turned due	538	* If an object with the IS_TURNABLE() flag needs to be turned due
540	* to the closest player being on the other side, this function can	539	* to the closest player being on the other side, this function can
541	* be called to update the face variable, _and_ how it looks on the map.	540	* be called to update the face variable, _and_ how it looks on the map.
542	*/	541	*/
543
544	void	542	void
545	update_turn_face (object *op)	543	update_turn_face (object *op)
546	{	544	{
547	if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) \|\| op->arch == NULL)	545	if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) \|\| !op->arch)
548	return;	546	return;
		547
549	SET_ANIMATION (op, op->direction);	548	SET_ANIMATION (op, op->direction);
550	update_object (op, UP_OBJ_FACE);	549	update_object (op, UP_OBJ_FACE);
551	}	550	}
552		551
553	/*	552	/*
…		…
556	* This function needs to be called whenever the speed of an object changes.	555	* This function needs to be called whenever the speed of an object changes.
557	*/	556	*/
558	void	557	void
559	object::set_speed (float speed)	558	object::set_speed (float speed)
560	{	559	{
561	extern int arch_init;
562
563	/* No reason putting the archetypes objects on the speed list,
564	* since they never really need to be updated.
565	*/
566	if (flag [FLAG_FREED] && speed)	560	if (flag [FLAG_FREED] && speed)
567	{	561	{
568	LOG (llevError, "Object %s is freed but has speed.\n", &name);	562	LOG (llevError, "Object %s is freed but has speed.\n", &name);
569	speed = 0;	563	speed = 0;
570	}	564	}
571		565
572	this->speed = speed;	566	this->speed = speed;
573		567
574	if (arch_init)	568	if (has_active_speed ())
575	return;	569	activate ();
576
577	if (FABS (speed) > MIN_ACTIVE_SPEED)
578	{
579	/* If already on active list, don't do anything */
580	if (active_next \|\| active_prev \|\| this == active_objects)
581	return;
582
583	/* process_events() expects us to insert the object at the beginning
584	* of the list. */
585	active_next = active_objects;
586
587	if (active_next)
588	active_next->active_prev = this;
589
590	active_objects = this;
591	}
592	else	570	else
593	{	571	deactivate ();
594	/* If not on the active list, nothing needs to be done */
595	if (!active_next && !active_prev && this != active_objects)
596	return;
597
598	if (!active_prev)
599	{
600	active_objects = active_next;
601
602	if (active_next)
603	active_next->active_prev = 0;
604	}
605	else
606	{
607	active_prev->active_next = active_next;
608
609	if (active_next)
610	active_next->active_prev = active_prev;
611	}
612
613	active_next = 0;
614	active_prev = 0;
615	}
616	}
617
618	/* This function removes object 'op' from the list of active
619	* objects.
620	* This should only be used for style maps or other such
621	* reference maps where you don't want an object that isn't
622	* in play chewing up cpu time getting processed.
623	* The reverse of this is to call update_ob_speed, which
624	* will do the right thing based on the speed of the object.
625	*/
626	void
627	remove_from_active_list (object *op)
628	{
629	/* If not on the active list, nothing needs to be done */
630	if (!op->active_next && !op->active_prev && op != active_objects)
631	return;
632
633	if (op->active_prev == NULL)
634	{
635	active_objects = op->active_next;
636	if (op->active_next != NULL)
637	op->active_next->active_prev = NULL;
638	}
639	else
640	{
641	op->active_prev->active_next = op->active_next;
642	if (op->active_next)
643	op->active_next->active_prev = op->active_prev;
644	}
645	op->active_next = NULL;
646	op->active_prev = NULL;
647	}	572	}
648		573
649	/*	574	/*
650	* update_object() updates the the map.	575	* update_object() updates the the map.
651	* It takes into account invisible objects (and represent squares covered	576	* It takes into account invisible objects (and represent squares covered
…		…
699	return;	624	return;
700	}	625	}
701		626
702	mapspace &m = op->ms ();	627	mapspace &m = op->ms ();
703		628
704	if (m.flags_ & P_NEED_UPDATE)	629	if (!(m.flags_ & P_UPTODATE))
705	/* nop */;	630	/* nop */;
706	else if (action == UP_OBJ_INSERT)	631	else if (action == UP_OBJ_INSERT)
707	{	632	{
708	// this is likely overkill, TODO: revisit (schmorp)	633	// this is likely overkill, TODO: revisit (schmorp)
709	if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW))	634	if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW))
…		…
718	/* This isn't perfect, but I don't expect a lot of objects to	643	/* This isn't perfect, but I don't expect a lot of objects to
719	* to have move_allow right now.	644	* to have move_allow right now.
720	*/	645	*/
721	\|\| ((m.move_block \| op->move_block) & ~op->move_allow) != m.move_block	646	\|\| ((m.move_block \| op->move_block) & ~op->move_allow) != m.move_block
722	\|\| 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)	647	\|\| 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
723	m.flags_ = P_NEED_UPDATE;	648	m.flags_ = 0;
724	}	649	}
725	/* if the object is being removed, we can't make intelligent	650	/* if the object is being removed, we can't make intelligent
726	* decisions, because remove_ob can't really pass the object	651	* decisions, because remove_ob can't really pass the object
727	* that is being removed.	652	* that is being removed.
728	*/	653	*/
729	else if (action == UP_OBJ_CHANGE \|\| action == UP_OBJ_REMOVE)	654	else if (action == UP_OBJ_CHANGE \|\| action == UP_OBJ_REMOVE)
730	m.flags_ = P_NEED_UPDATE;	655	m.flags_ = 0;
731	else if (action == UP_OBJ_FACE)	656	else if (action == UP_OBJ_FACE)
732	/* Nothing to do for that case */ ;	657	/* Nothing to do for that case */ ;
733	else	658	else
734	LOG (llevError, "update_object called with invalid action: %d\n", action);	659	LOG (llevError, "update_object called with invalid action: %d\n", action);
735		660
736	if (op->more)	661	if (op->more)
737	update_object (op->more, action);	662	update_object (op->more, action);
738	}	663	}
739		664
740	object::vector object::objects; // not yet used
741	object *object::first;	665	object *object::first;
742		666
743	object::object ()	667	object::object ()
744	{	668	{
745	SET_FLAG (this, FLAG_REMOVED);	669	SET_FLAG (this, FLAG_REMOVED);
…		…
778		702
779	prev = 0;	703	prev = 0;
780	next = 0;	704	next = 0;
781	}	705	}
782		706
783	object *object::create ()	707	bool
		708	object::active () const
784	{	709	{
785	object *op = new object;	710	return active_next \|\| active_prev \|\| this == active_objects;
786	op->link ();
787	return op;
788	}	711	}
789		712
790	void	713	void
791	object::do_destroy ()	714	object::activate ()
792	{	715	{
793	attachable::do_destroy ();	716	/* If already on active list, don't do anything */
794		717	if (active ())
795	if (flag [FLAG_IS_LINKED])
796	remove_button_link (this);
797
798	if (flag [FLAG_FRIENDLY])
799	remove_friendly_object (this);
800
801	if (!flag [FLAG_REMOVED])
802	remove ();
803
804	if (flag [FLAG_FREED])
805	return;	718	return;
806		719
807	flag [FLAG_FREED] = 1;	720	if (has_active_speed ())
808
809	// hack to ensure that freed objects still have a valid map
810	{
811	static maptile *freed_map; // freed objects are moved here to avoid crashes
812
813	if (!freed_map)
814	{	721	{
815	freed_map = new maptile;	722	/* process_events() expects us to insert the object at the beginning
		723	* of the list. */
		724	active_next = active_objects;
816		725
817	freed_map->name = "/internal/freed_objects_map";	726	if (active_next)
818	freed_map->width = 3;	727	active_next->active_prev = this;
819	freed_map->height = 3;
820		728
821	freed_map->allocate ();	729	active_objects = this;
822	}	730	}
		731	}
823		732
824	map = freed_map;	733	void
825	x = 1;	734	object::activate_recursive ()
826	y = 1;	735	{
		736	activate ();
		737
		738	for (object *op = inv; op; op = op->below)
		739	op->activate_recursive ();
		740	}
		741
		742	/* This function removes object 'op' from the list of active
		743	* objects.
		744	* This should only be used for style maps or other such
		745	* reference maps where you don't want an object that isn't
		746	* in play chewing up cpu time getting processed.
		747	* The reverse of this is to call update_ob_speed, which
		748	* will do the right thing based on the speed of the object.
		749	*/
		750	void
		751	object::deactivate ()
		752	{
		753	/* If not on the active list, nothing needs to be done */
		754	if (!active ())
		755	return;
		756
		757	if (active_prev == 0)
		758	{
		759	active_objects = active_next;
		760	if (active_next)
		761	active_next->active_prev = 0;
827	}	762	}
		763	else
		764	{
		765	active_prev->active_next = active_next;
		766	if (active_next)
		767	active_next->active_prev = active_prev;
		768	}
828		769
829	more = 0;	770	active_next = 0;
830	head = 0;	771	active_prev = 0;
831	inv = 0;	772	}
832		773
833	// clear those pointers that likely might have circular references to us	774	void
834	owner = 0;	775	object::deactivate_recursive ()
835	enemy = 0;	776	{
836	attacked_by = 0;	777	for (object *op = inv; op; op = op->below)
		778	op->deactivate_recursive ();
837		779
838	// only relevant for players(?), but make sure of it anyways	780	deactivate ();
839	contr = 0;
840
841	/* Remove object from the active list */
842	set_speed (0);
843
844	unlink ();
845	}	781	}
846		782
847	/*	783	/*
848	* Remove and free all objects in the inventory of the given object.	784	* Remove and free all objects in the inventory of the given object.
849	* object.c ?	785	* object.c ?
850	*/	786	*/
851	void	787	void
852	object::destroy_inv (bool drop_to_ground)	788	object::destroy_inv (bool drop_to_ground)
853	{	789	{
		790	// need to check first, because the checks below might segfault
		791	// as we might be on an invalid mapspace and crossfire code
		792	// is too buggy to ensure that the inventory is empty.
		793	// corollary: if you create arrows etc. with stuff in tis inventory,
		794	// cf will crash below with off-map x and y
854	if (!inv)	795	if (!inv)
855	return;	796	return;
856		797
857	/* Only if the space blocks everything do we not process -	798	/* Only if the space blocks everything do we not process -
858	* if some form of movement is allowed, let objects	799	* if some form of movement is allowed, let objects
859	* drop on that space.	800	* drop on that space.
860	*/	801	*/
861	if (!drop_to_ground \|\| !map \|\| map->in_memory != MAP_IN_MEMORY \|\| GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)	802	if (!drop_to_ground
		803	\|\| !map
		804	\|\| map->in_memory != MAP_IN_MEMORY
		805	\|\| ms ().move_block == MOVE_ALL)
862	{	806	{
863	while (inv)	807	while (inv)
864	{	808	{
865	inv->destroy_inv (drop_to_ground);	809	inv->destroy_inv (drop_to_ground);
866	inv->destroy ();	810	inv->destroy ();
…		…
877	\|\| op->type == RUNE	821	\|\| op->type == RUNE
878	\|\| op->type == TRAP	822	\|\| op->type == TRAP
879	\|\| op->flag [FLAG_IS_A_TEMPLATE])	823	\|\| op->flag [FLAG_IS_A_TEMPLATE])
880	op->destroy ();	824	op->destroy ();
881	else	825	else
882	{	826	map->insert (op, x, y);
883	op->remove ();
884	op->x = x;
885	op->y = y;
886	insert_ob_in_map (op, map, 0, 0); /* Insert in same map as the envir */
887	}	827	}
		828	}
		829	}
		830
		831	object *object::create ()
		832	{
		833	object *op = new object;
		834	op->link ();
		835	return op;
		836	}
		837
		838	void
		839	object::do_destroy ()
		840	{
		841	if (flag [FLAG_IS_LINKED])
		842	remove_button_link (this);
		843
		844	if (flag [FLAG_FRIENDLY])
		845	remove_friendly_object (this);
		846
		847	if (!flag [FLAG_REMOVED])
		848	remove ();
		849
		850	if (flag [FLAG_FREED])
		851	return;
		852
		853	set_speed (0);
		854
		855	flag [FLAG_FREED] = 1;
		856
		857	attachable::do_destroy ();
		858
		859	destroy_inv (true);
		860	unlink ();
		861
		862	// hack to ensure that freed objects still have a valid map
		863	{
		864	static maptile *freed_map; // freed objects are moved here to avoid crashes
		865
		866	if (!freed_map)
		867	{
		868	freed_map = new maptile;
		869
		870	freed_map->name = "/internal/freed_objects_map";
		871	freed_map->width = 3;
		872	freed_map->height = 3;
		873
		874	freed_map->alloc ();
		875	freed_map->in_memory = MAP_IN_MEMORY;
888	}	876	}
		877
		878	map = freed_map;
		879	x = 1;
		880	y = 1;
		881	}
		882
		883	head = 0;
		884
		885	if (more)
889	}	886	{
		887	more->destroy ();
		888	more = 0;
		889	}
		890
		891	// clear those pointers that likely might have circular references to us
		892	owner = 0;
		893	enemy = 0;
		894	attacked_by = 0;
		895
		896	// only relevant for players(?), but make sure of it anyways
		897	contr = 0;
890	}	898	}
891		899
892	void	900	void
893	object::destroy (bool destroy_inventory)	901	object::destroy (bool destroy_inventory)
894	{	902	{
895	if (destroyed ())	903	if (destroyed ())
896	return;	904	return;
897		905
898	if (more)
899	{
900	//TODO: non-head objects must not have inventory
901	more->destroy (destroy_inventory);
902	more = 0;
903	}
904
905	if (destroy_inventory)	906	if (destroy_inventory)
906	destroy_inv (true);	907	destroy_inv (false);
907		908
908	attachable::destroy ();	909	attachable::destroy ();
909	}	910	}
910		911
911	/*	912	/*
…		…
964	* to save cpu time.	965	* to save cpu time.
965	*/	966	*/
966	if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))	967	if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
967	otmp->update_stats ();	968	otmp->update_stats ();
968		969
969	if (above != NULL)	970	if (above)
970	above->below = below;	971	above->below = below;
971	else	972	else
972	env->inv = below;	973	env->inv = below;
973		974
974	if (below != NULL)	975	if (below)
975	below->above = above;	976	below->above = above;
976		977
977	/* we set up values so that it could be inserted into	978	/* we set up values so that it could be inserted into
978	* the map, but we don't actually do that - it is up	979	* the map, but we don't actually do that - it is up
979	* to the caller to decide what we want to do.	980	* to the caller to decide what we want to do.
…		…
983	above = 0, below = 0;	984	above = 0, below = 0;
984	env = 0;	985	env = 0;
985	}	986	}
986	else if (map)	987	else if (map)
987	{	988	{
988	/* Re did the following section of code - it looks like it had	989	if (type == PLAYER)
989	* lots of logic for things we no longer care about
990	*/	990	{
		991	--map->players;
		992	map->touch ();
		993	}
		994
		995	map->dirty = true;
991		996
992	/* link the object above us */	997	/* link the object above us */
993	if (above)	998	if (above)
994	above->below = below;	999	above->below = below;
995	else	1000	else
…		…
1024	if (map->in_memory == MAP_SAVING)	1029	if (map->in_memory == MAP_SAVING)
1025	return;	1030	return;
1026		1031
1027	int check_walk_off = !flag [FLAG_NO_APPLY];	1032	int check_walk_off = !flag [FLAG_NO_APPLY];
1028		1033
1029	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)	1034	for (tmp = map->at (x, y).bot; tmp; tmp = tmp->above)
1030	{	1035	{
1031	/* No point updating the players look faces if he is the object	1036	/* No point updating the players look faces if he is the object
1032	* being removed.	1037	* being removed.
1033	*/	1038	*/
1034		1039
…		…
1046		1051
1047	if (tmp->contr->ns)	1052	if (tmp->contr->ns)
1048	tmp->contr->ns->floorbox_update ();	1053	tmp->contr->ns->floorbox_update ();
1049	}	1054	}
1050		1055
1051	/* See if player moving off should effect something */	1056	/* See if object moving off should effect something */
1052	if (check_walk_off	1057	if (check_walk_off
1053	&& ((move_type & tmp->move_off)	1058	&& ((move_type & tmp->move_off)
1054	&& (move_type & ~tmp->move_off & ~tmp->move_block) == 0))	1059	&& (move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1055	{	1060	{
1056	move_apply (tmp, this, 0);	1061	move_apply (tmp, this, 0);
…		…
1058	if (destroyed ())	1063	if (destroyed ())
1059	LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());	1064	LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1060	}	1065	}
1061		1066
1062	/* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */	1067	/* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1063		1068	//TODO: why is this horrible hacka fix? get rid of this code=bug! (schmorp)
1064	if (tmp->above == tmp)	1069	if (tmp->above == tmp)
1065	tmp->above = 0;	1070	tmp->above = 0;
1066		1071
1067	last = tmp;	1072	last = tmp;
1068	}	1073	}
1069		1074
1070	/* last == NULL of there are no objects on this space */	1075	/* last == NULL if there are no objects on this space */
		1076	//TODO: this makes little sense, why only update the topmost object?
1071	if (!last)	1077	if (!last)
1072	map->at (x, y).flags_ = P_NEED_UPDATE;	1078	map->at (x, y).flags_ = 0;
1073	else	1079	else
1074	update_object (last, UP_OBJ_REMOVE);	1080	update_object (last, UP_OBJ_REMOVE);
1075		1081
1076	if (flag [FLAG_BLOCKSVIEW] \|\| glow_radius)	1082	if (flag [FLAG_BLOCKSVIEW] \|\| glow_radius)
1077	update_all_los (map, x, y);	1083	update_all_los (map, x, y);
…		…
1120	* job preparing multi-part monsters	1126	* job preparing multi-part monsters
1121	*/	1127	*/
1122	object *	1128	object *
1123	insert_ob_in_map_at (object op, maptile m, object *originator, int flag, int x, int y)	1129	insert_ob_in_map_at (object op, maptile m, object *originator, int flag, int x, int y)
1124	{	1130	{
1125	object *tmp;
1126
1127	if (op->head)
1128	op = op->head;
1129
1130	for (tmp = op; tmp; tmp = tmp->more)	1131	for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1131	{	1132	{
1132	tmp->x = x + tmp->arch->clone.x;	1133	tmp->x = x + tmp->arch->clone.x;
1133	tmp->y = y + tmp->arch->clone.y;	1134	tmp->y = y + tmp->arch->clone.y;
1134	}	1135	}
1135		1136
…		…
1166	{	1167	{
1167	LOG (llevError, "Trying to insert freed object!\n");	1168	LOG (llevError, "Trying to insert freed object!\n");
1168	return NULL;	1169	return NULL;
1169	}	1170	}
1170		1171
1171	if (m == NULL)	1172	if (!m)
1172	{	1173	{
1173	char *dump = dump_object (op);	1174	char *dump = dump_object (op);
1174	LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);	1175	LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
1175	free (dump);	1176	free (dump);
1176	return op;	1177	return op;
…		…
1203	{	1204	{
1204	/* The part may be on a different map. */	1205	/* The part may be on a different map. */
1205		1206
1206	object *more = op->more;	1207	object *more = op->more;
1207		1208
1208	/* We really need the caller to normalize coordinates - if	1209	/* We really need the caller to normalise coordinates - if
1209	* we set the map, that doesn't work if the location is within	1210	* we set the map, that doesn't work if the location is within
1210	* a map and this is straddling an edge. So only if coordinate	1211	* a map and this is straddling an edge. So only if coordinate
1211	* is clear wrong do we normalize it.	1212	* is clear wrong do we normalise it.
1212	*/	1213	*/
1213	if (OUT_OF_REAL_MAP (more->map, more->x, more->y))	1214	if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
1214	more->map = get_map_from_coord (m, &more->x, &more->y);	1215	more->map = get_map_from_coord (m, &more->x, &more->y);
1215	else if (!more->map)	1216	else if (!more->map)
1216	{	1217	{
…		…
1240	y = op->y;	1241	y = op->y;
1241		1242
1242	/* this has to be done after we translate the coordinates.	1243	/* this has to be done after we translate the coordinates.
1243	*/	1244	*/
1244	if (op->nrof && !(flag & INS_NO_MERGE))	1245	if (op->nrof && !(flag & INS_NO_MERGE))
1245	for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)	1246	for (tmp = GET_MAP_OB (op->map, x, y); tmp; tmp = tmp->above)
1246	if (object::can_merge (op, tmp))	1247	if (object::can_merge (op, tmp))
1247	{	1248	{
1248	op->nrof += tmp->nrof;	1249	op->nrof += tmp->nrof;
1249	tmp->destroy ();	1250	tmp->destroy ();
1250	}	1251	}
…		…
1277	else	1278	else
1278	{	1279	{
1279	/* If there are other objects, then */	1280	/* If there are other objects, then */
1280	if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))	1281	if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
1281	{	1282	{
1282	object *last = NULL;	1283	object *last = 0;
1283		1284
1284	/*	1285	/*
1285	* If there are multiple objects on this space, we do some trickier handling.	1286	* If there are multiple objects on this space, we do some trickier handling.
1286	* We've already dealt with merging if appropriate.	1287	* We've already dealt with merging if appropriate.
1287	* Generally, we want to put the new object on top. But if	1288	* Generally, we want to put the new object on top. But if
…		…
1291	* once we get to them. This reduces the need to traverse over all of	1292	* once we get to them. This reduces the need to traverse over all of
1292	* them when adding another one - this saves quite a bit of cpu time	1293	* them when adding another one - this saves quite a bit of cpu time
1293	* when lots of spells are cast in one area. Currently, it is presumed	1294	* when lots of spells are cast in one area. Currently, it is presumed
1294	* that flying non pickable objects are spell objects.	1295	* that flying non pickable objects are spell objects.
1295	*/	1296	*/
1296
1297	while (top != NULL)	1297	while (top)
1298	{	1298	{
1299	if (QUERY_FLAG (top, FLAG_IS_FLOOR) \|\| QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))	1299	if (QUERY_FLAG (top, FLAG_IS_FLOOR) \|\| QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
1300	floor = top;	1300	floor = top;
1301		1301
1302	if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW \| MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))	1302	if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW \| MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))
…		…
1355	op->above = GET_MAP_OB (op->map, op->x, op->y);	1355	op->above = GET_MAP_OB (op->map, op->x, op->y);
1356		1356
1357	if (op->above)	1357	if (op->above)
1358	op->above->below = op;	1358	op->above->below = op;
1359		1359
1360	op->below = NULL;	1360	op->below = 0;
1361	op->ms ().bot = op;	1361	op->ms ().bot = op;
1362	}	1362	}
1363	else	1363	else
1364	{ /* get inserted into the stack above top */	1364	{ /* get inserted into the stack above top */
1365	op->above = top->above;	1365	op->above = top->above;
…		…
1369		1369
1370	op->below = top;	1370	op->below = top;
1371	top->above = op;	1371	top->above = op;
1372	}	1372	}
1373		1373
1374	if (op->above == NULL)	1374	if (!op->above)
1375	op->ms ().top = op;	1375	op->ms ().top = op;
1376	} /* else not INS_BELOW_ORIGINATOR */	1376	} /* else not INS_BELOW_ORIGINATOR */
1377		1377
1378	if (op->type == PLAYER)	1378	if (op->type == PLAYER)
		1379	{
1379	op->contr->do_los = 1;	1380	op->contr->do_los = 1;
		1381	++op->map->players;
		1382	op->map->touch ();
		1383	}
		1384
		1385	op->map->dirty = true;
1380		1386
1381	/* If we have a floor, we know the player, if any, will be above	1387	/* If we have a floor, we know the player, if any, will be above
1382	* it, so save a few ticks and start from there.	1388	* it, so save a few ticks and start from there.
1383	*/	1389	*/
1384	if (!(flag & INS_MAP_LOAD))	1390	if (!(flag & INS_MAP_LOAD))
…		…
1390	* visible to others on this map. But update_all_los is really	1396	* visible to others on this map. But update_all_los is really
1391	* an inefficient way to do this, as it means los for all players	1397	* an inefficient way to do this, as it means los for all players
1392	* on the map will get recalculated. The players could very well	1398	* on the map will get recalculated. The players could very well
1393	* be far away from this change and not affected in any way -	1399	* be far away from this change and not affected in any way -
1394	* this should get redone to only look for players within range,	1400	* this should get redone to only look for players within range,
1395	* or just updating the P_NEED_UPDATE for spaces within this area	1401	* or just updating the P_UPTODATE for spaces within this area
1396	* of effect may be sufficient.	1402	* of effect may be sufficient.
1397	*/	1403	*/
1398	if (op->map->darkness && (op->glow_radius != 0))	1404	if (op->map->darkness && (op->glow_radius != 0))
1399	update_all_los (op->map, op->x, op->y);	1405	update_all_los (op->map, op->x, op->y);
1400		1406
…		…
1438	{	1444	{
1439	object tmp, tmp1;	1445	object tmp, tmp1;
1440		1446
1441	/* first search for itself and remove any old instances */	1447	/* first search for itself and remove any old instances */
1442		1448
1443	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1449	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
1444	if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */	1450	if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */
1445	tmp->destroy ();	1451	tmp->destroy ();
1446		1452
1447	tmp1 = arch_to_object (archetype::find (arch_string));	1453	tmp1 = arch_to_object (archetype::find (arch_string));
1448		1454
1449	tmp1->x = op->x;	1455	tmp1->x = op->x;
1450	tmp1->y = op->y;	1456	tmp1->y = op->y;
1451	insert_ob_in_map (tmp1, op->map, op, 0);	1457	insert_ob_in_map (tmp1, op->map, op, 0);
		1458	}
		1459
		1460	object *
		1461	object::insert_at (object where, object originator, int flags)
		1462	{
		1463	where->map->insert (this, where->x, where->y, originator, flags);
1452	}	1464	}
1453		1465
1454	/*	1466	/*
1455	* get_split_ob(ob,nr) splits up ob into two parts. The part which	1467	* get_split_ob(ob,nr) splits up ob into two parts. The part which
1456	* is returned contains nr objects, and the remaining parts contains	1468	* is returned contains nr objects, and the remaining parts contains
1457	* the rest (or is removed and freed if that number is 0).	1469	* the rest (or is removed and freed if that number is 0).
1458	* On failure, NULL is returned, and the reason put into the	1470	* On failure, NULL is returned, and the reason put into the
1459	* global static errmsg array.	1471	* global static errmsg array.
1460	*/	1472	*/
1461
1462	object *	1473	object *
1463	get_split_ob (object *orig_ob, uint32 nr)	1474	get_split_ob (object *orig_ob, uint32 nr)
1464	{	1475	{
1465	object *newob;	1476	object *newob;
1466	int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);	1477	int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
…		…
1730	*	1741	*
1731	* MSW 2001-07-08: Check all objects on space, not just those below	1742	* MSW 2001-07-08: Check all objects on space, not just those below
1732	* object being inserted. insert_ob_in_map may not put new objects	1743	* object being inserted. insert_ob_in_map may not put new objects
1733	* on top.	1744	* on top.
1734	*/	1745	*/
1735
1736	int	1746	int
1737	check_move_on (object op, object originator)	1747	check_move_on (object op, object originator)
1738	{	1748	{
1739	object *tmp;	1749	object *tmp;
1740	maptile *m = op->map;	1750	maptile *m = op->map;
…		…
1767		1777
1768	/* The objects have to be checked from top to bottom.	1778	/* The objects have to be checked from top to bottom.
1769	* Hence, we first go to the top:	1779	* Hence, we first go to the top:
1770	*/	1780	*/
1771		1781
1772	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp && tmp->above; tmp = tmp->above)	1782	for (tmp = op->ms ().bot; tmp && tmp->above; tmp = tmp->above)
1773	{	1783	{
1774	/* Trim the search when we find the first other spell effect	1784	/* Trim the search when we find the first other spell effect
1775	* this helps performance so that if a space has 50 spell objects,	1785	* this helps performance so that if a space has 50 spell objects,
1776	* we don't need to check all of them.	1786	* we don't need to check all of them.
1777	*/	1787	*/
…		…
1835	* The first matching object is returned, or NULL if none.	1845	* The first matching object is returned, or NULL if none.
1836	*/	1846	*/
1837	object *	1847	object *
1838	present_arch (const archetype at, maptile m, int x, int y)	1848	present_arch (const archetype at, maptile m, int x, int y)
1839	{	1849	{
1840	if (m == NULL \|\| out_of_map (m, x, y))	1850	if (!m \|\| out_of_map (m, x, y))
1841	{	1851	{
1842	LOG (llevError, "Present_arch called outside map.\n");	1852	LOG (llevError, "Present_arch called outside map.\n");
1843	return NULL;	1853	return NULL;
1844	}	1854	}
1845		1855
1846	for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	1856	for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1847	if (tmp->arch == at)	1857	if (tmp->arch == at)
1848	return tmp;	1858	return tmp;
1849		1859
1850	return NULL;	1860	return NULL;
1851	}	1861	}
…		…
1862	{	1872	{
1863	LOG (llevError, "Present called outside map.\n");	1873	LOG (llevError, "Present called outside map.\n");
1864	return NULL;	1874	return NULL;
1865	}	1875	}
1866		1876
1867	for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	1877	for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1868	if (tmp->type == type)	1878	if (tmp->type == type)
1869	return tmp;	1879	return tmp;
1870		1880
1871	return NULL;	1881	return NULL;
1872	}	1882	}
…		…
2597	}	2607	}
2598	else	2608	else
2599	item = item->env;	2609	item = item->env;
2600	}	2610	}
2601		2611
		2612
		2613	const char *
		2614	object::flag_desc (char *desc, int len) const
		2615	{
		2616	char *p = desc;
		2617	bool first = true;
		2618
		2619	*p = 0;
		2620
		2621	for (int i = 0; i < NUM_FLAGS; i++)
		2622	{
		2623	if (len <= 10) // magic constant!
		2624	{
		2625	snprintf (p, len, ",...");
		2626	break;
		2627	}
		2628
		2629	if (flag [i])
		2630	{
		2631	int cnt = snprintf (p, len, "%s%d", first ? "" : ",", i);
		2632	len -= cnt;
		2633	p += cnt;
		2634	first = false;
		2635	}
		2636	}
		2637
		2638	return desc;
		2639	}
		2640
2602	// return a suitable string describing an objetc in enough detail to find it	2641	// return a suitable string describing an object in enough detail to find it
2603	const char *	2642	const char *
2604	object::debug_desc (char *info) const	2643	object::debug_desc (char *info) const
2605	{	2644	{
		2645	char flagdesc[512];
2606	char info2[256 * 3];	2646	char info2[256 * 4];
2607	char *p = info;	2647	char *p = info;
2608		2648
2609	p += snprintf (p, 256, "%d=\"%s%s%s\"",	2649	p += snprintf (p, 512, "{cnt:%d,uuid:<1,%" PRIx64 ">,name:\"%s%s%s\",flags:[%s],type:%d}",
2610	count,	2650	count, uuid.seq,
2611	&name,	2651	&name,
2612	title ? " " : "",	2652	title ? "\",title:" : "",
2613	title ? (const char *)title : "");	2653	title ? (const char *)title : "",
		2654	flag_desc (flagdesc, 512), type);
2614		2655
2615	if (env)	2656	if (env)
2616	p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));	2657	p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2617		2658
2618	if (map)	2659	if (map)
2619	p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);	2660	p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2620		2661
2621	return info;	2662	return info;
2622	}	2663	}
2623		2664
2624	const char *	2665	const char *
2625	object::debug_desc () const	2666	object::debug_desc () const
2626	{	2667	{
2627	static char info[256 * 3];	2668	static char info[256 * 4];
2628	return debug_desc (info);	2669	return debug_desc (info);
2629	}	2670	}
2630		2671

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.87 by root, Tue Dec 26 08:54:59 2006 UTC vs. Revision 1.105 by pippijn, Wed Jan 3 00:21:35 2007 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.87 by root, Tue Dec 26 08:54:59 2006 UTC vs.
Revision 1.105 by pippijn, Wed Jan 3 00:21:35 2007 UTC