FWGS/cs16-client-legacy
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3157d15c37
cs16-client-legacy/pm_shared/pm_shared.c

2789 lines
55 KiB
C
Raw Normal View History

CP1251->UTF-8
2016-03-05 20:29:55 +01:00
/***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
#include <assert.h>
#include "mathlib.h"
#include "const.h"
#include "usercmd.h"
#include "pm_defs.h"
#include "pm_shared.h"
#include "pm_movevars.h"
#include "pm_debug.h"
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#ifdef CLIENT_DLL
int iJumpSpectator;
float vJumpOrigin[3];
float vJumpAngles[3];
#endif
static int pm_shared_initialized = 0;
#ifdef _MSC_VER
#pragma warning(disable:4101)
#pragma warning(disable:4305)
#endif
typedef enum
{
mod_brush,
mod_sprite,
mod_alias,
mod_studio
}
modtype_t;
playermove_t *pmove = NULL;
typedef struct
{
int planenum;
short children[2];
}
dclipnode_t;
typedef struct mplane_s
{
vec3_t normal;
float dist;
byte type;
byte signbits;
byte pad[2];
}
mplane_t;
typedef struct hull_s
{
dclipnode_t *clipnodes;
mplane_t *planes;
int firstclipnode;
int lastclipnode;
vec3_t clip_mins;
vec3_t clip_maxs;
}
hull_t;
#define TIME_TO_DUCK 0.4
#define VEC_DUCK_HULL_MIN -18
#define VEC_DUCK_HULL_MAX 32
#define VEC_DUCK_VIEW 12
#define PM_DEAD_VIEWHEIGHT -8
#define MAX_CLIMB_SPEED 200
#define STUCK_MOVEUP 1
#define STUCK_MOVEDOWN -1
#define VEC_HULL_MIN -36
#define VEC_HULL_MAX 36
#define VEC_VIEW 17
#define STOP_EPSILON 0.1
#define CTEXTURESMAX 1024
#define CBTEXTURENAMEMAX 17
#define CHAR_TEX_CONCRETE 'C'
#define CHAR_TEX_METAL 'M'
#define CHAR_TEX_DIRT 'D'
#define CHAR_TEX_VENT 'V'
#define CHAR_TEX_GRATE 'G'
#define CHAR_TEX_TILE 'T'
#define CHAR_TEX_SLOSH 'S'
#define CHAR_TEX_WOOD 'W'
#define CHAR_TEX_COMPUTER 'P'
#define CHAR_TEX_GLASS 'Y'
#define CHAR_TEX_FLESH 'F'
#define CHAR_TEX_SNOW 'N'
#define STEP_CONCRETE 0
#define STEP_METAL 1
#define STEP_DIRT 2
#define STEP_VENT 3
#define STEP_GRATE 4
#define STEP_TILE 5
#define STEP_SLOSH 6
#define STEP_WADE 7
#define STEP_LADDER 8
#define STEP_SNOW 9
#define PLAYER_FATAL_FALL_SPEED 1024
#define PLAYER_MAX_SAFE_FALL_SPEED 580
#define DAMAGE_FOR_FALL_SPEED (float)100 / (PLAYER_FATAL_FALL_SPEED - PLAYER_MAX_SAFE_FALL_SPEED)
#define PLAYER_MIN_BOUNCE_SPEED 350
#define PLAYER_FALL_PUNCH_THRESHHOLD (float)250
#define PLAYER_LONGJUMP_SPEED 350
cs16-client now compiles with -Wall
2016-03-12 21:45:33 +01:00
#ifdef MSC_VER
CP1251->UTF-8
2016-03-05 20:29:55 +01:00
#pragma warning(disable : 4244)
cs16-client now compiles with -Wall
2016-03-12 21:45:33 +01:00
#endif
CP1251->UTF-8
2016-03-05 20:29:55 +01:00
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define PITCH 0
#define YAW 1
#define ROLL 2
#define MAX_CLIENTS 32
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
static vec3_t rgv3tStuckTable[54];
static int rgStuckLast[MAX_CLIENTS][2];
static int gcTextures = 0;
static char grgszTextureName[CTEXTURESMAX][CBTEXTURENAMEMAX];
static char grgchTextureType[CTEXTURESMAX];
int g_onladder = 0;
void PM_SwapTextures(int i, int j)
{
char chTemp;
char szTemp[CBTEXTURENAMEMAX];
strcpy(szTemp, grgszTextureName[i]);
chTemp = grgchTextureType[i];
strcpy(grgszTextureName[i], grgszTextureName[j]);
grgchTextureType[i] = grgchTextureType[j];
strcpy(grgszTextureName[j], szTemp);
grgchTextureType[j] = chTemp;
}
void PM_SortTextures(void)
{
int i, j;
for (i = 0 ; i < gcTextures; i++)
{
for (j = i + 1; j < gcTextures; j++)
{
if (stricmp(grgszTextureName[i], grgszTextureName[j]) > 0)
PM_SwapTextures(i, j);
}
}
}
void PM_InitTextureTypes(void)
{
char buffer[512];
int i, j;
byte *pMemFile;
int fileSize, filePos = 0;
static qboolean bTextureTypeInit = false;
if (bTextureTypeInit)
return;
memset(&(grgszTextureName[0][0]), 0, CTEXTURESMAX * CBTEXTURENAMEMAX);
memset(grgchTextureType, 0, CTEXTURESMAX);
gcTextures = 0;
memset(buffer, 0, 512);
fileSize = pmove->COM_FileSize("sound/materials.txt");
pMemFile = pmove->COM_LoadFile("sound/materials.txt", 5, NULL);
if (!pMemFile)
return;
filePos = 0;
while (pmove->memfgets(pMemFile, fileSize, &filePos, buffer, 511) != NULL && (gcTextures < CTEXTURESMAX))
{
i = 0;
while (buffer[i] && isspace(buffer[i]))
i++;
if (!buffer[i])
continue;
if (buffer[i] == '/' || !isalpha(buffer[i]))
continue;
grgchTextureType[gcTextures] = toupper(buffer[i++]);
while (buffer[i] && isspace(buffer[i]))
i++;
if (!buffer[i])
continue;
j = i;
while (buffer[j] && !isspace(buffer[j]))
j++;
if (!buffer[j])
continue;
j = min (j, CBTEXTURENAMEMAX - 1 + i);
buffer[j] = 0;
strcpy(&(grgszTextureName[gcTextures++][0]), &(buffer[i]));
}
pmove->COM_FreeFile(pMemFile);
PM_SortTextures();
bTextureTypeInit = true;
}
char PM_FindTextureType(char *name)
{
int left, right, pivot;
int val;
assert(pm_shared_initialized);
left = 0;
right = gcTextures - 1;
while (left <= right)
{
pivot = (left + right) / 2;
val = strnicmp(name, grgszTextureName[pivot], CBTEXTURENAMEMAX - 1);
if (val == 0)
{
return grgchTextureType[pivot];
}
else if (val > 0)
{
left = pivot + 1;
}
else if (val < 0)
{
right = pivot - 1;
}
}
return CHAR_TEX_CONCRETE;
}
void PM_PlayStepSound(int step, float fvol)
{
static int iSkipStep = 0;
int irand;
pmove->iStepLeft = !pmove->iStepLeft;
if (!pmove->runfuncs)
return;
irand = pmove->RandomLong(0, 1) + (pmove->iStepLeft * 2);
if (pmove->multiplayer && !pmove->movevars->footsteps)
return;
switch (step)
{
default:
case STEP_CONCRETE:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_step1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_step3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_step2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_step4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_METAL:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_metal1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_metal3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_metal2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_metal4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_DIRT:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_dirt1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_dirt3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_dirt2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_dirt4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_VENT:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_duct1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_duct3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_duct2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_duct4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_GRATE:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_grate1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_grate3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_grate2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_grate4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_TILE:
{
if (!pmove->RandomLong(0, 4))
irand = 4;
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_tile1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_tile3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_tile2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_tile4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 4: pmove->PM_PlaySound(CHAN_BODY, "player/pl_tile5.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_SLOSH:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_slosh1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_slosh3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_slosh2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_slosh4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_WADE:
{
if (iSkipStep == 0)
{
iSkipStep++;
break;
}
if (iSkipStep++ == 3)
iSkipStep = 0;
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_LADDER:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_ladder1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_ladder3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_ladder2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_ladder4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
case STEP_SNOW:
{
switch (irand)
{
case 0: pmove->PM_PlaySound(CHAN_BODY, "player/pl_snow1.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 1: pmove->PM_PlaySound(CHAN_BODY, "player/pl_snow3.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 2: pmove->PM_PlaySound(CHAN_BODY, "player/pl_snow2.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
case 3: pmove->PM_PlaySound(CHAN_BODY, "player/pl_snow4.wav", fvol, ATTN_NORM, 0, PITCH_NORM); break;
}
break;
}
}
}
int PM_MapTextureTypeStepType( char chTextureType)
{
switch (chTextureType)
{
default:
case CHAR_TEX_CONCRETE: return STEP_CONCRETE;
case CHAR_TEX_METAL: return STEP_METAL;
case CHAR_TEX_DIRT: return STEP_DIRT;
case CHAR_TEX_VENT: return STEP_VENT;
case CHAR_TEX_GRATE: return STEP_GRATE;
case CHAR_TEX_TILE: return STEP_TILE;
case CHAR_TEX_SLOSH: return STEP_SLOSH;
case CHAR_TEX_SNOW: return STEP_SNOW;
}
}
void PM_CatagorizeTextureType(void)
{
vec3_t start, end;
const char *pTextureName;
VectorCopy(pmove->origin, start);
VectorCopy(pmove->origin, end);
end[2] -= 64;
pmove->sztexturename[0] = '\0';
pmove->chtexturetype = CHAR_TEX_CONCRETE;
pTextureName = pmove->PM_TraceTexture(pmove->onground, start, end);
if (!pTextureName)
return;
if (*pTextureName == '-' || *pTextureName == '+')
pTextureName += 2;
if (*pTextureName == '{' || *pTextureName == '!' || *pTextureName == '~' || *pTextureName == ' ')
pTextureName++;
strcpy(pmove->sztexturename, pTextureName);
pmove->sztexturename[CBTEXTURENAMEMAX - 1] = 0;
pmove->chtexturetype = PM_FindTextureType(pmove->sztexturename);
}
void PM_UpdateStepSound(void)
{
float fvol;
vec3_t knee;
vec3_t feet;
float height;
float speed;
int fLadder;
int step;
if (pmove->flTimeStepSound > 0)
return;
if (pmove->flags & FL_FROZEN)
return;
speed = Length(pmove->velocity);
if (speed < 150)
{
pmove->flTimeStepSound = 400;
return;
}
fLadder = (pmove->movetype == MOVETYPE_FLY);
if (fLadder || (pmove->onground != -1))
{
PM_CatagorizeTextureType();
VectorCopy(pmove->origin, knee);
VectorCopy(pmove->origin, feet);
height = pmove->player_maxs[pmove->usehull][2] - pmove->player_mins[pmove->usehull][2];
knee[2] = pmove->origin[2] - 0.3 * height;
feet[2] = pmove->origin[2] - 0.5 * height;
if (fLadder)
{
step = STEP_LADDER;
fvol = 0.35;
pmove->flTimeStepSound = 350;
}
else if (pmove->PM_PointContents(knee, NULL) == CONTENTS_WATER)
{
step = STEP_WADE;
fvol = 0.65;
pmove->flTimeStepSound = 600;
}
else if (pmove->PM_PointContents(feet, NULL) == CONTENTS_WATER)
{
step = STEP_SLOSH;
fvol = 0.5;
pmove->flTimeStepSound = 300;
}
else
{
step = PM_MapTextureTypeStepType(pmove->chtexturetype);
switch (pmove->chtexturetype)
{
case CHAR_TEX_CONCRETE:
{
fvol = 0.5;
pmove->flTimeStepSound = 300;
break;
}
case CHAR_TEX_METAL:
{
fvol = 0.5;
pmove->flTimeStepSound = 300;
break;
}
case CHAR_TEX_DIRT:
{
fvol = 0.55;
pmove->flTimeStepSound = 300;
break;
}
case CHAR_TEX_VENT:
{
fvol = 0.7;
pmove->flTimeStepSound = 300;
break;
}
default:
{
fvol = 0.5;
break;
}
case CHAR_TEX_GRATE:
{
fvol = 0.5;
pmove->flTimeStepSound = 300;
break;
}
case CHAR_TEX_TILE:
{
fvol = 0.5;
pmove->flTimeStepSound = 300;
break;
}
case CHAR_TEX_SLOSH:
{
fvol = 0.5;
pmove->flTimeStepSound = 300;
break;
}
case CHAR_TEX_SNOW:
{
fvol = 0.5;
pmove->flTimeStepSound = 300;
break;
}
pmove->flTimeStepSound = 300;
}
}
if (pmove->flags & FL_DUCKING || fLadder)
{
pmove->flTimeStepSound += 100;
if (pmove->flags & FL_DUCKING && pmove->flDuckTime < 950.0)
fvol *= 0.35;
}
PM_PlayStepSound(step, fvol);
}
}
qboolean PM_AddToTouched(pmtrace_t tr, vec3_t impactvelocity)
{
int i;
for (i = 0; i < pmove->numtouch; i++)
{
if (pmove->touchindex[i].ent == tr.ent)
break;
}
if (i != pmove->numtouch)
return false;
VectorCopy(impactvelocity, tr.deltavelocity);
if (pmove->numtouch >= MAX_PHYSENTS)
pmove->Con_DPrintf("Too many entities were touched!\n");
pmove->touchindex[pmove->numtouch++] = tr;
return true;
}
void PM_CheckVelocity(void)
{
int i;
for (i = 0; i < 3; i++)
{
if (IS_NAN(pmove->velocity[i]))
{
pmove->Con_Printf("PM Got a NaN velocity %i\n", i);
pmove->velocity[i] = 0;
}
if (IS_NAN(pmove->origin[i]))
{
pmove->Con_Printf("PM Got a NaN origin on %i\n", i);
pmove->origin[i] = 0;
}
if (pmove->velocity[i] > pmove->movevars->maxvelocity)
{
pmove->Con_DPrintf("PM Got a velocity too high on %i\n", i);
pmove->velocity[i] = pmove->movevars->maxvelocity;
}
else if (pmove->velocity[i] < -pmove->movevars->maxvelocity)
{
pmove->Con_DPrintf("PM Got a velocity too low on %i\n", i);
pmove->velocity[i] = -pmove->movevars->maxvelocity;
}
}
}
int PM_ClipVelocity(vec3_t in, vec3_t normal, vec3_t out, float overbounce)
{
float backoff;
float change;
float angle;
int i, blocked;
angle = normal[2];
blocked = 0x00;
if (angle > 0)
blocked |= 0x01;
if (!angle)
blocked |= 0x02;
backoff = DotProduct(in, normal) * overbounce;
for (i = 0; i < 3; i++)
{
change = normal[i] * backoff;
out[i] = in[i] - change;
if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
out[i] = 0;
}
return blocked;
}
void PM_AddCorrectGravity(void)
{
float ent_gravity;
if (pmove->waterjumptime)
return;
if (pmove->gravity)
ent_gravity = pmove->gravity;
else
ent_gravity = 1.0;
pmove->velocity[2] -= (ent_gravity * pmove->movevars->gravity * 0.5 * pmove->frametime);
pmove->velocity[2] += pmove->basevelocity[2] * pmove->frametime;
pmove->basevelocity[2] = 0;
PM_CheckVelocity();
}
void PM_FixupGravityVelocity(void)
{
float ent_gravity;
if (pmove->waterjumptime)
return;
if (pmove->gravity)
ent_gravity = pmove->gravity;
else
ent_gravity = 1.0;
pmove->velocity[2] -= (ent_gravity * pmove->movevars->gravity * pmove->frametime * 0.5);
PM_CheckVelocity();
}
int PM_FlyMove(void)
{
int bumpcount, numbumps;
vec3_t dir;
float d;
int numplanes;
vec3_t planes[MAX_CLIP_PLANES];
vec3_t primal_velocity, original_velocity;
vec3_t new_velocity;
int i, j;
pmtrace_t trace;
vec3_t end;
float time_left, allFraction;
int blocked;
numbumps = 4;
blocked = 0;
numplanes = 0;
VectorCopy(pmove->velocity, original_velocity);
VectorCopy(pmove->velocity, primal_velocity);
allFraction = 0;
time_left = pmove->frametime;
for (bumpcount = 0; bumpcount < numbumps; bumpcount++)
{
if (!pmove->velocity[0] && !pmove->velocity[1] && !pmove->velocity[2])
break;
for (i = 0; i < 3; i++)
end[i] = pmove->origin[i] + time_left * pmove->velocity[i];
trace = pmove->PM_PlayerTrace(pmove->origin, end, PM_NORMAL, -1);
allFraction += trace.fraction;
if (trace.allsolid)
{
VectorCopy(vec3_origin, pmove->velocity);
return 4;
}
if (trace.fraction > 0)
{
VectorCopy(trace.endpos, pmove->origin);
VectorCopy(pmove->velocity, original_velocity);
numplanes = 0;
}
if (trace.fraction == 1)
break;
PM_AddToTouched(trace, pmove->velocity);
if (trace.plane.normal[2] > 0.7)
blocked |= 1;
if (!trace.plane.normal[2])
blocked |= 2;
time_left -= time_left * trace.fraction;
if (numplanes >= MAX_CLIP_PLANES)
{
VectorCopy(vec3_origin, pmove->velocity);
break;
}
VectorCopy(trace.plane.normal, planes[numplanes]);
numplanes++;
if (pmove->movetype == MOVETYPE_WALK && ((pmove->onground == -1) || (pmove->friction != 1)))
{
for (i = 0; i < numplanes; i++)
{
if (planes[i][2] > 0.7)
{
PM_ClipVelocity(original_velocity, planes[i], new_velocity, 1);
VectorCopy(new_velocity, original_velocity);
}
else
PM_ClipVelocity( original_velocity, planes[i], new_velocity, 1.0 + pmove->movevars->bounce * (1 - pmove->friction));
}
VectorCopy(new_velocity, pmove->velocity);
VectorCopy(new_velocity, original_velocity);
}
else
{
for (i = 0; i < numplanes; i++)
{
PM_ClipVelocity(original_velocity, planes[i], pmove->velocity, 1);
for (j = 0; j <numplanes; j++)
{
if (j != i)
{
if (DotProduct(pmove->velocity, planes[j]) < 0)
break;
}
}
if (j == numplanes)
break;
}
if (i != numplanes)
{
}
else
{
if (numplanes != 2)
{
VectorCopy(vec3_origin, pmove->velocity);
break;
}
CrossProduct(planes[0], planes[1], dir);
d = DotProduct(dir, pmove->velocity);
VectorScale(dir, d, pmove->velocity);
}
if (DotProduct(pmove->velocity, primal_velocity) <= 0)
{
VectorCopy(vec3_origin, pmove->velocity);
break;
}
}
}
if (allFraction == 0)
VectorCopy(vec3_origin, pmove->velocity);
return blocked;
}
void PM_Accelerate(vec3_t wishdir, float wishspeed, float accel)
{
int i;
float addspeed, accelspeed, currentspeed;
if (pmove->dead)
return;
if (pmove->waterjumptime)
return;
currentspeed = DotProduct(pmove->velocity, wishdir);
addspeed = wishspeed - currentspeed;
if (addspeed <= 0)
return;
accelspeed = accel * pmove->frametime * wishspeed * pmove->friction;
if (accelspeed > addspeed)
accelspeed = addspeed;
for (i = 0; i < 3; i++)
pmove->velocity[i] += accelspeed * wishdir[i];
}
void PM_WalkMove(void)
{
int oldonground;
int i;
vec3_t wishvel;
float spd;
float fmove, smove;
vec3_t wishdir;
float wishspeed;
cs16-client now compiles with -Wall
2016-03-12 21:45:33 +01:00
vec3_t dest;
CP1251->UTF-8
2016-03-05 20:29:55 +01:00
vec3_t original, originalvel;
vec3_t down, downvel;
float downdist, updist;
pmtrace_t trace;
if (pmove->fuser2 > 0.0)
{
float factor;
factor = (100.0 - pmove->fuser2 * 0.001 * 19.0) * 0.01;
pmove->velocity[0] *= factor;
pmove->velocity[1] *= factor;
}
fmove = pmove->cmd.forwardmove;
smove = pmove->cmd.sidemove;
pmove->forward[2] = 0;
pmove->right[2] = 0;
VectorNormalize(pmove->forward);
VectorNormalize(pmove->right);
for (i = 0; i < 2; i++)
wishvel[i] = pmove->forward[i] * fmove + pmove->right[i] * smove;
wishvel[2] = 0;
VectorCopy(wishvel, wishdir);
wishspeed = VectorNormalize(wishdir);
if (wishspeed > pmove->maxspeed)
{
VectorScale(wishvel, pmove->maxspeed/wishspeed, wishvel);
wishspeed = pmove->maxspeed;
}
pmove->velocity[2] = 0;
PM_Accelerate(wishdir, wishspeed, pmove->movevars->accelerate);
pmove->velocity[2] = 0;
VectorAdd(pmove->velocity, pmove->basevelocity, pmove->velocity);
spd = Length(pmove->velocity);
if (spd < 1.0f)
{
VectorClear(pmove->velocity);
return;
}
oldonground = pmove->onground;
dest[0] = pmove->origin[0] + pmove->velocity[0]*pmove->frametime;
dest[1] = pmove->origin[1] + pmove->velocity[1]*pmove->frametime;
dest[2] = pmove->origin[2];
trace = pmove->PM_PlayerTrace(pmove->origin, dest, PM_NORMAL, -1);
if (trace.fraction == 1)
{
VectorCopy(trace.endpos, pmove->origin);
return;
}
if (oldonground == -1 && pmove->waterlevel == 0)
return;
if (pmove->waterjumptime)
return;
VectorCopy(pmove->origin, original);
VectorCopy(pmove->velocity, originalvel);
cs16-client now compiles with -Wall
2016-03-12 21:45:33 +01:00
PM_FlyMove();
CP1251->UTF-8
2016-03-05 20:29:55 +01:00
VectorCopy(pmove->origin, down);
VectorCopy(pmove->velocity, downvel);
VectorCopy(original, pmove->origin);
VectorCopy(originalvel, pmove->velocity);
VectorCopy(pmove->origin, dest);
dest[2] += pmove->movevars->stepsize;
trace = pmove->PM_PlayerTrace(pmove->origin, dest, PM_NORMAL, -1);
if (!trace.startsolid && !trace.allsolid)
VectorCopy(trace.endpos, pmove->origin);
cs16-client now compiles with -Wall
2016-03-12 21:45:33 +01:00
PM_FlyMove();
CP1251->UTF-8
2016-03-05 20:29:55 +01:00
VectorCopy(pmove->origin, dest);
dest[2] -= pmove->movevars->stepsize;
trace = pmove->PM_PlayerTrace(pmove->origin, dest, PM_NORMAL, -1);
if (trace.plane.normal[2] < 0.7)
goto usedown;
if (!trace.startsolid && !trace.allsolid)
VectorCopy(trace.endpos, pmove->origin);
VectorCopy(pmove->origin, pmove->up);
downdist = (down[0] - original[0])*(down[0] - original[0]) + (down[1] - original[1])*(down[1] - original[1]);
updist = (pmove->up[0] - original[0])*(pmove->up[0] - original[0]) + (pmove->up[1] - original[1])*(pmove->up[1] - original[1]);
if (downdist > updist)
{
usedown:
VectorCopy(down, pmove->origin);
VectorCopy(downvel, pmove->velocity);
}
else
pmove->velocity[2] = downvel[2];
}
void PM_Friction(void)
{
float *vel;
float speed, newspeed, control;
float friction;
float drop;
vec3_t newvel;
if (pmove->waterjumptime)
return;
vel = pmove->velocity;
speed = sqrt(vel[0] * vel[0] +vel[1] * vel[1] + vel[2] * vel[2]);
if (speed < 0.1f)
return;
drop = 0;
if (pmove->onground != -1)
{
vec3_t start, stop;
pmtrace_t trace;
start[0] = stop[0] = pmove->origin[0] + vel[0] / speed * 16;
start[1] = stop[1] = pmove->origin[1] + vel[1] / speed * 16;
start[2] = pmove->origin[2] + pmove->player_mins[pmove->usehull][2];
stop[2] = start[2] - 34;
trace = pmove->PM_PlayerTrace(start, stop, PM_NORMAL, -1);
if (trace.fraction == 1.0)
friction = pmove->movevars->friction * pmove->movevars->edgefriction;
else
friction = pmove->movevars->friction;
friction *= pmove->friction;
control = (speed < pmove->movevars->stopspeed) ? pmove->movevars->stopspeed : speed;
drop += control*friction*pmove->frametime;
}
newspeed = speed - drop;
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
newvel[0] = vel[0] * newspeed;
newvel[1] = vel[1] * newspeed;
newvel[2] = vel[2] * newspeed;
VectorCopy(newvel, pmove->velocity);
}
void PM_AirAccelerate(vec3_t wishdir, float wishspeed, float accel)
{
int i;
float addspeed, accelspeed, currentspeed, wishspd = wishspeed;
if (pmove->dead)
return;
if (pmove->waterjumptime)
return;
if (wishspd > 30)
wishspd = 30;
currentspeed = DotProduct(pmove->velocity, wishdir);
addspeed = wishspd - currentspeed;
if (addspeed <= 0)
return;
accelspeed = accel * wishspeed * pmove->frametime * pmove->friction;
if (accelspeed > addspeed)
accelspeed = addspeed;
for (i = 0; i < 3; i++)
pmove->velocity[i] += accelspeed * wishdir[i];
}
void PM_WaterMove(void)
{
int i;
vec3_t wishvel;
float wishspeed;
vec3_t wishdir;
vec3_t start, dest;
vec3_t temp;
pmtrace_t trace;
float speed, newspeed, addspeed, accelspeed;
for (i = 0; i < 3; i++)
wishvel[i] = pmove->forward[i] * pmove->cmd.forwardmove + pmove->right[i] * pmove->cmd.sidemove;
if (!pmove->cmd.forwardmove && !pmove->cmd.sidemove && !pmove->cmd.upmove)
wishvel[2] -= 60;
else
wishvel[2] += pmove->cmd.upmove;
VectorCopy(wishvel, wishdir);
wishspeed = VectorNormalize(wishdir);
if (wishspeed > pmove->maxspeed)
{
VectorScale(wishvel, pmove->maxspeed / wishspeed, wishvel);
wishspeed = pmove->maxspeed;
}
wishspeed *= 0.8;
VectorAdd(pmove->velocity, pmove->basevelocity, pmove->velocity);
VectorCopy(pmove->velocity, temp);
speed = VectorNormalize(temp);
if (speed)
{
newspeed = speed - pmove->frametime * speed * pmove->movevars->friction * pmove->friction;
if (newspeed < 0)
newspeed = 0;
VectorScale(pmove->velocity, newspeed / speed, pmove->velocity);
}
else
newspeed = 0;
if (wishspeed < 0.1f)
return;
addspeed = wishspeed - newspeed;
if (addspeed > 0)
{
VectorNormalize(wishvel);
accelspeed = pmove->movevars->accelerate * wishspeed * pmove->frametime * pmove->friction;
if (accelspeed > addspeed)
accelspeed = addspeed;
for (i = 0; i < 3; i++)
pmove->velocity[i] += accelspeed * wishvel[i];
}
VectorMA(pmove->origin, pmove->frametime, pmove->velocity, dest);
VectorCopy(dest, start);
start[2] += pmove->movevars->stepsize + 1;
trace = pmove->PM_PlayerTrace(start, dest, PM_NORMAL, -1);
if (!trace.startsolid && !trace.allsolid)
{
VectorCopy(trace.endpos, pmove->origin);
return;
}
PM_FlyMove();
}
void PM_AirMove(void)
{
int i;
vec3_t wishvel;
float fmove, smove;
vec3_t wishdir;
float wishspeed;
fmove = pmove->cmd.forwardmove;
smove = pmove->cmd.sidemove;
pmove->forward[2] = 0;
pmove->right[2] = 0;
VectorNormalize(pmove->forward);
VectorNormalize(pmove->right);
for (i = 0; i < 2; i++)
{
wishvel[i] = pmove->forward[i] * fmove + pmove->right[i] * smove;
}
wishvel[2] = 0;
VectorCopy(wishvel, wishdir);
wishspeed = VectorNormalize(wishdir);
if (wishspeed > pmove->maxspeed)
{
VectorScale(wishvel, pmove->maxspeed / wishspeed, wishvel);
wishspeed = pmove->maxspeed;
}
PM_AirAccelerate(wishdir, wishspeed, pmove->movevars->airaccelerate);
VectorAdd(pmove->velocity, pmove->basevelocity, pmove->velocity);
PM_FlyMove();
}
qboolean PM_InWater(void)
{
return (pmove->waterlevel > 1);
}
qboolean PM_CheckWater(void)
{
vec3_t point;
int cont;
int truecont;
float height;
float heightover2;
point[0] = pmove->origin[0] + (pmove->player_mins[pmove->usehull][0] + pmove->player_maxs[pmove->usehull][0]) * 0.5;
point[1] = pmove->origin[1] + (pmove->player_mins[pmove->usehull][1] + pmove->player_maxs[pmove->usehull][1]) * 0.5;
point[2] = pmove->origin[2] + pmove->player_mins[pmove->usehull][2] + 1;
pmove->waterlevel = 0;
pmove->watertype = CONTENTS_EMPTY;
cont = pmove->PM_PointContents(point, &truecont);
if (cont <= CONTENTS_WATER && cont > CONTENTS_TRANSLUCENT)
{
pmove->watertype = cont;
pmove->waterlevel = 1;
height = (pmove->player_mins[pmove->usehull][2] + pmove->player_maxs[pmove->usehull][2]);
heightover2 = height * 0.5;
point[2] = pmove->origin[2] + heightover2;
cont = pmove->PM_PointContents(point, NULL);
if (cont <= CONTENTS_WATER && cont > CONTENTS_TRANSLUCENT)
{
pmove->waterlevel = 2;
point[2] = pmove->origin[2] + pmove->view_ofs[2];
cont = pmove->PM_PointContents(point, NULL);
if (cont <= CONTENTS_WATER && cont > CONTENTS_TRANSLUCENT)
pmove->waterlevel = 3;
}
if ((truecont <= CONTENTS_CURRENT_0) && (truecont >= CONTENTS_CURRENT_DOWN))
{
static vec3_t current_table[] =
{
{ 1, 0, 0 }, { 0, 1, 0 }, { -1, 0, 0 },
{ 0, -1, 0 }, { 0, 0, 1 }, { 0, 0, -1 }
};
VectorMA(pmove->basevelocity, 50.0 * pmove->waterlevel, current_table[CONTENTS_CURRENT_0 - truecont], pmove->basevelocity);
}
}
return pmove->waterlevel > 1;
}
void PM_CatagorizePosition(void)
{
vec3_t point;
pmtrace_t tr;
PM_CheckWater();
point[0] = pmove->origin[0];
point[1] = pmove->origin[1];
point[2] = pmove->origin[2] - 2;
if (pmove->velocity[2] > 180)
{
pmove->onground = -1;
}
else
{
tr = pmove->PM_PlayerTrace(pmove->origin, point, PM_NORMAL, -1);
if (tr.plane.normal[2] < 0.7)
pmove->onground = -1;
else
pmove->onground = tr.ent;
if (pmove->onground != -1)
{
pmove->waterjumptime = 0;
if (pmove->waterlevel < 2 && !tr.startsolid && !tr.allsolid)
VectorCopy(tr.endpos, pmove->origin);
}
if (tr.ent > 0)
{
PM_AddToTouched(tr, pmove->velocity);
}
}
}
int PM_GetRandomStuckOffsets(int nIndex, int server, vec3_t offset)
{
int idx;
idx = rgStuckLast[nIndex][server]++;
VectorCopy(rgv3tStuckTable[idx % 54], offset);
return (idx % 54);
}
void PM_ResetStuckOffsets(int nIndex, int server)
{
rgStuckLast[nIndex][server] = 0;
}
#define PM_CHECKSTUCK_MINTIME 0.05
int PM_CheckStuck(void)
{
vec3_t base;
vec3_t offset;
vec3_t test;
int hitent;
int idx;
float fTime;
int i;
pmtrace_t traceresult;
static float rgStuckCheckTime[MAX_CLIENTS][2];
hitent = pmove->PM_TestPlayerPosition(pmove->origin, &traceresult);
if (hitent == -1)
{
PM_ResetStuckOffsets(pmove->player_index, pmove->server);
return 0;
}
VectorCopy(pmove->origin, base);
if (!pmove->server)
{
if ((hitent == 0) || (pmove->physents[hitent].model != NULL))
{
int nReps = 0;
PM_ResetStuckOffsets(pmove->player_index, pmove->server);
do
{
i = PM_GetRandomStuckOffsets(pmove->player_index, pmove->server, offset);
VectorAdd(base, offset, test);
if (pmove->PM_TestPlayerPosition(test, &traceresult) == -1)
{
PM_ResetStuckOffsets(pmove->player_index, pmove->server);
VectorCopy(test, pmove->origin);
return 0;
}
nReps++;
}
while (nReps < 54);
}
}
if (pmove->server)
idx = 0;
else
idx = 1;
fTime = pmove->Sys_FloatTime();
if (rgStuckCheckTime[pmove->player_index][idx] >= (fTime - PM_CHECKSTUCK_MINTIME))
return 1;
rgStuckCheckTime[pmove->player_index][idx] = fTime;
pmove->PM_StuckTouch(hitent, &traceresult);
i = PM_GetRandomStuckOffsets(pmove->player_index, pmove->server, offset);
VectorAdd(base, offset, test);
if ((hitent = pmove->PM_TestPlayerPosition(test, NULL)) == -1)
{
PM_ResetStuckOffsets(pmove->player_index, pmove->server);
if (i >= 27)
VectorCopy(test, pmove->origin);
return 0;
}
if (pmove->cmd.buttons & (IN_JUMP | IN_DUCK | IN_ATTACK) && ( pmove->physents[hitent].player != 0))
{
float x, y, z;
float xystep = 8.0;
float zstep = 18.0;
float xyminmax = xystep;
float zminmax = 4 * zstep;
for (z = 0; z <= zminmax; z += zstep)
{
for (x = -xyminmax; x <= xyminmax; x += xystep)
{
for (y = -xyminmax; y <= xyminmax; y += xystep)
{
VectorCopy(base, test);
test[0] += x;
test[1] += y;
test[2] += z;
if (pmove->PM_TestPlayerPosition(test, NULL) == -1)
{
VectorCopy(test, pmove->origin);
return 0;
}
}
}
}
}
return 1;
}
void PM_SpectatorMove(void)
{
float speed, drop, friction, control, newspeed;
float currentspeed, addspeed, accelspeed;
int i;
vec3_t wishvel;
float fmove, smove;
vec3_t wishdir;
float wishspeed;
if (pmove->iuser1 == OBS_ROAMING)
{
#ifdef CLIENT_DLL
if (iJumpSpectator)
{
VectorCopy(vJumpOrigin, pmove->origin);
VectorCopy(vJumpAngles, pmove->angles);
VectorCopy(vec3_origin, pmove->velocity);
iJumpSpectator = 0;
return;
}
#endif
speed = Length(pmove->velocity);
if (speed < 1)
{
VectorCopy(vec3_origin, pmove->velocity)
}
else
{
drop = 0;
friction = pmove->movevars->friction * 1.5;
control = speed < pmove->movevars->stopspeed ? pmove->movevars->stopspeed : speed;
drop += control*friction*pmove->frametime;
newspeed = speed - drop;
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
VectorScale(pmove->velocity, newspeed, pmove->velocity);
}
fmove = pmove->cmd.forwardmove;
smove = pmove->cmd.sidemove;
VectorNormalize(pmove->forward);
VectorNormalize(pmove->right);
for (i = 0; i < 3; i++)
wishvel[i] = pmove->forward[i] * fmove + pmove->right[i] * smove;
wishvel[2] += pmove->cmd.upmove;
VectorCopy(wishvel, wishdir);
wishspeed = VectorNormalize(wishdir);
if (wishspeed > pmove->movevars->spectatormaxspeed)
{
VectorScale(wishvel, pmove->movevars->spectatormaxspeed / wishspeed, wishvel);
wishspeed = pmove->movevars->spectatormaxspeed;
}
currentspeed = DotProduct(pmove->velocity, wishdir);
addspeed = wishspeed - currentspeed;
if (addspeed <= 0)
return;
accelspeed = pmove->movevars->accelerate * pmove->frametime * wishspeed;
if (accelspeed > addspeed)
accelspeed = addspeed;
for (i = 0; i < 3; i++)
pmove->velocity[i] += accelspeed * wishdir[i];
VectorMA(pmove->origin, pmove->frametime, pmove->velocity, pmove->origin);
}
else
{
int target;
if (pmove->iuser2 <= 0)
return;
for (target = 0; target < pmove->numphysent; target++)
{
if (pmove->physents[target].info == pmove->iuser2)
break;
}
if (target == pmove->numphysent)
return;
VectorCopy(pmove->physents[target].angles, pmove->angles);
VectorCopy(pmove->physents[target].origin, pmove->origin);
VectorCopy(vec3_origin, pmove->velocity);
}
}
float PM_SplineFraction(float value, float scale)
{
float valueSquared;
value = scale * value;
valueSquared = value * value;
return 3 * valueSquared - 2 * valueSquared * value;
}
void PM_FixPlayerCrouchStuck(int direction)
{
int hitent;
int i;
vec3_t test;
hitent = pmove->PM_TestPlayerPosition(pmove->origin, NULL);
if (hitent == -1)
return;
VectorCopy(pmove->origin, test);
for (i = 0; i < 36; i++)
{
pmove->origin[2] += direction;
hitent = pmove->PM_TestPlayerPosition(pmove->origin, NULL);
if (hitent == -1)
return;
}
VectorCopy(test, pmove->origin);
}
void PM_UnDuck(void)
{
pmtrace_t trace;
vec3_t newOrigin;
VectorCopy(pmove->origin, newOrigin);
if (pmove->onground != -1)
{
newOrigin[2] += 18.0;
}
trace = pmove->PM_PlayerTrace(newOrigin, newOrigin, PM_NORMAL, -1);
if (!trace.startsolid)
{
pmove->usehull = 0;
trace = pmove->PM_PlayerTrace(newOrigin, newOrigin, PM_NORMAL, -1);
if (trace.startsolid)
{
pmove->usehull = 1;
return;
}
pmove->flags &= ~FL_DUCKING;
pmove->bInDuck = false;
pmove->view_ofs[2] = VEC_VIEW;
pmove->flDuckTime = 0;
pmove->flTimeStepSound -= 100;
if (pmove->flTimeStepSound < 0)
{
pmove->flTimeStepSound = 0;
}
VectorCopy(newOrigin, pmove->origin);
PM_CatagorizePosition();
}
}
void PM_Duck(void)
{
float time;
float duckFraction;
int buttonsChanged = (pmove->oldbuttons ^ pmove->cmd.buttons);
int nButtonPressed = buttonsChanged & pmove->cmd.buttons;
if (pmove->cmd.buttons & IN_DUCK)
{
pmove->oldbuttons |= IN_DUCK;
}
else
{
pmove->oldbuttons &= ~IN_DUCK;
}
if (pmove->dead)
return;
if ((pmove->cmd.buttons & IN_DUCK) || (pmove->bInDuck) || (pmove->flags & FL_DUCKING))
{
pmove->cmd.forwardmove *= 0.333;
pmove->cmd.sidemove *= 0.333;
pmove->cmd.upmove *= 0.333;
if (pmove->cmd.buttons & IN_DUCK)
{
if ((nButtonPressed & IN_DUCK) && !(pmove->flags & FL_DUCKING))
{
pmove->flDuckTime = 1000;
pmove->bInDuck = true;
}
time = max(0.0, ( 1.0 - (float)pmove->flDuckTime / 1000.0));
if (pmove->bInDuck)
{
if (((float)pmove->flDuckTime / 1000.0 <= (1.0 - TIME_TO_DUCK)) || (pmove->onground == -1))
{
pmove->usehull = 1;
pmove->view_ofs[2] = VEC_DUCK_VIEW;
pmove->flags |= FL_DUCKING;
pmove->bInDuck = false;
if (pmove->onground != -1)
{
pmove->origin[2] = pmove->origin[2] - 18.0;
PM_FixPlayerCrouchStuck(STUCK_MOVEUP);
PM_CatagorizePosition();
}
}
else
{
float fMore = (VEC_DUCK_HULL_MIN - VEC_HULL_MIN);
duckFraction = PM_SplineFraction(time, (1.0 / TIME_TO_DUCK));
pmove->view_ofs[2] = ((VEC_DUCK_VIEW - fMore) * duckFraction) + (VEC_VIEW * (1 - duckFraction));
}
}
}
else
{
PM_UnDuck();
}
}
}
void PM_LadderMove(physent_t *pLadder)
{
vec3_t ladderCenter;
trace_t trace;
qboolean onFloor;
vec3_t floor;
vec3_t modelmins, modelmaxs;
if (pmove->movetype == MOVETYPE_NOCLIP)
return;
pmove->PM_GetModelBounds(pLadder->model, modelmins, modelmaxs);
VectorAdd(modelmins, modelmaxs, ladderCenter);
VectorScale(ladderCenter, 0.5, ladderCenter);
pmove->movetype = MOVETYPE_FLY;
VectorCopy(pmove->origin, floor);
floor[2] += pmove->player_mins[pmove->usehull][2] - 1;
if (pmove->PM_PointContents(floor, NULL) == CONTENTS_SOLID)
onFloor = true;
else
onFloor = false;
pmove->gravity = 0;
pmove->PM_TraceModel(pLadder, pmove->origin, ladderCenter, &trace);
if (trace.fraction != 1.0)
{
float forward = 0, right = 0;
vec3_t vpn, v_right;
float flSpeed = MAX_CLIMB_SPEED;
if (pmove->maxspeed < MAX_CLIMB_SPEED)
flSpeed = pmove->maxspeed;
AngleVectors(pmove->angles, vpn, v_right, NULL);
if (pmove->flags & FL_DUCKING)
{
flSpeed *= 0.333;
}
if (pmove->cmd.buttons & IN_BACK)
forward -= flSpeed;
if (pmove->cmd.buttons & IN_FORWARD)
forward += flSpeed;
if (pmove->cmd.buttons & IN_MOVELEFT)
right -= flSpeed;
if (pmove->cmd.buttons & IN_MOVERIGHT)
right += flSpeed;
if (pmove->cmd.buttons & IN_JUMP)
{
pmove->movetype = MOVETYPE_WALK;
VectorScale(trace.plane.normal, 270, pmove->velocity);
}
else
{
if (forward != 0 || right != 0)
{
vec3_t velocity, perp, cross, lateral, tmp;
float normal;
VectorScale(vpn, forward, velocity);
VectorMA(velocity, right, v_right, velocity);
VectorClear(tmp);
tmp[2] = 1;
CrossProduct(tmp, trace.plane.normal, perp);
VectorNormalize(perp);
normal = DotProduct(velocity, trace.plane.normal);
VectorScale(trace.plane.normal, normal, cross);
VectorSubtract(velocity, cross, lateral);
CrossProduct(trace.plane.normal, perp, tmp);
VectorMA(lateral, -normal, tmp, pmove->velocity);
if (onFloor && normal > 0)
{
VectorMA(pmove->velocity, MAX_CLIMB_SPEED, trace.plane.normal, pmove->velocity);
}
}
else
{
VectorClear(pmove->velocity);
}
}
}
}
physent_t *PM_Ladder(void)
{
int i;
physent_t *pe;
hull_t *hull;
int num;
vec3_t test;
for (i = 0; i < pmove->nummoveent; i++)
{
pe = &pmove->moveents[i];
if (pe->model && (modtype_t)pmove->PM_GetModelType(pe->model) == mod_brush && pe->skin == CONTENTS_LADDER)
{
hull = (hull_t *)pmove->PM_HullForBsp(pe, test);
num = hull->firstclipnode;
VectorSubtract(pmove->origin, test, test);
if (pmove->PM_HullPointContents (hull, num, test) == CONTENTS_EMPTY)
continue;
return pe;
}
}
return NULL;
}
void PM_WaterJump(void)
{
if (pmove->waterjumptime > 10000)
pmove->waterjumptime = 10000;
if (!pmove->waterjumptime)
return;
pmove->waterjumptime -= pmove->cmd.msec;
if (pmove->waterjumptime < 0 || !pmove->waterlevel)
{
pmove->waterjumptime = 0;
pmove->flags &= ~FL_WATERJUMP;
}
pmove->velocity[0] = pmove->movedir[0];
pmove->velocity[1] = pmove->movedir[1];
}
void PM_AddGravity(void)
{
float ent_gravity;
if (pmove->gravity)
ent_gravity = pmove->gravity;
else
ent_gravity = 1.0;
pmove->velocity[2] -= (ent_gravity * pmove->movevars->gravity * pmove->frametime);
pmove->velocity[2] += pmove->basevelocity[2] * pmove->frametime;
pmove->basevelocity[2] = 0;
PM_CheckVelocity();
}
pmtrace_t PM_PushEntity(vec3_t push)
{
pmtrace_t trace;
vec3_t end;
VectorAdd(pmove->origin, push, end);
trace = pmove->PM_PlayerTrace(pmove->origin, end, PM_NORMAL, -1);
VectorCopy(trace.endpos, pmove->origin);
if (trace.fraction < 1.0 && !trace.allsolid)
{
PM_AddToTouched(trace, pmove->velocity);
}
return trace;
}
void PM_Physics_Toss(void)
{
pmtrace_t trace;
vec3_t move;
float backoff;
PM_CheckWater();
if (pmove->velocity[2] > 0)
pmove->onground = -1;
if (pmove->onground != -1)
{
if (VectorCompare(pmove->basevelocity, vec3_origin) && VectorCompare(pmove->velocity, vec3_origin))
return;
}
PM_CheckVelocity();
if (pmove->movetype != MOVETYPE_FLY && pmove->movetype != MOVETYPE_BOUNCEMISSILE && pmove->movetype != MOVETYPE_FLYMISSILE)
PM_AddGravity();
VectorAdd(pmove->velocity, pmove->basevelocity, pmove->velocity);
PM_CheckVelocity();
VectorScale(pmove->velocity, pmove->frametime, move);
VectorSubtract(pmove->velocity, pmove->basevelocity, pmove->velocity);
trace = PM_PushEntity(move);
PM_CheckVelocity();
if (trace.allsolid)
{
pmove->onground = trace.ent;
VectorCopy(vec3_origin, pmove->velocity);
return;
}
if (trace.fraction == 1)
{
PM_CheckWater();
return;
}
if (pmove->movetype == MOVETYPE_BOUNCE)
backoff = 2.0 - pmove->friction;
else if (pmove->movetype == MOVETYPE_BOUNCEMISSILE)
backoff = 2.0;
else
backoff = 1;
PM_ClipVelocity(pmove->velocity, trace.plane.normal, pmove->velocity, backoff);
if (trace.plane.normal[2] > 0.7)
{
float vel;
vec3_t base;
VectorClear(base);
if (pmove->velocity[2] < pmove->movevars->gravity * pmove->frametime)
{
pmove->onground = trace.ent;
pmove->velocity[2] = 0;
}
vel = DotProduct(pmove->velocity, pmove->velocity);
if (vel < (30 * 30) || (pmove->movetype != MOVETYPE_BOUNCE && pmove->movetype != MOVETYPE_BOUNCEMISSILE))
{
pmove->onground = trace.ent;
VectorCopy(vec3_origin, pmove->velocity);
}
else
{
VectorScale(pmove->velocity, (1.0 - trace.fraction) * pmove->frametime * 0.9, move);
trace = PM_PushEntity(move);
}
VectorSubtract(pmove->velocity, base, pmove->velocity)
}
PM_CheckWater();
}
void PM_NoClip(void)
{
int i;
vec3_t wishvel;
float fmove, smove;
fmove = pmove->cmd.forwardmove;
smove = pmove->cmd.sidemove;
VectorNormalize(pmove->forward);
VectorNormalize(pmove->right);
for (i = 0; i < 3; i++)
{
wishvel[i] = pmove->forward[i] * fmove + pmove->right[i] * smove;
}
wishvel[2] += pmove->cmd.upmove;
VectorMA(pmove->origin, pmove->frametime, wishvel, pmove->origin);
VectorClear(pmove->velocity);
}
#define BUNNYJUMP_MAX_SPEED_FACTOR 1.2f
void PM_PreventMegaBunnyJumping(void)
{
float spd;
float fraction;
float maxscaledspeed;
maxscaledspeed = BUNNYJUMP_MAX_SPEED_FACTOR * pmove->maxspeed;
if (maxscaledspeed <= 0.0f)
return;
spd = Length(pmove->velocity);
if (spd <= maxscaledspeed)
return;
fraction = (maxscaledspeed / spd) * 0.8;
VectorScale(pmove->velocity, fraction, pmove->velocity);
}
void PM_Jump(void)
{
if (pmove->dead)
{
pmove->oldbuttons |= IN_JUMP;
return;
}
if (pmove->waterjumptime)
{
pmove->waterjumptime -= pmove->cmd.msec;
if (pmove->waterjumptime < 0)
{
pmove->waterjumptime = 0;
}
return;
}
if (pmove->waterlevel >= 2)
{
pmove->onground = -1;
if (pmove->watertype == CONTENTS_WATER)
pmove->velocity[2] = 100;
else if (pmove->watertype == CONTENTS_SLIME)
pmove->velocity[2] = 80;
else
pmove->velocity[2] = 50;
if (pmove->flSwimTime <= 0)
{
pmove->flSwimTime = 1000;
switch (pmove->RandomLong(0, 3))
{
case 0:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade1.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
case 1:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade2.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
case 2:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade3.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
case 3:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade4.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
}
}
return;
}
if (pmove->onground == -1)
{
pmove->oldbuttons |= IN_JUMP;
return;
}
if (~pmove->oldbuttons & IN_JUMP && (!pmove->bInDuck || ~pmove->flags & FL_DUCKING))
{
pmove->onground = -1;
PM_CatagorizeTextureType();
PM_PreventMegaBunnyJumping();
if (Length(pmove->velocity) >= 150.0)
{
PM_PlayStepSound(PM_MapTextureTypeStepType(pmove->chtexturetype), 1.0);
}
pmove->velocity[2] = sqrt(2 * 800 * 45.0);
if (pmove->fuser2 > 0.0)
pmove->velocity[2] *= (100.0 - pmove->fuser2 * 0.001 * 19.0) * 0.01;
pmove->fuser2 = 1315.7894;
PM_FixupGravityVelocity();
pmove->oldbuttons |= IN_JUMP;
}
}
#define WJ_HEIGHT 8
void PM_CheckWaterJump(void)
{
vec3_t vecStart, vecEnd;
vec3_t flatforward;
vec3_t flatvelocity;
float curspeed;
pmtrace_t tr;
int savehull;
if (pmove->waterjumptime)
return;
if (pmove->velocity[2] < -180)
return;
flatvelocity[0] = pmove->velocity[0];
flatvelocity[1] = pmove->velocity[1];
flatvelocity[2] = 0;
curspeed = VectorNormalize(flatvelocity);
flatforward[0] = pmove->forward[0];
flatforward[1] = pmove->forward[1];
flatforward[2] = 0;
VectorNormalize (flatforward);
if (curspeed != 0.0 && (DotProduct(flatvelocity, flatforward) < 0.0))
return;
VectorCopy(pmove->origin, vecStart);
vecStart[2] += WJ_HEIGHT;
VectorMA(vecStart, 24, flatforward, vecEnd);
savehull = pmove->usehull;
pmove->usehull = 2;
tr = pmove->PM_PlayerTrace(vecStart, vecEnd, PM_NORMAL, -1);
if (tr.fraction < 1.0 && fabs(tr.plane.normal[2]) < 0.1f)
{
vecStart[2] += pmove->player_maxs[savehull][2] - WJ_HEIGHT;
VectorMA(vecStart, 24, flatforward, vecEnd);
VectorMA(vec3_origin, -50, tr.plane.normal, pmove->movedir);
tr = pmove->PM_PlayerTrace(vecStart, vecEnd, PM_NORMAL, -1);
if (tr.fraction == 1.0)
{
pmove->waterjumptime = 2000;
pmove->velocity[2] = 225;
pmove->oldbuttons |= IN_JUMP;
pmove->flags |= FL_WATERJUMP;
}
}
pmove->usehull = savehull;
}
void PM_CheckFalling(void)
{
if (pmove->onground != -1 && !pmove->dead && pmove->flFallVelocity >= PLAYER_FALL_PUNCH_THRESHHOLD)
{
float fvol = 0.5;
if (pmove->waterlevel > 0)
{
}
else if (pmove->flFallVelocity > PLAYER_MAX_SAFE_FALL_SPEED)
{
fvol = 1.0;
}
else if (pmove->flFallVelocity > PLAYER_MAX_SAFE_FALL_SPEED / 2)
{
fvol = 0.85;
}
else if (pmove->flFallVelocity < PLAYER_MIN_BOUNCE_SPEED)
{
fvol = 0;
}
if (fvol > 0.0)
{
PM_CatagorizeTextureType();
PM_PlayStepSound(PM_MapTextureTypeStepType(pmove->chtexturetype), fvol);
pmove->flTimeStepSound = 300;
pmove->punchangle[2] = pmove->flFallVelocity * 0.013;
if (pmove->punchangle[0] > 8)
pmove->punchangle[0] = 8;
}
}
if (pmove->onground != -1)
{
pmove->flFallVelocity = 0;
}
}
void PM_PlayWaterSounds(void)
{
if ((pmove->oldwaterlevel == 0 && pmove->waterlevel != 0) || (pmove->oldwaterlevel != 0 && pmove->waterlevel == 0))
{
switch (pmove->RandomLong(0, 3))
{
case 0:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade1.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
case 1:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade2.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
case 2:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade3.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
case 3:
{
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade4.wav", 1, ATTN_NORM, 0, PITCH_NORM);
break;
}
}
}
}
float PM_CalcRoll(vec3_t angles, vec3_t velocity, float rollangle, float rollspeed)
{
float sign;
float side;
float value;
vec3_t forward, right, up;
AngleVectors(angles, forward, right, up);
side = DotProduct(velocity, right);
sign = side < 0 ? -1 : 1;
side = fabs(side);
value = rollangle;
if (side < rollspeed)
{
side = side * value / rollspeed;
}
else
{
side = value;
}
return side * sign;
}
void PM_DropPunchAngle(vec3_t punchangle)
{
float len;
len = VectorNormalize (punchangle);
len -= (10.0 + len * 0.5) * pmove->frametime;
len = max(len, 0.0);
VectorScale(punchangle, len, punchangle);
}
void PM_CheckParamters(void)
{
float spd;
float maxspeed;
vec3_t v_angle;
spd = (pmove->cmd.forwardmove * pmove->cmd.forwardmove) + (pmove->cmd.sidemove * pmove->cmd.sidemove) + (pmove->cmd.upmove * pmove->cmd.upmove);
spd = sqrt(spd);
maxspeed = pmove->clientmaxspeed;
if (maxspeed != 0.0)
pmove->maxspeed = min(maxspeed, pmove->maxspeed);
if ((spd != 0.0) && (spd > pmove->maxspeed))
{
float fRatio = pmove->maxspeed / spd;
pmove->cmd.forwardmove *= fRatio;
pmove->cmd.sidemove *= fRatio;
pmove->cmd.upmove *= fRatio;
}
if (pmove->flags & FL_FROZEN || pmove->flags & FL_ONTRAIN || pmove->dead)
{
pmove->cmd.forwardmove = 0;
pmove->cmd.sidemove = 0;
pmove->cmd.upmove = 0;
}
PM_DropPunchAngle(pmove->punchangle);
if (!pmove->dead)
{
VectorCopy(pmove->cmd.viewangles, v_angle);
VectorAdd(v_angle, pmove->punchangle, v_angle);
pmove->angles[ROLL] = PM_CalcRoll(v_angle, pmove->velocity, pmove->movevars->rollangle, pmove->movevars->rollspeed) * 4;
pmove->angles[PITCH] = v_angle[PITCH];
pmove->angles[YAW] = v_angle[YAW];
}
else
{
VectorCopy(pmove->oldangles, pmove->angles);
}
if (pmove->dead)
{
pmove->view_ofs[2] = PM_DEAD_VIEWHEIGHT;
}
if (pmove->angles[YAW] > 180.0f)
{
pmove->angles[YAW] -= 360.0f;
}
}
void PM_ReduceTimers(void)
{
if (pmove->flTimeStepSound > 0)
{
pmove->flTimeStepSound -= pmove->cmd.msec;
if (pmove->flTimeStepSound < 0)
{
pmove->flTimeStepSound = 0;
}
}
if (pmove->flDuckTime > 0)
{
pmove->flDuckTime -= pmove->cmd.msec;
if (pmove->flDuckTime < 0)
{
pmove->flDuckTime = 0;
}
}
if (pmove->flSwimTime > 0)
{
pmove->flSwimTime -= pmove->cmd.msec;
if (pmove->flSwimTime < 0)
{
pmove->flSwimTime = 0;
}
}
if (pmove->fuser2 > 0.0)
{
pmove->fuser2 -= pmove->cmd.msec;
if (pmove->fuser2 < 0)
pmove->fuser2 = 0;
}
}
void PM_PlayerMove(qboolean server)
{
physent_t *pLadder = NULL;
pmove->server = server;
PM_CheckParamters();
pmove->numtouch = 0;
pmove->frametime = pmove->cmd.msec * 0.001;
PM_ReduceTimers();
AngleVectors(pmove->angles, pmove->forward, pmove->right, pmove->up);
if ((pmove->spectator || pmove->iuser1 > 0) && (pmove->iuser3 <= 0 || pmove->deadflag == DEAD_DEAD))
{
PM_SpectatorMove();
PM_CatagorizePosition();
return;
}
if (pmove->movetype != MOVETYPE_NOCLIP && pmove->movetype != MOVETYPE_NONE)
{
if (PM_CheckStuck())
{
return;
}
}
PM_CatagorizePosition();
pmove->oldwaterlevel = pmove->waterlevel;
if (pmove->onground == -1)
{
pmove->flFallVelocity = -pmove->velocity[2];
}
g_onladder = 0;
if (!pmove->dead && !(pmove->flags & FL_ONTRAIN))
{
pLadder = PM_Ladder();
if (pLadder)
{
g_onladder = 1;
}
}
PM_Duck();
PM_UpdateStepSound();
if (!pmove->dead && !(pmove->flags & FL_ONTRAIN))
{
if (pLadder)
{
PM_LadderMove(pLadder);
}
else if (pmove->movetype != MOVETYPE_WALK && pmove->movetype != MOVETYPE_NOCLIP)
{
pmove->movetype = MOVETYPE_WALK;
}
}
switch (pmove->movetype)
{
default:
{
pmove->Con_DPrintf("Bogus pmove player movetype %i on (%i) 0=cl 1=sv\n", pmove->movetype, pmove->server);
break;
}
case MOVETYPE_NONE:
{
break;
}
case MOVETYPE_NOCLIP:
{
PM_NoClip();
break;
}
case MOVETYPE_TOSS:
case MOVETYPE_BOUNCE:
{
PM_Physics_Toss();
break;
}
case MOVETYPE_FLY:
{
PM_CheckWater();
if (pmove->cmd.buttons & IN_JUMP)
{
if (!pLadder)
{
PM_Jump();
}
}
else
{
pmove->oldbuttons &= ~IN_JUMP;
}
VectorAdd(pmove->velocity, pmove->basevelocity, pmove->velocity);
PM_FlyMove();
VectorSubtract(pmove->velocity, pmove->basevelocity, pmove->velocity);
break;
}
case MOVETYPE_WALK:
{
if (!PM_InWater())
{
PM_AddCorrectGravity();
}
if (pmove->waterjumptime)
{
PM_WaterJump();
PM_FlyMove();
PM_CheckWater();
return;
}
if (pmove->waterlevel >= 2)
{
if (pmove->waterlevel == 2)
{
PM_CheckWaterJump();
}
if (pmove->velocity[2] < 0 && pmove->waterjumptime)
{
pmove->waterjumptime = 0;
}
if (pmove->cmd.buttons & IN_JUMP)
{
PM_Jump();
}
else
{
pmove->oldbuttons &= ~IN_JUMP;
}
PM_WaterMove();
VectorSubtract(pmove->velocity, pmove->basevelocity, pmove->velocity);
PM_CatagorizePosition();
}
else
{
if (pmove->cmd.buttons & IN_JUMP)
{
if (!pLadder)
{
PM_Jump();
}
}
else
{
pmove->oldbuttons &= ~IN_JUMP;
}
if (pmove->onground != -1)
{
pmove->velocity[2] = 0.0;
PM_Friction();
}
PM_CheckVelocity();
if (pmove->onground != -1)
{
PM_WalkMove();
}
else
{
PM_AirMove();
}
PM_CatagorizePosition();
VectorSubtract(pmove->velocity, pmove->basevelocity, pmove->velocity);
PM_CheckVelocity();
if (!PM_InWater())
{
PM_FixupGravityVelocity();
}
if (pmove->onground != -1)
{
pmove->velocity[2] = 0;
}
PM_CheckFalling();
}
PM_PlayWaterSounds();
break;
}
}
}
void PM_CreateStuckTable(void)
{
float x, y, z;
int idx;
int i;
float zi[3];
memset(rgv3tStuckTable, 0, sizeof(rgv3tStuckTable));
idx = 0;
x = y = 0;
for (z = -0.125; z <= 0.125; z += 0.125, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
x = z = 0;
for (y = -0.125; y <= 0.125; y += 0.125, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
y = z = 0;
for (x = -0.125; x <= 0.125; x += 0.125, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
for (x = -0.125; x <= 0.125; x += 0.250)
{
for (y = -0.125; y <= 0.125; y += 0.250)
{
for (z = -0.125; z <= 0.125; z += 0.250, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
}
}
x = y = 0;
zi[0] = 0;
zi[1] = 1;
zi[2] = 6;
for (i = 0; i < 3; i++, idx++)
{
z = zi[i];
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
x = z = 0;
for (y = -2; y <= 2; y += 2, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
y = z = 0;
for (x = -2; x <= 2; x += 2, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
for (i = 0; i < 3; i++)
{
z = zi[i];
for (y = -2; y <= 2; y += 2)
{
for (z = -2; z <= 2; z += 2, idx++)
{
rgv3tStuckTable[idx][0] = x;
rgv3tStuckTable[idx][1] = y;
rgv3tStuckTable[idx][2] = z;
}
}
}
}
void PM_Move (struct playermove_s *ppmove, int server)
{
assert(pm_shared_initialized);
pmove = ppmove;
PM_PlayerMove((server != 0) ? true : false);
if (pmove->onground != -1)
{
pmove->flags |= FL_ONGROUND;
}
else
{
pmove->flags &= ~FL_ONGROUND;
}
if (!pmove->multiplayer && (pmove->movetype == MOVETYPE_WALK))
{
pmove->friction = 1.0f;
}
}
int PM_GetVisEntInfo(int ent)
{
if (ent >= 0 && ent <= pmove->numvisent)
{
return pmove->visents[ent].info;
}
return -1;
}
int PM_GetPhysEntInfo(int ent)
{
if (ent >= 0 && ent <= pmove->numphysent)
return pmove->physents[ent].info;
return -1;
}
void PM_Init(struct playermove_s *ppmove)
{
assert(!pm_shared_initialized);
pmove = ppmove;
PM_CreateStuckTable();
PM_InitTextureTypes();
pm_shared_initialized = 1;
}
Reference in New Issue Copy Permalink