BSPC: merged parts of wop botlib

Author: mgerhardy

deps/botlib/be_aas_bspq3.c

@@ -260,8 +260,7 @@ int AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size) {
 		return qfalse;
 	for (epair = bspworld.entities[ent].epairs; epair; epair = epair->next) {
 		if (!strcmp(epair->key, key)) {
-			strncpy(value, epair->value, size - 1);
-			value[size - 1] = '\0';
+			Q_strncpyz(value, epair->value, size);
 			return qtrue;
 		} // end if
 	}	  // end for

deps/botlib/be_aas_cluster.c

@@ -775,7 +775,7 @@ int AAS_CheckAreaForPossiblePortals(int areanum) {
 	//
 	Com_Memset(numareafrontfaces, 0, sizeof(numareafrontfaces));
 	Com_Memset(numareabackfaces, 0, sizeof(numareabackfaces));
-	numareas = numfrontfaces = numbackfaces = 0;
+	numfrontfaces = numbackfaces = 0;
 	numfrontareas = numbackareas = 0;
 	frontplanenum = backplanenum = -1;
 	// add any adjacent areas with less presence types

deps/botlib/be_aas_debug.c

@@ -762,4 +762,5 @@ void AAS_FloodAreas(vec3_t origin) {
 	areanum = AAS_PointAreaNum(origin);
 	cluster = AAS_AreaCluster(areanum);
 	AAS_FloodAreas_r(areanum, cluster, done);
+	FreeMemory(done);
 }

deps/botlib/be_aas_entity.c

@@ -353,8 +353,8 @@ int AAS_NearestEntity(vec3_t origin, int modelindex) {
 		if (ent->i.modelindex != modelindex)
 			continue;
 		VectorSubtract(ent->i.origin, origin, dir);
-		if (abs(dir[0]) < 40) {
-			if (abs(dir[1]) < 40) {
+		if (fabsf(dir[0]) < 40) {
+			if (fabsf(dir[1]) < 40) {
 				dist = VectorLength(dir);
 				if (dist < bestdist) {
 					bestdist = dist;

deps/botlib/be_aas_main.c

@@ -59,7 +59,7 @@ void QDECL AAS_Error(char *fmt, ...) {
 	va_list arglist;
 
 	va_start(arglist, fmt);
-	vsprintf(str, fmt, arglist);
+	Q_vsnprintf(str, sizeof(str), fmt, arglist);
 	va_end(arglist);
 	botimport.Print(PRT_FATAL, str);
 } // end of the function AAS_Error
@@ -231,7 +231,7 @@ int AAS_StartFrame(float time) {
 	//
 	aasworld.frameroutingupdates = 0;
 	//
-	if (bot_developer) {
+	if (botDeveloper) {
 		if (LibVarGetValue("showcacheupdates")) {
 			AAS_RoutingInfo();
 			LibVarSet("showcacheupdates", "0");
@@ -286,10 +286,9 @@ void AAS_ProjectPointOntoVector(vec3_t point, vec3_t vStart, vec3_t vEnd, vec3_t
 //===========================================================================
 int AAS_LoadFiles(const char *mapname) {
 	int errnum;
-	char aasfile[MAX_PATH];
-	//	char bspfile[MAX_PATH];
+	char aasfile[MAX_QPATH];
 
-	strcpy(aasworld.mapname, mapname);
+	Q_strncpyz(aasworld.mapname, mapname, sizeof(aasworld.mapname));
 	// NOTE: first reset the entity links into the AAS areas and BSP leaves
 	// the AAS link heap and BSP link heap are reset after respectively the
 	// AAS file and BSP file are loaded
@@ -304,7 +303,7 @@ int AAS_LoadFiles(const char *mapname) {
 		return errnum;
 
 	botimport.Print(PRT_MESSAGE, "loaded %s\n", aasfile);
-	strncpy(aasworld.filename, aasfile, MAX_PATH);
+	Q_strncpyz(aasworld.filename, aasfile, sizeof(aasworld.filename));
 	return BLERR_NOERROR;
 } // end of the function AAS_LoadFiles
 //===========================================================================

deps/botlib/be_aas_move.c

@@ -166,7 +166,7 @@ int AAS_AgainstLadder(vec3_t origin) {
 		// get the plane the face is in
 		plane = &aasworld.planes[face->planenum ^ side];
 		// if the origin is pretty close to the plane
-		if (fabs(DotProduct(plane->normal, origin) - plane->dist) < 3.0f) {
+		if (fabsf(DotProduct(plane->normal, origin) - plane->dist) < 3) {
 			if (AAS_PointInsideFace(abs(facenum), origin, 0.1f))
 				return qtrue;
 		} // end if
@@ -420,13 +420,15 @@ void AAS_ApplyFriction(vec3_t vel, float friction, float stopspeed, float framet
 		vel[1] *= newspeed;
 	} // end if
 } // end of the function AAS_ApplyFriction
+
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
-int AAS_ClipToBBox(aas_trace_t *trace, vec3_t start, vec3_t end, int presencetype, vec3_t mins, vec3_t maxs) {
+static qboolean AAS_ClipToBBox(aas_trace_t *trace, const vec3_t start, const vec3_t end, int presencetype,
+							   const vec3_t mins, const vec3_t maxs) {
 	int i, j, side;
 	float front, back, frac, planedist;
 	vec3_t bboxmins, bboxmaxs, absmins, absmaxs, dir, mid;
@@ -520,6 +522,7 @@ int AAS_ClientMovementPrediction(aas_clientmove_t *move, int entnum, const vec3_
 	float phys_maxstep, phys_maxsteepness, phys_jumpvel, friction;
 	float gravity, delta, maxvel, wishspeed, accelerate;
 	// float velchange, newvel;
+	// int ax;
 	int n, i, j, pc, step, swimming, crouch, event, jump_frame, areanum;
 	int areas[20], numareas;
 	vec3_t points[20];
@@ -574,6 +577,7 @@ int AAS_ClientMovementPrediction(aas_clientmove_t *move, int entnum, const vec3_
 		crouch = qfalse;
 		// apply command movement
 		if (n < cmdframes) {
+			// ax = 0;
 			maxvel = phys_maxwalkvelocity;
 			accelerate = phys_airaccelerate;
 			VectorCopy(cmdmove, wishdir);
@@ -597,10 +601,12 @@ int AAS_ClientMovementPrediction(aas_clientmove_t *move, int entnum, const vec3_
 				else {
 					accelerate = phys_walkaccelerate;
 				} // end else
-			}	  // end if
+				// ax = 2;
+			} // end if
 			if (swimming) {
 				maxvel = phys_maxswimvelocity;
 				accelerate = phys_swimaccelerate;
+				// ax = 3;
 			} // end if
 			else {
 				wishdir[2] = 0;
@@ -612,6 +618,19 @@ int AAS_ClientMovementPrediction(aas_clientmove_t *move, int entnum, const vec3_
 			VectorScale(frame_test_vel, 1 / frametime, frame_test_vel);
 			AAS_Accelerate(frame_test_vel, frametime, wishdir, wishspeed, accelerate);
 			VectorScale(frame_test_vel, frametime, frame_test_vel);
+			/*
+			for (i = 0; i < ax; i++)
+			{
+				velchange = (cmdmove[i] * frametime) - frame_test_vel[i];
+				if (velchange > phys_maxacceleration) velchange = phys_maxacceleration;
+				else if (velchange < -phys_maxacceleration) velchange = -phys_maxacceleration;
+				newvel = frame_test_vel[i] + velchange;
+				//
+				if (frame_test_vel[i] <= maxvel && newvel > maxvel) frame_test_vel[i] = maxvel;
+				else if (frame_test_vel[i] >= -maxvel && newvel < -maxvel) frame_test_vel[i] = -maxvel;
+				else frame_test_vel[i] = newvel;
+			} //end for
+			*/
 		} // end if
 		if (crouch) {
 			presencetype = PRESENCE_CROUCH;
@@ -938,7 +957,8 @@ int AAS_ClientMovementPrediction(aas_clientmove_t *move, int entnum, const vec3_
 int AAS_PredictClientMovement(struct aas_clientmove_s *move, int entnum, vec3_t origin, int presencetype, int onground,
 							  vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime,
 							  int stopevent, int stopareanum, int visualize) {
-	vec3_t mins, maxs;
+	const vec3_t mins = {-4, -4, -4};
+	const vec3_t maxs = {4, 4, 4};
 	return AAS_ClientMovementPrediction(move, entnum, origin, presencetype, onground, velocity, cmdmove, cmdframes,
 										maxframes, frametime, stopevent, stopareanum, mins, maxs, visualize, 0); // cyr
 } // end of the function AAS_PredictClientMovement

deps/botlib/be_aas_reach.c

@@ -1033,12 +1033,13 @@ static int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, in
 	int water_bestarea2groundedgenum, water_foundreach;
 	int side1, area1swim, faceside1, groundface1num;
 	float dist, dist1, dist2, diff, ortdot;
+	// float invgravitydot;
 	float x1, x2, x3, x4, y1, y2, y3, y4, tmp, y;
 	float length, ground_bestlength, water_bestlength, ground_bestdist, water_bestdist;
 	vec3_t v1, v2, v3, v4, tmpv, p1area1, p1area2, p2area1, p2area2;
 	vec3_t normal, ort, edgevec, start, end, dir;
-	vec3_t ground_beststart, ground_bestend, ground_bestnormal;
-	vec3_t water_beststart, water_bestend, water_bestnormal;
+	vec3_t ground_beststart = {0, 0, 0}, ground_bestend = {0, 0, 0}, ground_bestnormal = {0, 0, 0};
+	vec3_t water_beststart = {0, 0, 0}, water_bestend = {0, 0, 0}, water_bestnormal = {0, 0, 0};
 	vec3_t invgravity = {0, 0, 1};
 	vec3_t testpoint;
 	aas_plane_t *plane;
@@ -1143,6 +1144,7 @@ static int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, in
 					// edges if they overlap in the direction orthogonal to
 					// the gravity direction
 					CrossProduct(invgravity, normal, ort);
+					// invgravitydot = DotProduct(invgravity, invgravity);
 					ortdot = DotProduct(ort, ort);
 					// projection into the step plane
 					// NOTE: since gravity is vertical this is just the z coordinate
@@ -1506,7 +1508,7 @@ static int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, in
 					trace.endpos[2] += 1;
 					if (AAS_PointAreaNum(trace.endpos) == area2num) {
 						// if not going through a cluster portal
-						numareas = AAS_TraceAreas(start, end, areas, NULL, sizeof(areas) / sizeof(int));
+						numareas = AAS_TraceAreas(start, end, areas, NULL, ARRAY_LEN(areas));
 						for (i = 0; i < numareas; i++)
 							if (AAS_AreaClusterPortal(areas[i]))
 								break;
@@ -2032,7 +2034,7 @@ static int AAS_Reachability_Jump(int area1num, int area2num) {
 	int stopevent, areas[10], numareas;
 	float phys_jumpvel, maxjumpdistance, maxjumpheight, height, bestdist, speed;
 	vec_t *v1, *v2, *v3, *v4;
-	vec3_t beststart, beststart2, bestend, bestend2;
+	vec3_t beststart = {0}, beststart2 = {0}, bestend = {0}, bestend2 = {0};
 	vec3_t teststart, testend, dir, velocity, cmdmove, up = {0, 0, 1}, sidewards;
 	aas_area_t *area1, *area2;
 	aas_face_t *face1, *face2;
@@ -2220,7 +2222,7 @@ static int AAS_Reachability_Jump(int area1num, int area2num) {
 			// because the predicted jump could have rushed through the area
 			VectorMA(move.endpos, -64, dir, teststart);
 			teststart[2] += 1;
-			numareas = AAS_TraceAreas(move.endpos, teststart, areas, NULL, sizeof(areas) / sizeof(int));
+			numareas = AAS_TraceAreas(move.endpos, teststart, areas, NULL, ARRAY_LEN(areas));
 			for (j = 0; j < numareas; j++) {
 				if (areas[j] == area2num)
 					break;
@@ -2281,16 +2283,16 @@ static int AAS_Reachability_Jump(int area1num, int area2num) {
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
-int AAS_Reachability_Ladder(int area1num, int area2num) {
-	int i, j, k, l, edge1num, edge2num, sharededgenum, lowestedgenum;
-	int face1num, face2num, ladderface1num, ladderface2num;
+static int AAS_Reachability_Ladder(int area1num, int area2num) {
+	int i, j, k, l, edge1num, edge2num, sharededgenum = 0, lowestedgenum = 0;
+	int face1num, face2num, ladderface1num = 0, ladderface2num = 0;
 	int ladderface1vertical, ladderface2vertical, firstv;
-	float face1area, face2area, bestface1area, bestface2area;
+	float face1area, face2area, bestface1area = -9999, bestface2area = -9999;
 	float phys_jumpvel, maxjumpheight;
 	vec3_t area1point, area2point, v1, v2, up = {0, 0, 1};
-	vec3_t mid, lowestpoint, start, end, sharededgevec, dir;
+	vec3_t mid, lowestpoint = {0, 0}, start, end, sharededgevec, dir;
 	aas_area_t *area1, *area2;
-	aas_face_t *face1, *face2, *ladderface1, *ladderface2;
+	aas_face_t *face1, *face2, *ladderface1 = NULL, *ladderface2 = NULL;
 	aas_plane_t *plane1, *plane2;
 	aas_edge_t *sharededge, *edge1;
 	aas_lreachability_t *lreach;
@@ -2305,16 +2307,7 @@ int AAS_Reachability_Ladder(int area1num, int area2num) {
 
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
-	//
-	ladderface1 = NULL;
-	ladderface2 = NULL;
-	ladderface1num = 0; // make compiler happy
-	ladderface2num = 0; // make compiler happy
-	bestface1area = -9999;
-	bestface2area = -9999;
-	sharededgenum = 0; // make compiler happy
-	lowestedgenum = 0; // make compiler happy
-	//
+
 	for (i = 0; i < area1->numfaces; i++) {
 		face1num = aasworld.faceindex[area1->firstface + i];
 		face1 = &aasworld.faces[abs(face1num)];
@@ -2378,18 +2371,18 @@ int AAS_Reachability_Ladder(int area1num, int area2num) {
 		VectorMA(area1point, -32, dir, area1point);
 		VectorMA(area2point, 32, dir, area2point);
 		//
-		ladderface1vertical = fabs(DotProduct(plane1->normal, up)) < 0.1f;
-		ladderface2vertical = fabs(DotProduct(plane2->normal, up)) < 0.1f;
+		ladderface1vertical = fabsf(DotProduct(plane1->normal, up)) < 0.1;
+		ladderface2vertical = fabsf(DotProduct(plane2->normal, up)) < 0.1;
 		// there's only reachability between vertical ladder faces
 		if (!ladderface1vertical && !ladderface2vertical)
 			return qfalse;
 		// if both vertical ladder faces
 		if (ladderface1vertical &&
 			ladderface2vertical
 			// and the ladder faces do not make a sharp corner
-			&& DotProduct(plane1->normal, plane2->normal) > 0.7f
+			&& DotProduct(plane1->normal, plane2->normal) > 0.7
 			// and the shared edge is not too vertical
-			&& fabs(DotProduct(sharededgevec, up)) < 0.7f) {
+			&& fabsf(DotProduct(sharededgevec, up)) < 0.7) {
 			// create a new reachability link
 			lreach = AAS_AllocReachability();
 			if (!lreach)
@@ -2510,7 +2503,7 @@ int AAS_Reachability_Ladder(int area1num, int area2num) {
 				//
 				if (face2->faceflags & FACE_LADDER) {
 					plane2 = &aasworld.planes[face2->planenum];
-					if (fabs(DotProduct(plane2->normal, up)) < 0.1f)
+					if (fabsf(DotProduct(plane2->normal, up)) < 0.1)
 						break;
 				} // end if
 			}	  // end for
@@ -3115,7 +3108,7 @@ static aas_lreachability_t *AAS_FindFaceReachabilities(vec3_t *facepoints, int n
 	int facenum, edgenum, bestfacenum;
 	float *v1, *v2, *v3, *v4;
 	float bestdist, speed, hordist, dist;
-	vec3_t beststart, beststart2, bestend, bestend2, tmp, hordir, testpoint;
+	vec3_t beststart = {0}, beststart2 = {0}, bestend = {0}, bestend2 = {0}, tmp, hordir, testpoint;
 	aas_lreachability_t *lreach, *lreachabilities;
 	aas_area_t *area;
 	aas_face_t *face;
@@ -3462,6 +3455,7 @@ static void AAS_Reachability_JumpPad(void) {
 	// int modelnum, ent2;
 	// float dist, time, height, gravity, forward;
 	float speed, zvel;
+	// float hordist;
 	aas_face_t *face2;
 	aas_area_t *area2;
 	aas_lreachability_t *lreach;
@@ -3685,6 +3679,8 @@ static void AAS_Reachability_JumpPad(void) {
 					// direction towards the face center
 					VectorSubtract(facecenter, areastart, dir);
 					dir[2] = 0;
+					// hordist = VectorNormalize(dir);
+					// if (hordist < 1.6 * facecenter[2] - areastart[2])
 					{
 						// get command movement
 						VectorScale(dir, speed, cmdmove);
@@ -3696,7 +3692,8 @@ static void AAS_Reachability_JumpPad(void) {
 												  area2num, visualize);
 						// if prediction time wasn't enough to fully predict the movement
 						// don't enter slime or lava and don't fall from too high
-						if (move.frames < 30 && !(move.stopevent & (SE_ENTERSLIME | SE_ENTERLAVA)) &&
+						if (move.frames < 30 &&
+							!(move.stopevent & (SE_ENTERSLIME | SE_ENTERLAVA)) &&
 							(move.stopevent & (SE_HITGROUNDAREA | SE_TOUCHJUMPPAD | SE_TOUCHTELEPORTER))) {
 							// never go back to the same jumppad
 							for (link = areas; link; link = link->next_area) {
@@ -3755,7 +3752,7 @@ static int AAS_Reachability_Grapple(int area1num, int area2num) {
 	aas_face_t *face2;
 	aas_area_t *area1, *area2;
 	aas_lreachability_t *lreach;
-	vec3_t areastart, facecenter, start, end, dir, down = {0, 0, -1};
+	vec3_t areastart = {0, 0, 0}, facecenter, start, end, dir, down = {0, 0, -1};
 	vec_t *v;
 
 	// only grapple when on the ground or swimming
@@ -3970,6 +3967,7 @@ static void AAS_SetWeaponJumpAreaFlags(void) {
 int AAS_Reachability_WeaponJump(int area1num, int area2num) {
 	int face2num, i, n, ret, visualize;
 	float speed, zvel;
+	// float hordist;
 	aas_face_t *face2;
 	aas_area_t *area1, *area2;
 	aas_lreachability_t *lreach;
@@ -4035,6 +4033,8 @@ int AAS_Reachability_WeaponJump(int area1num, int area2num) {
 				// direction towards the face center
 				VectorSubtract(facecenter, areastart, dir);
 				dir[2] = 0;
+				// hordist = VectorNormalize(dir);
+				// if (hordist < 1.6 * (facecenter[2] - areastart[2]))
 				{
 					// get command movement
 					VectorScale(dir, speed, cmdmove);
@@ -4218,7 +4218,7 @@ static void AAS_Reachability_WalkOffLedge(int areanum) {
 							break;
 						} // end if
 						// if not going through a cluster portal
-						numareas = AAS_TraceAreas(mid, testend, areas, NULL, sizeof(areas) / sizeof(int));
+						numareas = AAS_TraceAreas(mid, testend, areas, NULL, ARRAY_LEN(areas));
 						for (p = 0; p < numareas; p++)
 							if (AAS_AreaClusterPortal(areas[p]))
 								break;
@@ -4603,7 +4603,7 @@ void AAS_StoreReachability(void) {
 	if (aasworld.reachability)
 		FreeMemory(aasworld.reachability);
 	aasworld.reachability =
-		(aas_reachability_t *)GetClearedMemory((numlreachabilities + 10) * sizeof(aas_reachability_t)); // cyr
+		(aas_reachability_t *)GetClearedMemory((numlreachabilities + 10) * sizeof(aas_reachability_t));
 	aasworld.reachabilitysize = 1;
 	for (i = 0; i < aasworld.numareas; i++) {
 		areasettings = &aasworld.areasettings[i];