mirror of
https://github.com/s1lentq/ReGameDLL_CS.git
synced 2024-10-17 07:46:52 +03:00
1259 lines
37 KiB
C++
1259 lines
37 KiB
C++
#include "precompiled.h"
|
|
|
|
/*
|
|
* Globals initialization
|
|
*/
|
|
#ifndef HOOK_GAMEDLL
|
|
|
|
//static int pm_shared_initialized = 0;
|
|
|
|
//static vec_t rgv3tStuckTable[54][3];
|
|
//static int rgStuckLast[32][2];
|
|
|
|
//static int pm_gcTextures = 0; // TODO: var names without pm_*
|
|
//static char pm_grgszTextureName[1024][17];
|
|
//static char pm_grgchTextureType[1024];
|
|
|
|
//playermove_t *pmove = NULL;
|
|
//int g_onladder = 0;
|
|
|
|
#else // HOOK_GAMEDLL
|
|
|
|
int pm_shared_initialized;
|
|
|
|
vec3_t rgv3tStuckTable[54];
|
|
//int rgStuckLast[32][2];
|
|
|
|
int pm_gcTextures;
|
|
char pm_grgszTextureName[ CTEXTURESMAX ][ CBTEXTURENAMEMAX ];
|
|
char pm_grgchTextureType[ CTEXTURESMAX ];
|
|
|
|
playermove_t *pmove;
|
|
//int g_onladder;
|
|
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
/* <2cc613> ../cstrike/pm_shared/pm_shared.c:165 */
|
|
NOXREF void PM_SwapTextures(int i, int j)
|
|
{
|
|
char chTemp;
|
|
char szTemp[CBTEXTURENAMEMAX];
|
|
|
|
Q_strcpy(szTemp, pm_grgszTextureName[i]);
|
|
chTemp = pm_grgchTextureType[i];
|
|
|
|
Q_strcpy(pm_grgszTextureName[i], pm_grgszTextureName[j]);
|
|
pm_grgchTextureType[i] = pm_grgchTextureType[j];
|
|
|
|
Q_strcpy(pm_grgszTextureName[j], szTemp);
|
|
pm_grgchTextureType[j] = chTemp;
|
|
}
|
|
|
|
/* <2cc691> ../cstrike/pm_shared/pm_shared.c:180 */
|
|
NOXREF int PM_IsThereGrassTexture(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0 ; i < pm_gcTextures; i++)
|
|
{
|
|
if (pm_grgchTextureType[i] == CHAR_TEX_GRASS)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* <2cc6bb> ../cstrike/pm_shared/pm_shared.c:193 */
|
|
NOXREF void PM_SortTextures(void)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0 ; i < pm_gcTextures; i++)
|
|
{
|
|
for (j = i + 1; j < pm_gcTextures; j++)
|
|
{
|
|
if (Q_stricmp(pm_grgszTextureName[i], pm_grgszTextureName[j]) > 0)
|
|
PM_SwapTextures(i, j);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* <2cc720> ../cstrike/pm_shared/pm_shared.c:213 */
|
|
void PM_InitTextureTypes(void)
|
|
{
|
|
char buffer[512];
|
|
int i, j;
|
|
byte *pMemFile;
|
|
int fileSize, filePos;
|
|
static qboolean bTextureTypeInit = false;
|
|
|
|
if (bTextureTypeInit)
|
|
return;
|
|
|
|
Q_memset(&(pm_grgszTextureName[0][0]), 0, sizeof(pm_grgszTextureName));
|
|
Q_memset(pm_grgchTextureType, 0, sizeof(pm_grgchTextureType));
|
|
|
|
pm_gcTextures = 0;
|
|
Q_memset(buffer, 0, sizeof(buffer));
|
|
|
|
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 && (pm_gcTextures < CTEXTURESMAX))
|
|
{
|
|
i = 0;
|
|
|
|
while (buffer[i] && isspace(buffer[i]))
|
|
i++;
|
|
|
|
if (!buffer[i])
|
|
continue;
|
|
|
|
if (buffer[i] == '/' || !isalpha(buffer[i]))
|
|
continue;
|
|
|
|
pm_grgchTextureType[pm_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;
|
|
Q_strcpy(&(pm_grgszTextureName[pm_gcTextures++][0]), &(buffer[i]));
|
|
}
|
|
|
|
pmove->COM_FreeFile(pMemFile);
|
|
|
|
PM_SortTextures();
|
|
|
|
bTextureTypeInit = true;
|
|
}
|
|
|
|
/* <2cc7c5> ../cstrike/pm_shared/pm_shared.c:283 */
|
|
char PM_FindTextureType(char *name)
|
|
{
|
|
int left = 0;
|
|
int right = pm_gcTextures - 1;
|
|
int pivot;
|
|
int val;
|
|
|
|
assert( pm_shared_initialized );
|
|
|
|
while (left <= right)
|
|
{
|
|
pivot = (left + right) / 2;
|
|
|
|
val = Q_strnicmp(name, pm_grgszTextureName[pivot], CBTEXTURENAMEMAX - 1);
|
|
|
|
if (val == 0)
|
|
return pm_grgchTextureType[pivot];
|
|
|
|
else if (val > 0)
|
|
left = pivot + 1;
|
|
|
|
else if (val < 0)
|
|
right = pivot - 1;
|
|
}
|
|
|
|
return CHAR_TEX_CONCRETE;
|
|
}
|
|
|
|
/* <2cc416> ../cstrike/pm_shared/pm_shared.c:315 */
|
|
void PM_PlayStepSound(int step, float fvol)
|
|
{
|
|
static int iSkipStep = 0;
|
|
int irand;
|
|
//vec3_t hvel;//unused?
|
|
|
|
pmove->iStepLeft = pmove->iStepLeft == 0;
|
|
|
|
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)
|
|
{
|
|
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_wade2.wav", fvol, ATTN_NORM, 0, PITCH_NORM);
|
|
break;
|
|
case 2:
|
|
pmove->PM_PlaySound(CHAN_BODY, "player/pl_wade3.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;
|
|
}
|
|
}
|
|
else
|
|
iSkipStep++;
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* <2cc462> ../cstrike/pm_shared/pm_shared.c:489 */
|
|
NOXREF 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;
|
|
}
|
|
}
|
|
|
|
/* <2cc8af> ../cstrike/pm_shared/pm_shared.c:512 */
|
|
void PM_CatagorizeTextureType(void)
|
|
{
|
|
vec3_t start, end;
|
|
const char *pTextureName;
|
|
|
|
VectorCopy(pmove->origin, start);
|
|
VectorCopy(pmove->origin, end);
|
|
|
|
end[2] -= 64.0f;
|
|
|
|
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++;
|
|
|
|
Q_strcpy(pmove->sztexturename, pTextureName);
|
|
pmove->sztexturename[CBTEXTURENAMEMAX - 1] = 0;
|
|
|
|
pmove->chtexturetype = PM_FindTextureType(pmove->sztexturename);
|
|
}
|
|
|
|
/* <2cc93c> ../cstrike/pm_shared/pm_shared.c:546 */
|
|
void PM_UpdateStepSound(void)
|
|
{
|
|
float fvol;
|
|
vec3_t knee;
|
|
vec3_t feet;
|
|
vec3_t center;
|
|
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.0)
|
|
{
|
|
pmove->flTimeStepSound = 400;
|
|
return;
|
|
}
|
|
|
|
fLadder = (pmove->movetype == MOVETYPE_FLY);
|
|
|
|
if (fLadder || pmove->onground != -1)
|
|
{
|
|
PM_CatagorizeTextureType();
|
|
|
|
VectorCopy(pmove->origin, center);
|
|
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_DIRT:
|
|
{
|
|
fvol = 0.55;
|
|
break;
|
|
}
|
|
case CHAR_TEX_VENT:
|
|
{
|
|
fvol = 0.7;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
fvol = 0.5;
|
|
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);
|
|
}
|
|
}
|
|
|
|
/* <2cca3d> ../cstrike/pm_shared/pm_shared.c:679 */
|
|
NOBODY qboolean PM_AddToTouched(pmtrace_t tr, vec3_t impactvelocity)
|
|
{
|
|
// int i; // 681
|
|
}
|
|
|
|
/* <2cca88> ../cstrike/pm_shared/pm_shared.c:707 */
|
|
NOBODY void PM_CheckVelocity(void)
|
|
{
|
|
// int i; // 709
|
|
}
|
|
|
|
/* <2ccbe9> ../cstrike/pm_shared/pm_shared.c:752 */
|
|
NOBODY int PM_ClipVelocity(vec3_t in, vec3_t normal, vec3_t out, float overbounce)
|
|
{
|
|
// float backoff; // 754
|
|
// float change; // 755
|
|
// float angle; // 756
|
|
// int i; // 757
|
|
// int blocked; // 757
|
|
}
|
|
|
|
/* <2ccc93> ../cstrike/pm_shared/pm_shared.c:784 */
|
|
NOBODY void PM_AddCorrectGravity(void)
|
|
{
|
|
// float ent_gravity; // 786
|
|
}
|
|
|
|
/* <2cc482> ../cstrike/pm_shared/pm_shared.c:806 */
|
|
NOBODY void PM_FixupGravityVelocity(void)
|
|
{
|
|
// float ent_gravity; // 808
|
|
}
|
|
|
|
/* <2ccd08> ../cstrike/pm_shared/pm_shared.c:831 */
|
|
NOBODY int PM_FlyMove(void)
|
|
{
|
|
// int bumpcount; // 833
|
|
// int numbumps; // 833
|
|
// vec3_t dir; // 834
|
|
// float d; // 835
|
|
// int numplanes; // 836
|
|
// vec_t planes; // 837
|
|
// vec3_t primal_velocity; // 838
|
|
// vec3_t original_velocity; // 838
|
|
// vec3_t new_velocity; // 839
|
|
// int i; // 840
|
|
// int j; // 840
|
|
// pmtrace_t trace; // 841
|
|
// vec3_t end; // 842
|
|
// float time_left; // 843
|
|
// float allFraction; // 843
|
|
// int blocked; // 844
|
|
}
|
|
|
|
/* <2cce2e> ../cstrike/pm_shared/pm_shared.c:1027 */
|
|
NOBODY void PM_Accelerate(vec3_t wishdir, float wishspeed, float accel)
|
|
{
|
|
// int i; // 1029
|
|
// float addspeed; // 1030
|
|
// float accelspeed; // 1030
|
|
// float currentspeed; // 1030
|
|
}
|
|
|
|
/* <2cceaf> ../cstrike/pm_shared/pm_shared.c:1071 */
|
|
NOBODY void PM_WalkMove(void)
|
|
{
|
|
// int clip; // 1073
|
|
// int oldonground; // 1074
|
|
// int i; // 1075
|
|
// vec3_t wishvel; // 1077
|
|
// float spd; // 1078
|
|
// float fmove; // 1079
|
|
// float smove; // 1079
|
|
// vec3_t wishdir; // 1080
|
|
// float wishspeed; // 1081
|
|
// vec3_t dest; // 1083
|
|
// vec3_t start; // 1083
|
|
// vec3_t original; // 1084
|
|
// vec3_t originalvel; // 1084
|
|
// vec3_t down; // 1085
|
|
// vec3_t downvel; // 1085
|
|
// float downdist; // 1086
|
|
// float updist; // 1086
|
|
// pmtrace_t trace; // 1088
|
|
//
|
|
//usedown: // 1234
|
|
// {
|
|
// float flRatio; // 1092
|
|
// }
|
|
}
|
|
|
|
/* <2ccffb> ../cstrike/pm_shared/pm_shared.c:1249 */
|
|
NOBODY void PM_Friction(void)
|
|
{
|
|
// float *vel; // 1251
|
|
// float speed; // 1252
|
|
// float newspeed; // 1252
|
|
// float control; // 1252
|
|
// float friction; // 1253
|
|
// float drop; // 1254
|
|
// vec3_t newvel; // 1255
|
|
// {
|
|
// vec3_t start; // 1278
|
|
// vec3_t stop; // 1278
|
|
// pmtrace_t trace; // 1279
|
|
// }
|
|
}
|
|
|
|
/* <2cd0ba> ../cstrike/pm_shared/pm_shared.c:1326 */
|
|
NOBODY void PM_AirAccelerate(vec3_t wishdir, float wishspeed, float accel)
|
|
{
|
|
// int i; // 1328
|
|
// float addspeed; // 1329
|
|
// float accelspeed; // 1329
|
|
// float currentspeed; // 1329
|
|
// float wishspd; // 1329
|
|
}
|
|
|
|
/* <2cd14b> ../cstrike/pm_shared/pm_shared.c:1368 */
|
|
NOBODY void PM_WaterMove(void)
|
|
{
|
|
// int i; // 1370
|
|
// vec3_t wishvel; // 1371
|
|
// float wishspeed; // 1372
|
|
// vec3_t wishdir; // 1373
|
|
// vec3_t start; // 1374
|
|
// vec3_t dest; // 1374
|
|
// vec3_t temp; // 1375
|
|
// pmtrace_t trace; // 1376
|
|
// float speed; // 1378
|
|
// float newspeed; // 1378
|
|
// float addspeed; // 1378
|
|
// float accelspeed; // 1378
|
|
}
|
|
|
|
/* <2cd220> ../cstrike/pm_shared/pm_shared.c:1464 */
|
|
NOBODY void PM_AirMove(void)
|
|
{
|
|
// int i; // 1466
|
|
// vec3_t wishvel; // 1467
|
|
// float fmove; // 1468
|
|
// float smove; // 1468
|
|
// vec3_t wishdir; // 1469
|
|
// float wishspeed; // 1470
|
|
}
|
|
|
|
/* <2cc586> ../cstrike/pm_shared/pm_shared.c:1510 */
|
|
NOBODY qboolean PM_InWater(void)
|
|
{
|
|
}
|
|
|
|
/* <2cd2a7> ../cstrike/pm_shared/pm_shared.c:1522 */
|
|
NOBODY qboolean PM_CheckWater(void)
|
|
{
|
|
// vec3_t point; // 1524
|
|
// int cont; // 1525
|
|
// int truecont; // 1526
|
|
// float height; // 1527
|
|
// float heightover2; // 1528
|
|
// {
|
|
// vec_t current_table; // 1575
|
|
// }
|
|
}
|
|
|
|
/* <2cd33a> ../cstrike/pm_shared/pm_shared.c:1593 */
|
|
NOBODY void PM_CatagorizePosition(void)
|
|
{
|
|
// vec3_t point; // 1595
|
|
// pmtrace_t tr; // 1596
|
|
}
|
|
|
|
/* <2cc4c5> ../cstrike/pm_shared/pm_shared.c:1654 */
|
|
NOBODY int PM_GetRandomStuckOffsets(int nIndex, int server, vec3_t offset)
|
|
{
|
|
// int idx; // 1657
|
|
}
|
|
|
|
/* <2cc49d> ../cstrike/pm_shared/pm_shared.c:1665 */
|
|
NOBODY void PM_ResetStuckOffsets(int nIndex, int server)
|
|
{
|
|
}
|
|
|
|
/* <2cd3cf> ../cstrike/pm_shared/pm_shared.c:1681 */
|
|
NOBODY int PM_CheckStuck(void)
|
|
{
|
|
// vec3_t base; // 1683
|
|
// vec3_t offset; // 1684
|
|
// vec3_t test; // 1685
|
|
// int hitent; // 1686
|
|
// int idx; // 1687
|
|
// float fTime; // 1688
|
|
// int i; // 1689
|
|
// pmtrace_t traceresult; // 1690
|
|
// float rgStuckCheckTime; // 1692
|
|
// {
|
|
// int nReps; // 1713
|
|
// PM_ResetStuckOffsets(int nIndex,
|
|
// int server); // 1714
|
|
// PM_GetRandomStuckOffsets(int nIndex,
|
|
// int server,
|
|
// vec3_t offset); // 1717
|
|
// PM_ResetStuckOffsets(int nIndex,
|
|
// int server); // 1722
|
|
// }
|
|
// {
|
|
// float x; // 1769
|
|
// float y; // 1769
|
|
// float z; // 1769
|
|
// float xystep; // 1770
|
|
// float zstep; // 1771
|
|
// float xyminmax; // 1772
|
|
// float zminmax; // 1773
|
|
// }
|
|
// PM_GetRandomStuckOffsets(int nIndex,
|
|
// int server,
|
|
// vec3_t offset); // 1750
|
|
// PM_ResetStuckOffsets(int nIndex,
|
|
// int server); // 1757
|
|
// PM_ResetStuckOffsets(int nIndex,
|
|
// int server); // 1698
|
|
}
|
|
|
|
/* <2cd61f> ../cstrike/pm_shared/pm_shared.c:1807 */
|
|
NOBODY void PM_SpectatorMove(void)
|
|
{
|
|
// float speed; // 1809
|
|
// float drop; // 1809
|
|
// float friction; // 1809
|
|
// float control; // 1809
|
|
// float newspeed; // 1809
|
|
// float currentspeed; // 1811
|
|
// float addspeed; // 1811
|
|
// float accelspeed; // 1811
|
|
// int i; // 1812
|
|
// vec3_t wishvel; // 1813
|
|
// float fmove; // 1814
|
|
// float smove; // 1814
|
|
// vec3_t wishdir; // 1815
|
|
// float wishspeed; // 1816
|
|
// {
|
|
// int target; // 1905
|
|
// }
|
|
}
|
|
|
|
/* <2cc509> ../cstrike/pm_shared/pm_shared.c:1941 */
|
|
NOBODY float PM_SplineFraction(float value, float scale)
|
|
{
|
|
// float valueSquared; // 1943
|
|
}
|
|
|
|
/* <2cd757> ../cstrike/pm_shared/pm_shared.c:1952 */
|
|
NOBODY float PM_SimpleSpline(float value)
|
|
{
|
|
// float valueSquared; // 1954
|
|
}
|
|
|
|
/* <2cc595> ../cstrike/pm_shared/pm_shared.c:1959 */
|
|
NOBODY void PM_FixPlayerCrouchStuck(int direction)
|
|
{
|
|
// int hitent; // 1961
|
|
// int i; // 1962
|
|
// vec3_t test; // 1963
|
|
}
|
|
|
|
/* <2cd7cd> ../cstrike/pm_shared/pm_shared.c:1983 */
|
|
NOBODY void PM_Duck(void)
|
|
{
|
|
// float duckFraction; // 1986
|
|
// int buttonsChanged; // 1988
|
|
// int nButtonPressed; // 1989
|
|
// int duckchange; // 1991
|
|
// int duckpressed; // 1992
|
|
// {
|
|
// float fMore; // 2063
|
|
// float time; // 2064
|
|
// }
|
|
// {
|
|
// pmtrace_t trace; // 2074
|
|
// vec3_t newOrigin; // 2075
|
|
// }
|
|
// PM_FixPlayerCrouchStuck(int direction); // 2055
|
|
}
|
|
|
|
/* <2cd8c2> ../cstrike/pm_shared/pm_shared.c:2332 */
|
|
NOBODY void PM_LadderMove(physent_t *pLadder)
|
|
{
|
|
// vec3_t ladderCenter; // 2334
|
|
// trace_t trace; // 2335
|
|
// qboolean onFloor; // 2336
|
|
// vec3_t floor; // 2337
|
|
// vec3_t modelmins; // 2338
|
|
// vec3_t modelmaxs; // 2338
|
|
// {
|
|
// float forward; // 2364
|
|
// float right; // 2364
|
|
// vec3_t vpn; // 2365
|
|
// vec3_t v_right; // 2365
|
|
// float flSpeed; // 2366
|
|
// {
|
|
// vec3_t velocity; // 2407
|
|
// vec3_t perp; // 2407
|
|
// vec3_t cross; // 2407
|
|
// vec3_t lateral; // 2407
|
|
// vec3_t tmp; // 2407
|
|
// float normal; // 2408
|
|
// }
|
|
// }
|
|
}
|
|
|
|
/* <2cda06> ../cstrike/pm_shared/pm_shared.c:2457 */
|
|
NOBODY physent_t *PM_Ladder(void)
|
|
{
|
|
// int i; // 2459
|
|
// physent_t *pe; // 2460
|
|
// hull_t *hull; // 2461
|
|
// int num; // 2462
|
|
// vec3_t test; // 2463
|
|
}
|
|
|
|
/* <2cda77> ../cstrike/pm_shared/pm_shared.c:2491 */
|
|
NOBODY void PM_WaterJump(void)
|
|
{
|
|
}
|
|
|
|
/* <2cda8d> ../cstrike/pm_shared/pm_shared.c:2519 */
|
|
NOBODY void PM_AddGravity(void)
|
|
{
|
|
// float ent_gravity; // 2521
|
|
}
|
|
|
|
/* <2cdac6> ../cstrike/pm_shared/pm_shared.c:2541 */
|
|
NOBODY pmtrace_t PM_PushEntity(vec3_t push)
|
|
{
|
|
// pmtrace_t trace; // 2543
|
|
// vec3_t end; // 2544
|
|
}
|
|
|
|
/* <2cdb13> ../cstrike/pm_shared/pm_shared.c:2569 */
|
|
NOBODY void PM_Physics_Toss(void)
|
|
{
|
|
// pmtrace_t trace; // 2571
|
|
// vec3_t move; // 2572
|
|
// float backoff; // 2573
|
|
// PM_AddGravity(void); // 2594
|
|
// {
|
|
// float vel; // 2636
|
|
// vec3_t base; // 2637
|
|
// }
|
|
}
|
|
|
|
/* <2cdba2> ../cstrike/pm_shared/pm_shared.c:2674 */
|
|
NOBODY void PM_NoClip(void)
|
|
{
|
|
// int i; // 2676
|
|
// vec3_t wishvel; // 2677
|
|
// float fmove; // 2678
|
|
// float smove; // 2678
|
|
}
|
|
|
|
/* <2ccab0> ../cstrike/pm_shared/pm_shared.c:2711 */
|
|
NOBODY void PM_PreventMegaBunnyJumping(void)
|
|
{
|
|
// float spd; // 2714
|
|
// float fraction; // 2716
|
|
// float maxscaledspeed; // 2718
|
|
}
|
|
|
|
/* <2cc541> ../cstrike/pm_shared/pm_shared.c:2741 */
|
|
NOBODY void PM_Jump(void)
|
|
{
|
|
// float fvol; // 2743
|
|
// float fvel; // 2744
|
|
// {
|
|
// float flRatio; // 2847
|
|
// }
|
|
}
|
|
|
|
/* <2cdc4b> ../cstrike/pm_shared/pm_shared.c:2869 */
|
|
NOBODY void PM_CheckWaterJump(void)
|
|
{
|
|
// vec3_t vecStart; // 2871
|
|
// vec3_t vecEnd; // 2871
|
|
// vec3_t flatforward; // 2872
|
|
// vec3_t flatvelocity; // 2873
|
|
// float curspeed; // 2874
|
|
// pmtrace_t tr; // 2875
|
|
// int savehull; // 2876
|
|
}
|
|
|
|
/* <2cdcd3> ../cstrike/pm_shared/pm_shared.c:2933 */
|
|
NOBODY void PM_CheckFalling(void)
|
|
{
|
|
// {
|
|
// float fvol; // 2939
|
|
// PM_MapTextureTypeStepType(char chTextureType); // 2963
|
|
// PM_PlayStepSound(int step,
|
|
// float fvol); // 2963
|
|
// }
|
|
}
|
|
|
|
/* <2cdd60> ../cstrike/pm_shared/pm_shared.c:2988 */
|
|
NOBODY void PM_PlayWaterSounds(void)
|
|
{
|
|
}
|
|
|
|
/* <2cdd76> ../cstrike/pm_shared/pm_shared.c:3018 */
|
|
NOXREF float PM_CalcRoll(vec_t *angles, vec_t *velocity, float rollangle, float rollspeed)
|
|
{
|
|
long double sign;
|
|
long double side;
|
|
long double value;
|
|
|
|
vec3_t forward;
|
|
vec3_t right;
|
|
vec3_t up;
|
|
|
|
AngleVectors(angles, forward, right, up);
|
|
|
|
side = velocity[0] * right[0] + velocity[1] * right[1] + velocity[2] * right[2];
|
|
|
|
sign = side < 0 ? -1 : 1;
|
|
|
|
side = fabs(side);
|
|
|
|
value = rollangle;
|
|
|
|
if (side < rollspeed)
|
|
side = side * value / rollspeed;
|
|
else
|
|
side = value;
|
|
|
|
return side * sign;
|
|
}
|
|
|
|
/* <2cde69> ../cstrike/pm_shared/pm_shared.c:3053 */
|
|
NOXREF void PM_DropPunchAngle(vec_t *punchangle)
|
|
{
|
|
long double len = VectorNormalize(punchangle);
|
|
|
|
len -= (len * 0.5f + 10.0f) * pmove->frametime;
|
|
len = max(len, 0.0f);
|
|
|
|
VectorScale(punchangle, len, punchangle);
|
|
}
|
|
|
|
/* <2cdeb8> ../cstrike/pm_shared/pm_shared.c:3069 */
|
|
void PM_CheckParamters(void)
|
|
{
|
|
long double spd;
|
|
float maxspeed;
|
|
vec3_t v_angle;
|
|
|
|
spd = sqrt((long double)(pmove->cmd.sidemove * pmove->cmd.sidemove + pmove->cmd.forwardmove * pmove->cmd.forwardmove + pmove->cmd.upmove * pmove->cmd.upmove));
|
|
|
|
maxspeed = pmove->clientmaxspeed;
|
|
|
|
if (maxspeed)
|
|
{
|
|
if (maxspeed <= pmove->clientmaxspeed)
|
|
maxspeed = pmove->maxspeed;
|
|
|
|
pmove->maxspeed = maxspeed;
|
|
}
|
|
|
|
if (spd)
|
|
{
|
|
if (spd > pmove->maxspeed)
|
|
{
|
|
long double fRatio = pmove->maxspeed / spd;
|
|
|
|
pmove->cmd.forwardmove *= fRatio;
|
|
pmove->cmd.sidemove *= fRatio;
|
|
pmove->cmd.upmove *= fRatio;
|
|
}
|
|
}
|
|
|
|
if ((pmove->flags & (FL_FROZEN | FL_ONTRAIN)) || pmove->dead)
|
|
{
|
|
pmove->cmd.forwardmove = 0.0f;
|
|
pmove->cmd.sidemove = 0.0f;
|
|
pmove->cmd.upmove = 0.0f;
|
|
}
|
|
|
|
PM_DropPunchAngle(pmove->punchangle);
|
|
|
|
if (pmove->dead)
|
|
{
|
|
pmove->angles[0] = pmove->oldangles[0];
|
|
pmove->angles[1] = pmove->oldangles[1];
|
|
pmove->angles[2] = pmove->oldangles[2];
|
|
}
|
|
else
|
|
{
|
|
v_angle[0] = pmove->cmd.viewangles[0] + pmove->punchangle[0];
|
|
v_angle[1] = pmove->cmd.viewangles[1] + pmove->punchangle[1];
|
|
v_angle[2] = pmove->cmd.viewangles[2] + pmove->punchangle[2];
|
|
|
|
pmove->angles[2] = PM_CalcRoll(v_angle, pmove->velocity, pmove->movevars->rollangle, pmove->movevars->rollspeed) * 4.0f;
|
|
pmove->angles[0] = v_angle[0];
|
|
pmove->angles[1] = v_angle[1];
|
|
}
|
|
|
|
if (pmove->dead)
|
|
pmove->view_ofs[2] = -8.000000f;
|
|
|
|
if (pmove->angles[1] > 180.0f)
|
|
pmove->angles[1] = pmove->angles[1] - 360.0f;
|
|
}
|
|
|
|
/* <2cdfc3> ../cstrike/pm_shared/pm_shared.c:3136 */
|
|
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.0)
|
|
pmove->fuser2 = 0;
|
|
}
|
|
}
|
|
|
|
/* <2cc577> ../cstrike/pm_shared/pm_shared.c:3203 */
|
|
NOXREF qboolean PM_ShouldDoSpectMode(void)
|
|
{
|
|
return (pmove->iuser3 <= 0 || pmove->deadflag == DEAD_DEAD);
|
|
}
|
|
|
|
/* <2cdfe9> ../cstrike/pm_shared/pm_shared.c:3225 */
|
|
NOBODY void PM_PlayerMove(qboolean server)
|
|
{
|
|
// physent_t *pLadder; // 3227
|
|
// PM_ShouldDoSpectMode(void); // 3251
|
|
// PM_InWater(void); // 3457
|
|
// PM_Jump(void); // 3392
|
|
// PM_AddCorrectGravity(void); // 3360
|
|
// PM_Jump(void); // 3343
|
|
// PM_FixupGravityVelocity(void); // 3459
|
|
}
|
|
|
|
/* <2ce101> ../cstrike/pm_shared/pm_shared.c:3479 */
|
|
void PM_CreateStuckTable(void)
|
|
{
|
|
float x, y, z;
|
|
int idx;
|
|
int i;
|
|
float zi[3];
|
|
|
|
Q_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.0;
|
|
|
|
for (y = -2.0; y <= 2.0; y += 2.0, idx++)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
}
|
|
|
|
y = z = 0;
|
|
|
|
for (x = -2.0; x <= 2.0; x += 2.0, 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.0; y <= 2.0; y += 2.0)
|
|
{
|
|
for (z = -2.0; z <= 2.0; z += 2.0, idx++)
|
|
{
|
|
rgv3tStuckTable[idx][0] = x;
|
|
rgv3tStuckTable[idx][1] = y;
|
|
rgv3tStuckTable[idx][2] = z;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* <2ce182> ../cstrike/pm_shared/pm_shared.c:3596 */
|
|
void PM_Move(struct playermove_s *ppmove, int server)
|
|
{
|
|
assert( pm_shared_initialized );
|
|
|
|
pmove = ppmove;
|
|
|
|
PM_PlayerMove((server != 0) ? TRUE : FALSE);// TODO: Reverse me
|
|
|
|
if (pmove->onground != -1)
|
|
pmove->flags |= FL_ONGROUND;
|
|
else
|
|
pmove->flags &= ~FL_ONGROUND;
|
|
|
|
if (!pmove->multiplayer && pmove->movetype == MOVETYPE_WALK)
|
|
pmove->friction = 1.0f;
|
|
}
|
|
|
|
/* <2ce1c1> ../cstrike/pm_shared/pm_shared.c:3620 */
|
|
NOXREF int PM_GetVisEntInfo(int ent)
|
|
{
|
|
if (ent >= 0 && ent <= pmove->numvisent)
|
|
return pmove->visents[ent].info;
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* <2ce1ee> ../cstrike/pm_shared/pm_shared.c:3629 */
|
|
NOXREF int PM_GetPhysEntInfo(int ent)
|
|
{
|
|
if (ent >= 0 && ent <= pmove->numphysent)
|
|
return pmove->physents[ent].info;
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* <2ce21b> ../cstrike/pm_shared/pm_shared.c:3638 */
|
|
void PM_Init(struct playermove_s *ppmove)
|
|
{
|
|
assert( !pm_shared_initialized );
|
|
|
|
pmove = ppmove;
|
|
|
|
PM_CreateStuckTable();
|
|
PM_InitTextureTypes();
|
|
|
|
pm_shared_initialized = 1;
|
|
}
|