mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2024-12-12 21:22:14 +00:00
Bug 5094 - Code cleanup, patch by Zack Middleton and DevHC. Fixes unused-but-set gcc warnings
This commit is contained in:
parent
1ea7ab1f42
commit
23f6fd1633
85 changed files with 246 additions and 496 deletions
|
@ -811,7 +811,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
|
||||
|
|
|
@ -382,18 +382,6 @@ void AAS_Accelerate(vec3_t velocity, float frametime, vec3_t wishdir, float wish
|
|||
}
|
||||
} //end of the function AAS_Accelerate
|
||||
//===========================================================================
|
||||
//
|
||||
// Parameter: -
|
||||
// Returns: -
|
||||
// Changes Globals: -
|
||||
//===========================================================================
|
||||
void AAS_AirControl(vec3_t start, vec3_t end, vec3_t velocity, vec3_t cmdmove)
|
||||
{
|
||||
vec3_t dir;
|
||||
|
||||
VectorSubtract(end, start, dir);
|
||||
} //end of the function AAS_AirControl
|
||||
//===========================================================================
|
||||
// applies ground friction to the given velocity
|
||||
//
|
||||
// Parameter: -
|
||||
|
@ -518,7 +506,8 @@ int AAS_ClientMovementPrediction(struct aas_clientmove_s *move,
|
|||
float phys_maxstep, phys_maxsteepness, phys_jumpvel, friction;
|
||||
float gravity, delta, maxvel, wishspeed, accelerate;
|
||||
//float velchange, newvel;
|
||||
int n, i, j, pc, step, swimming, ax, crouch, event, jump_frame, areanum;
|
||||
//int ax;
|
||||
int n, i, j, pc, step, swimming, crouch, event, jump_frame, areanum;
|
||||
int areas[20], numareas;
|
||||
vec3_t points[20];
|
||||
vec3_t org, end, feet, start, stepend, lastorg, wishdir;
|
||||
|
@ -574,7 +563,7 @@ int AAS_ClientMovementPrediction(struct aas_clientmove_s *move,
|
|||
//apply command movement
|
||||
if (n < cmdframes)
|
||||
{
|
||||
ax = 0;
|
||||
//ax = 0;
|
||||
maxvel = phys_maxwalkvelocity;
|
||||
accelerate = phys_airaccelerate;
|
||||
VectorCopy(cmdmove, wishdir);
|
||||
|
@ -598,13 +587,13 @@ int AAS_ClientMovementPrediction(struct aas_clientmove_s *move,
|
|||
{
|
||||
accelerate = phys_walkaccelerate;
|
||||
} //end else
|
||||
ax = 2;
|
||||
//ax = 2;
|
||||
} //end if
|
||||
if (swimming)
|
||||
{
|
||||
maxvel = phys_maxswimvelocity;
|
||||
accelerate = phys_swimaccelerate;
|
||||
ax = 3;
|
||||
//ax = 3;
|
||||
} //end if
|
||||
else
|
||||
{
|
||||
|
|
|
@ -289,7 +289,7 @@ int AAS_GetJumpPadInfo(int ent, vec3_t areastart, vec3_t absmins, vec3_t absmaxs
|
|||
//===========================================================================
|
||||
int AAS_BestReachableFromJumpPadArea(vec3_t origin, vec3_t mins, vec3_t maxs)
|
||||
{
|
||||
int area2num, ent, bot_visualizejumppads, bestareanum;
|
||||
int ent, bot_visualizejumppads, bestareanum;
|
||||
float volume, bestareavolume;
|
||||
vec3_t areastart, cmdmove, bboxmins, bboxmaxs;
|
||||
vec3_t absmins, absmaxs, velocity;
|
||||
|
@ -327,7 +327,6 @@ int AAS_BestReachableFromJumpPadArea(vec3_t origin, vec3_t mins, vec3_t maxs)
|
|||
//
|
||||
VectorSet(cmdmove, 0, 0, 0);
|
||||
Com_Memset(&move, 0, sizeof(aas_clientmove_t));
|
||||
area2num = 0;
|
||||
AAS_ClientMovementHitBBox(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
|
||||
velocity, cmdmove, 0, 30, 0.1f, bboxmins, bboxmaxs, bot_visualizejumppads);
|
||||
if (move.frames < 30)
|
||||
|
@ -837,7 +836,6 @@ int AAS_Reachability_Swim(int area1num, int area2num)
|
|||
{
|
||||
int i, j, face1num, face2num, side1;
|
||||
aas_area_t *area1, *area2;
|
||||
aas_areasettings_t *areasettings;
|
||||
aas_lreachability_t *lreach;
|
||||
aas_face_t *face1;
|
||||
aas_plane_t *plane;
|
||||
|
@ -875,7 +873,6 @@ int AAS_Reachability_Swim(int area1num, int area2num)
|
|||
{
|
||||
//
|
||||
face1 = &aasworld.faces[face1num];
|
||||
areasettings = &aasworld.areasettings[area1num];
|
||||
//create a new reachability link
|
||||
lreach = AAS_AllocReachability();
|
||||
if (!lreach) return qfalse;
|
||||
|
@ -1062,7 +1059,8 @@ int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2
|
|||
int ground_bestarea2groundedgenum, ground_foundreach;
|
||||
int water_bestarea2groundedgenum, water_foundreach;
|
||||
int side1, area1swim, faceside1, groundface1num;
|
||||
float dist, dist1, dist2, diff, invgravitydot, ortdot;
|
||||
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;
|
||||
|
@ -1073,7 +1071,7 @@ int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2
|
|||
vec3_t testpoint;
|
||||
aas_plane_t *plane;
|
||||
aas_area_t *area1, *area2;
|
||||
aas_face_t *groundface1, *groundface2, *ground_bestface1, *water_bestface1;
|
||||
aas_face_t *groundface1, *groundface2;
|
||||
aas_edge_t *edge1, *edge2;
|
||||
aas_lreachability_t *lreach;
|
||||
aas_trace_t trace;
|
||||
|
@ -1172,7 +1170,7 @@ int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2
|
|||
//edges if they overlap in the direction orthogonal to
|
||||
//the gravity direction
|
||||
CrossProduct(invgravity, normal, ort);
|
||||
invgravitydot = DotProduct(invgravity, invgravity);
|
||||
//invgravitydot = DotProduct(invgravity, invgravity);
|
||||
ortdot = DotProduct(ort, ort);
|
||||
//projection into the step plane
|
||||
//NOTE: since gravity is vertical this is just the z coordinate
|
||||
|
@ -1302,7 +1300,6 @@ int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2
|
|||
ground_bestlength = length;
|
||||
ground_foundreach = qtrue;
|
||||
ground_bestarea2groundedgenum = edge1num;
|
||||
ground_bestface1 = groundface1;
|
||||
//best point towards area1
|
||||
VectorCopy(start, ground_beststart);
|
||||
//normal is pointing into area2
|
||||
|
@ -1323,7 +1320,6 @@ int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2
|
|||
water_bestlength = length;
|
||||
water_foundreach = qtrue;
|
||||
water_bestarea2groundedgenum = edge1num;
|
||||
water_bestface1 = groundface1;
|
||||
//best point towards area1
|
||||
VectorCopy(start, water_beststart);
|
||||
//normal is pointing into area2
|
||||
|
@ -2852,9 +2848,9 @@ void AAS_Reachability_Teleport(void)
|
|||
botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target);
|
||||
continue;
|
||||
} //end if
|
||||
/*
|
||||
area2num = AAS_PointAreaNum(trace.endpos);
|
||||
//
|
||||
/*
|
||||
if (!AAS_AreaTeleporter(area2num) &&
|
||||
!AAS_AreaJumpPad(area2num) &&
|
||||
!AAS_AreaGrounded(area2num))
|
||||
|
@ -3396,7 +3392,6 @@ void AAS_Reachability_FuncBobbing(void)
|
|||
//
|
||||
for (i = 0; i < 2; i++)
|
||||
{
|
||||
firststartreach = firstendreach = NULL;
|
||||
//
|
||||
if (i == 0)
|
||||
{
|
||||
|
@ -3492,7 +3487,8 @@ void AAS_Reachability_JumpPad(void)
|
|||
int face2num, i, ret, area2num, visualize, ent, bot_visualizejumppads;
|
||||
//int modelnum, ent2;
|
||||
//float dist, time, height, gravity, forward;
|
||||
float speed, zvel, hordist;
|
||||
float speed, zvel;
|
||||
//float hordist;
|
||||
aas_face_t *face2;
|
||||
aas_area_t *area2;
|
||||
aas_lreachability_t *lreach;
|
||||
|
@ -3714,7 +3710,7 @@ void AAS_Reachability_JumpPad(void)
|
|||
//direction towards the face center
|
||||
VectorSubtract(facecenter, areastart, dir);
|
||||
dir[2] = 0;
|
||||
hordist = VectorNormalize(dir);
|
||||
//hordist = VectorNormalize(dir);
|
||||
//if (hordist < 1.6 * facecenter[2] - areastart[2])
|
||||
{
|
||||
//get command movement
|
||||
|
@ -3997,7 +3993,8 @@ void AAS_SetWeaponJumpAreaFlags(void)
|
|||
int AAS_Reachability_WeaponJump(int area1num, int area2num)
|
||||
{
|
||||
int face2num, i, n, ret, visualize;
|
||||
float speed, zvel, hordist;
|
||||
float speed, zvel;
|
||||
//float hordist;
|
||||
aas_face_t *face2;
|
||||
aas_area_t *area1, *area2;
|
||||
aas_lreachability_t *lreach;
|
||||
|
@ -4057,7 +4054,7 @@ int AAS_Reachability_WeaponJump(int area1num, int area2num)
|
|||
//direction towards the face center
|
||||
VectorSubtract(facecenter, areastart, dir);
|
||||
dir[2] = 0;
|
||||
hordist = VectorNormalize(dir);
|
||||
//hordist = VectorNormalize(dir);
|
||||
//if (hordist < 1.6 * (facecenter[2] - areastart[2]))
|
||||
{
|
||||
//get command movement
|
||||
|
|
|
@ -506,9 +506,11 @@ void AAS_CalculateAreaTravelTimes(void)
|
|||
aas_reversedlink_t *revlink;
|
||||
aas_reachability_t *reach;
|
||||
aas_areasettings_t *settings;
|
||||
#ifdef DEBUG
|
||||
int starttime;
|
||||
|
||||
starttime = Sys_MilliSeconds();
|
||||
#endif
|
||||
//if there are still area travel times, free the memory
|
||||
if (aasworld.areatraveltimes) FreeMemory(aasworld.areatraveltimes);
|
||||
//get the total size of all the area travel times
|
||||
|
@ -887,7 +889,8 @@ void AAS_InitRoutingUpdate(void)
|
|||
//===========================================================================
|
||||
void AAS_CreateAllRoutingCache(void)
|
||||
{
|
||||
int i, j, t;
|
||||
int i, j;
|
||||
//int t;
|
||||
|
||||
aasworld.initialized = qtrue;
|
||||
botimport.Print(PRT_MESSAGE, "AAS_CreateAllRoutingCache\n");
|
||||
|
@ -898,7 +901,8 @@ void AAS_CreateAllRoutingCache(void)
|
|||
{
|
||||
if (i == j) continue;
|
||||
if (!AAS_AreaReachability(j)) continue;
|
||||
t = AAS_AreaTravelTimeToGoalArea(i, aasworld.areas[i].center, j, TFL_DEFAULT);
|
||||
AAS_AreaTravelTimeToGoalArea(i, aasworld.areas[i].center, j, TFL_DEFAULT);
|
||||
//t = AAS_AreaTravelTimeToGoalArea(i, aasworld.areas[i].center, j, TFL_DEFAULT);
|
||||
//Log_Write("traveltime from %d to %d is %d", i, j, t);
|
||||
} //end for
|
||||
} //end for
|
||||
|
|
|
@ -844,7 +844,6 @@ void BotReplaceReplySynonyms(char *string, unsigned long int context)
|
|||
if (!(syn->context & context)) continue;
|
||||
for (synonym = syn->firstsynonym->next; synonym; synonym = synonym->next)
|
||||
{
|
||||
str2 = synonym->string;
|
||||
//if the synonym is not at the front of the string continue
|
||||
str2 = StringContainsWord(str1, synonym->string, qfalse);
|
||||
if (!str2 || str2 != str1) continue;
|
||||
|
@ -2939,7 +2938,6 @@ int BotAllocChatState(void)
|
|||
//========================================================================
|
||||
void BotFreeChatState(int handle)
|
||||
{
|
||||
bot_chatstate_t *cs;
|
||||
bot_consolemessage_t m;
|
||||
int h;
|
||||
|
||||
|
@ -2953,7 +2951,6 @@ void BotFreeChatState(int handle)
|
|||
botimport.Print(PRT_FATAL, "invalid chat state %d\n", handle);
|
||||
return;
|
||||
} //end if
|
||||
cs = botchatstates[handle];
|
||||
if (LibVarGetValue("bot_reloadcharacters"))
|
||||
{
|
||||
BotFreeChatFile(handle);
|
||||
|
|
|
@ -51,7 +51,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
//===========================================================================
|
||||
int GeneticSelection(int numranks, float *rankings)
|
||||
{
|
||||
float sum, select;
|
||||
float sum;
|
||||
int i, index;
|
||||
|
||||
sum = 0;
|
||||
|
@ -64,7 +64,7 @@ int GeneticSelection(int numranks, float *rankings)
|
|||
{
|
||||
//select a bot where the ones with the higest rankings have
|
||||
//the highest chance of being selected
|
||||
select = random() * sum;
|
||||
//sum *= random();
|
||||
for (i = 0; i < numranks; i++)
|
||||
{
|
||||
if (rankings[i] < 0) continue;
|
||||
|
|
|
@ -238,9 +238,9 @@ void BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child)
|
|||
//===========================================================================
|
||||
void BotSaveGoalFuzzyLogic(int goalstate, char *filename)
|
||||
{
|
||||
bot_goalstate_t *gs;
|
||||
//bot_goalstate_t *gs;
|
||||
|
||||
gs = BotGoalStateFromHandle(goalstate);
|
||||
//gs = BotGoalStateFromHandle(goalstate);
|
||||
|
||||
//WriteWeightConfig(filename, gs->itemweightconfig);
|
||||
} //end of the function BotSaveGoalFuzzyLogic
|
||||
|
|
|
@ -848,7 +848,6 @@ int BotMovementViewTarget(int movestate, bot_goal_t *goal, int travelflags, floa
|
|||
|
||||
ms = BotMoveStateFromHandle(movestate);
|
||||
if (!ms) return qfalse;
|
||||
reachnum = 0;
|
||||
//if the bot has no goal or no last reachability
|
||||
if (!ms->lastreachnum || !goal) return qfalse;
|
||||
|
||||
|
@ -997,12 +996,13 @@ void MoverBottomCenter(aas_reachability_t *reach, vec3_t bottomcenter)
|
|||
//===========================================================================
|
||||
float BotGapDistance(vec3_t origin, vec3_t hordir, int entnum)
|
||||
{
|
||||
float dist, startz;
|
||||
int dist;
|
||||
float startz;
|
||||
vec3_t start, end;
|
||||
aas_trace_t trace;
|
||||
|
||||
//do gap checking
|
||||
startz = origin[2];
|
||||
//startz = origin[2];
|
||||
//this enables walking down stairs more fluidly
|
||||
{
|
||||
VectorCopy(origin, start);
|
||||
|
@ -1030,7 +1030,7 @@ float BotGapDistance(vec3_t origin, vec3_t hordir, int entnum)
|
|||
end[2] -= 20;
|
||||
if (AAS_PointContents(end) & CONTENTS_WATER) break;
|
||||
//if a gap is found slow down
|
||||
//botimport.Print(PRT_MESSAGE, "gap at %f\n", dist);
|
||||
//botimport.Print(PRT_MESSAGE, "gap at %i\n", dist);
|
||||
return dist;
|
||||
} //end if
|
||||
startz = trace.endpos[2];
|
||||
|
@ -1480,7 +1480,6 @@ bot_moveresult_t BotTravel_BarrierJump(bot_movestate_t *ms, aas_reachability_t *
|
|||
//===========================================================================
|
||||
bot_moveresult_t BotFinishTravel_BarrierJump(bot_movestate_t *ms, aas_reachability_t *reach)
|
||||
{
|
||||
float dist;
|
||||
vec3_t hordir;
|
||||
bot_moveresult_t_cleared( result );
|
||||
|
||||
|
@ -1490,7 +1489,6 @@ bot_moveresult_t BotFinishTravel_BarrierJump(bot_movestate_t *ms, aas_reachabili
|
|||
hordir[0] = reach->end[0] - ms->origin[0];
|
||||
hordir[1] = reach->end[1] - ms->origin[1];
|
||||
hordir[2] = 0;
|
||||
dist = VectorNormalize(hordir);
|
||||
//
|
||||
BotCheckBlocked(ms, hordir, qtrue, &result);
|
||||
//
|
||||
|
@ -1567,7 +1565,6 @@ bot_moveresult_t BotTravel_WaterJump(bot_movestate_t *ms, aas_reachability_t *re
|
|||
bot_moveresult_t BotFinishTravel_WaterJump(bot_movestate_t *ms, aas_reachability_t *reach)
|
||||
{
|
||||
vec3_t dir, pnt;
|
||||
float dist;
|
||||
bot_moveresult_t_cleared( result );
|
||||
|
||||
//botimport.Print(PRT_MESSAGE, "BotFinishTravel_WaterJump\n");
|
||||
|
@ -1583,7 +1580,6 @@ bot_moveresult_t BotFinishTravel_WaterJump(bot_movestate_t *ms, aas_reachability
|
|||
dir[0] += crandom() * 10;
|
||||
dir[1] += crandom() * 10;
|
||||
dir[2] += 70 + crandom() * 10;
|
||||
dist = VectorNormalize(dir);
|
||||
//elemantary actions
|
||||
EA_Move(ms->client, dir, 400);
|
||||
//set the ideal view angles
|
||||
|
@ -1721,7 +1717,6 @@ bot_moveresult_t BotFinishTravel_WalkOffLedge(bot_movestate_t *ms, aas_reachabil
|
|||
VectorCopy(dir, hordir);
|
||||
hordir[2] = 0;
|
||||
//
|
||||
dist = VectorNormalize(hordir);
|
||||
speed = 400;
|
||||
} //end if
|
||||
//
|
||||
|
@ -1788,6 +1783,7 @@ bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
|
|||
bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
|
||||
{
|
||||
vec3_t hordir, dir1, dir2, mins, maxs, start, end;
|
||||
int gapdist;
|
||||
float dist1, dist2, speed;
|
||||
bot_moveresult_t_cleared( result );
|
||||
bsp_trace_t trace;
|
||||
|
@ -1808,13 +1804,13 @@ bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
|
|||
trace = AAS_Trace(start, mins, maxs, end, ms->entitynum, MASK_PLAYERSOLID);
|
||||
if (trace.startsolid) VectorCopy(start, trace.endpos);
|
||||
//check for a gap
|
||||
for (dist1 = 0; dist1 < 80; dist1 += 10)
|
||||
for (gapdist = 0; gapdist < 80; gapdist += 10)
|
||||
{
|
||||
VectorMA(start, dist1+10, hordir, end);
|
||||
VectorMA(start, gapdist+10, hordir, end);
|
||||
end[2] += 1;
|
||||
if (AAS_PointAreaNum(end) != ms->reachareanum) break;
|
||||
} //end for
|
||||
if (dist1 < 80) VectorMA(reach->start, dist1, hordir, trace.endpos);
|
||||
if (gapdist < 80) VectorMA(reach->start, gapdist, hordir, trace.endpos);
|
||||
// dist1 = BotGapDistance(start, hordir, ms->entitynum);
|
||||
// if (dist1 && dist1 <= trace.fraction * 80) VectorMA(reach->start, dist1-20, hordir, trace.endpos);
|
||||
//
|
||||
|
@ -1860,6 +1856,7 @@ bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
|
|||
{
|
||||
vec3_t hordir, dir1, dir2, start, end, runstart;
|
||||
// vec3_t runstart, dir1, dir2, hordir;
|
||||
int gapdist;
|
||||
float dist1, dist2, speed;
|
||||
bot_moveresult_t_cleared( result );
|
||||
|
||||
|
@ -1875,13 +1872,13 @@ bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
|
|||
start[2] += 1;
|
||||
VectorMA(reach->start, 80, hordir, runstart);
|
||||
//check for a gap
|
||||
for (dist1 = 0; dist1 < 80; dist1 += 10)
|
||||
for (gapdist = 0; gapdist < 80; gapdist += 10)
|
||||
{
|
||||
VectorMA(start, dist1+10, hordir, end);
|
||||
VectorMA(start, gapdist+10, hordir, end);
|
||||
end[2] += 1;
|
||||
if (AAS_PointAreaNum(end) != ms->reachareanum) break;
|
||||
} //end for
|
||||
if (dist1 < 80) VectorMA(reach->start, dist1, hordir, runstart);
|
||||
if (gapdist < 80) VectorMA(reach->start, gapdist, hordir, runstart);
|
||||
//
|
||||
VectorSubtract(ms->origin, reach->start, dir1);
|
||||
dir1[2] = 0;
|
||||
|
@ -2867,7 +2864,6 @@ bot_moveresult_t BotFinishTravel_WeaponJump(bot_movestate_t *ms, aas_reachabilit
|
|||
//===========================================================================
|
||||
bot_moveresult_t BotTravel_JumpPad(bot_movestate_t *ms, aas_reachability_t *reach)
|
||||
{
|
||||
float dist, speed;
|
||||
vec3_t hordir;
|
||||
bot_moveresult_t_cleared( result );
|
||||
|
||||
|
@ -2875,12 +2871,10 @@ bot_moveresult_t BotTravel_JumpPad(bot_movestate_t *ms, aas_reachability_t *reac
|
|||
hordir[0] = reach->start[0] - ms->origin[0];
|
||||
hordir[1] = reach->start[1] - ms->origin[1];
|
||||
hordir[2] = 0;
|
||||
dist = VectorNormalize(hordir);
|
||||
//
|
||||
BotCheckBlocked(ms, hordir, qtrue, &result);
|
||||
speed = 400;
|
||||
//elemantary action move in direction
|
||||
EA_Move(ms->client, hordir, speed);
|
||||
EA_Move(ms->client, hordir, 400);
|
||||
VectorCopy(hordir, result.movedir);
|
||||
//
|
||||
return result;
|
||||
|
|
|
@ -1698,7 +1698,6 @@ int PC_EvaluateTokens(source_t *source, token_t *tokens, signed long int *intval
|
|||
int questmarkintvalue = 0;
|
||||
float questmarkfloatvalue = 0;
|
||||
int gotquestmarkvalue = qfalse;
|
||||
int lastoperatortype = 0;
|
||||
//
|
||||
operator_t operator_heap[MAX_OPERATORS];
|
||||
int numoperators = 0;
|
||||
|
@ -2087,7 +2086,6 @@ int PC_EvaluateTokens(source_t *source, token_t *tokens, signed long int *intval
|
|||
else Log_Write("result value = %f", v1->floatvalue);
|
||||
#endif //DEBUG_EVAL
|
||||
if (error) break;
|
||||
lastoperatortype = o->operator;
|
||||
//if not an operator with arity 1
|
||||
if (o->operator != P_LOGIC_NOT
|
||||
&& o->operator != P_BIN_NOT)
|
||||
|
|
|
@ -904,9 +904,9 @@ static float CG_DrawTeamOverlay( float y, qboolean right, qboolean upper ) {
|
|||
p = CG_ConfigString(CS_LOCATIONS + ci->location);
|
||||
if (!p || !*p)
|
||||
p = "unknown";
|
||||
len = CG_DrawStrlen(p);
|
||||
if (len > lwidth)
|
||||
len = lwidth;
|
||||
// len = CG_DrawStrlen(p);
|
||||
// if (len > lwidth)
|
||||
// len = lwidth;
|
||||
|
||||
// xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth +
|
||||
// ((lwidth/2 - len/2) * TINYCHAR_WIDTH);
|
||||
|
@ -1348,8 +1348,8 @@ CG_DrawTeamInfo
|
|||
*/
|
||||
#ifndef MISSIONPACK
|
||||
static void CG_DrawTeamInfo( void ) {
|
||||
int w, h;
|
||||
int i, len;
|
||||
int h;
|
||||
int i;
|
||||
vec4_t hcolor;
|
||||
int chatHeight;
|
||||
|
||||
|
@ -1370,16 +1370,6 @@ static void CG_DrawTeamInfo( void ) {
|
|||
|
||||
h = (cgs.teamChatPos - cgs.teamLastChatPos) * TINYCHAR_HEIGHT;
|
||||
|
||||
w = 0;
|
||||
|
||||
for (i = cgs.teamLastChatPos; i < cgs.teamChatPos; i++) {
|
||||
len = CG_DrawStrlen(cgs.teamChatMsgs[i % chatHeight]);
|
||||
if (len > w)
|
||||
w = len;
|
||||
}
|
||||
w *= TINYCHAR_WIDTH;
|
||||
w += TINYCHAR_WIDTH * 2;
|
||||
|
||||
if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED ) {
|
||||
hcolor[0] = 1.0f;
|
||||
hcolor[1] = 0.0f;
|
||||
|
@ -1924,7 +1914,7 @@ CG_DrawCrosshair3D
|
|||
*/
|
||||
static void CG_DrawCrosshair3D(void)
|
||||
{
|
||||
float w, h;
|
||||
float w;
|
||||
qhandle_t hShader;
|
||||
float f;
|
||||
int ca;
|
||||
|
@ -1947,14 +1937,13 @@ static void CG_DrawCrosshair3D(void)
|
|||
return;
|
||||
}
|
||||
|
||||
w = h = cg_crosshairSize.value;
|
||||
w = cg_crosshairSize.value;
|
||||
|
||||
// pulse the size of the crosshair when picking up items
|
||||
f = cg.time - cg.itemPickupBlendTime;
|
||||
if ( f > 0 && f < ITEM_BLOB_TIME ) {
|
||||
f /= ITEM_BLOB_TIME;
|
||||
w *= ( 1 + f );
|
||||
h *= ( 1 + f );
|
||||
}
|
||||
|
||||
ca = cg_drawCrosshair.integer;
|
||||
|
@ -2164,7 +2153,6 @@ static void CG_DrawTeamVote(void) {
|
|||
static qboolean CG_DrawScoreboard( void ) {
|
||||
#ifdef MISSIONPACK
|
||||
static qboolean firstTime = qtrue;
|
||||
float fade, *fadeColor;
|
||||
|
||||
if (menuScoreboard) {
|
||||
menuScoreboard->window.flags &= ~WINDOW_FORCED;
|
||||
|
@ -2188,20 +2176,15 @@ static qboolean CG_DrawScoreboard( void ) {
|
|||
}
|
||||
|
||||
if ( cg.showScores || cg.predictedPlayerState.pm_type == PM_DEAD || cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
|
||||
fade = 1.0;
|
||||
fadeColor = colorWhite;
|
||||
} else {
|
||||
fadeColor = CG_FadeColor( cg.scoreFadeTime, FADE_TIME );
|
||||
if ( !fadeColor ) {
|
||||
if ( !CG_FadeColor( cg.scoreFadeTime, FADE_TIME ) ) {
|
||||
// next time scoreboard comes up, don't print killer
|
||||
cg.deferredPlayerLoading = 0;
|
||||
cg.killerName[0] = 0;
|
||||
firstTime = qtrue;
|
||||
return qfalse;
|
||||
}
|
||||
fade = *fadeColor;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (menuScoreboard == NULL) {
|
||||
if ( cgs.gametype >= GT_TEAM ) {
|
||||
|
@ -2361,9 +2344,12 @@ static void CG_DrawWarmup( void ) {
|
|||
int w;
|
||||
int sec;
|
||||
int i;
|
||||
float scale;
|
||||
clientInfo_t *ci1, *ci2;
|
||||
#ifdef MISSIONPACK
|
||||
float scale;
|
||||
#else
|
||||
int cw;
|
||||
#endif
|
||||
clientInfo_t *ci1, *ci2;
|
||||
const char *s;
|
||||
|
||||
sec = cg.warmup;
|
||||
|
@ -2464,30 +2450,41 @@ static void CG_DrawWarmup( void ) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
scale = 0.45f;
|
||||
|
||||
#ifdef MISSIONPACK
|
||||
switch ( cg.warmupCount ) {
|
||||
case 0:
|
||||
cw = 28;
|
||||
scale = 0.54f;
|
||||
break;
|
||||
case 1:
|
||||
cw = 24;
|
||||
scale = 0.51f;
|
||||
break;
|
||||
case 2:
|
||||
cw = 20;
|
||||
scale = 0.48f;
|
||||
break;
|
||||
default:
|
||||
cw = 16;
|
||||
scale = 0.45f;
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef MISSIONPACK
|
||||
w = CG_Text_Width(s, scale, 0);
|
||||
CG_Text_Paint(320 - w / 2, 125, scale, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE);
|
||||
w = CG_Text_Width(s, scale, 0);
|
||||
CG_Text_Paint(320 - w / 2, 125, scale, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE);
|
||||
#else
|
||||
switch ( cg.warmupCount ) {
|
||||
case 0:
|
||||
cw = 28;
|
||||
break;
|
||||
case 1:
|
||||
cw = 24;
|
||||
break;
|
||||
case 2:
|
||||
cw = 20;
|
||||
break;
|
||||
default:
|
||||
cw = 16;
|
||||
break;
|
||||
}
|
||||
|
||||
w = CG_DrawStrlen( s );
|
||||
CG_DrawStringExt( 320 - w * cw/2, 70, s, colorWhite,
|
||||
qfalse, qtrue, cw, (int)(cw * 1.5), 0 );
|
||||
|
|
|
@ -671,7 +671,8 @@ Also called by client movement prediction code
|
|||
void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out ) {
|
||||
centity_t *cent;
|
||||
vec3_t oldOrigin, origin, deltaOrigin;
|
||||
vec3_t oldAngles, angles, deltaAngles;
|
||||
vec3_t oldAngles, angles;
|
||||
//vec3_t deltaAngles;
|
||||
|
||||
if ( moverNum <= 0 || moverNum >= ENTITYNUM_MAX_NORMAL ) {
|
||||
VectorCopy( in, out );
|
||||
|
@ -691,7 +692,7 @@ void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int fromTime, int
|
|||
BG_EvaluateTrajectory( ¢->currentState.apos, toTime, angles );
|
||||
|
||||
VectorSubtract( origin, oldOrigin, deltaOrigin );
|
||||
VectorSubtract( angles, oldAngles, deltaAngles );
|
||||
//VectorSubtract( angles, oldAngles, deltaAngles );
|
||||
|
||||
VectorAdd( in, deltaOrigin, out );
|
||||
|
||||
|
|
|
@ -599,11 +599,10 @@ void CG_EntityEvent( centity_t *cent, vec3_t position ) {
|
|||
DEBUGNAME("EV_JUMP_PAD");
|
||||
// CG_Printf( "EV_JUMP_PAD w/effect #%i\n", es->eventParm );
|
||||
{
|
||||
localEntity_t *smoke;
|
||||
vec3_t up = {0, 0, 1};
|
||||
|
||||
|
||||
smoke = CG_SmokePuff( cent->lerpOrigin, up,
|
||||
CG_SmokePuff( cent->lerpOrigin, up,
|
||||
32,
|
||||
1, 1, 1, 0.33f,
|
||||
1000,
|
||||
|
|
|
@ -150,10 +150,6 @@ typedef struct {
|
|||
int painDirection; // flip from 0 to 1
|
||||
int lightningFiring;
|
||||
|
||||
// railgun trail spawning
|
||||
vec3_t railgunImpact;
|
||||
qboolean railgunFlash;
|
||||
|
||||
int railFireTime;
|
||||
|
||||
// machinegun spinning
|
||||
|
@ -419,7 +415,6 @@ typedef struct weaponInfo_s {
|
|||
|
||||
sfxHandle_t readySound;
|
||||
sfxHandle_t firingSound;
|
||||
qboolean loopFireSound;
|
||||
} weaponInfo_t;
|
||||
|
||||
|
||||
|
@ -837,7 +832,7 @@ typedef struct {
|
|||
sfxHandle_t sfx_ric1;
|
||||
sfxHandle_t sfx_ric2;
|
||||
sfxHandle_t sfx_ric3;
|
||||
sfxHandle_t sfx_railg;
|
||||
//sfxHandle_t sfx_railg;
|
||||
sfxHandle_t sfx_rockexp;
|
||||
sfxHandle_t sfx_plasmaexp;
|
||||
#ifdef MISSIONPACK
|
||||
|
@ -862,7 +857,6 @@ typedef struct {
|
|||
sfxHandle_t obeliskRespawnSound;
|
||||
sfxHandle_t winnerSound;
|
||||
sfxHandle_t loserSound;
|
||||
sfxHandle_t youSuckSound;
|
||||
#endif
|
||||
sfxHandle_t gibSound;
|
||||
sfxHandle_t gibBounce1Sound;
|
||||
|
|
|
@ -629,9 +629,6 @@ void CG_AddKamikaze( localEntity_t *le ) {
|
|||
le->angles.trBase[1] = random() * 360;
|
||||
le->angles.trBase[2] = random() * 360;
|
||||
}
|
||||
else {
|
||||
c = 0;
|
||||
}
|
||||
memset(&shockwave, 0, sizeof(shockwave));
|
||||
shockwave.hModel = cgs.media.kamikazeShockWave;
|
||||
shockwave.reType = RT_MODEL;
|
||||
|
|
|
@ -725,7 +725,7 @@ static void CG_RegisterSounds( void ) {
|
|||
cgs.media.sfx_ric1 = trap_S_RegisterSound ("sound/weapons/machinegun/ric1.wav", qfalse);
|
||||
cgs.media.sfx_ric2 = trap_S_RegisterSound ("sound/weapons/machinegun/ric2.wav", qfalse);
|
||||
cgs.media.sfx_ric3 = trap_S_RegisterSound ("sound/weapons/machinegun/ric3.wav", qfalse);
|
||||
cgs.media.sfx_railg = trap_S_RegisterSound ("sound/weapons/railgun/railgf1a.wav", qfalse);
|
||||
//cgs.media.sfx_railg = trap_S_RegisterSound ("sound/weapons/railgun/railgf1a.wav", qfalse);
|
||||
cgs.media.sfx_rockexp = trap_S_RegisterSound ("sound/weapons/rocket/rocklx1a.wav", qfalse);
|
||||
cgs.media.sfx_plasmaexp = trap_S_RegisterSound ("sound/weapons/plasma/plasmx1a.wav", qfalse);
|
||||
#ifdef MISSIONPACK
|
||||
|
@ -742,7 +742,6 @@ static void CG_RegisterSounds( void ) {
|
|||
cgs.media.kamikazeFarSound = trap_S_RegisterSound( "sound/items/kam_explode_far.wav", qfalse );
|
||||
cgs.media.winnerSound = trap_S_RegisterSound( "sound/feedback/voc_youwin.wav", qfalse );
|
||||
cgs.media.loserSound = trap_S_RegisterSound( "sound/feedback/voc_youlose.wav", qfalse );
|
||||
cgs.media.youSuckSound = trap_S_RegisterSound( "sound/misc/yousuck.wav", qfalse );
|
||||
|
||||
cgs.media.wstbimplSound = trap_S_RegisterSound("sound/weapons/proxmine/wstbimpl.wav", qfalse);
|
||||
cgs.media.wstbimpmSound = trap_S_RegisterSound("sound/weapons/proxmine/wstbimpm.wav", qfalse);
|
||||
|
|
|
@ -160,52 +160,42 @@ void CG_SelectPrevPlayer( void ) {
|
|||
|
||||
|
||||
static void CG_DrawPlayerArmorIcon( rectDef_t *rect, qboolean draw2D ) {
|
||||
centity_t *cent;
|
||||
playerState_t *ps;
|
||||
vec3_t angles;
|
||||
vec3_t origin;
|
||||
|
||||
if ( cg_drawStatus.integer == 0 ) {
|
||||
if ( cg_drawStatus.integer == 0 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
cent = &cg_entities[cg.snap->ps.clientNum];
|
||||
ps = &cg.snap->ps;
|
||||
|
||||
if ( draw2D || ( !cg_draw3dIcons.integer && cg_drawIcons.integer) ) {
|
||||
CG_DrawPic( rect->x, rect->y + rect->h/2 + 1, rect->w, rect->h, cgs.media.armorIcon );
|
||||
} else if (cg_draw3dIcons.integer) {
|
||||
VectorClear( angles );
|
||||
origin[0] = 90;
|
||||
origin[1] = 0;
|
||||
origin[2] = -10;
|
||||
angles[YAW] = ( cg.time & 2047 ) * 360 / 2048.0;
|
||||
|
||||
CG_Draw3DModel( rect->x, rect->y, rect->w, rect->h, cgs.media.armorModel, 0, origin, angles );
|
||||
}
|
||||
|
||||
} else if (cg_draw3dIcons.integer) {
|
||||
VectorClear( angles );
|
||||
origin[0] = 90;
|
||||
origin[1] = 0;
|
||||
origin[2] = -10;
|
||||
angles[YAW] = ( cg.time & 2047 ) * 360 / 2048.0f;
|
||||
CG_Draw3DModel( rect->x, rect->y, rect->w, rect->h, cgs.media.armorModel, 0, origin, angles );
|
||||
}
|
||||
}
|
||||
|
||||
static void CG_DrawPlayerArmorValue(rectDef_t *rect, float scale, vec4_t color, qhandle_t shader, int textStyle) {
|
||||
char num[16];
|
||||
int value;
|
||||
centity_t *cent;
|
||||
int value;
|
||||
playerState_t *ps;
|
||||
|
||||
cent = &cg_entities[cg.snap->ps.clientNum];
|
||||
ps = &cg.snap->ps;
|
||||
|
||||
value = ps->stats[STAT_ARMOR];
|
||||
|
||||
|
||||
if (shader) {
|
||||
trap_R_SetColor( color );
|
||||
trap_R_SetColor( color );
|
||||
CG_DrawPic(rect->x, rect->y, rect->w, rect->h, shader);
|
||||
trap_R_SetColor( NULL );
|
||||
trap_R_SetColor( NULL );
|
||||
} else {
|
||||
Com_sprintf (num, sizeof(num), "%i", value);
|
||||
value = CG_Text_Width(num, scale, 0);
|
||||
CG_Text_Paint(rect->x + (rect->w - value) / 2, rect->y + rect->h, scale, color, num, 0, 0, textStyle);
|
||||
CG_Text_Paint(rect->x + (rect->w - value) / 2, rect->y + rect->h, scale, color, num, 0, 0, textStyle);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -220,29 +210,27 @@ static float healthColors[4][4] = {
|
|||
|
||||
static void CG_DrawPlayerAmmoIcon( rectDef_t *rect, qboolean draw2D ) {
|
||||
centity_t *cent;
|
||||
playerState_t *ps;
|
||||
vec3_t angles;
|
||||
vec3_t origin;
|
||||
|
||||
cent = &cg_entities[cg.snap->ps.clientNum];
|
||||
ps = &cg.snap->ps;
|
||||
|
||||
if ( draw2D || (!cg_draw3dIcons.integer && cg_drawIcons.integer) ) {
|
||||
qhandle_t icon;
|
||||
icon = cg_weapons[ cg.predictedPlayerState.weapon ].ammoIcon;
|
||||
qhandle_t icon;
|
||||
icon = cg_weapons[ cg.predictedPlayerState.weapon ].ammoIcon;
|
||||
if ( icon ) {
|
||||
CG_DrawPic( rect->x, rect->y, rect->w, rect->h, icon );
|
||||
CG_DrawPic( rect->x, rect->y, rect->w, rect->h, icon );
|
||||
}
|
||||
} else if (cg_draw3dIcons.integer) {
|
||||
if ( cent->currentState.weapon && cg_weapons[ cent->currentState.weapon ].ammoModel ) {
|
||||
VectorClear( angles );
|
||||
origin[0] = 70;
|
||||
origin[1] = 0;
|
||||
origin[2] = 0;
|
||||
angles[YAW] = 90 + 20 * sin( cg.time / 1000.0 );
|
||||
CG_Draw3DModel( rect->x, rect->y, rect->w, rect->h, cg_weapons[ cent->currentState.weapon ].ammoModel, 0, origin, angles );
|
||||
}
|
||||
}
|
||||
} else if (cg_draw3dIcons.integer) {
|
||||
if ( cent->currentState.weapon && cg_weapons[ cent->currentState.weapon ].ammoModel ) {
|
||||
VectorClear( angles );
|
||||
origin[0] = 70;
|
||||
origin[1] = 0;
|
||||
origin[2] = 0;
|
||||
angles[YAW] = 90 + 20 * sin( cg.time / 1000.0 );
|
||||
CG_Draw3DModel( rect->x, rect->y, rect->w, rect->h, cg_weapons[ cent->currentState.weapon ].ammoModel, 0, origin, angles );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void CG_DrawPlayerAmmoValue(rectDef_t *rect, float scale, vec4_t color, qhandle_t shader, int textStyle) {
|
||||
|
@ -364,7 +352,7 @@ static void CG_DrawSelectedPlayerArmor( rectDef_t *rect, float scale, vec4_t col
|
|||
}
|
||||
|
||||
qhandle_t CG_StatusHandle(int task) {
|
||||
qhandle_t h = cgs.media.assaultShader;
|
||||
qhandle_t h;
|
||||
switch (task) {
|
||||
case TEAMTASK_OFFENSE :
|
||||
h = cgs.media.assaultShader;
|
||||
|
|
|
@ -858,9 +858,7 @@ void CG_AddParticles (void)
|
|||
float alpha;
|
||||
float time, time2;
|
||||
vec3_t org;
|
||||
int color;
|
||||
cparticle_t *active, *tail;
|
||||
int type;
|
||||
vec3_t rotate_ang;
|
||||
|
||||
if (!initparticles)
|
||||
|
@ -965,16 +963,12 @@ void CG_AddParticles (void)
|
|||
if (alpha > 1.0)
|
||||
alpha = 1;
|
||||
|
||||
color = p->color;
|
||||
|
||||
time2 = time*time;
|
||||
|
||||
org[0] = p->org[0] + p->vel[0]*time + p->accel[0]*time2;
|
||||
org[1] = p->org[1] + p->vel[1]*time + p->accel[1]*time2;
|
||||
org[2] = p->org[2] + p->vel[2]*time + p->accel[2]*time2;
|
||||
|
||||
type = p->type;
|
||||
|
||||
CG_AddParticleToScene (p, org, alpha);
|
||||
}
|
||||
|
||||
|
@ -1682,8 +1676,8 @@ qboolean ValidBloodPool (vec3_t start)
|
|||
vec3_t angles;
|
||||
vec3_t right, up;
|
||||
vec3_t this_pos, x_pos, center_pos, end_pos;
|
||||
float x, y;
|
||||
float fwidth, fheight;
|
||||
int x, y;
|
||||
int fwidth, fheight;
|
||||
trace_t trace;
|
||||
vec3_t normal;
|
||||
|
||||
|
|
|
@ -1575,7 +1575,6 @@ CG_DustTrail
|
|||
*/
|
||||
static void CG_DustTrail( centity_t *cent ) {
|
||||
int anim;
|
||||
localEntity_t *dust;
|
||||
vec3_t end, vel;
|
||||
trace_t tr;
|
||||
|
||||
|
@ -1607,7 +1606,7 @@ static void CG_DustTrail( centity_t *cent ) {
|
|||
end[2] -= 16;
|
||||
|
||||
VectorSet(vel, 0, 0, -30);
|
||||
dust = CG_SmokePuff( end, vel,
|
||||
CG_SmokePuff( end, vel,
|
||||
24,
|
||||
.8f, .8f, 0.7f, 0.33f,
|
||||
500,
|
||||
|
|
|
@ -295,7 +295,10 @@ CG_CheckLocalSounds
|
|||
==================
|
||||
*/
|
||||
void CG_CheckLocalSounds( playerState_t *ps, playerState_t *ops ) {
|
||||
int highScore, health, armor, reward;
|
||||
int highScore, reward;
|
||||
#ifdef MISSIONPACK
|
||||
int health, armor;
|
||||
#endif
|
||||
sfxHandle_t sfx;
|
||||
|
||||
// don't play the sounds if the player just changed teams
|
||||
|
@ -305,9 +308,9 @@ void CG_CheckLocalSounds( playerState_t *ps, playerState_t *ops ) {
|
|||
|
||||
// hit changes
|
||||
if ( ps->persistant[PERS_HITS] > ops->persistant[PERS_HITS] ) {
|
||||
#ifdef MISSIONPACK
|
||||
armor = ps->persistant[PERS_ATTACKEE_ARMOR] & 0xff;
|
||||
health = ps->persistant[PERS_ATTACKEE_ARMOR] >> 8;
|
||||
#ifdef MISSIONPACK
|
||||
if (armor > 50 ) {
|
||||
trap_S_StartLocalSound( cgs.media.hitSoundHighArmor, CHAN_LOCAL_SOUND );
|
||||
} else if (armor || health > 100) {
|
||||
|
|
|
@ -213,7 +213,7 @@ CG_RailTrail
|
|||
==========================
|
||||
*/
|
||||
void CG_RailTrail (clientInfo_t *ci, vec3_t start, vec3_t end) {
|
||||
vec3_t axis[36], move, move2, next_move, vec, temp;
|
||||
vec3_t axis[36], move, move2, vec, temp;
|
||||
float len;
|
||||
int i, j, skip;
|
||||
|
||||
|
@ -271,7 +271,6 @@ void CG_RailTrail (clientInfo_t *ci, vec3_t start, vec3_t end) {
|
|||
}
|
||||
|
||||
VectorMA(move, 20, vec, move);
|
||||
VectorCopy(move, next_move);
|
||||
VectorScale (vec, SPACING, vec);
|
||||
|
||||
skip = -1;
|
||||
|
@ -471,7 +470,6 @@ static void CG_PlasmaTrail( centity_t *cent, const weaponInfo_t *wi ) {
|
|||
vec3_t velocity, xvelocity, origin;
|
||||
vec3_t offset, xoffset;
|
||||
vec3_t v[3];
|
||||
int t, startTime, step;
|
||||
|
||||
float waterScale = 1.0f;
|
||||
|
||||
|
@ -479,11 +477,7 @@ static void CG_PlasmaTrail( centity_t *cent, const weaponInfo_t *wi ) {
|
|||
return;
|
||||
}
|
||||
|
||||
step = 50;
|
||||
|
||||
es = ¢->currentState;
|
||||
startTime = cent->trailTime;
|
||||
t = step * ( (startTime + step) / step );
|
||||
|
||||
BG_EvaluateTrajectory( &es->pos, cg.time, origin );
|
||||
|
||||
|
@ -528,21 +522,21 @@ static void CG_PlasmaTrail( centity_t *cent, const weaponInfo_t *wi ) {
|
|||
VectorScale( xvelocity, waterScale, le->pos.trDelta );
|
||||
|
||||
AxisCopy( axisDefault, re->axis );
|
||||
re->shaderTime = cg.time / 1000.0f;
|
||||
re->reType = RT_SPRITE;
|
||||
re->radius = 0.25f;
|
||||
re->shaderTime = cg.time / 1000.0f;
|
||||
re->reType = RT_SPRITE;
|
||||
re->radius = 0.25f;
|
||||
re->customShader = cgs.media.railRingsShader;
|
||||
le->bounceFactor = 0.3f;
|
||||
|
||||
re->shaderRGBA[0] = wi->flashDlightColor[0] * 63;
|
||||
re->shaderRGBA[1] = wi->flashDlightColor[1] * 63;
|
||||
re->shaderRGBA[2] = wi->flashDlightColor[2] * 63;
|
||||
re->shaderRGBA[3] = 63;
|
||||
re->shaderRGBA[0] = wi->flashDlightColor[0] * 63;
|
||||
re->shaderRGBA[1] = wi->flashDlightColor[1] * 63;
|
||||
re->shaderRGBA[2] = wi->flashDlightColor[2] * 63;
|
||||
re->shaderRGBA[3] = 63;
|
||||
|
||||
le->color[0] = wi->flashDlightColor[0] * 0.2;
|
||||
le->color[1] = wi->flashDlightColor[1] * 0.2;
|
||||
le->color[2] = wi->flashDlightColor[2] * 0.2;
|
||||
le->color[3] = 0.25f;
|
||||
le->color[0] = wi->flashDlightColor[0] * 0.2;
|
||||
le->color[1] = wi->flashDlightColor[1] * 0.2;
|
||||
le->color[2] = wi->flashDlightColor[2] * 0.2;
|
||||
le->color[3] = 0.25f;
|
||||
|
||||
le->angles.trType = TR_LINEAR;
|
||||
le->angles.trTime = cg.time;
|
||||
|
@ -680,8 +674,6 @@ void CG_RegisterWeapon( int weaponNum ) {
|
|||
weaponInfo->handsModel = trap_R_RegisterModel( "models/weapons2/shotgun/shotgun_hand.md3" );
|
||||
}
|
||||
|
||||
weaponInfo->loopFireSound = qfalse;
|
||||
|
||||
switch ( weaponNum ) {
|
||||
case WP_GAUNTLET:
|
||||
MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
|
||||
|
@ -708,8 +700,6 @@ void CG_RegisterWeapon( int weaponNum ) {
|
|||
weaponInfo->missileModel = trap_R_RegisterModel( "models/ammo/rocket/rocket.md3" );
|
||||
weaponInfo->missileTrailFunc = CG_GrappleTrail;
|
||||
weaponInfo->missileDlight = 200;
|
||||
weaponInfo->wiTrailTime = 2000;
|
||||
weaponInfo->trailRadius = 64;
|
||||
MAKERGB( weaponInfo->missileDlightColor, 1, 0.75f, 0 );
|
||||
weaponInfo->readySound = trap_S_RegisterSound( "sound/weapons/melee/fsthum.wav", qfalse );
|
||||
weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/melee/fstrun.wav", qfalse );
|
||||
|
@ -719,7 +709,6 @@ void CG_RegisterWeapon( int weaponNum ) {
|
|||
#ifdef MISSIONPACK
|
||||
case WP_CHAINGUN:
|
||||
weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/vulcan/wvulfire.wav", qfalse );
|
||||
weaponInfo->loopFireSound = qtrue;
|
||||
MAKERGB( weaponInfo->flashDlightColor, 1, 1, 0 );
|
||||
weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/vulcan/vulcanf1b.wav", qfalse );
|
||||
weaponInfo->flashSound[1] = trap_S_RegisterSound( "sound/weapons/vulcan/vulcanf2b.wav", qfalse );
|
||||
|
@ -1135,28 +1124,6 @@ static void CG_LightningBolt( centity_t *cent, vec3_t origin ) {
|
|||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
===============
|
||||
CG_SpawnRailTrail
|
||||
|
||||
Origin will be the exact tag point, which is slightly
|
||||
different than the muzzle point used for determining hits.
|
||||
===============
|
||||
*/
|
||||
static void CG_SpawnRailTrail( centity_t *cent, vec3_t origin ) {
|
||||
clientInfo_t *ci;
|
||||
|
||||
if ( cent->currentState.weapon != WP_RAILGUN ) {
|
||||
return;
|
||||
}
|
||||
if ( !cent->pe.railgunFlash ) {
|
||||
return;
|
||||
}
|
||||
cent->pe.railgunFlash = qtrue;
|
||||
ci = &cgs.clientinfo[ cent->currentState.clientNum ];
|
||||
CG_RailTrail( ci, origin, cent->pe.railgunImpact );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
======================
|
||||
|
@ -1338,7 +1305,7 @@ void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent
|
|||
// continuous flash
|
||||
} else {
|
||||
// impulse flash
|
||||
if ( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME && !cent->pe.railgunFlash ) {
|
||||
if ( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME ) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -1375,9 +1342,6 @@ void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent
|
|||
// add lightning bolt
|
||||
CG_LightningBolt( nonPredictedCent, flash.origin );
|
||||
|
||||
// add rail trail
|
||||
CG_SpawnRailTrail( cent, flash.origin );
|
||||
|
||||
if ( weapon->flashDlightColor[0] || weapon->flashDlightColor[1] || weapon->flashDlightColor[2] ) {
|
||||
trap_R_AddLightToScene( flash.origin, 300 + (rand()&31), weapon->flashDlightColor[0],
|
||||
weapon->flashDlightColor[1], weapon->flashDlightColor[2] );
|
||||
|
@ -1878,6 +1842,7 @@ void CG_MissileHitWall( int weapon, int clientNum, vec3_t origin, vec3_t dir, im
|
|||
case WP_RAILGUN:
|
||||
mod = cgs.media.ringFlashModel;
|
||||
shader = cgs.media.railExplosionShader;
|
||||
//sfx = cgs.media.sfx_railg;
|
||||
sfx = cgs.media.sfx_plasmaexp;
|
||||
mark = cgs.media.energyMarkShader;
|
||||
radius = 24;
|
||||
|
@ -1917,15 +1882,6 @@ void CG_MissileHitWall( int weapon, int clientNum, vec3_t origin, vec3_t dir, im
|
|||
}
|
||||
mark = cgs.media.bulletMarkShader;
|
||||
|
||||
r = rand() & 3;
|
||||
if ( r < 2 ) {
|
||||
sfx = cgs.media.sfx_ric1;
|
||||
} else if ( r == 2 ) {
|
||||
sfx = cgs.media.sfx_ric2;
|
||||
} else {
|
||||
sfx = cgs.media.sfx_ric3;
|
||||
}
|
||||
|
||||
radius = 8;
|
||||
break;
|
||||
#endif
|
||||
|
|
|
@ -827,7 +827,6 @@ or bursted delayed packets.
|
|||
#define RESET_TIME 500
|
||||
|
||||
void CL_AdjustTimeDelta( void ) {
|
||||
int resetTime;
|
||||
int newDelta;
|
||||
int deltaDelta;
|
||||
|
||||
|
@ -838,13 +837,6 @@ void CL_AdjustTimeDelta( void ) {
|
|||
return;
|
||||
}
|
||||
|
||||
// if the current time is WAY off, just correct to the current value
|
||||
if ( com_sv_running->integer ) {
|
||||
resetTime = 100;
|
||||
} else {
|
||||
resetTime = RESET_TIME;
|
||||
}
|
||||
|
||||
newDelta = cl.snap.serverTime - cls.realtime;
|
||||
deltaDelta = abs( newDelta - cl.serverTimeDelta );
|
||||
|
||||
|
|
|
@ -937,10 +937,6 @@ static void setupQuad( long xOff, long yOff )
|
|||
cin.oldysize = cinTable[currentHandle].ysize;
|
||||
cin.oldxsize = cinTable[currentHandle].xsize;
|
||||
|
||||
numQuadCels = (cinTable[currentHandle].CIN_WIDTH*cinTable[currentHandle].CIN_HEIGHT) / (16);
|
||||
numQuadCels += numQuadCels/4 + numQuadCels/16;
|
||||
numQuadCels += 64; // for overflow
|
||||
|
||||
numQuadCels = (cinTable[currentHandle].xsize*cinTable[currentHandle].ysize) / (16);
|
||||
numQuadCels += numQuadCels/4;
|
||||
numQuadCels += 64; // for overflow
|
||||
|
@ -1610,7 +1606,6 @@ void CIN_DrawCinematic (int handle) {
|
|||
|
||||
void CL_PlayCinematic_f(void) {
|
||||
char *arg, *s;
|
||||
qboolean holdatend;
|
||||
int bits = CIN_system;
|
||||
|
||||
Com_DPrintf("CL_PlayCinematic_f\n");
|
||||
|
@ -1621,7 +1616,6 @@ void CL_PlayCinematic_f(void) {
|
|||
arg = Cmd_Argv( 1 );
|
||||
s = Cmd_Argv(2);
|
||||
|
||||
holdatend = qfalse;
|
||||
if ((s && s[0] == '1') || Q_stricmp(arg,"demoend.roq")==0 || Q_stricmp(arg,"end.roq")==0) {
|
||||
bits |= CIN_hold;
|
||||
}
|
||||
|
|
|
@ -279,10 +279,6 @@ void IN_CenterView (void) {
|
|||
|
||||
//==========================================================================
|
||||
|
||||
cvar_t *cl_upspeed;
|
||||
cvar_t *cl_forwardspeed;
|
||||
cvar_t *cl_sidespeed;
|
||||
|
||||
cvar_t *cl_yawspeed;
|
||||
cvar_t *cl_pitchspeed;
|
||||
|
||||
|
@ -399,13 +395,9 @@ CL_JoystickMove
|
|||
=================
|
||||
*/
|
||||
void CL_JoystickMove( usercmd_t *cmd ) {
|
||||
int movespeed;
|
||||
float anglespeed;
|
||||
|
||||
if ( in_speed.active ^ cl_run->integer ) {
|
||||
movespeed = 2;
|
||||
} else {
|
||||
movespeed = 1;
|
||||
if ( !(in_speed.active ^ cl_run->integer) ) {
|
||||
cmd->buttons |= BUTTON_WALKING;
|
||||
}
|
||||
|
||||
|
@ -617,10 +609,10 @@ usercmd_t CL_CreateCmd( void ) {
|
|||
// draw debug graphs of turning for mouse testing
|
||||
if ( cl_debugMove->integer ) {
|
||||
if ( cl_debugMove->integer == 1 ) {
|
||||
SCR_DebugGraph( abs(cl.viewangles[YAW] - oldAngles[YAW]), 0 );
|
||||
SCR_DebugGraph( abs(cl.viewangles[YAW] - oldAngles[YAW]) );
|
||||
}
|
||||
if ( cl_debugMove->integer == 2 ) {
|
||||
SCR_DebugGraph( abs(cl.viewangles[PITCH] - oldAngles[PITCH]), 0 );
|
||||
SCR_DebugGraph( abs(cl.viewangles[PITCH] - oldAngles[PITCH]) );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -636,7 +628,6 @@ Create a new usercmd_t structure for this frame
|
|||
=================
|
||||
*/
|
||||
void CL_CreateNewCommands( void ) {
|
||||
usercmd_t *cmd;
|
||||
int cmdNum;
|
||||
|
||||
// no need to create usercmds until we have a gamestate
|
||||
|
@ -658,7 +649,6 @@ void CL_CreateNewCommands( void ) {
|
|||
cl.cmdNumber++;
|
||||
cmdNum = cl.cmdNumber & CMD_MASK;
|
||||
cl.cmds[cmdNum] = CL_CreateCmd ();
|
||||
cmd = &cl.cmds[cmdNum];
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -440,9 +440,7 @@ void CL_CaptureVoip(void)
|
|||
// try to get more audio data from the sound card...
|
||||
|
||||
if (initialFrame) {
|
||||
float gain = cl_voipGainDuringCapture->value;
|
||||
if (gain < 0.0f) gain = 0.0f; else if (gain >= 1.0f) gain = 1.0f;
|
||||
S_MasterGain(cl_voipGainDuringCapture->value);
|
||||
S_MasterGain(Com_Clamp(0.0f, 1.0f, cl_voipGainDuringCapture->value));
|
||||
S_StartCapture();
|
||||
CL_VoipNewGeneration();
|
||||
CL_VoipParseTargets();
|
||||
|
@ -582,9 +580,8 @@ CL_ChangeReliableCommand
|
|||
======================
|
||||
*/
|
||||
void CL_ChangeReliableCommand( void ) {
|
||||
int r, index, l;
|
||||
int index, l;
|
||||
|
||||
r = clc.reliableSequence - (random() * 5);
|
||||
index = clc.reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
|
||||
l = strlen(clc.reliableCommands[ index ]);
|
||||
if ( l >= MAX_STRING_CHARS - 1 ) {
|
||||
|
@ -3001,7 +2998,7 @@ void CL_Frame ( int msec ) {
|
|||
cls.realtime += cls.frametime;
|
||||
|
||||
if ( cl_timegraph->integer ) {
|
||||
SCR_DebugGraph ( cls.realFrametime * 0.25, 0 );
|
||||
SCR_DebugGraph ( cls.realFrametime * 0.25 );
|
||||
}
|
||||
|
||||
// see if we need to update any userinfo
|
||||
|
@ -3803,10 +3800,8 @@ CL_GetServerStatus
|
|||
===================
|
||||
*/
|
||||
serverStatus_t *CL_GetServerStatus( netadr_t from ) {
|
||||
serverStatus_t *serverStatus;
|
||||
int i, oldest, oldestTime;
|
||||
|
||||
serverStatus = NULL;
|
||||
for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
|
||||
if ( NET_CompareAdr( from, cl_serverStatusList[i].address ) ) {
|
||||
return &cl_serverStatusList[i];
|
||||
|
@ -4330,7 +4325,6 @@ qboolean CL_UpdateVisiblePings_f(int source) {
|
|||
if (slots < MAX_PINGREQUESTS) {
|
||||
serverInfo_t *server = NULL;
|
||||
|
||||
max = (source == AS_GLOBAL) ? MAX_GLOBAL_SERVERS : MAX_OTHER_SERVERS;
|
||||
switch (source) {
|
||||
case AS_LOCAL :
|
||||
server = &cls.localServers[0];
|
||||
|
|
|
@ -395,25 +395,18 @@ DEBUG GRAPH
|
|||
===============================================================================
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float value;
|
||||
int color;
|
||||
} graphsamp_t;
|
||||
|
||||
static int current;
|
||||
static graphsamp_t values[1024];
|
||||
static float values[1024];
|
||||
|
||||
/*
|
||||
==============
|
||||
SCR_DebugGraph
|
||||
==============
|
||||
*/
|
||||
void SCR_DebugGraph (float value, int color)
|
||||
void SCR_DebugGraph (float value)
|
||||
{
|
||||
values[current&1023].value = value;
|
||||
values[current&1023].color = color;
|
||||
current++;
|
||||
values[current] = value;
|
||||
current = (current + 1) % ARRAY_LEN(values);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -425,7 +418,6 @@ void SCR_DrawDebugGraph (void)
|
|||
{
|
||||
int a, x, y, w, i, h;
|
||||
float v;
|
||||
int color;
|
||||
|
||||
//
|
||||
// draw the graph
|
||||
|
@ -440,9 +432,8 @@ void SCR_DrawDebugGraph (void)
|
|||
|
||||
for (a=0 ; a<w ; a++)
|
||||
{
|
||||
i = (current-1-a+1024) & 1023;
|
||||
v = values[i].value;
|
||||
color = values[i].color;
|
||||
i = (ARRAY_LEN(values)+current-1-(a % ARRAY_LEN(values))) % ARRAY_LEN(values);
|
||||
v = values[i];
|
||||
v = v * cl_graphscale->integer + cl_graphshift->integer;
|
||||
|
||||
if (v < 0)
|
||||
|
|
|
@ -564,7 +564,7 @@ void CL_SaveConsoleHistory( void );
|
|||
void SCR_Init (void);
|
||||
void SCR_UpdateScreen (void);
|
||||
|
||||
void SCR_DebugGraph (float value, int color);
|
||||
void SCR_DebugGraph (float value);
|
||||
|
||||
int SCR_GetBigStringWidth( const char *str ); // returns in virtual 640x480 coordinates
|
||||
|
||||
|
|
|
@ -131,7 +131,6 @@ S_ReadRIFFHeader
|
|||
static qboolean S_ReadRIFFHeader(fileHandle_t file, snd_info_t *info)
|
||||
{
|
||||
char dump[16];
|
||||
int wav_format;
|
||||
int bits;
|
||||
int fmtlen = 0;
|
||||
|
||||
|
@ -146,7 +145,7 @@ static qboolean S_ReadRIFFHeader(fileHandle_t file, snd_info_t *info)
|
|||
}
|
||||
|
||||
// Save the parameters
|
||||
wav_format = FGetLittleShort(file);
|
||||
FGetLittleShort(file); // wav_format
|
||||
info->channels = FGetLittleShort(file);
|
||||
info->rate = FGetLittleLong(file);
|
||||
FGetLittleLong(file);
|
||||
|
|
|
@ -243,8 +243,6 @@ S_AL_BufferUnload
|
|||
*/
|
||||
static void S_AL_BufferUnload(sfxHandle_t sfx)
|
||||
{
|
||||
ALenum error;
|
||||
|
||||
if(knownSfx[sfx].filename[0] == '\0')
|
||||
return;
|
||||
|
||||
|
@ -254,7 +252,7 @@ static void S_AL_BufferUnload(sfxHandle_t sfx)
|
|||
// Delete it
|
||||
S_AL_ClearError( qfalse );
|
||||
qalDeleteBuffers(1, &knownSfx[sfx].buffer);
|
||||
if((error = qalGetError()) != AL_NO_ERROR)
|
||||
if(qalGetError() != AL_NO_ERROR)
|
||||
Com_Printf( S_COLOR_RED "ERROR: Can't delete sound buffer for %s\n",
|
||||
knownSfx[sfx].filename);
|
||||
|
||||
|
@ -673,7 +671,6 @@ qboolean S_AL_SrcInit( void )
|
|||
{
|
||||
int i;
|
||||
int limit;
|
||||
ALenum error;
|
||||
|
||||
// Clear the sources data structure
|
||||
memset(srcList, 0, sizeof(srcList));
|
||||
|
@ -692,7 +689,7 @@ qboolean S_AL_SrcInit( void )
|
|||
for(i = 0; i < limit; i++)
|
||||
{
|
||||
qalGenSources(1, &srcList[i].alSource);
|
||||
if((error = qalGetError()) != AL_NO_ERROR)
|
||||
if(qalGetError() != AL_NO_ERROR)
|
||||
break;
|
||||
srcCount++;
|
||||
}
|
||||
|
@ -2440,20 +2437,26 @@ qboolean S_AL_Init( soundInterface_t *si )
|
|||
{
|
||||
char devicenames[16384] = "";
|
||||
const char *devicelist;
|
||||
#ifdef _WIN32
|
||||
const char *defaultdevice;
|
||||
#endif
|
||||
int curlen;
|
||||
|
||||
// get all available devices + the default device name.
|
||||
if(enumeration_all_ext)
|
||||
{
|
||||
devicelist = qalcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
|
||||
#ifdef _WIN32
|
||||
defaultdevice = qalcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
// We don't have ALC_ENUMERATE_ALL_EXT but normal enumeration.
|
||||
devicelist = qalcGetString(NULL, ALC_DEVICE_SPECIFIER);
|
||||
#ifdef _WIN32
|
||||
defaultdevice = qalcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
|
||||
#endif
|
||||
enumeration_ext = qtrue;
|
||||
}
|
||||
|
||||
|
|
|
@ -959,9 +959,9 @@ BotChatTime
|
|||
==================
|
||||
*/
|
||||
float BotChatTime(bot_state_t *bs) {
|
||||
int cpm;
|
||||
//int cpm;
|
||||
|
||||
cpm = trap_Characteristic_BInteger(bs->character, CHARACTERISTIC_CHAT_CPM, 1, 4000);
|
||||
//cpm = trap_Characteristic_BInteger(bs->character, CHARACTERISTIC_CHAT_CPM, 1, 4000);
|
||||
|
||||
return 2.0; //(float) trap_BotChatLength(bs->cs) * 30 / cpm;
|
||||
}
|
||||
|
|
|
@ -684,9 +684,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
|
|||
bs->ltgtype = 0;
|
||||
}
|
||||
//
|
||||
if (bs->camp_range > 0) {
|
||||
//FIXME: move around a bit
|
||||
}
|
||||
//FIXME: move around a bit
|
||||
//
|
||||
trap_BotResetAvoidReach(bs->ms);
|
||||
return qfalse;
|
||||
|
|
|
@ -4429,7 +4429,8 @@ open, which buttons to activate etc.
|
|||
*/
|
||||
void BotAIBlocked(bot_state_t *bs, bot_moveresult_t *moveresult, int activate) {
|
||||
int movetype, bspent;
|
||||
vec3_t hordir, start, end, mins, maxs, sideward, angles, up = {0, 0, 1};
|
||||
vec3_t hordir, sideward, angles, up = {0, 0, 1};
|
||||
//vec3_t start, end, mins, maxs;
|
||||
aas_entityinfo_t entinfo;
|
||||
bot_activategoal_t activategoal;
|
||||
|
||||
|
@ -4491,11 +4492,11 @@ void BotAIBlocked(bot_state_t *bs, bot_moveresult_t *moveresult, int activate) {
|
|||
movetype = MOVE_WALK;
|
||||
// if there's an obstacle at the bot's feet and head then
|
||||
// the bot might be able to crouch through
|
||||
VectorCopy(bs->origin, start);
|
||||
start[2] += 18;
|
||||
VectorMA(start, 5, hordir, end);
|
||||
VectorSet(mins, -16, -16, -24);
|
||||
VectorSet(maxs, 16, 16, 4);
|
||||
//VectorCopy(bs->origin, start);
|
||||
//start[2] += 18;
|
||||
//VectorMA(start, 5, hordir, end);
|
||||
//VectorSet(mins, -16, -16, -24);
|
||||
//VectorSet(maxs, 16, 16, 4);
|
||||
//
|
||||
//bsptrace = AAS_Trace(start, mins, maxs, end, bs->entitynum, MASK_PLAYERSOLID);
|
||||
//if (bsptrace.fraction >= 1) movetype = MOVE_CROUCH;
|
||||
|
|
|
@ -192,7 +192,6 @@ typedef struct bot_state_s
|
|||
float lastair_time; //last time the bot had air
|
||||
float teleport_time; //last time the bot teleported
|
||||
float camp_time; //last time camped
|
||||
float camp_range; //camp range
|
||||
float weaponchange_time; //time the bot started changing weapons
|
||||
float firethrottlewait_time; //amount of time to wait
|
||||
float firethrottleshoot_time; //amount of time to shoot
|
||||
|
@ -264,11 +263,6 @@ typedef struct bot_state_s
|
|||
int ctfstrategy; //ctf strategy
|
||||
char subteam[32]; //sub team name
|
||||
float formation_dist; //formation team mate intervening space
|
||||
char formation_teammate[16]; //netname of the team mate the bot uses for relative positioning
|
||||
float formation_angle; //angle relative to the formation team mate
|
||||
vec3_t formation_dir; //the direction the formation is moving in
|
||||
vec3_t formation_origin; //origin the bot uses for relative positioning
|
||||
bot_goal_t formation_goal; //formation goal
|
||||
|
||||
bot_activategoal_t *activatestack; //first activate goal on the stack
|
||||
bot_activategoal_t activategoalheap[MAX_ACTIVATESTACK]; //activate goal heap
|
||||
|
|
|
@ -513,7 +513,8 @@ voiceCommand_t voiceCommands[] = {
|
|||
};
|
||||
|
||||
int BotVoiceChatCommand(bot_state_t *bs, int mode, char *voiceChat) {
|
||||
int i, voiceOnly, clientNum, color;
|
||||
int i, clientNum;
|
||||
//int voiceOnly, color;
|
||||
char *ptr, buf[MAX_MESSAGE_SIZE], *cmd;
|
||||
|
||||
if (!TeamPlayIsOn()) {
|
||||
|
@ -528,13 +529,13 @@ int BotVoiceChatCommand(bot_state_t *bs, int mode, char *voiceChat) {
|
|||
cmd = buf;
|
||||
for (ptr = cmd; *cmd && *cmd > ' '; cmd++);
|
||||
while (*cmd && *cmd <= ' ') *cmd++ = '\0';
|
||||
voiceOnly = atoi(ptr);
|
||||
//voiceOnly = atoi(ptr);
|
||||
for (ptr = cmd; *cmd && *cmd > ' '; cmd++);
|
||||
while (*cmd && *cmd <= ' ') *cmd++ = '\0';
|
||||
clientNum = atoi(ptr);
|
||||
for (ptr = cmd; *cmd && *cmd > ' '; cmd++);
|
||||
while (*cmd && *cmd <= ' ') *cmd++ = '\0';
|
||||
color = atoi(ptr);
|
||||
//color = atoi(ptr);
|
||||
|
||||
if (!BotSameTeam(bs, clientNum)) {
|
||||
return qfalse;
|
||||
|
|
|
@ -232,7 +232,7 @@ PM_StepSlideMove
|
|||
*/
|
||||
void PM_StepSlideMove( qboolean gravity ) {
|
||||
vec3_t start_o, start_v;
|
||||
vec3_t down_o, down_v;
|
||||
// vec3_t down_o, down_v;
|
||||
trace_t trace;
|
||||
// float down_dist, up_dist;
|
||||
// vec3_t delta, delta2;
|
||||
|
@ -256,8 +256,8 @@ void PM_StepSlideMove( qboolean gravity ) {
|
|||
return;
|
||||
}
|
||||
|
||||
VectorCopy (pm->ps->origin, down_o);
|
||||
VectorCopy (pm->ps->velocity, down_v);
|
||||
//VectorCopy (pm->ps->origin, down_o);
|
||||
//VectorCopy (pm->ps->velocity, down_v);
|
||||
|
||||
VectorCopy (start_o, up);
|
||||
up[2] += STEPSIZE;
|
||||
|
|
|
@ -539,7 +539,6 @@ void ClientEvents( gentity_t *ent, int oldEventSequence ) {
|
|||
int event;
|
||||
gclient_t *client;
|
||||
int damage;
|
||||
vec3_t dir;
|
||||
vec3_t origin, angles;
|
||||
// qboolean fired;
|
||||
gitem_t *item;
|
||||
|
@ -567,7 +566,6 @@ void ClientEvents( gentity_t *ent, int oldEventSequence ) {
|
|||
} else {
|
||||
damage = 5;
|
||||
}
|
||||
VectorSet (dir, 0, 0, 1);
|
||||
ent->pain_debounce_time = level.time + 200; // no normal pain sound
|
||||
G_Damage (ent, NULL, NULL, NULL, NULL, damage, 0, MOD_FALLING);
|
||||
break;
|
||||
|
@ -1106,15 +1104,12 @@ while a slow client may have multiple ClientEndFrame between ClientThink.
|
|||
*/
|
||||
void ClientEndFrame( gentity_t *ent ) {
|
||||
int i;
|
||||
clientPersistant_t *pers;
|
||||
|
||||
if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
|
||||
SpectatorClientEndFrame( ent );
|
||||
return;
|
||||
}
|
||||
|
||||
pers = &ent->client->pers;
|
||||
|
||||
// turn off any expired powerups
|
||||
for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
|
||||
if ( ent->client->ps.powerups[ i ] < level.time ) {
|
||||
|
|
|
@ -216,7 +216,6 @@ LookAtKiller
|
|||
*/
|
||||
void LookAtKiller( gentity_t *self, gentity_t *inflictor, gentity_t *attacker ) {
|
||||
vec3_t dir;
|
||||
vec3_t angles;
|
||||
|
||||
if ( attacker && attacker != self ) {
|
||||
VectorSubtract (attacker->s.pos.trBase, self->s.pos.trBase, dir);
|
||||
|
@ -228,10 +227,6 @@ void LookAtKiller( gentity_t *self, gentity_t *inflictor, gentity_t *attacker )
|
|||
}
|
||||
|
||||
self->client->ps.stats[STAT_DEAD_YAW] = vectoyaw ( dir );
|
||||
|
||||
angles[YAW] = vectoyaw ( dir );
|
||||
angles[PITCH] = 0;
|
||||
angles[ROLL] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -822,7 +817,6 @@ void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker,
|
|||
vec3_t dir, vec3_t point, int damage, int dflags, int mod ) {
|
||||
gclient_t *client;
|
||||
int take;
|
||||
int save;
|
||||
int asave;
|
||||
int knockback;
|
||||
int max;
|
||||
|
@ -996,7 +990,6 @@ void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker,
|
|||
damage = 1;
|
||||
}
|
||||
take = damage;
|
||||
save = 0;
|
||||
|
||||
// save some from armor
|
||||
asave = CheckArmor (targ, take, dflags);
|
||||
|
|
|
@ -281,7 +281,7 @@ int Pickup_Health (gentity_t *ent, gentity_t *other) {
|
|||
|
||||
// small and mega healths will go over the max
|
||||
#ifdef MISSIONPACK
|
||||
if( other->client && bg_itemlist[other->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
|
||||
if( bg_itemlist[other->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
|
||||
max = other->client->ps.stats[STAT_MAX_HEALTH];
|
||||
}
|
||||
else
|
||||
|
|
|
@ -1758,8 +1758,6 @@ Advances the non-player objects in the world
|
|||
void G_RunFrame( int levelTime ) {
|
||||
int i;
|
||||
gentity_t *ent;
|
||||
int msec;
|
||||
int start, end;
|
||||
|
||||
// if we are waiting for the level to restart, do nothing
|
||||
if ( level.restarted ) {
|
||||
|
@ -1769,7 +1767,6 @@ int start, end;
|
|||
level.framenum++;
|
||||
level.previousTime = level.time;
|
||||
level.time = levelTime;
|
||||
msec = level.time - level.previousTime;
|
||||
|
||||
// get any cvar changes
|
||||
G_UpdateCvars();
|
||||
|
@ -1777,7 +1774,6 @@ int start, end;
|
|||
//
|
||||
// go through all allocated objects
|
||||
//
|
||||
start = trap_Milliseconds();
|
||||
ent = &g_entities[0];
|
||||
for (i=0 ; i<level.num_entities ; i++, ent++) {
|
||||
if ( !ent->inuse ) {
|
||||
|
@ -1837,9 +1833,7 @@ int start, end;
|
|||
|
||||
G_RunThink( ent );
|
||||
}
|
||||
end = trap_Milliseconds();
|
||||
|
||||
start = trap_Milliseconds();
|
||||
// perform final fixups on the players
|
||||
ent = &g_entities[0];
|
||||
for (i=0 ; i < level.maxclients ; i++, ent++ ) {
|
||||
|
@ -1847,7 +1841,6 @@ start = trap_Milliseconds();
|
|||
ClientEndFrame( ent );
|
||||
}
|
||||
}
|
||||
end = trap_Milliseconds();
|
||||
|
||||
// see if it is time to do a tournement restart
|
||||
CheckTournament();
|
||||
|
|
|
@ -81,16 +81,6 @@ const char *TeamName(int team) {
|
|||
return "FREE";
|
||||
}
|
||||
|
||||
const char *OtherTeamName(int team) {
|
||||
if (team==TEAM_RED)
|
||||
return "BLUE";
|
||||
else if (team==TEAM_BLUE)
|
||||
return "RED";
|
||||
else if (team==TEAM_SPECTATOR)
|
||||
return "SPECTATOR";
|
||||
return "FREE";
|
||||
}
|
||||
|
||||
const char *TeamColorString(int team) {
|
||||
if (team==TEAM_RED)
|
||||
return S_COLOR_RED;
|
||||
|
@ -365,7 +355,6 @@ void Team_FragBonuses(gentity_t *targ, gentity_t *inflictor, gentity_t *attacker
|
|||
targ->client->pers.teamState.lasthurtcarrier = 0;
|
||||
|
||||
attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
|
||||
team = attacker->client->sess.sessionTeam;
|
||||
// add the sprite over the player's head
|
||||
attacker->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
|
||||
attacker->client->ps.eFlags |= EF_AWARD_DEFEND;
|
||||
|
@ -383,7 +372,6 @@ void Team_FragBonuses(gentity_t *targ, gentity_t *inflictor, gentity_t *attacker
|
|||
targ->client->pers.teamState.lasthurtcarrier = 0;
|
||||
|
||||
attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
|
||||
team = attacker->client->sess.sessionTeam;
|
||||
// add the sprite over the player's head
|
||||
attacker->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
|
||||
attacker->client->ps.eFlags |= EF_AWARD_DEFEND;
|
||||
|
|
|
@ -69,7 +69,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
|
||||
int OtherTeam(int team);
|
||||
const char *TeamName(int team);
|
||||
const char *OtherTeamName(int team);
|
||||
const char *TeamColorString(int team);
|
||||
void AddTeamScore(vec3_t origin, int team, int score);
|
||||
|
||||
|
|
|
@ -324,7 +324,6 @@ void ShotgunPattern( vec3_t origin, vec3_t origin2, int seed, gentity_t *ent ) {
|
|||
float r, u;
|
||||
vec3_t end;
|
||||
vec3_t forward, right, up;
|
||||
int oldScore;
|
||||
qboolean hitClient = qfalse;
|
||||
|
||||
// derive the right and up vectors from the forward vector, because
|
||||
|
@ -333,8 +332,6 @@ void ShotgunPattern( vec3_t origin, vec3_t origin2, int seed, gentity_t *ent ) {
|
|||
PerpendicularVector( right, forward );
|
||||
CrossProduct( forward, right, up );
|
||||
|
||||
oldScore = ent->client->ps.persistant[PERS_SCORE];
|
||||
|
||||
// generate the "random" spread pattern
|
||||
for ( i = 0 ; i < DEFAULT_SHOTGUN_COUNT ; i++ ) {
|
||||
r = Q_crandom( &seed ) * DEFAULT_SHOTGUN_SPREAD * 16;
|
||||
|
|
|
@ -524,14 +524,15 @@ spx_int32_t *seed
|
|||
VARDECL(int *ind);
|
||||
VARDECL(int *signs);
|
||||
const signed char *shape_cb;
|
||||
int shape_cb_size, subvect_size, nb_subvect;
|
||||
//int shape_cb_size;
|
||||
int subvect_size, nb_subvect;
|
||||
const split_cb_params *params;
|
||||
int have_sign;
|
||||
|
||||
params = (const split_cb_params *) par;
|
||||
subvect_size = params->subvect_size;
|
||||
nb_subvect = params->nb_subvect;
|
||||
shape_cb_size = 1<<params->shape_bits;
|
||||
//shape_cb_size = 1<<params->shape_bits;
|
||||
shape_cb = params->shape_cb;
|
||||
have_sign = params->have_sign;
|
||||
|
||||
|
|
|
@ -463,7 +463,7 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
|
|||
{
|
||||
int i;
|
||||
unsigned int j;
|
||||
int incomplete = 0;
|
||||
//int incomplete = 0;
|
||||
spx_int16_t opt;
|
||||
|
||||
if (start_offset != NULL)
|
||||
|
@ -568,7 +568,7 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
|
|||
if (found)
|
||||
{
|
||||
i=besti;
|
||||
incomplete = 1;
|
||||
//incomplete = 1;
|
||||
/*fprintf (stderr, "incomplete: %d %d %d %d\n", jitter->packets[i].timestamp, jitter->pointer_timestamp, chunk_size, jitter->packets[i].span);*/
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1300,7 +1300,7 @@ int nb_decode(void *state, SpeexBits *bits, void *vout)
|
|||
{
|
||||
int offset;
|
||||
spx_word16_t *exc;
|
||||
spx_word16_t *sp;
|
||||
//spx_word16_t *sp;
|
||||
spx_word16_t *innov_save = NULL;
|
||||
spx_word16_t tmp;
|
||||
|
||||
|
@ -1309,7 +1309,7 @@ int nb_decode(void *state, SpeexBits *bits, void *vout)
|
|||
/* Excitation */
|
||||
exc=st->exc+offset;
|
||||
/* Original signal */
|
||||
sp=out+offset;
|
||||
//sp=out+offset;
|
||||
if (st->innov_save)
|
||||
innov_save = st->innov_save+offset;
|
||||
|
||||
|
@ -1502,13 +1502,13 @@ int nb_decode(void *state, SpeexBits *bits, void *vout)
|
|||
{
|
||||
int offset;
|
||||
spx_word16_t *sp;
|
||||
spx_word16_t *exc;
|
||||
//spx_word16_t *exc;
|
||||
/* Offset relative to start of frame */
|
||||
offset = st->subframeSize*sub;
|
||||
/* Original signal */
|
||||
sp=out+offset;
|
||||
/* Excitation */
|
||||
exc=st->exc+offset;
|
||||
//exc=st->exc+offset;
|
||||
|
||||
/* LSP interpolation (quantized and unquantized) */
|
||||
lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, st->lpcSize, sub, st->nbSubframes);
|
||||
|
|
|
@ -126,7 +126,7 @@ float vbr_analysis(VBRState *vbr, spx_word16_t *sig, int len, int pitch, float p
|
|||
int i;
|
||||
float ener=0, ener1=0, ener2=0;
|
||||
float qual=7;
|
||||
int va;
|
||||
//int va;
|
||||
float log_energy;
|
||||
float non_st=0;
|
||||
float voicing;
|
||||
|
@ -159,7 +159,7 @@ float vbr_analysis(VBRState *vbr, spx_word16_t *sig, int len, int pitch, float p
|
|||
|| (voicing<0 && non_st < .05))
|
||||
{
|
||||
float tmp;
|
||||
va = 0;
|
||||
//va = 0;
|
||||
vbr->consec_noise++;
|
||||
if (pow_ener > 3*vbr->noise_level)
|
||||
tmp = 3*vbr->noise_level;
|
||||
|
@ -171,7 +171,7 @@ float vbr_analysis(VBRState *vbr, spx_word16_t *sig, int len, int pitch, float p
|
|||
vbr->noise_accum_count = .95*vbr->noise_accum_count + .05;
|
||||
}
|
||||
} else {
|
||||
va = 1;
|
||||
//va = 1;
|
||||
vbr->consec_noise=0;
|
||||
}
|
||||
|
||||
|
|
|
@ -82,7 +82,7 @@ static void UI_DisplayDownloadInfo( const char *downloadName ) {
|
|||
downloadCount = trap_Cvar_VariableValue( "cl_downloadCount" );
|
||||
downloadTime = trap_Cvar_VariableValue( "cl_downloadTime" );
|
||||
|
||||
leftWidth = width = UI_ProportionalStringWidth( dlText ) * UI_ProportionalSizeScale( style );
|
||||
leftWidth = UI_ProportionalStringWidth( dlText ) * UI_ProportionalSizeScale( style );
|
||||
width = UI_ProportionalStringWidth( etaText ) * UI_ProportionalSizeScale( style );
|
||||
if (width > leftWidth) leftWidth = width;
|
||||
width = UI_ProportionalStringWidth( xferText ) * UI_ProportionalSizeScale( style );
|
||||
|
|
|
@ -111,20 +111,6 @@ static void Demos_MenuEvent( void *ptr, int event ) {
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
=================
|
||||
UI_DemosMenu_Key
|
||||
=================
|
||||
*/
|
||||
static sfxHandle_t UI_DemosMenu_Key( int key ) {
|
||||
menucommon_s *item;
|
||||
|
||||
item = Menu_ItemAtCursor( &s_demos.menu );
|
||||
|
||||
return Menu_DefaultKey( &s_demos.menu, key );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
Demos_MenuInit
|
||||
|
@ -137,7 +123,6 @@ static void Demos_MenuInit( void ) {
|
|||
int protocol, protocolLegacy;
|
||||
|
||||
memset( &s_demos, 0 ,sizeof(demos_t) );
|
||||
s_demos.menu.key = UI_DemosMenu_Key;
|
||||
|
||||
Demos_Cache();
|
||||
|
||||
|
|
|
@ -623,7 +623,7 @@ void UI_SPSkillMenu_Cache( void );
|
|||
// ui_syscalls.c
|
||||
//
|
||||
void trap_Print( const char *string );
|
||||
void trap_Error( const char *string );
|
||||
void trap_Error( const char *string ) __attribute__((noreturn));
|
||||
int trap_Milliseconds( void );
|
||||
void trap_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
|
||||
void trap_Cvar_Update( vmCvar_t *vmCvar );
|
||||
|
|
|
@ -334,7 +334,6 @@ void MenuField_Draw( menufield_s *f )
|
|||
int x;
|
||||
int y;
|
||||
int w;
|
||||
int h;
|
||||
int style;
|
||||
qboolean focus;
|
||||
float *color;
|
||||
|
@ -345,13 +344,11 @@ void MenuField_Draw( menufield_s *f )
|
|||
if (f->generic.flags & QMF_SMALLFONT)
|
||||
{
|
||||
w = SMALLCHAR_WIDTH;
|
||||
h = SMALLCHAR_HEIGHT;
|
||||
style = UI_SMALLFONT;
|
||||
}
|
||||
else
|
||||
{
|
||||
w = BIGCHAR_WIDTH;
|
||||
h = BIGCHAR_HEIGHT;
|
||||
style = UI_BIGFONT;
|
||||
}
|
||||
|
||||
|
|
|
@ -739,13 +739,11 @@ void ArenaServers_LoadFavorites( void )
|
|||
int i;
|
||||
int j;
|
||||
int numtempitems;
|
||||
char emptyinfo[MAX_INFO_STRING];
|
||||
char adrstr[MAX_ADDRESSLENGTH];
|
||||
servernode_t templist[MAX_FAVORITESERVERS];
|
||||
qboolean found;
|
||||
|
||||
found = qfalse;
|
||||
emptyinfo[0] = '\0';
|
||||
|
||||
// copy the old
|
||||
memcpy( templist, g_favoriteserverlist, sizeof(servernode_t)*MAX_FAVORITESERVERS );
|
||||
|
|
|
@ -725,7 +725,6 @@ static void UI_SPLevelMenu_Init( void ) {
|
|||
skill = (int)trap_Cvar_VariableValue( "g_spSkill" );
|
||||
if( skill < 1 || skill > 5 ) {
|
||||
trap_Cvar_Set( "g_spSkill", "2" );
|
||||
skill = 2;
|
||||
}
|
||||
|
||||
memset( &levelMenuInfo, 0, sizeof(levelMenuInfo) );
|
||||
|
|
|
@ -138,7 +138,7 @@ void CMod_LoadSubmodels( lump_t *l ) {
|
|||
Com_Error( ERR_DROP, "MAX_SUBMODELS exceeded" );
|
||||
}
|
||||
|
||||
for ( i=0 ; i<count ; i++, in++, out++)
|
||||
for ( i=0 ; i<count ; i++, in++)
|
||||
{
|
||||
out = &cm.cmodels[i];
|
||||
|
||||
|
|
|
@ -732,7 +732,8 @@ get the first intersection of the ray with the sphere
|
|||
*/
|
||||
void CM_TraceThroughSphere( traceWork_t *tw, vec3_t origin, float radius, vec3_t start, vec3_t end ) {
|
||||
float l1, l2, length, scale, fraction;
|
||||
float a, b, c, d, sqrtd;
|
||||
//float a;
|
||||
float b, c, d, sqrtd;
|
||||
vec3_t v1, dir, intersection;
|
||||
|
||||
// if inside the sphere
|
||||
|
@ -768,7 +769,7 @@ void CM_TraceThroughSphere( traceWork_t *tw, vec3_t origin, float radius, vec3_t
|
|||
//
|
||||
VectorSubtract(start, origin, v1);
|
||||
// dir is normalized so a = 1
|
||||
a = 1.0f;//dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];
|
||||
//a = 1.0f;//dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];
|
||||
b = 2.0f * (dir[0] * v1[0] + dir[1] * v1[1] + dir[2] * v1[2]);
|
||||
c = v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] - (radius+RADIUS_EPSILON) * (radius+RADIUS_EPSILON);
|
||||
|
||||
|
@ -820,7 +821,8 @@ the cylinder extends halfheight above and below the origin
|
|||
*/
|
||||
void CM_TraceThroughVerticalCylinder( traceWork_t *tw, vec3_t origin, float radius, float halfheight, vec3_t start, vec3_t end) {
|
||||
float length, scale, fraction, l1, l2;
|
||||
float a, b, c, d, sqrtd;
|
||||
//float a;
|
||||
float b, c, d, sqrtd;
|
||||
vec3_t v1, dir, start2d, end2d, org2d, intersection;
|
||||
|
||||
// 2d coordinates
|
||||
|
@ -866,7 +868,7 @@ void CM_TraceThroughVerticalCylinder( traceWork_t *tw, vec3_t origin, float radi
|
|||
//
|
||||
VectorSubtract(start, origin, v1);
|
||||
// dir is normalized so we can use a = 1
|
||||
a = 1.0f;// * (dir[0] * dir[0] + dir[1] * dir[1]);
|
||||
//a = 1.0f;// * (dir[0] * dir[0] + dir[1] * dir[1]);
|
||||
b = 2.0f * (v1[0] * dir[0] + v1[1] * dir[1]);
|
||||
c = v1[0] * v1[0] + v1[1] * v1[1] - (radius+RADIUS_EPSILON) * (radius+RADIUS_EPSILON);
|
||||
|
||||
|
|
|
@ -269,7 +269,6 @@ void Cmd_Exec_f( void ) {
|
|||
char *c;
|
||||
void *v;
|
||||
} f;
|
||||
int len;
|
||||
char filename[MAX_QPATH];
|
||||
|
||||
if (Cmd_Argc () != 2) {
|
||||
|
@ -279,7 +278,7 @@ void Cmd_Exec_f( void ) {
|
|||
|
||||
Q_strncpyz( filename, Cmd_Argv(1), sizeof( filename ) );
|
||||
COM_DefaultExtension( filename, sizeof( filename ), ".cfg" );
|
||||
len = FS_ReadFile( filename, &f.v);
|
||||
FS_ReadFile( filename, &f.v);
|
||||
if (!f.c) {
|
||||
Com_Printf ("couldn't exec %s\n",Cmd_Argv(1));
|
||||
return;
|
||||
|
|
|
@ -930,10 +930,11 @@ Z_TagMalloc
|
|||
*/
|
||||
#ifdef ZONE_DEBUG
|
||||
void *Z_TagMallocDebug( int size, int tag, char *label, char *file, int line ) {
|
||||
int allocSize;
|
||||
#else
|
||||
void *Z_TagMalloc( int size, int tag ) {
|
||||
#endif
|
||||
int extra, allocSize;
|
||||
int extra;
|
||||
memblock_t *start, *rover, *new, *base;
|
||||
memzone_t *zone;
|
||||
|
||||
|
@ -948,7 +949,9 @@ void *Z_TagMalloc( int size, int tag ) {
|
|||
zone = mainzone;
|
||||
}
|
||||
|
||||
#ifdef ZONE_DEBUG
|
||||
allocSize = size;
|
||||
#endif
|
||||
//
|
||||
// scan through the block list looking for the first free block
|
||||
// of sufficient size
|
||||
|
@ -1087,7 +1090,10 @@ void Z_LogZoneHeap( memzone_t *zone, char *name ) {
|
|||
|
||||
if (!logfile || !FS_Initialized())
|
||||
return;
|
||||
size = allocSize = numBlocks = 0;
|
||||
size = numBlocks = 0;
|
||||
#ifdef ZONE_DEBUG
|
||||
allocSize = 0;
|
||||
#endif
|
||||
Com_sprintf(buf, sizeof(buf), "\r\n================\r\n%s log\r\n================\r\n", name);
|
||||
FS_Write(buf, strlen(buf), logfile);
|
||||
for (block = zone->blocklist.next ; block->next != &zone->blocklist; block = block->next) {
|
||||
|
@ -3105,7 +3111,6 @@ void Com_Frame( void ) {
|
|||
else
|
||||
minMsec = 1;
|
||||
|
||||
timeVal = 0;
|
||||
do
|
||||
{
|
||||
if(com_sv_running->integer)
|
||||
|
|
|
@ -2443,7 +2443,7 @@ int FS_GetModList( char *listbuf, int bufsize ) {
|
|||
qboolean bDrop = qfalse;
|
||||
|
||||
*listbuf = 0;
|
||||
nMods = nPotential = nTotal = 0;
|
||||
nMods = nTotal = 0;
|
||||
|
||||
pFiles0 = Sys_ListFiles( fs_homepath->string, NULL, NULL, &dummy, qtrue );
|
||||
pFiles1 = Sys_ListFiles( fs_basepath->string, NULL, NULL, &dummy, qtrue );
|
||||
|
@ -2946,7 +2946,7 @@ we are not interested in a download string format, we want something human-reada
|
|||
*/
|
||||
qboolean FS_ComparePaks( char *neededpaks, int len, qboolean dlstring ) {
|
||||
searchpath_t *sp;
|
||||
qboolean havepak, badchecksum;
|
||||
qboolean havepak;
|
||||
char *origpos = neededpaks;
|
||||
int i;
|
||||
|
||||
|
@ -2958,7 +2958,6 @@ qboolean FS_ComparePaks( char *neededpaks, int len, qboolean dlstring ) {
|
|||
for ( i = 0 ; i < fs_numServerReferencedPaks ; i++ )
|
||||
{
|
||||
// Ok, see if we have this pak file
|
||||
badchecksum = qfalse;
|
||||
havepak = qfalse;
|
||||
|
||||
// never autodownload any of the id paks
|
||||
|
|
|
@ -1208,7 +1208,6 @@ void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct p
|
|||
int ammobits;
|
||||
int powerupbits;
|
||||
int numFields;
|
||||
int c;
|
||||
netField_t *field;
|
||||
int *fromF, *toF;
|
||||
float fullFloat;
|
||||
|
@ -1219,8 +1218,6 @@ void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct p
|
|||
Com_Memset (&dummy, 0, sizeof(dummy));
|
||||
}
|
||||
|
||||
c = msg->cursize;
|
||||
|
||||
numFields = ARRAY_LEN( playerStateFields );
|
||||
|
||||
lc = 0;
|
||||
|
@ -1268,7 +1265,6 @@ void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct p
|
|||
MSG_WriteBits( msg, *toF, field->bits );
|
||||
}
|
||||
}
|
||||
c = msg->cursize - c;
|
||||
|
||||
|
||||
//
|
||||
|
|
|
@ -243,7 +243,6 @@ copied out.
|
|||
*/
|
||||
qboolean Netchan_Process( netchan_t *chan, msg_t *msg ) {
|
||||
int sequence;
|
||||
int qport;
|
||||
int fragmentStart, fragmentLength;
|
||||
qboolean fragmented;
|
||||
|
||||
|
@ -264,7 +263,7 @@ qboolean Netchan_Process( netchan_t *chan, msg_t *msg ) {
|
|||
|
||||
// read the qport if we are a server
|
||||
if ( chan->sock == NS_SERVER ) {
|
||||
qport = MSG_ReadShort( msg );
|
||||
MSG_ReadShort( msg );
|
||||
}
|
||||
|
||||
#ifdef LEGACY_PROTOCOL
|
||||
|
|
|
@ -1073,7 +1073,6 @@ NET_OpenSocks
|
|||
*/
|
||||
void NET_OpenSocks( int port ) {
|
||||
struct sockaddr_in address;
|
||||
int err;
|
||||
struct hostent *h;
|
||||
int len;
|
||||
qboolean rfc1929;
|
||||
|
@ -1084,14 +1083,12 @@ void NET_OpenSocks( int port ) {
|
|||
Com_Printf( "Opening connection to SOCKS server.\n" );
|
||||
|
||||
if ( ( socks_socket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) == INVALID_SOCKET ) {
|
||||
err = socketError;
|
||||
Com_Printf( "WARNING: NET_OpenSocks: socket: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
||||
h = gethostbyname( net_socksServer->string );
|
||||
if ( h == NULL ) {
|
||||
err = socketError;
|
||||
Com_Printf( "WARNING: NET_OpenSocks: gethostbyname: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1104,7 +1101,6 @@ void NET_OpenSocks( int port ) {
|
|||
address.sin_port = htons( (short)net_socksPort->integer );
|
||||
|
||||
if ( connect( socks_socket, (struct sockaddr *)&address, sizeof( address ) ) == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: connect: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1132,7 +1128,6 @@ void NET_OpenSocks( int port ) {
|
|||
buf[2] = 2; // method #2 - method id #02: username/password
|
||||
}
|
||||
if ( send( socks_socket, (void *)buf, len, 0 ) == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1140,7 +1135,6 @@ void NET_OpenSocks( int port ) {
|
|||
// get the response
|
||||
len = recv( socks_socket, (void *)buf, 64, 0 );
|
||||
if ( len == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1179,7 +1173,6 @@ void NET_OpenSocks( int port ) {
|
|||
|
||||
// send it
|
||||
if ( send( socks_socket, (void *)buf, 3 + ulen + plen, 0 ) == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1187,7 +1180,6 @@ void NET_OpenSocks( int port ) {
|
|||
// get the response
|
||||
len = recv( socks_socket, (void *)buf, 64, 0 );
|
||||
if ( len == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1209,7 +1201,6 @@ void NET_OpenSocks( int port ) {
|
|||
*(int *)&buf[4] = INADDR_ANY;
|
||||
*(short *)&buf[8] = htons( (short)port ); // port
|
||||
if ( send( socks_socket, (void *)buf, 10, 0 ) == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
@ -1217,7 +1208,6 @@ void NET_OpenSocks( int port ) {
|
|||
// get the response
|
||||
len = recv( socks_socket, (void *)buf, 64, 0 );
|
||||
if( len == SOCKET_ERROR ) {
|
||||
err = socketError;
|
||||
Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -419,8 +419,9 @@ int COM_Compress( char *data_p ) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
*out = 0;
|
||||
}
|
||||
*out = 0;
|
||||
return out - data_p;
|
||||
}
|
||||
|
||||
|
|
|
@ -1027,7 +1027,7 @@ void Key_WriteBindings( fileHandle_t f );
|
|||
void S_ClearSoundBuffer( void );
|
||||
// call before filesystem access
|
||||
|
||||
void SCR_DebugGraph (float value, int color); // FIXME: move logging to common?
|
||||
void SCR_DebugGraph (float value); // FIXME: move logging to common?
|
||||
|
||||
// AVI files have the start of pixel lines 4 byte-aligned
|
||||
#define AVI_LINE_PADDING 4
|
||||
|
@ -1089,7 +1089,7 @@ void *Sys_GetBotLibAPI( void *parms );
|
|||
|
||||
char *Sys_GetCurrentUser( void );
|
||||
|
||||
void QDECL Sys_Error( const char *error, ...) __attribute__ ((noreturn)) __attribute__ ((format (printf, 1, 2)));
|
||||
void QDECL Sys_Error( const char *error, ...) __attribute__ ((noreturn, format (printf, 1, 2)));
|
||||
void Sys_Quit (void) __attribute__ ((noreturn));
|
||||
char *Sys_GetClipboardData( void ); // note that this isn't journaled...
|
||||
|
||||
|
|
|
@ -217,7 +217,6 @@ VM_LoadSymbols
|
|||
===============
|
||||
*/
|
||||
void VM_LoadSymbols( vm_t *vm ) {
|
||||
int len;
|
||||
union {
|
||||
char *c;
|
||||
void *v;
|
||||
|
@ -239,7 +238,7 @@ void VM_LoadSymbols( vm_t *vm ) {
|
|||
|
||||
COM_StripExtension(vm->name, name, sizeof(name));
|
||||
Com_sprintf( symbols, sizeof( symbols ), "vm/%s.map", name );
|
||||
len = FS_ReadFile( symbols, &mapfile.v );
|
||||
FS_ReadFile( symbols, &mapfile.v );
|
||||
if ( !mapfile.c ) {
|
||||
Com_Printf( "Couldn't load symbol file: %s\n", symbols );
|
||||
return;
|
||||
|
@ -365,7 +364,6 @@ Load a .qvm file
|
|||
=================
|
||||
*/
|
||||
vmHeader_t *VM_LoadQVM( vm_t *vm, qboolean alloc ) {
|
||||
int length;
|
||||
int dataLength;
|
||||
int i;
|
||||
char filename[MAX_QPATH];
|
||||
|
@ -378,7 +376,7 @@ vmHeader_t *VM_LoadQVM( vm_t *vm, qboolean alloc ) {
|
|||
Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", vm->name );
|
||||
Com_Printf( "Loading vm file %s...\n", filename );
|
||||
|
||||
length = FS_ReadFileDir(filename, vm->searchPath, &header.v);
|
||||
FS_ReadFileDir(filename, vm->searchPath, &header.v);
|
||||
|
||||
if ( !header.h ) {
|
||||
Com_Printf( "Failed.\n" );
|
||||
|
|
|
@ -237,7 +237,6 @@ void VM_PrepareInterpreter( vm_t *vm, vmHeader_t *header ) {
|
|||
}
|
||||
int_pc = 0;
|
||||
instruction = 0;
|
||||
code = (byte *)header + header->codeOffset;
|
||||
|
||||
// Now that the code has been expanded to int-sized opcodes, we'll translate instruction index
|
||||
//into an index into codeBase[], which contains opcodes and operands.
|
||||
|
|
|
@ -1716,7 +1716,6 @@ int VM_CallCompiled(vm_t *vm, int *args)
|
|||
{
|
||||
byte stack[OPSTACK_SIZE + 15];
|
||||
void *entryPoint;
|
||||
int programCounter;
|
||||
int programStack, stackOnEntry;
|
||||
byte *image;
|
||||
int *opStack;
|
||||
|
@ -1733,8 +1732,6 @@ int VM_CallCompiled(vm_t *vm, int *args)
|
|||
// set up the stack frame
|
||||
image = vm->dataBase;
|
||||
|
||||
programCounter = 0;
|
||||
|
||||
programStack -= 48;
|
||||
|
||||
*(int *)&image[ programStack + 44] = args[9];
|
||||
|
|
|
@ -753,7 +753,7 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
|
|||
// we definately want to sync every frame for the cinematics
|
||||
qglFinish();
|
||||
|
||||
start = end = 0;
|
||||
start = 0;
|
||||
if ( r_speeds->integer ) {
|
||||
start = ri.Milliseconds();
|
||||
}
|
||||
|
|
|
@ -204,10 +204,9 @@ static int neighbors[8][2] = {
|
|||
VectorAdd( normal, sum, sum );
|
||||
count++;
|
||||
}
|
||||
if ( count == 0 ) {
|
||||
//printf("bad normal\n");
|
||||
count = 1;
|
||||
}
|
||||
//if ( count == 0 ) {
|
||||
// printf("bad normal\n");
|
||||
//}
|
||||
VectorNormalize2( sum, dv->normal );
|
||||
}
|
||||
}
|
||||
|
|
|
@ -114,7 +114,7 @@ This is called at surface tesselation time
|
|||
*/
|
||||
void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal ) {
|
||||
int i;
|
||||
flare_t *f, *oldest;
|
||||
flare_t *f;
|
||||
vec3_t local;
|
||||
float d = 1;
|
||||
vec4_t eye, clip, normalized, window;
|
||||
|
@ -152,7 +152,6 @@ void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t
|
|||
}
|
||||
|
||||
// see if a flare with a matching surface, scene, and view exists
|
||||
oldest = r_flareStructs;
|
||||
for ( f = r_activeFlares ; f ; f = f->next ) {
|
||||
if ( f->surface == surface && f->frameSceneNum == backEnd.viewParms.frameSceneNum
|
||||
&& f->inPortal == backEnd.viewParms.isPortal ) {
|
||||
|
|
|
@ -1098,14 +1098,11 @@ R_CreateFogImage
|
|||
static void R_CreateFogImage( void ) {
|
||||
int x,y;
|
||||
byte *data;
|
||||
float g;
|
||||
float d;
|
||||
float borderColor[4];
|
||||
|
||||
data = ri.Hunk_AllocateTempMemory( FOG_S * FOG_T * 4 );
|
||||
|
||||
g = 2.0;
|
||||
|
||||
// S is distance, T is depth
|
||||
for (x=0 ; x<FOG_S ; x++) {
|
||||
for (y=0 ; y<FOG_T ; y++) {
|
||||
|
|
|
@ -791,8 +791,6 @@ static uint8_t PredictPaeth(uint8_t a, uint8_t b, uint8_t c)
|
|||
int p;
|
||||
int pa, pb, pc;
|
||||
|
||||
Pr = 0;
|
||||
|
||||
p = ((int) a) + ((int) b) - ((int) c);
|
||||
pa = abs(p - ((int) a));
|
||||
pb = abs(p - ((int) b));
|
||||
|
|
|
@ -912,7 +912,6 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
|
|||
for ( i = 0; i < tess.numIndexes; i += 3 )
|
||||
{
|
||||
vec3_t normal;
|
||||
float dot;
|
||||
float len;
|
||||
|
||||
VectorSubtract( tess.xyz[tess.indexes[i]], tr.viewParms.or.origin, normal );
|
||||
|
@ -923,7 +922,7 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
|
|||
shortest = len;
|
||||
}
|
||||
|
||||
if ( ( dot = DotProduct( normal, tess.normal[tess.indexes[i]] ) ) >= 0 )
|
||||
if ( DotProduct( normal, tess.normal[tess.indexes[i]] ) >= 0 )
|
||||
{
|
||||
numTriangles--;
|
||||
}
|
||||
|
@ -1269,7 +1268,6 @@ void R_AddEntitySurfaces (void) {
|
|||
if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal) {
|
||||
break;
|
||||
}
|
||||
shader = R_GetShaderByHandle( ent->e.customShader );
|
||||
R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, 0 );
|
||||
break;
|
||||
default:
|
||||
|
|
|
@ -272,6 +272,10 @@ int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projectio
|
|||
vec3_t v1, v2;
|
||||
int *indexes;
|
||||
|
||||
if (numPoints <= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
//increment view count for double check prevention
|
||||
tr.viewCount++;
|
||||
|
||||
|
|
|
@ -931,7 +931,7 @@ static qboolean R_LoadMD4( model_t *mod, void *buffer, const char *mod_name ) {
|
|||
|
||||
// swap all the frames
|
||||
frameSize = (size_t)( &((md4Frame_t *)0)->bones[ md4->numBones ] );
|
||||
for ( i = 0 ; i < md4->numFrames ; i++, frame++) {
|
||||
for ( i = 0 ; i < md4->numFrames ; i++) {
|
||||
frame = (md4Frame_t *) ( (byte *)md4 + md4->ofsFrames + i * frameSize );
|
||||
frame->radius = LittleFloat( frame->radius );
|
||||
for ( j = 0 ; j < 3 ; j++ ) {
|
||||
|
|
|
@ -885,8 +885,8 @@ static void ComputeJointMats( iqmData_t *data, int frame, int oldframe,
|
|||
int *joint = data->jointParents;
|
||||
int i;
|
||||
|
||||
if ( oldframe == frame ) {
|
||||
mat1 = mat2 = data->poseMats + 12 * data->num_joints * frame;
|
||||
if ( oldframe == frame ) {
|
||||
mat1 = data->poseMats + 12 * data->num_joints * frame;
|
||||
for( i = 0; i < data->num_joints; i++, joint++ ) {
|
||||
if( *joint >= 0 ) {
|
||||
Matrix34Multiply( mat + 12 * *joint,
|
||||
|
|
|
@ -109,7 +109,7 @@ typedef struct {
|
|||
void (QDECL *Printf)( int printLevel, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
|
||||
|
||||
// abort the game
|
||||
void (QDECL *Error)( int errorLevel, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
|
||||
void (QDECL *Error)( int errorLevel, const char *fmt, ...) __attribute__ ((noreturn, format (printf, 2, 3)));
|
||||
|
||||
// milliseconds should only be used for profiling, never
|
||||
// for anything game related. Get time from the refdef
|
||||
|
|
|
@ -1174,8 +1174,10 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
|
|||
void RB_StageIteratorGeneric( void )
|
||||
{
|
||||
shaderCommands_t *input;
|
||||
shader_t *shader;
|
||||
|
||||
input = &tess;
|
||||
shader = input->shader;
|
||||
|
||||
RB_DeformTessGeometry();
|
||||
|
||||
|
@ -1192,10 +1194,10 @@ void RB_StageIteratorGeneric( void )
|
|||
//
|
||||
// set face culling appropriately
|
||||
//
|
||||
GL_Cull( input->shader->cullType );
|
||||
GL_Cull( shader->cullType );
|
||||
|
||||
// set polygon offset if necessary
|
||||
if ( input->shader->polygonOffset )
|
||||
if ( shader->polygonOffset )
|
||||
{
|
||||
qglEnable( GL_POLYGON_OFFSET_FILL );
|
||||
qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
|
||||
|
@ -1207,7 +1209,7 @@ void RB_StageIteratorGeneric( void )
|
|||
// to avoid compiling those arrays since they will change
|
||||
// during multipass rendering
|
||||
//
|
||||
if ( tess.numPasses > 1 || input->shader->multitextureEnv )
|
||||
if ( tess.numPasses > 1 || shader->multitextureEnv )
|
||||
{
|
||||
setArraysOnce = qfalse;
|
||||
qglDisableClientState (GL_COLOR_ARRAY);
|
||||
|
@ -1275,7 +1277,7 @@ void RB_StageIteratorGeneric( void )
|
|||
//
|
||||
// reset polygon offset
|
||||
//
|
||||
if ( input->shader->polygonOffset )
|
||||
if ( shader->polygonOffset )
|
||||
{
|
||||
qglDisable( GL_POLYGON_OFFSET_FILL );
|
||||
}
|
||||
|
@ -1291,7 +1293,6 @@ void RB_StageIteratorVertexLitTexture( void )
|
|||
shader_t *shader;
|
||||
|
||||
input = &tess;
|
||||
|
||||
shader = input->shader;
|
||||
|
||||
//
|
||||
|
@ -1312,7 +1313,7 @@ void RB_StageIteratorVertexLitTexture( void )
|
|||
//
|
||||
// set face culling appropriately
|
||||
//
|
||||
GL_Cull( input->shader->cullType );
|
||||
GL_Cull( shader->cullType );
|
||||
|
||||
//
|
||||
// set arrays and lock
|
||||
|
@ -1365,8 +1366,10 @@ void RB_StageIteratorVertexLitTexture( void )
|
|||
|
||||
void RB_StageIteratorLightmappedMultitexture( void ) {
|
||||
shaderCommands_t *input;
|
||||
shader_t *shader;
|
||||
|
||||
input = &tess;
|
||||
shader = input->shader;
|
||||
|
||||
//
|
||||
// log this call
|
||||
|
@ -1380,7 +1383,7 @@ void RB_StageIteratorLightmappedMultitexture( void ) {
|
|||
//
|
||||
// set face culling appropriately
|
||||
//
|
||||
GL_Cull( input->shader->cullType );
|
||||
GL_Cull( shader->cullType );
|
||||
|
||||
//
|
||||
// set color, pointers, and lock
|
||||
|
|
|
@ -634,7 +634,7 @@ void RB_CalcColorFromOneMinusEntity( unsigned char *dstColors )
|
|||
|
||||
for ( i = 0; i < tess.numVertexes; i++, pColors++ )
|
||||
{
|
||||
*pColors = * ( int * ) invModulate;
|
||||
*pColors = c;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -618,14 +618,14 @@ void R_BuildCloudData( shaderCommands_t *input )
|
|||
tess.numIndexes = 0;
|
||||
tess.numVertexes = 0;
|
||||
|
||||
if ( input->shader->sky.cloudHeight )
|
||||
if ( shader->sky.cloudHeight )
|
||||
{
|
||||
for ( i = 0; i < MAX_SHADER_STAGES; i++ )
|
||||
{
|
||||
if ( !tess.xstages[i] ) {
|
||||
break;
|
||||
}
|
||||
FillCloudBox( input->shader, i );
|
||||
FillCloudBox( shader, i );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -928,10 +928,6 @@ static void RB_SurfaceFace( srfSurfaceFace_t *surf ) {
|
|||
|
||||
tess.numIndexes += surf->numIndices;
|
||||
|
||||
v = surf->points[0];
|
||||
|
||||
ndx = tess.numVertexes;
|
||||
|
||||
numPoints = surf->numPoints;
|
||||
|
||||
if ( tess.shader->needsNormal ) {
|
||||
|
@ -1046,7 +1042,6 @@ static void RB_SurfaceGrid( srfGridMesh_t *cv ) {
|
|||
// in the tess structure, so we may have to issue it in multiple passes
|
||||
|
||||
used = 0;
|
||||
rows = 0;
|
||||
while ( used < lodHeight - 1 ) {
|
||||
// see how many rows of both verts and indexes we can add without overflowing
|
||||
do {
|
||||
|
|
|
@ -63,7 +63,6 @@ static qboolean R_CullGrid( srfGridMesh_t *cv ) {
|
|||
} else {
|
||||
sphereCull = R_CullPointAndRadius( cv->localOrigin, cv->meshRadius );
|
||||
}
|
||||
boxCull = CULL_OUT;
|
||||
|
||||
// check for trivial reject
|
||||
if ( sphereCull == CULL_OUT )
|
||||
|
|
|
@ -1213,7 +1213,6 @@ static void SV_VerifyPaks_f( client_t *cl ) {
|
|||
//
|
||||
if ( sv_pure->integer != 0 ) {
|
||||
|
||||
bGood = qtrue;
|
||||
nChkSum1 = nChkSum2 = 0;
|
||||
// we run the game, so determine which cgame and ui the client "should" be running
|
||||
bGood = (FS_FileIsInPAK("vm/cgame.qvm", &nChkSum1) == 1);
|
||||
|
|
|
@ -382,9 +382,6 @@ SV_AreaEntities_r
|
|||
static void SV_AreaEntities_r( worldSector_t *node, areaParms_t *ap ) {
|
||||
svEntity_t *check, *next;
|
||||
sharedEntity_t *gcheck;
|
||||
int count;
|
||||
|
||||
count = 0;
|
||||
|
||||
for ( check = node->entities ; check ; check = next ) {
|
||||
next = check->nextEntityInWorldSector;
|
||||
|
@ -680,7 +677,7 @@ int SV_PointContents( const vec3_t p, int passEntityNum ) {
|
|||
angles = vec3_origin; // boxes don't rotate
|
||||
}
|
||||
|
||||
c2 = CM_TransformedPointContents (p, clipHandle, hit->s.origin, hit->s.angles);
|
||||
c2 = CM_TransformedPointContents (p, clipHandle, hit->s.origin, angles);
|
||||
|
||||
contents |= c2;
|
||||
}
|
||||
|
|
|
@ -405,9 +405,9 @@ char **Sys_ListFiles( const char *directory, const char *extension, char *filter
|
|||
continue;
|
||||
|
||||
if (*extension) {
|
||||
if ( strlen( d->d_name ) < strlen( extension ) ||
|
||||
if ( strlen( d->d_name ) < extLen ||
|
||||
Q_stricmp(
|
||||
d->d_name + strlen( d->d_name ) - strlen( extension ),
|
||||
d->d_name + strlen( d->d_name ) - extLen,
|
||||
extension ) ) {
|
||||
continue; // didn't match
|
||||
}
|
||||
|
|
|
@ -5018,7 +5018,6 @@ UI_Init
|
|||
*/
|
||||
void _UI_Init( qboolean inGameLoad ) {
|
||||
const char *menuSet;
|
||||
int start;
|
||||
|
||||
//uiInfo.inGameLoad = inGameLoad;
|
||||
|
||||
|
@ -5102,8 +5101,6 @@ void _UI_Init( qboolean inGameLoad ) {
|
|||
|
||||
AssetCache();
|
||||
|
||||
start = trap_Milliseconds();
|
||||
|
||||
uiInfo.teamCount = 0;
|
||||
uiInfo.characterCount = 0;
|
||||
uiInfo.aliasCount = 0;
|
||||
|
@ -5493,9 +5490,6 @@ void UI_DrawConnectScreen( qboolean overlay ) {
|
|||
yStart = 130;
|
||||
scale = 0.5f;
|
||||
} else {
|
||||
centerPoint = 320;
|
||||
yStart = 32;
|
||||
scale = 0.6f;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -246,6 +246,7 @@ void String_Init(void) {
|
|||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
/*
|
||||
=================
|
||||
PC_SourceWarning
|
||||
|
@ -267,6 +268,7 @@ static __attribute__ ((format (printf, 2, 3))) void PC_SourceWarning(int handle,
|
|||
|
||||
Com_Printf(S_COLOR_YELLOW "WARNING: %s, line %d: %s\n", filename, line, string);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
=================
|
||||
|
@ -1528,12 +1530,8 @@ int Item_Slider_OverSlider(itemDef_t *item, float x, float y) {
|
|||
|
||||
int Item_ListBox_OverLB(itemDef_t *item, float x, float y) {
|
||||
rectDef_t r;
|
||||
listBoxDef_t *listPtr;
|
||||
int thumbstart;
|
||||
int count;
|
||||
|
||||
count = DC->feederCount(item->special);
|
||||
listPtr = (listBoxDef_t*)item->typeData;
|
||||
if (item->window.flags & WINDOW_HORIZONTAL) {
|
||||
// check if on left arrow
|
||||
r.x = item->window.rect.x;
|
||||
|
@ -2592,16 +2590,9 @@ static rectDef_t *Item_CorrectedTextRect(itemDef_t *item) {
|
|||
void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) {
|
||||
int i;
|
||||
itemDef_t *item = NULL;
|
||||
qboolean inHandler = qfalse;
|
||||
|
||||
if (inHandler) {
|
||||
return;
|
||||
}
|
||||
|
||||
inHandler = qtrue;
|
||||
if (g_waitingForKey && down) {
|
||||
Item_Bind_HandleKey(g_bindItem, key, down);
|
||||
inHandler = qfalse;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -2609,7 +2600,6 @@ void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) {
|
|||
if (!Item_TextField_HandleKey(g_editItem, key)) {
|
||||
g_editingField = qfalse;
|
||||
g_editItem = NULL;
|
||||
inHandler = qfalse;
|
||||
return;
|
||||
} else if (key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3) {
|
||||
g_editingField = qfalse;
|
||||
|
@ -2621,18 +2611,16 @@ void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) {
|
|||
}
|
||||
|
||||
if (menu == NULL) {
|
||||
inHandler = qfalse;
|
||||
return;
|
||||
}
|
||||
|
||||
// see if the mouse is within the window bounds and if so is this a mouse click
|
||||
// see if the mouse is within the window bounds and if so is this a mouse click
|
||||
if (down && !(menu->window.flags & WINDOW_POPUP) && !Rect_ContainsPoint(&menu->window.rect, DC->cursorx, DC->cursory)) {
|
||||
static qboolean inHandleKey = qfalse;
|
||||
if (!inHandleKey && ( key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3 ) ) {
|
||||
inHandleKey = qtrue;
|
||||
Menus_HandleOOBClick(menu, key, down);
|
||||
inHandleKey = qfalse;
|
||||
inHandler = qfalse;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -2647,13 +2635,11 @@ void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) {
|
|||
if (item != NULL) {
|
||||
if (Item_HandleKey(item, key, down)) {
|
||||
Item_Action(item);
|
||||
inHandler = qfalse;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (!down) {
|
||||
inHandler = qfalse;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -2744,7 +2730,6 @@ void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) {
|
|||
}
|
||||
break;
|
||||
}
|
||||
inHandler = qfalse;
|
||||
}
|
||||
|
||||
void ToWindowCoords(float *x, float *y, windowDef_t *window) {
|
||||
|
@ -3036,8 +3021,6 @@ void Item_TextField_Paint(itemDef_t *item) {
|
|||
DC->getCVarString(item->cvar, buff, sizeof(buff));
|
||||
}
|
||||
|
||||
parent = (menuDef_t*)item->parent;
|
||||
|
||||
if (item->window.flags & WINDOW_HASFOCUS) {
|
||||
lowLight[0] = 0.8 * parent->focusColor[0];
|
||||
lowLight[1] = 0.8 * parent->focusColor[1];
|
||||
|
@ -3375,11 +3358,9 @@ void BindingFromName(const char *cvar) {
|
|||
|
||||
void Item_Slider_Paint(itemDef_t *item) {
|
||||
vec4_t newColor, lowLight;
|
||||
float x, y, value;
|
||||
float x, y;
|
||||
menuDef_t *parent = (menuDef_t*)item->parent;
|
||||
|
||||
value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
|
||||
|
||||
if (item->window.flags & WINDOW_HASFOCUS) {
|
||||
lowLight[0] = 0.8 * parent->focusColor[0];
|
||||
lowLight[1] = 0.8 * parent->focusColor[1];
|
||||
|
@ -3402,12 +3383,10 @@ void Item_Slider_Paint(itemDef_t *item) {
|
|||
|
||||
x = Item_Slider_ThumbPosition(item);
|
||||
DC->drawHandlePic( x - (SLIDER_THUMB_WIDTH / 2), y - 2, SLIDER_THUMB_WIDTH, SLIDER_THUMB_HEIGHT, DC->Assets.sliderThumb );
|
||||
|
||||
}
|
||||
|
||||
void Item_Bind_Paint(itemDef_t *item) {
|
||||
vec4_t newColor, lowLight;
|
||||
float value;
|
||||
int maxChars = 0;
|
||||
menuDef_t *parent = (menuDef_t*)item->parent;
|
||||
editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
|
||||
|
@ -3415,8 +3394,6 @@ void Item_Bind_Paint(itemDef_t *item) {
|
|||
maxChars = editPtr->maxPaintChars;
|
||||
}
|
||||
|
||||
value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
|
||||
|
||||
if (item->window.flags & WINDOW_HASFOCUS) {
|
||||
if (g_bindItem == item) {
|
||||
lowLight[0] = 0.8f * 1.0f;
|
||||
|
@ -3439,7 +3416,7 @@ void Item_Bind_Paint(itemDef_t *item) {
|
|||
BindingFromName(item->cvar);
|
||||
DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, g_nameBind1, 0, maxChars, item->textStyle);
|
||||
} else {
|
||||
DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, (value != 0) ? "FIXME" : "FIXME", 0, maxChars, item->textStyle);
|
||||
DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, "FIXME", 0, maxChars, item->textStyle);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -3644,7 +3621,8 @@ void Item_Image_Paint(itemDef_t *item) {
|
|||
}
|
||||
|
||||
void Item_ListBox_Paint(itemDef_t *item) {
|
||||
float x, y, size, count, i, thumb;
|
||||
float x, y, size, thumb;
|
||||
int count, i;
|
||||
qhandle_t image;
|
||||
qhandle_t optionalImage;
|
||||
listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
|
||||
|
@ -3797,12 +3775,9 @@ void Item_ListBox_Paint(itemDef_t *item) {
|
|||
|
||||
|
||||
void Item_OwnerDraw_Paint(itemDef_t *item) {
|
||||
menuDef_t *parent;
|
||||
|
||||
if (item == NULL) {
|
||||
return;
|
||||
}
|
||||
parent = (menuDef_t*)item->parent;
|
||||
|
||||
if (DC->ownerDrawItem) {
|
||||
vec4_t color, lowLight;
|
||||
|
|
|
@ -354,7 +354,7 @@ typedef struct {
|
|||
void (*getBindingBuf)( int keynum, char *buf, int buflen );
|
||||
void (*setBinding)( int keynum, const char *binding );
|
||||
void (*executeText)(int exec_when, const char *text );
|
||||
void (*Error)(int level, const char *error, ...) __attribute__ ((format (printf, 2, 3)));
|
||||
void (*Error)(int level, const char *error, ...) __attribute__ ((noreturn, format (printf, 2, 3)));
|
||||
void (*Print)(const char *msg, ...) __attribute__ ((format (printf, 1, 2)));
|
||||
void (*Pause)(qboolean b);
|
||||
int (*ownerDrawWidth)(int ownerDraw, float scale);
|
||||
|
|
Loading…
Reference in a new issue