X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=world.c;h=4fab85e10db08bfc556078bd943737cd6ea347d8;hb=c48b9daf204119696a95fb9699f718d3c67ec380;hp=f4e2436c8fa88b0687496d0e46fff7ce5893000e;hpb=1019743b2072b60aa1a2897b04c7cbb8f94454d1;p=xonotic%2Fdarkplaces.git

diff --git a/world.c b/world.c
index f4e2436c..4fab85e1 100644
--- a/world.c
+++ b/world.c
@@ -29,12 +29,13 @@ line of sight checks trace->crosscontent, but bullets don't
 
 */
 
-/*
-typedef struct link_s
+cvar_t sv_useareanodes = {CVAR_NOTIFY, "sv_useareanodes", "1"};
+
+void SV_World_Init(void)
 {
-	struct link_s	*prev, *next;
-} link_t;
-*/
+	Cvar_RegisterVariable(&sv_useareanodes);
+	Collision_Init ();
+}
 
 
 void ClearLink (link_t *l);
@@ -42,11 +43,6 @@ void RemoveLink (link_t *l);
 void InsertLinkBefore (link_t *l, link_t *before);
 void InsertLinkAfter (link_t *l, link_t *after);
 
-// (type *)STRUCT_FROM_LINK(link_t *link, type, member)
-// ent = STRUCT_FROM_LINK(link,entity_t,order)
-// FIXME: remove this mess!
-//#define	STRUCT_FROM_LINK(l,t,m) ((t *)((qbyte *)l - (int)&(((t *)0)->m)))
-
 #define	EDICT_FROM_AREA(l) ((edict_t *)((qbyte *)l - (int)&(((edict_t *)0)->area)))
 
 //============================================================================
@@ -184,8 +180,6 @@ SV_ClearWorld
 */
 void SV_ClearWorld (void)
 {
-	Collision_Init ();
-
 	memset (sv_areanodes, 0, sizeof(sv_areanodes));
 	sv_numareanodes = 0;
 	Mod_CheckLoaded(sv.worldmodel);
@@ -227,14 +221,14 @@ loc0:
 		touch = EDICT_FROM_AREA(l);
 		if (touch == ent)
 			continue;
-		if (!touch->v.touch || touch->v.solid != SOLID_TRIGGER)
+		if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
 			continue;
-		if (ent->v.absmin[0] > touch->v.absmax[0]
-		 || ent->v.absmin[1] > touch->v.absmax[1]
-		 || ent->v.absmin[2] > touch->v.absmax[2]
-		 || ent->v.absmax[0] < touch->v.absmin[0]
-		 || ent->v.absmax[1] < touch->v.absmin[1]
-		 || ent->v.absmax[2] < touch->v.absmin[2])
+		if (ent->v->absmin[0] > touch->v->absmax[0]
+		 || ent->v->absmin[1] > touch->v->absmax[1]
+		 || ent->v->absmin[2] > touch->v->absmax[2]
+		 || ent->v->absmax[0] < touch->v->absmin[0]
+		 || ent->v->absmax[1] < touch->v->absmin[1]
+		 || ent->v->absmax[2] < touch->v->absmin[2])
 			continue;
 		old_self = pr_global_struct->self;
 		old_other = pr_global_struct->other;
@@ -242,7 +236,7 @@ loc0:
 		pr_global_struct->self = EDICT_TO_PROG(touch);
 		pr_global_struct->other = EDICT_TO_PROG(ent);
 		pr_global_struct->time = sv.time;
-		PR_ExecuteProgram (touch->v.touch, "");
+		PR_ExecuteProgram (touch->v->touch, "");
 
 		pr_global_struct->self = old_self;
 		pr_global_struct->other = old_other;
@@ -252,19 +246,16 @@ loc0:
 	if (node->axis == -1)
 		return;
 
-	// LordHavoc: optimized recursion
-//	if (ent->v.absmax[node->axis] > node->dist) SV_TouchLinks (ent, node->children[0]);
-//	if (ent->v.absmin[node->axis] < node->dist) SV_TouchLinks (ent, node->children[1]);
-	if (ent->v.absmax[node->axis] > node->dist)
+	if (ent->v->absmax[node->axis] > node->dist)
 	{
-		if (ent->v.absmin[node->axis] < node->dist)
+		if (ent->v->absmin[node->axis] < node->dist)
 			SV_TouchLinks(ent, node->children[1]); // order reversed to reduce code
 		node = node->children[0];
 		goto loc0;
 	}
 	else
 	{
-		if (ent->v.absmin[node->axis] < node->dist)
+		if (ent->v->absmin[node->axis] < node->dist)
 		{
 			node = node->children[1];
 			goto loc0;
@@ -295,111 +286,71 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
 
 // set the abs box
 
-	/*
-// LordHavoc: enabling rotating bmodels
-	if (ent->v.solid == SOLID_BSP && (ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]))
+	if (ent->v->solid == SOLID_BSP)
 	{
-		// expand for rotation
-		float		max, v;
-		int			i;
-
-		max = DotProduct(ent->v.mins, ent->v.mins);
-		v = DotProduct(ent->v.maxs, ent->v.maxs);
-		if (max < v)
-			max = v;
-		max = sqrt(max);
-	*/
-		/*
-		max = 0;
-		for (i=0 ; i<3 ; i++)
-		{
-			v = fabs(ent->v.mins[i]);
-			if (max < v)
-				max = v;
-			v = fabs(ent->v.maxs[i]);
-			if (max < v)
-				max = v;
-		}
-		*/
-	/*
-		for (i=0 ; i<3 ; i++)
-		{
-			ent->v.absmin[i] = ent->v.origin[i] - max;
-			ent->v.absmax[i] = ent->v.origin[i] + max;
-		}
-	}
-	else
-	{
-		VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
-		VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
-	}
-	*/
-
-	if (ent->v.solid == SOLID_BSP)
-	{
-		if (ent->v.modelindex < 0 || ent->v.modelindex > MAX_MODELS)
-			PR_RunError("SOLID_BSP with invalid modelindex!\n");
-		model = sv.models[(int) ent->v.modelindex];
+		if (ent->v->modelindex < 0 || ent->v->modelindex > MAX_MODELS)
+			Host_Error("SOLID_BSP with invalid modelindex!\n");
+		model = sv.models[(int) ent->v->modelindex];
 		if (model != NULL)
 		{
 			if (model->type != mod_brush)
-				PR_RunError("SOLID_BSP with non-BSP model\n");
+				Host_Error("SOLID_BSP with non-BSP model\n");
 
-			if (ent->v.angles[0] || ent->v.angles[2] || ent->v.avelocity[0] || ent->v.avelocity[2])
+			if (ent->v->angles[0] || ent->v->angles[2] || ent->v->avelocity[0] || ent->v->avelocity[2])
 			{
-				VectorAdd(ent->v.origin, model->rotatedmins, ent->v.absmin);
-				VectorAdd(ent->v.origin, model->rotatedmaxs, ent->v.absmax);
+				VectorAdd(ent->v->origin, model->rotatedmins, ent->v->absmin);
+				VectorAdd(ent->v->origin, model->rotatedmaxs, ent->v->absmax);
 			}
-			else if (ent->v.angles[1] || ent->v.avelocity[1])
+			else if (ent->v->angles[1] || ent->v->avelocity[1])
 			{
-				VectorAdd(ent->v.origin, model->yawmins, ent->v.absmin);
-				VectorAdd(ent->v.origin, model->yawmaxs, ent->v.absmax);
+				VectorAdd(ent->v->origin, model->yawmins, ent->v->absmin);
+				VectorAdd(ent->v->origin, model->yawmaxs, ent->v->absmax);
 			}
 			else
 			{
-				VectorAdd(ent->v.origin, model->normalmins, ent->v.absmin);
-				VectorAdd(ent->v.origin, model->normalmaxs, ent->v.absmax);
+				VectorAdd(ent->v->origin, model->normalmins, ent->v->absmin);
+				VectorAdd(ent->v->origin, model->normalmaxs, ent->v->absmax);
 			}
 		}
 		else
 		{
 			// SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily
-			VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
-			VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
+			VectorAdd (ent->v->origin, ent->v->mins, ent->v->absmin);
+			VectorAdd (ent->v->origin, ent->v->maxs, ent->v->absmax);
 		}
 	}
 	else
 	{
-		VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
-		VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
+		VectorAdd (ent->v->origin, ent->v->mins, ent->v->absmin);
+		VectorAdd (ent->v->origin, ent->v->maxs, ent->v->absmax);
 	}
 
 //
 // to make items easier to pick up and allow them to be grabbed off
 // of shelves, the abs sizes are expanded
 //
-	if ((int)ent->v.flags & FL_ITEM)
+	if ((int)ent->v->flags & FL_ITEM)
 	{
-		ent->v.absmin[0] -= 15;
-		ent->v.absmin[1] -= 15;
-		ent->v.absmin[2] -= 1;
-		ent->v.absmax[0] += 15;
-		ent->v.absmax[1] += 15;
-		ent->v.absmax[2] += 1;
+		ent->v->absmin[0] -= 15;
+		ent->v->absmin[1] -= 15;
+		ent->v->absmin[2] -= 1;
+		ent->v->absmax[0] += 15;
+		ent->v->absmax[1] += 15;
+		ent->v->absmax[2] += 1;
 	}
 	else
 	{
 		// because movement is clipped an epsilon away from an actual edge,
 		// we must fully check even when bounding boxes don't quite touch
-		ent->v.absmin[0] -= 1;
-		ent->v.absmin[1] -= 1;
-		ent->v.absmin[2] -= 1;
-		ent->v.absmax[0] += 1;
-		ent->v.absmax[1] += 1;
-		ent->v.absmax[2] += 1;
+		ent->v->absmin[0] -= 1;
+		ent->v->absmin[1] -= 1;
+		ent->v->absmin[2] -= 1;
+		ent->v->absmax[0] += 1;
+		ent->v->absmax[1] += 1;
+		ent->v->absmax[2] += 1;
 	}
 
-	if (ent->v.solid == SOLID_NOT)
+	if (ent->v->solid == SOLID_NOT)
 		return;
 
 // find the first node that the ent's box crosses
@@ -408,9 +359,9 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
 	{
 		if (node->axis == -1)
 			break;
-		if (ent->v.absmin[node->axis] > node->dist)
+		if (ent->v->absmin[node->axis] > node->dist)
 			node = node->children[0];
-		else if (ent->v.absmax[node->axis] < node->dist)
+		else if (ent->v->absmax[node->axis] < node->dist)
 			node = node->children[1];
 		else
 			break;		// crosses the node
@@ -418,7 +369,7 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
 
 // link it in
 
-	if (ent->v.solid == SOLID_TRIGGER)
+	if (ent->v->solid == SOLID_TRIGGER)
 		InsertLinkBefore (&ent->area, &node->trigger_edicts);
 	else
 		InsertLinkBefore (&ent->area, &node->solid_edicts);
@@ -438,20 +389,6 @@ POINT TESTING IN HULLS
 ===============================================================================
 */
 
-/*
-==================
-SV_HullPointContents
-
-==================
-*/
-int SV_HullPointContents (hull_t *hull, int num, vec3_t p)
-{
-	while (num >= 0)
-		num = hull->clipnodes[num].children[(hull->planes[hull->clipnodes[num].planenum].type < 3 ? p[hull->planes[hull->clipnodes[num].planenum].type] : DotProduct (hull->planes[hull->clipnodes[num].planenum].normal, p)) < hull->planes[hull->clipnodes[num].planenum].dist];
-
-	return num;
-}
-
 /*
 ============
 SV_TestEntityPosition
@@ -459,16 +396,9 @@ SV_TestEntityPosition
 This could be a lot more efficient...
 ============
 */
-edict_t	*SV_TestEntityPosition (edict_t *ent)
+int SV_TestEntityPosition (edict_t *ent)
 {
-	trace_t	trace;
-
-	trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, MOVE_NORMAL, ent);
-
-	if (trace.startsolid)
-		return sv.edicts;
-
-	return NULL;
+	return SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, ent->v->origin, MOVE_NORMAL, ent).startsolid;
 }
 
 
@@ -494,14 +424,14 @@ trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t max
 	trace_t trace;
 	model_t *model;
 
-	i = ent->v.modelindex;
+	i = ent->v->modelindex;
 	if ((unsigned int) i >= MAX_MODELS)
-		PR_RunError("SV_ClipMoveToEntity: invalid modelindex\n");
+		Host_Error("SV_ClipMoveToEntity: invalid modelindex\n");
 	model = sv.models[i];
 	if (i != 0 && model == NULL)
-		PR_RunError("SV_ClipMoveToEntity: invalid modelindex\n");
+		Host_Error("SV_ClipMoveToEntity: invalid modelindex\n");
 
-	if ((int) ent->v.solid == SOLID_BSP)
+	if ((int) ent->v->solid == SOLID_BSP)
 	{
 		Mod_CheckLoaded(model);
 		if (model->type != mod_brush)
@@ -510,11 +440,11 @@ trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t max
 			ED_Print (ent);
 			Host_Error ("SV_ClipMoveToEntity: SOLID_BSP with a non bsp model\n");
 		}
-		if (ent->v.movetype != MOVETYPE_PUSH)
+		if (ent->v->movetype != MOVETYPE_PUSH)
 			Host_Error ("SV_ClipMoveToEntity: SOLID_BSP without MOVETYPE_PUSH");
 	}
 
-	Collision_ClipTrace(&trace, ent, model, ent->v.origin, ent->v.angles, ent->v.mins, ent->v.maxs, start, mins, maxs, end);
+	Collision_ClipTrace(&trace, ent, model, ent->v->origin, ent->v->angles, ent->v->mins, ent->v->maxs, start, mins, maxs, end);
 
 	return trace;
 }
@@ -542,44 +472,47 @@ loc0:
 	{
 		next = l->next;
 		touch = EDICT_FROM_AREA(l);
-		if (touch->v.solid == SOLID_NOT)
+		if (touch->v->solid == SOLID_NOT)
 			continue;
 		if (touch == clip->passedict)
 			continue;
-		if (touch->v.solid == SOLID_TRIGGER)
+		if (touch->v->solid == SOLID_TRIGGER)
+		{
+			ED_Print(touch);
 			Host_Error ("Trigger in clipping list");
+		}
 
-		if (clip->type == MOVE_NOMONSTERS && touch->v.solid != SOLID_BSP)
+		if (clip->type == MOVE_NOMONSTERS && touch->v->solid != SOLID_BSP)
 			continue;
 
-		if (clip->boxmins[0] > touch->v.absmax[0]
-		 || clip->boxmaxs[0] < touch->v.absmin[0]
-		 || clip->boxmins[1] > touch->v.absmax[1]
-		 || clip->boxmaxs[1] < touch->v.absmin[1]
-		 || clip->boxmins[2] > touch->v.absmax[2]
-		 || clip->boxmaxs[2] < touch->v.absmin[2])
+		if (clip->boxmins[0] > touch->v->absmax[0]
+		 || clip->boxmaxs[0] < touch->v->absmin[0]
+		 || clip->boxmins[1] > touch->v->absmax[1]
+		 || clip->boxmaxs[1] < touch->v->absmin[1]
+		 || clip->boxmins[2] > touch->v->absmax[2]
+		 || clip->boxmaxs[2] < touch->v->absmin[2])
 			continue;
 
 		if (clip->passedict)
 		{
-			if (clip->passedict->v.size[0] && !touch->v.size[0])
+			if (clip->passedict->v->size[0] && !touch->v->size[0])
 				continue;	// points never interact
-		 	if (PROG_TO_EDICT(touch->v.owner) == clip->passedict)
+		 	if (PROG_TO_EDICT(touch->v->owner) == clip->passedict)
 				continue;	// don't clip against own missiles
-			if (PROG_TO_EDICT(clip->passedict->v.owner) == touch)
+			if (PROG_TO_EDICT(clip->passedict->v->owner) == touch)
 				continue;	// don't clip against owner
 			// LordHavoc: corpse code
-			if (clip->passedict->v.solid == SOLID_CORPSE && (touch->v.solid == SOLID_SLIDEBOX || touch->v.solid == SOLID_CORPSE))
+			if (clip->passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
 				continue;
-			if (clip->passedict->v.solid == SOLID_SLIDEBOX && touch->v.solid == SOLID_CORPSE)
+			if (clip->passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
 				continue;
 		}
 
 		// might interact, so do an exact clip
-		if ((int)touch->v.flags & FL_MONSTER)
-			trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins2, clip->maxs2, clip->end);
-		else if (touch->v.solid == SOLID_BSP)
+		if (touch->v->solid == SOLID_BSP)
 			trace = SV_ClipMoveToEntity (touch, clip->start, clip->hullmins, clip->hullmaxs, clip->end);
+		else if ((int)touch->v->flags & FL_MONSTER)
+			trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins2, clip->maxs2, clip->end);
 		else
 			trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins, clip->maxs, clip->end);
 		// LordHavoc: take the 'best' answers from the new trace and combine with existing data
@@ -609,9 +542,6 @@ loc0:
 	if (node->axis == -1)
 		return;
 
-	// LordHavoc: optimized recursion
-//	if (clip->boxmaxs[node->axis] > node->dist) SV_ClipToLinks(node->children[0], clip);
-//	if (clip->boxmins[node->axis] < node->dist) SV_ClipToLinks(node->children[1], clip);
 	if (clip->boxmaxs[node->axis] > node->dist)
 	{
 		if (clip->boxmins[node->axis] < node->dist)
@@ -634,27 +564,30 @@ SV_MoveBounds
 */
 void SV_MoveBounds (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, vec3_t boxmins, vec3_t boxmaxs)
 {
-#if 0
-// debug to test against everything
-boxmins[0] = boxmins[1] = boxmins[2] = -999999999;
-boxmaxs[0] = boxmaxs[1] = boxmaxs[2] =  999999999;
-#else
-	int		i;
-
-	for (i=0 ; i<3 ; i++)
+	if (sv_useareanodes.integer)
 	{
-		if (end[i] > start[i])
-		{
-			boxmins[i] = start[i] + mins[i] - 1;
-			boxmaxs[i] = end[i] + maxs[i] + 1;
-		}
-		else
+		int i;
+
+		for (i=0 ; i<3 ; i++)
 		{
-			boxmins[i] = end[i] + mins[i] - 1;
-			boxmaxs[i] = start[i] + maxs[i] + 1;
+			if (end[i] > start[i])
+			{
+				boxmins[i] = start[i] + mins[i] - 1;
+				boxmaxs[i] = end[i] + maxs[i] + 1;
+			}
+			else
+			{
+				boxmins[i] = end[i] + mins[i] - 1;
+				boxmaxs[i] = start[i] + maxs[i] + 1;
+			}
 		}
 	}
-#endif
+	else
+	{
+		// debug to test against everything
+		boxmins[0] = boxmins[1] = boxmins[2] = -999999999;
+		boxmaxs[0] = boxmaxs[1] = boxmaxs[2] =  999999999;
+	}
 }
 
 /*
@@ -712,3 +645,4 @@ trace_t SV_Move (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, e
 
 	return clip.trace;
 }
+