tech
/
nuclide
2
0
Fork 0
Code Issues 33 Releases Activity

Add helpers across the codebase to deal with networking ents. I tried prototyped a more elegant solution the compiler didn't like - the language should really deal with this.

This commit is contained in:
Marco Cawthorne 2022-08-07 14:12:55 -07:00
parent 41d3f3b520
commit 5ca96bbcd9
Signed by: eukara
GPG Key ID: CE2032F0A2882A22
29 changed files with 1672 additions and 1892 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/client/defs.h
View File

@ -23,6 +23,51 @@
#include "util.h"
#include "NSView.h"
#define READENTITY_BYTE(field, changedflag) {\
if (flChanged & changedflag)\
field = readbyte();\
}
#define READENTITY_SHORT(field, changedflag) {\
if (flChanged & changedflag)\
field = readshort();\
}
#define READENTITY_FLOAT(field, changedflag) {\
if (flChanged & changedflag)\
field = readfloat();\
}
#define READENTITY_INT(field, changedflag) {\
if (flChanged & changedflag)\
field = readint();\
}
#define READENTITY_STRING(field, changedflag) {\
if (flChanged & changedflag)\
field = readstring();\
}
#define READENTITY_COORD(field, changedflag) {\
if (flChanged & changedflag)\
field = readcoord();\
}
#define READENTITY_ANGLE(field, changedflag) {\
if (flChanged & changedflag)\
field = readshort() / (32767 / 360);\
}
#define READENTITY_ENTITY(field, changedflag) {\
if (flChanged & changedflag)\
field = findfloat(world, ::entnum, readentitynum());\
}
#define READENTITY_ENTNUM(field, changedflag) {\
if (flChanged & changedflag)\
field = readentitynum();\
}
/* undocumented printcall types */
#define PRINT_LOW 0
#define PRINT_MEDIUM 1

2
src/gs-entbase/server/func_conveyor.qc
View File

@ -109,7 +109,7 @@ func_conveyor::Trigger(entity act, int state)
/* changes direction */
glowmod[1] = 0.5f;
glowmod[2] = m_flSpeed / 1024;
SetSendFlags(BASEFL_CHANGED_RENDERCOLOR);
SetSendFlags(RDENT_CHANGED_RENDERMODE);
}
void

590
src/gs-entbase/server/func_door.qc
View File

@ -122,6 +122,301 @@ class func_door:NSRenderableEntity
virtual void(entity, string, string) Input;
};
void
func_door::func_door(void)
{
m_vecPos1 =
m_vecPos2 =
m_vecDest =
m_vecMoveDir = [0,0,0];
m_flSpeed =
m_flLip =
m_iState =
m_flNextTrigger =
m_flWait =
m_flDelay = 0.0f;
m_iDamage =
m_iLocked =
m_iPortalState =
m_iForceClosed = 0;
m_iCanTouch = false;
m_flSoundWait = 0.0f;
targetClose =
m_strLockedSfx =
m_strUnlockedSfx =
m_strSndOpen =
m_strSndClose =
m_strSndMove =
m_strSndStop = __NULL__;
}
void
func_door::Save(float handle)
{
SaveVector(handle, "m_vecPos1", m_vecPos1);
SaveVector(handle, "m_vecPos2", m_vecPos2);
SaveVector(handle, "m_vecDest", m_vecDest);
SaveVector(handle, "m_vecMoveDir", m_vecMoveDir);
SaveFloat(handle, "m_flSpeed", m_flSpeed);
SaveFloat(handle, "m_flLip", m_flLip);
SaveFloat(handle, "m_iState", m_iState);
SaveFloat(handle, "m_flNextTrigger", m_flNextTrigger);
SaveFloat(handle, "m_flWait", m_flWait);
SaveFloat(handle, "m_flDelay", m_flDelay);
SaveFloat(handle, "m_flSoundWait", m_flSoundWait);
SaveInt(handle, "m_iDamage", m_iDamage);
SaveInt(handle, "m_iLocked", m_iLocked);
SaveInt(handle, "m_iPortalState", m_iPortalState);
SaveInt(handle, "m_iForceClosed", m_iForceClosed);
SaveString(handle, "m_strLockedSfx", m_strLockedSfx);
SaveString(handle, "m_strUnlockedSfx", m_strUnlockedSfx);
SaveString(handle, "m_strSndOpen", m_strSndOpen);
SaveString(handle, "m_strSndClose", m_strSndClose);
SaveString(handle, "m_strSndStop", m_strSndStop);
SaveString(handle, "m_strSndMove", m_strSndMove);
SaveString(handle, "targetClose", targetClose);
super::Save(handle);
}
void
func_door::Restore(string strKey, string strValue)
{
switch (strKey) {
case "m_vecPos1":
m_vecPos1 = ReadVector(strValue);
break;
case "m_vecPos2":
m_vecPos2 = ReadVector(strValue);
break;
case "m_vecDest":
m_vecDest = ReadVector(strValue);
break;
case "m_vecMoveDir":
m_vecMoveDir = ReadVector(strValue);
break;
case "m_flSpeed":
m_flSpeed = ReadFloat(strValue);
break;
case "m_flLip":
m_flLip = ReadFloat(strValue);
break;
case "m_iState":
m_iState = ReadFloat(strValue);
break;
case "m_flNextTrigger":
m_flNextTrigger = ReadFloat(strValue);
break;
case "m_flWait":
m_flWait = ReadFloat(strValue);
break;
case "m_flDelay":
m_flDelay = ReadFloat(strValue);
break;
case "m_flSoundWait":
m_flSoundWait = ReadFloat(strValue);
break;
case "m_iDamage":
m_iDamage = ReadInt(strValue);
break;
case "m_iLocked":
m_iLocked = ReadInt(strValue);
break;
case "m_iPortalState":
m_iPortalState = ReadInt(strValue);
break;
case "m_iForceClosed":
m_iForceClosed = ReadInt(strValue);
break;
case "m_strLockedSfx":
m_strLockedSfx = ReadString(strValue);
break;
case "m_strUnlockedSfx":
m_strUnlockedSfx = ReadString(strValue);
break;
case "m_strSndOpen":
m_strSndOpen = ReadString(strValue);
break;
case "m_strSndClose":
m_strSndClose = ReadString(strValue);
break;
case "m_strSndStop":
m_strSndStop = ReadString(strValue);
break;
case "m_strSndMove":
m_strSndMove = ReadString(strValue);
break;
case "targetClose":
targetClose = ReadString(strValue);
break;
default:
super::Restore(strKey, strValue);
}
}
void
func_door::SpawnKey(string strKey, string strValue)
{
int x;
switch (strKey) {
case "speed":
m_flSpeed = stof(strValue);
break;
case "lip":
m_flLip = stof(strValue);
break;
case "wait":
m_flWait = stof(strValue);
break;
case "netname":
targetClose = strValue;
netname = __NULL__;
break;
case "dmg":
m_iDamage = stoi(strValue);
break;
case "snd_open":
m_strSndOpen = strValue;
break;
case "snd_close":
m_strSndClose = strValue;
break;
case "noise1":
m_strSndOpen = m_strSndClose = strValue;
break;
case "snd_stop":
case "noise2":
m_strSndStop = strValue;
break;
case "snd_move":
m_strSndMove = strValue;
break;
case "forceclosed":
m_iForceClosed = stoi(strValue);
break;
/* GoldSrc compat */
case "movesnd":
x = stoi(strValue);
m_strSndOpen = m_strSndClose = sprintf("func_door.move_%i", x);
break;
case "stopsnd":
x = stoi(strValue);
m_strSndStop = sprintf("func_door.stop_%i", x);
break;
case "locked_sound":
x = stoi(strValue);
m_strLockedSfx = sprintf("func_button.hlsfx_%i", x+1i);
break;
case "unlocked_sound":
x = stoi(strValue);
m_strUnlockedSfx = sprintf("func_button.hlsfx_%i", x+1i);
break;
default:
super::SpawnKey(strKey, strValue);
}
}
void
func_door::Spawned(void)
{
super::Spawned();
if (m_strSndOpen)
Sound_Precache(m_strSndOpen);
if (m_strSndClose)
Sound_Precache(m_strSndClose);
if (m_strSndStop)
Sound_Precache(m_strSndStop);
if (m_strSndMove)
Sound_Precache(m_strSndMove);
/* GoldSrc compat */
if (m_strLockedSfx)
Sound_Precache(m_strLockedSfx);
if (m_strUnlockedSfx)
Sound_Precache(m_strUnlockedSfx);
}
void
func_door::Respawn(void)
{
/* reset */
m_vecPos1 = [0,0,0];
m_vecPos2 = [0,0,0];
m_vecDest = [0,0,0];
m_vecMoveDir = [0,0,0];
/* this is a terrible hack */
if (m_flWait == 0)
m_flWait = 0.01f;
RestoreAngles();
SetMovementDirection();
ClearAngles();
if (HasSpawnFlags(SF_MOV_PASSABLE))
SetSolid(SOLID_NOT);
else
SetSolid(SOLID_BSP);
SetMovetype(MOVETYPE_PUSH);
SetModel(GetSpawnModel());
SetOrigin(GetSpawnOrigin());
flags |= FL_FINDABLE_NONSOLID;
think = __NULL__;
nextthink = 0.0f;
/* FIXME: Is this correct? */
if (m_flWait == -1) {
spawnflags |= SF_MOV_TOGGLE;
}
if (!m_flSpeed) {
m_flSpeed = 100.0f;
}
if (!m_iDamage) {
m_iDamage = 2;
}
m_iValue = 0;
m_iState = DOORSTATE_LOWERED;
m_vecPos1 = GetSpawnOrigin();
m_vecPos2 = (m_vecPos1 + m_vecMoveDir * (fabs(m_vecMoveDir * size) - m_flLip));
if (spawnflags & SF_MOV_USE)
m_iCanTouch = false;
else
m_iCanTouch = true;
if (HasSpawnFlags(SF_MOV_OPEN)) {
SetOrigin(m_vecPos2);
m_vecPos2 = m_vecPos1;
m_vecPos1 = origin;
m_iValue = 1;
PortalOpen();
} else {
PortalClose();
}
if (targetname) {
m_iLocked = TRUE;
}
}
void
func_door::Input(entity eAct, string strInput, string strData)
{
@ -395,301 +690,6 @@ func_door::MoveToDestination(vector vecDest, void(void) func)
velocity = (vecDifference * (1.0f / fTravelTime));
}
void
func_door::Respawn(void)
{
/* reset */
m_vecPos1 = [0,0,0];
m_vecPos2 = [0,0,0];
m_vecDest = [0,0,0];
m_vecMoveDir = [0,0,0];
/* this is a terrible hack */
if (m_flWait == 0)
m_flWait = 0.01f;
RestoreAngles();
SetMovementDirection();
ClearAngles();
if (HasSpawnFlags(SF_MOV_PASSABLE))
SetSolid(SOLID_NOT);
else
SetSolid(SOLID_BSP);
SetMovetype(MOVETYPE_PUSH);
SetModel(GetSpawnModel());
SetOrigin(GetSpawnOrigin());
flags |= FL_FINDABLE_NONSOLID;
think = __NULL__;
nextthink = 0.0f;
/* FIXME: Is this correct? */
if (m_flWait == -1) {
spawnflags |= SF_MOV_TOGGLE;
}
if (!m_flSpeed) {
m_flSpeed = 100.0f;
}
if (!m_iDamage) {
m_iDamage = 2;
}
m_iValue = 0;
m_iState = DOORSTATE_LOWERED;
m_vecPos1 = GetSpawnOrigin();
m_vecPos2 = (m_vecPos1 + m_vecMoveDir * (fabs(m_vecMoveDir * size) - m_flLip));
if (spawnflags & SF_MOV_USE)
m_iCanTouch = false;
else
m_iCanTouch = true;
if (HasSpawnFlags(SF_MOV_OPEN)) {
SetOrigin(m_vecPos2);
m_vecPos2 = m_vecPos1;
m_vecPos1 = origin;
m_iValue = 1;
PortalOpen();
} else {
PortalClose();
}
if (targetname) {
m_iLocked = TRUE;
}
}
void
func_door::Save(float handle)
{
SaveVector(handle, "m_vecPos1", m_vecPos1);
SaveVector(handle, "m_vecPos2", m_vecPos2);
SaveVector(handle, "m_vecDest", m_vecDest);
SaveVector(handle, "m_vecMoveDir", m_vecMoveDir);
SaveFloat(handle, "m_flSpeed", m_flSpeed);
SaveFloat(handle, "m_flLip", m_flLip);
SaveFloat(handle, "m_iState", m_iState);
SaveFloat(handle, "m_flNextTrigger", m_flNextTrigger);
SaveFloat(handle, "m_flWait", m_flWait);
SaveFloat(handle, "m_flDelay", m_flDelay);
SaveFloat(handle, "m_flSoundWait", m_flSoundWait);
SaveInt(handle, "m_iDamage", m_iDamage);
SaveInt(handle, "m_iLocked", m_iLocked);
SaveInt(handle, "m_iPortalState", m_iPortalState);
SaveInt(handle, "m_iForceClosed", m_iForceClosed);
SaveString(handle, "m_strLockedSfx", m_strLockedSfx);
SaveString(handle, "m_strUnlockedSfx", m_strUnlockedSfx);
SaveString(handle, "m_strSndOpen", m_strSndOpen);
SaveString(handle, "m_strSndClose", m_strSndClose);
SaveString(handle, "m_strSndStop", m_strSndStop);
SaveString(handle, "m_strSndMove", m_strSndMove);
SaveString(handle, "targetClose", targetClose);
super::Save(handle);
}
void
func_door::Restore(string strKey, string strValue)
{
switch (strKey) {
case "m_vecPos1":
m_vecPos1 = ReadVector(strValue);
break;
case "m_vecPos2":
m_vecPos2 = ReadVector(strValue);
break;
case "m_vecDest":
m_vecDest = ReadVector(strValue);
break;
case "m_vecMoveDir":
m_vecMoveDir = ReadVector(strValue);
break;
case "m_flSpeed":
m_flSpeed = ReadFloat(strValue);
break;
case "m_flLip":
m_flLip = ReadFloat(strValue);
break;
case "m_iState":
m_iState = ReadFloat(strValue);
break;
case "m_flNextTrigger":
m_flNextTrigger = ReadFloat(strValue);
break;
case "m_flWait":
m_flWait = ReadFloat(strValue);
break;
case "m_flDelay":
m_flDelay = ReadFloat(strValue);
break;
case "m_flSoundWait":
m_flSoundWait = ReadFloat(strValue);
break;
case "m_iDamage":
m_iDamage = ReadInt(strValue);
break;
case "m_iLocked":
m_iLocked = ReadInt(strValue);
break;
case "m_iPortalState":
m_iPortalState = ReadInt(strValue);
break;
case "m_iForceClosed":
m_iForceClosed = ReadInt(strValue);
break;
case "m_strLockedSfx":
m_strLockedSfx = ReadString(strValue);
break;
case "m_strUnlockedSfx":
m_strUnlockedSfx = ReadString(strValue);
break;
case "m_strSndOpen":
m_strSndOpen = ReadString(strValue);
break;
case "m_strSndClose":
m_strSndClose = ReadString(strValue);
break;
case "m_strSndStop":
m_strSndStop = ReadString(strValue);
break;
case "m_strSndMove":
m_strSndMove = ReadString(strValue);
break;
case "targetClose":
targetClose = ReadString(strValue);
break;
default:
super::Restore(strKey, strValue);
}
}
void
func_door::SpawnKey(string strKey, string strValue)
{
int x;
switch (strKey) {
case "speed":
m_flSpeed = stof(strValue);
break;
case "lip":
m_flLip = stof(strValue);
break;
case "wait":
m_flWait = stof(strValue);
break;
case "netname":
targetClose = strValue;
netname = __NULL__;
break;
case "dmg":
m_iDamage = stoi(strValue);
break;
case "snd_open":
m_strSndOpen = strValue;
break;
case "snd_close":
m_strSndClose = strValue;
break;
case "noise1":
m_strSndOpen = m_strSndClose = strValue;
break;
case "snd_stop":
case "noise2":
m_strSndStop = strValue;
break;
case "snd_move":
m_strSndMove = strValue;
break;
case "forceclosed":
m_iForceClosed = stoi(strValue);
break;
/* GoldSrc compat */
case "movesnd":
x = stoi(strValue);
m_strSndOpen = m_strSndClose = sprintf("func_door.move_%i", x);
break;
case "stopsnd":
x = stoi(strValue);
m_strSndStop = sprintf("func_door.stop_%i", x);
break;
case "locked_sound":
x = stoi(strValue);
m_strLockedSfx = sprintf("func_button.hlsfx_%i", x+1i);
break;
case "unlocked_sound":
x = stoi(strValue);
m_strUnlockedSfx = sprintf("func_button.hlsfx_%i", x+1i);
break;
default:
super::SpawnKey(strKey, strValue);
}
}
void
func_door::Spawned(void)
{
super::Spawned();
if (m_strSndOpen)
Sound_Precache(m_strSndOpen);
if (m_strSndClose)
Sound_Precache(m_strSndClose);
if (m_strSndStop)
Sound_Precache(m_strSndStop);
if (m_strSndMove)
Sound_Precache(m_strSndMove);
/* GoldSrc compat */
if (m_strLockedSfx)
Sound_Precache(m_strLockedSfx);
if (m_strUnlockedSfx)
Sound_Precache(m_strUnlockedSfx);
}
void
func_door::func_door(void)
{
m_vecPos1 =
m_vecPos2 =
m_vecDest =
m_vecMoveDir = [0,0,0];
m_flSpeed =
m_flLip =
m_iState =
m_flNextTrigger =
m_flWait =
m_flDelay = 0.0f;
m_iDamage =
m_iLocked =
m_iPortalState =
m_iForceClosed = 0;
m_iCanTouch = false;
m_flSoundWait = 0.0f;
targetClose =
m_strLockedSfx =
m_strUnlockedSfx =
m_strSndOpen =
m_strSndClose =
m_strSndMove =
m_strSndStop = __NULL__;
}
void
func_water(void)
{

407
src/gs-entbase/server/func_door_rotating.qc
View File

@ -75,19 +75,19 @@ class func_door_rotating:NSRenderableEntity
string m_strSndClose;
string m_strLockedSfx;
float m_flSoundWait;
int m_iDamage;
int m_iLocked;
float m_flDistance;
float m_flSpeed;
float m_iState;
float m_flNextAction;
float m_flWait;
float m_flDelay;
int m_iPortalState;
int m_iDamage;
int m_iLocked;
vector m_vecDest;
vector m_vecPos1;
vector m_vecPos2;
vector m_vecMoveDir;
int m_iPortalState;
bool m_iCanTouch;
void(void) func_door_rotating;
@ -113,6 +113,263 @@ class func_door_rotating:NSRenderableEntity
#endif
};
void
func_door_rotating::func_door_rotating(void)
{
targetClose = __NULL__;
m_strSndStop = __NULL__;
m_strSndOpen = __NULL__;
m_strSndClose = __NULL__;
m_strLockedSfx = __NULL__;
m_flSoundWait = 0.0f;
m_iDamage = 0i;
m_iLocked = 0i;
m_flDistance = 90.0f;
m_flSpeed = 100.0f;
m_iState = 0i;
m_flNextAction = 0.0f;
m_flWait = 0.0f;
m_flDelay = 4.0f;
m_vecDest = [0.0f, 0.0f, 0.0f];
m_vecPos1 = [0.0f, 0.0f, 0.0f];
m_vecPos2 = [0,0,0];
m_vecMoveDir = [0.0f, 0.0f, 0.0f];
m_iPortalState = 0i;
m_iCanTouch = false;
}
void
func_door_rotating::Save(float handle)
{
SaveString(handle, "targetClose", targetClose);
SaveString(handle, "m_strSndStop", m_strSndStop);
SaveString(handle, "m_strSndOpen", m_strSndOpen);
SaveString(handle, "m_strSndClose", m_strSndClose);
SaveString(handle, "m_strLockedSfx", m_strLockedSfx);
SaveFloat(handle, "m_flSoundWait", m_flSoundWait);
SaveFloat(handle, "m_flDistance", m_flDistance);
SaveFloat(handle, "m_flSpeed", m_flSpeed);
SaveFloat(handle, "m_iState", m_iState);
SaveFloat(handle, "m_flNextAction", m_flNextAction);
SaveFloat(handle, "m_flWait", m_flWait);
SaveFloat(handle, "m_flDelay", m_flDelay);
SaveInt(handle, "m_iPortalState", m_iPortalState);
SaveInt(handle, "m_iDamage", m_iDamage);
SaveInt(handle, "m_iLocked", m_iLocked);
SaveVector(handle, "m_vecDest", m_vecDest);
SaveVector(handle, "m_vecPos1", m_vecPos1);
SaveVector(handle, "m_vecPos2", m_vecPos2);
SaveVector(handle, "m_vecMoveDir", m_vecMoveDir);
SaveBool(handle, "____", m_iCanTouch);
super::Save(handle);
}
void
func_door_rotating::Restore(string strKey, string strValue)
{
switch (strKey) {
case "targetClose":
targetClose = ReadString(strValue);
break;
case "m_strSndStop":
m_strSndStop = ReadString(strValue);
break;
case "m_strSndOpen":
m_strSndOpen = ReadString(strValue);
break;
case "m_strSndClose":
m_strSndClose = ReadString(strValue);
break;
case "m_strLockedSfx":
m_strLockedSfx = ReadString(strValue);
break;
case "m_flSoundWait":
m_flSoundWait = ReadFloat(strValue);
break;
case "m_flDistance":
m_flDistance = ReadFloat(strValue);
break;
case "m_flSpeed":
m_flSpeed = ReadFloat(strValue);
break;
case "m_iState":
m_iState = ReadInt(strValue);
break;
case "m_flNextAction":
m_flNextAction = ReadFloat(strValue);
break;
case "m_flWait":
m_flWait = ReadFloat(strValue);
break;
case "m_flDelay":
m_flDelay = ReadFloat(strValue);
break;
case "m_iPortalState":
m_iPortalState = ReadInt(strValue);
break;
case "m_iDamage":
m_iDamage = ReadInt(strValue);
break;
case "m_iLocked":
m_iLocked = ReadInt(strValue);
break;
case "m_vecDest":
m_vecDest = ReadVector(strValue);
break;
case "m_vecPos1":
m_vecPos1 = ReadVector(strValue);
break;
case "m_vecPos2":
m_vecPos2 = ReadVector(strValue);
break;
case "m_vecMoveDir":
m_vecMoveDir = ReadVector(strValue);
break;
case "m_iCanTouch":
m_iCanTouch = ReadInt(strValue);
break;
default:
super::Restore(strKey, strValue);
}
}
void
func_door_rotating::Spawned(void)
{
super::Spawned();
if (m_strSndOpen)
Sound_Precache(m_strSndOpen);
if (m_strSndClose)
Sound_Precache(m_strSndClose);
if (m_strSndStop)
Sound_Precache(m_strSndStop);
if (m_strLockedSfx)
Sound_Precache(m_strLockedSfx);
}
void
func_door_rotating::Respawn(void)
{
RestoreAngles();
SetMovementDirection();
ClearAngles();
#ifdef GS_PHYSICS
takedamage = DAMAGE_YES;
health = 100;
Death = func_door_rotating::Unhinge;
#endif
SetSolid(SOLID_BSP);
SetMovetype(MOVETYPE_PUSH);
SetModel(GetSpawnModel());
SetOrigin(GetSpawnOrigin());
think = __NULL__;
nextthink = 0.0f;
avelocity = [0,0,0];
if (spawnflags & SF_ROT_USE)
m_iCanTouch = false;
else
m_iCanTouch = true;
/* this is a terrible hack */
if (m_flWait == 0)
m_flWait = 0.01f;
if (HasSpawnFlags(SF_ROT_USE)) {
PlayerUse = Use;
} else {
PlayerUse = __NULL__;
}
m_vecPos1 = GetSpawnAngles();
if (HasSpawnFlags(SF_ROT_BACKWARDS)) {
m_vecPos2 = GetSpawnAngles() + m_vecMoveDir * -m_flDistance;
} else {
m_vecPos2 = GetSpawnAngles() + m_vecMoveDir * m_flDistance;
}
if (HasSpawnFlags(SF_ROT_OPEN)) {
vector vTemp = m_vecPos2;
m_vecPos2 = m_vecPos1;
m_vecPos1 = vTemp;
m_vecMoveDir = m_vecMoveDir * -1;
PortalOpen();
} else {
PortalClose();
}
m_iState = STATE_LOWERED;
if (HasSpawnFlags(SF_ROT_PASSABLE)) {
SetSolid(SOLID_NOT);
}
if (targetname) {
m_iLocked = TRUE;
}
SetAngles(m_vecPos1);
}
void
func_door_rotating::SpawnKey(string strKey, string strValue)
{
int x = 0;
switch (strKey) {
case "speed":
m_flSpeed = stof(strValue);
break;
/*case "lip":
m_flDistance = stof(strValue);
break;*/
case "snd_open":
m_strSndOpen = strValue;
break;
case "snd_close":
m_strSndClose = strValue;
break;
case "noise1":
m_strSndOpen = m_strSndClose = strValue;
break;
case "snd_stop":
case "noise2":
m_strSndStop = strValue;
break;
/* GoldSrc compat */
case "movesnd":
x = stoi(strValue);
m_strSndOpen = m_strSndClose = sprintf("func_door_rotating.move_%i", x);
break;
case "stopsnd":
x = stoi(strValue);
m_strSndStop = sprintf("func_door_rotating.stop_%i", x);
break;
case "distance":
m_flDistance = stof(strValue);
break;
case "dmg":
m_iDamage = stoi(strValue);
break;
case "wait":
m_flWait = stof(strValue);
break;
case "netname":
targetClose = strValue;
break;
case "locked_sound":
x = stoi(strValue);
m_strLockedSfx = sprintf("func_button.hlsfx_%i", x+1i);
break;
default:
super::SpawnKey(strKey, strValue);
}
}
void
func_door_rotating::PortalOpen(void)
{
@ -370,147 +627,3 @@ func_door_rotating::RotToDest(vector vDestAngle, void(void) func)
nextthink = (ltime + flTravelTime);
}
}
void
func_door_rotating::Respawn(void)
{
RestoreAngles();
SetMovementDirection();
ClearAngles();
#ifdef GS_PHYSICS
takedamage = DAMAGE_YES;
health = 100;
Death = func_door_rotating::Unhinge;
#endif
SetSolid(SOLID_BSP);
SetMovetype(MOVETYPE_PUSH);
SetModel(GetSpawnModel());
SetOrigin(GetSpawnOrigin());
think = __NULL__;
nextthink = 0.0f;
avelocity = [0,0,0];
if (spawnflags & SF_ROT_USE)
m_iCanTouch = false;
else
m_iCanTouch = true;
/* this is a terrible hack */
if (m_flWait == 0)
m_flWait = 0.01f;
if (HasSpawnFlags(SF_ROT_USE)) {
PlayerUse = Use;
} else {
PlayerUse = __NULL__;
}
m_vecPos1 = GetSpawnAngles();
if (HasSpawnFlags(SF_ROT_BACKWARDS)) {
m_vecPos2 = GetSpawnAngles() + m_vecMoveDir * -m_flDistance;
} else {
m_vecPos2 = GetSpawnAngles() + m_vecMoveDir * m_flDistance;
}
if (HasSpawnFlags(SF_ROT_OPEN)) {
vector vTemp = m_vecPos2;
m_vecPos2 = m_vecPos1;
m_vecPos1 = vTemp;
m_vecMoveDir = m_vecMoveDir * -1;
PortalOpen();
} else {
PortalClose();
}
m_iState = STATE_LOWERED;
if (HasSpawnFlags(SF_ROT_PASSABLE)) {
SetSolid(SOLID_NOT);
}
if (targetname) {
m_iLocked = TRUE;
}
SetAngles(m_vecPos1);
}
void
func_door_rotating::SpawnKey(string strKey, string strValue)
{
int x = 0;
switch (strKey) {
case "speed":
m_flSpeed = stof(strValue);
break;
/*case "lip":
m_flLip = stof(strValue);
break;*/
case "snd_open":
m_strSndOpen = strValue;
break;
case "snd_close":
m_strSndClose = strValue;
break;
case "noise1":
m_strSndOpen = m_strSndClose = strValue;
break;
case "snd_stop":
case "noise2":
m_strSndStop = strValue;
break;
/* GoldSrc compat */
case "movesnd":
x = stoi(strValue);
m_strSndOpen = m_strSndClose = sprintf("func_door_rotating.move_%i", x);
break;
case "stopsnd":
x = stoi(strValue);
m_strSndStop = sprintf("func_door_rotating.stop_%i", x);
break;
case "distance":
m_flDistance = stof(strValue);
break;
case "dmg":
m_iDamage = stoi(strValue);
break;
case "wait":
m_flWait = stof(strValue);
break;
case "netname":
targetClose = strValue;
break;
case "locked_sound":
x = stoi(strValue);
m_strLockedSfx = sprintf("func_button.hlsfx_%i", x+1i);
break;
default:
super::SpawnKey(strKey, strValue);
}
}
void
func_door_rotating::Spawned(void)
{
super::Spawned();
if (m_strSndOpen)
Sound_Precache(m_strSndOpen);
if (m_strSndClose)
Sound_Precache(m_strSndClose);
if (m_strSndStop)
Sound_Precache(m_strSndStop);
if (m_strLockedSfx)
Sound_Precache(m_strLockedSfx);
}
void
func_door_rotating::func_door_rotating(void)
{
m_flSpeed = 100;
m_flDelay = 4;
m_flDistance = 90;
}

2
src/gs-entbase/shared/func_tankmortar.qc
View File

@ -304,7 +304,7 @@ func_tankmortar::PlayerInput(void)
if (m_eDriver && m_eDriver.health <= 0)
PlayerLeave((NSClientPlayer)m_eDriver);
#else
print("foooo\n");
//print("foooo\n");
#endif
if (m_eDriver) {

4
src/menu-fn/m_customize.qc
View File

@ -136,7 +136,7 @@ menu_customize_init(void)
}
}
if (g_sprayscount) {
if (g_sprayscount >= 1) {
/* only allocate what we truly need */
g_sprays = memalloc(sizeof(string) * g_sprayscount);
for (int i = 0; i < search_getsize(searchy); i++) {
@ -159,7 +159,7 @@ menu_customize_init(void)
g_modelcount = search_getsize(searchy);
if (g_modelcount) {
if (g_modelcount >= 1) {
g_models = memalloc(sizeof(string) * g_modelcount);
for (int i = 0; i < g_modelcount; i++) {
g_models[i] = substring(search_getfilename(searchy, i), 0, -5);

61
src/server/defs.h
View File

@ -31,17 +31,58 @@
/* helper macros */
#define EVALUATE_FIELD(fieldname, changedflag) {\
if (ATTR_CHANGED(fieldname)) { \
SetSendFlags(changedflag); \
} \
SAVE_STATE(fieldname); \
}
if (ATTR_CHANGED(fieldname)) {\
SetSendFlags(changedflag);\
}\
SAVE_STATE(fieldname);\
}
#define EVALUATE_VECTOR(fieldname, id, changedflag) {\
if (VEC_CHANGED(fieldname, id)) { \
SetSendFlags(changedflag); \
} \
SAVE_STATE(fieldname);\
}
if (VEC_CHANGED(fieldname, id)) {\
SetSendFlags(changedflag);\
}\
SAVE_STATE_FIELD(fieldname, id);\
}
#define SENDENTITY_BYTE(field, changedflag) {\
if (flChanged & changedflag)\
WriteByte(MSG_ENTITY, field);\
}
#define SENDENTITY_SHORT(field, changedflag) {\
if (flChanged & changedflag)\
WriteShort(MSG_ENTITY, field);\
}
#define SENDENTITY_INT(field, changedflag) {\
if (flChanged & changedflag)\
WriteInt(MSG_ENTITY, field);\
}
#define SENDENTITY_FLOAT(field, changedflag) {\
if (flChanged & changedflag)\
WriteFloat(MSG_ENTITY, field);\
}
#define SENDENTITY_STRING(field, changedflag) {\
if (flChanged & changedflag)\
WriteString(MSG_ENTITY, field);\
}
#define SENDENTITY_COORD(field, changedflag) {\
if (flChanged & changedflag)\
WriteCoord(MSG_ENTITY, field);\
}
#define SENDENTITY_ANGLE(field, changedflag) {\
if (flChanged & changedflag)\
WriteShort(MSG_ENTITY, field * 32767 / 360);\
}
#define SENDENTITY_ENTITY(field, changedflag) {\
if (flChanged & changedflag)\
WriteEntity(MSG_ENTITY, field);\
}
#define AREAPORTAL_CLOSED 0
#define AREAPORTAL_OPEN 1

10
src/shared/NSBrushTrigger.qc
View File

@ -14,6 +14,11 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSBrushTrigger::NSBrushTrigger(void)
{
}
#ifdef SERVER
void
NSBrushTrigger::InitBrushTrigger(void)
@ -23,8 +28,3 @@ NSBrushTrigger::InitBrushTrigger(void)
SetSolid(SOLID_BSPTRIGGER);
}
#endif
void
NSBrushTrigger::NSBrushTrigger(void)
{
}

15
src/shared/NSClient.qc
View File

@ -14,6 +14,13 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSClient::NSClient(void)
{
flags |= FL_CLIENT;
XR_Init(this);
}
#ifdef SERVER
void
NSClient::Save(float handle)
@ -115,14 +122,6 @@ NSClient::predraw(void)
}
#endif
void
NSClient::NSClient(void)
{
flags |= FL_CLIENT;
XR_Init(this);
}
float
Client_InIntermission(void)
{

22
src/shared/NSClientPlayer.h
View File

@ -126,3 +126,25 @@ NSClientPlayer:NSClientSpectator
virtual void(void) InputUse_Up;
#endif
};
/* all potential SendFlags bits we can possibly send */
enumflags
{
PLAYER_MODELINDEX,
PLAYER_ORIGIN,
PLAYER_ANGLES,
PLAYER_COLORMAP,
PLAYER_VELOCITY,
PLAYER_FLAGS,
PLAYER_WEAPON,
PLAYER_ITEMS,
PLAYER_HEALTH,
PLAYER_SIZE,
PLAYER_MOVETYPE,
PLAYER_PUNCHANGLE,
PLAYER_VIEWZOOM,
PLAYER_TIMINGS,
PLAYER_VEHICLE,
PLAYER_SPECTATE,
PLAYER_CUSTOMFIELDSTART = PLAYER_SPECTATE
};

434
src/shared/NSClientPlayer.qc
View File

@ -14,6 +14,13 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSClientPlayer::NSClientPlayer(void)
{
flags |= FL_CLIENT;
vehicle = __NULL__;
}
bool
NSClientPlayer::IsRealSpectator(void)
{
@ -269,7 +276,7 @@ at the top of player::ReceiveEntity
=================
*/
void
NSClientPlayer::ReceiveEntity(float new, float fl)
NSClientPlayer::ReceiveEntity(float new, float flChanged)
{
/* store which input sequence we're on, this helps us
* later when we run prediction again between last/latest
@ -277,86 +284,62 @@ NSClientPlayer::ReceiveEntity(float new, float fl)
sequence = servercommandframe;
/* HACK: we need to make this more reliable */
if (fl == UPDATE_ALL) {
if (flChanged == UPDATE_ALL) {
/* we respawned */
gravity = 1.0f;
}
modelindex = readint();
READENTITY_INT(modelindex, PLAYER_MODELINDEX)
READENTITY_COORD(origin[0], PLAYER_ORIGIN)
READENTITY_COORD(origin[1], PLAYER_ORIGIN)
READENTITY_COORD(origin[2], PLAYER_ORIGIN)
READENTITY_ANGLE(v_angle[0], PLAYER_ANGLES)
READENTITY_ANGLE(v_angle[1], PLAYER_ANGLES)
READENTITY_ANGLE(v_angle[2], PLAYER_ANGLES)
READENTITY_ANGLE(angles[0], PLAYER_ANGLES)
READENTITY_ANGLE(angles[1], PLAYER_ANGLES)
READENTITY_ANGLE(angles[2], PLAYER_ANGLES)
READENTITY_BYTE(colormap, PLAYER_VELOCITY)
READENTITY_COORD(velocity[0], PLAYER_VELOCITY)
READENTITY_COORD(velocity[1], PLAYER_VELOCITY)
READENTITY_COORD(velocity[2], PLAYER_VELOCITY)
READENTITY_INT(flags, PLAYER_FLAGS)
READENTITY_INT(gflags, PLAYER_FLAGS)
READENTITY_INT(pmove_flags, PLAYER_FLAGS)
READENTITY_BYTE(activeweapon, PLAYER_WEAPON)
READENTITY_BYTE(weaponframe, PLAYER_WEAPON)
READENTITY_INT(g_items, PLAYER_ITEMS)
READENTITY_BYTE(health, PLAYER_HEALTH)
READENTITY_BYTE(armor, PLAYER_HEALTH)
READENTITY_COORD(mins[0], PLAYER_SIZE)
READENTITY_COORD(mins[1], PLAYER_SIZE)
READENTITY_COORD(mins[2], PLAYER_SIZE)
READENTITY_COORD(maxs[0], PLAYER_SIZE)
READENTITY_COORD(maxs[1], PLAYER_SIZE)
READENTITY_COORD(maxs[2], PLAYER_SIZE)
READENTITY_BYTE(view_ofs[2], PLAYER_SIZE)
READENTITY_BYTE(movetype, PLAYER_MOVETYPE)
READENTITY_BYTE(solid, PLAYER_MOVETYPE)
READENTITY_FLOAT(punchangle[0], PLAYER_PUNCHANGLE)
READENTITY_FLOAT(punchangle[1], PLAYER_PUNCHANGLE)
READENTITY_FLOAT(punchangle[2], PLAYER_PUNCHANGLE)
READENTITY_FLOAT(viewzoom, PLAYER_VIEWZOOM)
READENTITY_FLOAT(teleport_time, PLAYER_TIMINGS)
READENTITY_FLOAT(weapontime, PLAYER_TIMINGS)
READENTITY_FLOAT(w_attack_next, PLAYER_TIMINGS)
READENTITY_FLOAT(w_idle_next, PLAYER_TIMINGS)
READENTITY_ENTNUM(vehicle_entnum, PLAYER_VEHICLE)
READENTITY_BYTE(spec_ent, PLAYER_SPECTATE)
READENTITY_BYTE(spec_mode, PLAYER_SPECTATE)
READENTITY_BYTE(spec_flags, PLAYER_SPECTATE)
if (fl & PLAYER_ORIGIN) {
origin[0] = readcoord();
origin[1] = readcoord();
}
if (fl & PLAYER_ORIGIN_Z)
origin[2] = readcoord();
if (fl & PLAYER_ANGLES_X) {
v_angle[0] = readshort() / (32767 / 360);
v_angle[1] = readshort() / (32767 / 360);
v_angle[2] = readshort() / (32767 / 360);
}
if (fl & PLAYER_ANGLES_Y) {
angles[0] = readshort() / (32767 / 360);
angles[1] = readshort() / (32767 / 360);
angles[2] = readshort() / (32767 / 360);
}
if (fl & PLAYER_COLORMAP)
colormap = readbyte();
if (fl & PLAYER_VELOCITY) {
velocity[0] = readcoord();
velocity[1] = readcoord();
}
if (fl & PLAYER_VELOCITY_Z)
velocity[2] = readcoord();
if (fl & PLAYER_FLAGS) {
flags = readfloat();
gflags = readfloat();
pmove_flags = readfloat();
/* mainly used for other players receiving us */
if (flags & FL_CROUCHING)
setsize(self, PHY_HULL_CROUCHED_MIN, PHY_HULL_CROUCHED_MAX);
else
setsize(self, PHY_HULL_MIN, PHY_HULL_MAX);
}
if (fl & PLAYER_WEAPON) {
activeweapon = readbyte();
weaponframe = (int)readbyte();
}
if (fl & PLAYER_ITEMS)
g_items = (__variant)readfloat();
if (fl & PLAYER_HEALTH)
health = readbyte();
if (fl & PLAYER_ARMOR)
armor = readbyte();
if (fl & PLAYER_MOVETYPE) {
movetype = readbyte();
solid = readbyte();
}
if (fl & PLAYER_VIEWOFS)
view_ofs[2] = readfloat();
/* TO OPTIMISE */
teleport_time = readfloat();
viewzoom = readfloat();
weapontime = readfloat();
w_attack_next = readfloat();
w_idle_next = readfloat();
punchangle[0] = readfloat();
punchangle[1] = readfloat();
punchangle[2] = readfloat();
vehicle_entnum = readentitynum();
VehicleRelink();
/* FIXME: Make this temp spec only */
spec_ent = readbyte();
spec_mode = readbyte();
spec_flags = readbyte();
PredictPreFrame();
if (flChanged & PLAYER_SIZE)
setsize(this, mins, maxs);
setorigin(this, origin);
}
/*
@ -371,34 +354,32 @@ at the top of player::PredictPreFrame
void
NSClientPlayer::PredictPreFrame(void)
{
/* base player attributes/fields we're going to roll back */
SAVE_STATE(modelindex);
SAVE_STATE(origin);
SAVE_STATE(angles);
SAVE_STATE(v_angle);
SAVE_STATE(angles);
SAVE_STATE(colormap);
SAVE_STATE(velocity);
SAVE_STATE(flags);
SAVE_STATE(gflags);
SAVE_STATE(pmove_flags);
SAVE_STATE(activeweapon);
SAVE_STATE(weaponframe);
SAVE_STATE(g_items);
SAVE_STATE(health);
SAVE_STATE(armor);
SAVE_STATE(mins);
SAVE_STATE(maxs);
SAVE_STATE(view_ofs);
SAVE_STATE(movetype);
SAVE_STATE(solid);
SAVE_STATE(view_ofs);
/* TO OPTIMISE */
SAVE_STATE(teleport_time);
SAVE_STATE(punchangle);
SAVE_STATE(viewzoom);
SAVE_STATE(weaponframe);
SAVE_STATE(teleport_time);
SAVE_STATE(weapontime);
SAVE_STATE(w_attack_next);
SAVE_STATE(w_idle_next);
SAVE_STATE(punchangle);
SAVE_STATE(vehicle_entnum);
SAVE_STATE(spec_ent);
SAVE_STATE(spec_mode);
SAVE_STATE(spec_flags);
@ -417,34 +398,32 @@ at the top of player::PredictPostFrame
void
NSClientPlayer::PredictPostFrame(void)
{
/* finally roll the values back */
ROLL_BACK(modelindex);
ROLL_BACK(origin);
ROLL_BACK(angles);
ROLL_BACK(v_angle);
ROLL_BACK(angles);
ROLL_BACK(colormap);
ROLL_BACK(velocity);
ROLL_BACK(flags);
ROLL_BACK(gflags);
ROLL_BACK(pmove_flags);
ROLL_BACK(activeweapon);
ROLL_BACK(weaponframe);
ROLL_BACK(g_items);
ROLL_BACK(health);
ROLL_BACK(armor);
ROLL_BACK(mins);
ROLL_BACK(maxs);
ROLL_BACK(view_ofs);
ROLL_BACK(movetype);
ROLL_BACK(solid);
ROLL_BACK(view_ofs);
/* TO OPTIMISE */
ROLL_BACK(teleport_time);
ROLL_BACK(punchangle);
ROLL_BACK(viewzoom);
ROLL_BACK(weaponframe);
ROLL_BACK(teleport_time);
ROLL_BACK(weapontime);
ROLL_BACK(w_attack_next);
ROLL_BACK(w_idle_next);
ROLL_BACK(punchangle);
ROLL_BACK(vehicle_entnum);
ROLL_BACK(spec_ent);
ROLL_BACK(spec_mode);
ROLL_BACK(spec_flags);
@ -684,98 +663,49 @@ at the top of player::EvaluateEntity
void
NSClientPlayer::EvaluateEntity(void)
{
SetSendFlags(PLAYER_MODELINDEX);
if (VEC_CHANGED(origin, 0))
SetSendFlags(PLAYER_ORIGIN);
if (VEC_CHANGED(origin, 1))
SetSendFlags(PLAYER_ORIGIN);
if (VEC_CHANGED(origin, 2))
SetSendFlags(PLAYER_ORIGIN_Z);
if (VEC_CHANGED(v_angle, 0) || VEC_CHANGED(v_angle, 1) || VEC_CHANGED(v_angle, 2))
SetSendFlags(PLAYER_ANGLES_X);
if (VEC_CHANGED(angles, 0) || VEC_CHANGED(angles, 1) || VEC_CHANGED(angles, 2))
SetSendFlags(PLAYER_ANGLES_Y);
if (ATTR_CHANGED(colormap))
SetSendFlags(PLAYER_COLORMAP);
if (VEC_CHANGED(velocity, 0))
SetSendFlags(PLAYER_VELOCITY);
if (VEC_CHANGED(velocity, 1))
SetSendFlags(PLAYER_VELOCITY);
if (VEC_CHANGED(velocity, 2))
SetSendFlags(PLAYER_VELOCITY_Z);
if (ATTR_CHANGED(flags))
SetSendFlags(PLAYER_FLAGS);
if (ATTR_CHANGED(gflags))
SetSendFlags(PLAYER_FLAGS);
if (ATTR_CHANGED(pmove_flags))
SetSendFlags(PLAYER_FLAGS);
if (ATTR_CHANGED(weaponframe))
SetSendFlags(PLAYER_WEAPON);
if (ATTR_CHANGED(activeweapon))
SetSendFlags(PLAYER_WEAPON);
if (ATTR_CHANGED(g_items))
SetSendFlags(PLAYER_ITEMS);
if (ATTR_CHANGED(health))
SetSendFlags(PLAYER_HEALTH);
if (ATTR_CHANGED(armor))
SetSendFlags(PLAYER_ARMOR);
if (ATTR_CHANGED(movetype))
SetSendFlags(PLAYER_MOVETYPE);
if (ATTR_CHANGED(solid))
SetSendFlags(PLAYER_MOVETYPE);
if (ATTR_CHANGED(view_ofs))
SetSendFlags(PLAYER_VIEWOFS);
SAVE_STATE(modelindex);
SAVE_STATE(origin);
SAVE_STATE(angles);
SAVE_STATE(colormap);
SAVE_STATE(velocity);
SAVE_STATE(flags);
SAVE_STATE(gflags);
SAVE_STATE(pmove_flags);
SAVE_STATE(activeweapon);
SAVE_STATE(g_items);
SAVE_STATE(health);
SAVE_STATE(armor);
SAVE_STATE(movetype);
SAVE_STATE(solid);
SAVE_STATE(view_ofs);
/* TO OPTIMISE */
SAVE_STATE(teleport_time);
SAVE_STATE(viewzoom);
SAVE_STATE(weaponframe);
SAVE_STATE(weapontime);
SAVE_STATE(w_attack_next);
SAVE_STATE(w_idle_next);
SAVE_STATE(punchangle);
SAVE_STATE(vehicle);
/* FIXME: Make this temp spec only */
SAVE_STATE(spec_ent);
SAVE_STATE(spec_mode);
SAVE_STATE(spec_flags);
EVALUATE_FIELD(modelindex, PLAYER_MODELINDEX)
EVALUATE_VECTOR(origin, 0, PLAYER_ORIGIN)
EVALUATE_VECTOR(origin, 1, PLAYER_ORIGIN)
EVALUATE_VECTOR(origin, 2, PLAYER_ORIGIN)
EVALUATE_VECTOR(v_angle, 0, PLAYER_ANGLES)
EVALUATE_VECTOR(v_angle, 1, PLAYER_ANGLES)
EVALUATE_VECTOR(v_angle, 2, PLAYER_ANGLES)
EVALUATE_VECTOR(angles, 0, PLAYER_ANGLES)
EVALUATE_VECTOR(angles, 1, PLAYER_ANGLES)
EVALUATE_VECTOR(angles, 2, PLAYER_ANGLES)
EVALUATE_FIELD(colormap, PLAYER_VELOCITY)
EVALUATE_VECTOR(velocity, 0, PLAYER_VELOCITY)
EVALUATE_VECTOR(velocity, 1, PLAYER_VELOCITY)
EVALUATE_VECTOR(velocity, 2, PLAYER_VELOCITY)
EVALUATE_FIELD(flags, PLAYER_FLAGS)
EVALUATE_FIELD(gflags, PLAYER_FLAGS)
EVALUATE_FIELD(pmove_flags, PLAYER_FLAGS)
EVALUATE_FIELD(activeweapon, PLAYER_WEAPON)
EVALUATE_FIELD(weaponframe, PLAYER_WEAPON)
EVALUATE_FIELD(g_items, PLAYER_ITEMS)
EVALUATE_FIELD(health, PLAYER_HEALTH)
EVALUATE_FIELD(armor, PLAYER_HEALTH)
EVALUATE_VECTOR(mins, 0, PLAYER_SIZE)
EVALUATE_VECTOR(mins, 1, PLAYER_SIZE)
EVALUATE_VECTOR(mins, 2, PLAYER_SIZE)
EVALUATE_VECTOR(maxs, 0, PLAYER_SIZE)
EVALUATE_VECTOR(maxs, 1, PLAYER_SIZE)
EVALUATE_VECTOR(maxs, 2, PLAYER_SIZE)
EVALUATE_FIELD(view_ofs, 2, PLAYER_SIZE)
EVALUATE_FIELD(movetype, PLAYER_MOVETYPE)
EVALUATE_FIELD(solid, PLAYER_MOVETYPE)
EVALUATE_VECTOR(punchangle, 0, PLAYER_PUNCHANGLE)
EVALUATE_VECTOR(punchangle, 1, PLAYER_PUNCHANGLE)
EVALUATE_VECTOR(punchangle, 2, PLAYER_PUNCHANGLE)
EVALUATE_FIELD(viewzoom, PLAYER_VIEWZOOM)
EVALUATE_FIELD(teleport_time, PLAYER_TIMINGS)
EVALUATE_FIELD(weapontime, PLAYER_TIMINGS)
EVALUATE_FIELD(w_attack_next, PLAYER_TIMINGS)
EVALUATE_FIELD(w_idle_next, PLAYER_TIMINGS)
EVALUATE_FIELD(vehicle, PLAYER_VEHICLE)
EVALUATE_FIELD(spec_ent, PLAYER_SPECTATE)
EVALUATE_FIELD(spec_mode, PLAYER_SPECTATE)
EVALUATE_FIELD(spec_flags, PLAYER_SPECTATE)
}
/*
@ -788,92 +718,51 @@ at the top of player::SendEntity
=================
*/
float
NSClientPlayer::SendEntity(entity ePEnt, float fChanged)
NSClientPlayer::SendEntity(entity ePEnt, float flChanged)
{
/* really trying to get our moneys worth with 23 bits of mantissa */
if (fChanged & PLAYER_MODELINDEX) {
WriteInt(MSG_ENTITY, modelindex);
}
/* if origin[0] changes, it's very likely [1] changes too, since
* we rarely ever walk in a straight line on the world grid */
if (fChanged & PLAYER_ORIGIN) {
WriteCoord(MSG_ENTITY, origin[0]);
WriteCoord(MSG_ENTITY, origin[1]);
}
/* the height doesn't change as much */
if (fChanged & PLAYER_ORIGIN_Z)
WriteCoord(MSG_ENTITY, origin[2]);
if (fChanged & PLAYER_ANGLES_X) {
WriteShort(MSG_ENTITY, v_angle[0] * 32767 / 360);
WriteShort(MSG_ENTITY, v_angle[1] * 32767 / 360);
WriteShort(MSG_ENTITY, v_angle[2] * 32767 / 360);
}
if (fChanged & PLAYER_ANGLES_Y) {
WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
}
if (fChanged & PLAYER_COLORMAP)
WriteByte(MSG_ENTITY, colormap);
/* similar as with origin, we separate x/y from z */
if (fChanged & PLAYER_VELOCITY) {
WriteCoord(MSG_ENTITY, velocity[0]);
WriteCoord(MSG_ENTITY, velocity[1]);
}
if (fChanged & PLAYER_VELOCITY_Z)
WriteCoord(MSG_ENTITY, velocity[2]);
if (fChanged & PLAYER_FLAGS) {
WriteFloat(MSG_ENTITY, flags);
WriteFloat(MSG_ENTITY, gflags);
WriteFloat(MSG_ENTITY, pmove_flags);
}
if (fChanged & PLAYER_WEAPON) {
WriteByte(MSG_ENTITY, activeweapon);
WriteByte(MSG_ENTITY, weaponframe);
}
/* g_items is a proper integer, so we can't let WriteFloat truncate it (hence __variant) */
if (fChanged & PLAYER_ITEMS)
WriteFloat(MSG_ENTITY, (__variant)g_items);
/* only got byte precision, clamp to avoid weird values on the client-side */
if (fChanged & PLAYER_HEALTH)
WriteByte(MSG_ENTITY, bound(0, health, 255));
if (fChanged & PLAYER_ARMOR)
WriteByte(MSG_ENTITY, bound(0, armor, 255));
if (fChanged & PLAYER_MOVETYPE) {
WriteByte(MSG_ENTITY, movetype);
WriteByte(MSG_ENTITY, solid);
}
/* the view_ofs[0] and [1] are rarely changed */
if (fChanged & PLAYER_VIEWOFS)
WriteFloat(MSG_ENTITY, view_ofs[2]);
/* TO OPTIMISE */
WriteFloat(MSG_ENTITY, teleport_time);
WriteFloat(MSG_ENTITY, viewzoom);
WriteFloat(MSG_ENTITY, weapontime);
WriteFloat(MSG_ENTITY, w_attack_next);
WriteFloat(MSG_ENTITY, w_idle_next);
WriteFloat(MSG_ENTITY, punchangle[0]);
WriteFloat(MSG_ENTITY, punchangle[1]);
WriteFloat(MSG_ENTITY, punchangle[2]);
if (vehicle)
WriteEntity(MSG_ENTITY, vehicle);
else
WriteEntity(MSG_ENTITY, __NULL__);
/* FIXME: Make this fake NSClientSpectator only. */
WriteByte(MSG_ENTITY, spec_ent);
WriteByte(MSG_ENTITY, spec_mode);
WriteByte(MSG_ENTITY, spec_flags);
SENDENTITY_INT(modelindex, PLAYER_MODELINDEX)
SENDENTITY_COORD(origin[0], PLAYER_ORIGIN)
SENDENTITY_COORD(origin[1], PLAYER_ORIGIN)
SENDENTITY_COORD(origin[2], PLAYER_ORIGIN)
SENDENTITY_ANGLE(v_angle[0], PLAYER_ANGLES)
SENDENTITY_ANGLE(v_angle[1], PLAYER_ANGLES)
SENDENTITY_ANGLE(v_angle[2], PLAYER_ANGLES)
SENDENTITY_ANGLE(angles[0], PLAYER_ANGLES)
SENDENTITY_ANGLE(angles[1], PLAYER_ANGLES)
SENDENTITY_ANGLE(angles[2], PLAYER_ANGLES)
SENDENTITY_BYTE(colormap, PLAYER_VELOCITY)
SENDENTITY_COORD(velocity[0], PLAYER_VELOCITY)
SENDENTITY_COORD(velocity[1], PLAYER_VELOCITY)
SENDENTITY_COORD(velocity[2], PLAYER_VELOCITY)
SENDENTITY_INT(flags, PLAYER_FLAGS)
SENDENTITY_INT(gflags, PLAYER_FLAGS)
SENDENTITY_INT(pmove_flags, PLAYER_FLAGS)
SENDENTITY_BYTE(activeweapon, PLAYER_WEAPON)
SENDENTITY_BYTE(weaponframe, PLAYER_WEAPON)
SENDENTITY_INT(g_items, PLAYER_ITEMS)
SENDENTITY_BYTE(health, PLAYER_HEALTH)
SENDENTITY_BYTE(armor, PLAYER_HEALTH)
SENDENTITY_COORD(mins[0], PLAYER_SIZE)
SENDENTITY_COORD(mins[1], PLAYER_SIZE)
SENDENTITY_COORD(mins[2], PLAYER_SIZE)
SENDENTITY_COORD(maxs[0], PLAYER_SIZE)
SENDENTITY_COORD(maxs[1], PLAYER_SIZE)
SENDENTITY_COORD(maxs[2], PLAYER_SIZE)
SENDENTITY_BYTE(view_ofs[2], PLAYER_SIZE)
SENDENTITY_BYTE(movetype, PLAYER_MOVETYPE)
SENDENTITY_BYTE(solid, PLAYER_MOVETYPE)
SENDENTITY_FLOAT(punchangle[0], PLAYER_PUNCHANGLE)
SENDENTITY_FLOAT(punchangle[1], PLAYER_PUNCHANGLE)
SENDENTITY_FLOAT(punchangle[2], PLAYER_PUNCHANGLE)
SENDENTITY_FLOAT(viewzoom, PLAYER_VIEWZOOM)
SENDENTITY_FLOAT(teleport_time, PLAYER_TIMINGS)
SENDENTITY_FLOAT(weapontime, PLAYER_TIMINGS)
SENDENTITY_FLOAT(w_attack_next, PLAYER_TIMINGS)
SENDENTITY_FLOAT(w_idle_next, PLAYER_TIMINGS)
SENDENTITY_ENTITY(vehicle, PLAYER_VEHICLE)
SENDENTITY_BYTE(spec_ent, PLAYER_SPECTATE)
SENDENTITY_BYTE(spec_mode, PLAYER_SPECTATE)
SENDENTITY_BYTE(spec_flags, PLAYER_SPECTATE)
return (1);
}
@ -990,10 +879,3 @@ NSClientPlayer::InputUse_Up(void)
}
}
#endif
void
NSClientPlayer::NSClientPlayer(void)
{
flags |= FL_CLIENT;
vehicle = __NULL__;
}

12
src/shared/NSClientSpectator.qc
View File

@ -14,6 +14,12 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSClientSpectator::NSClientSpectator(void)
{
flags |= FL_CLIENT;
}
#ifdef SERVER
void
NSClientSpectator::Save(float handle)
@ -463,12 +469,6 @@ NSClientSpectator::PostFrame(void)
#endif
}
void
NSClientSpectator::NSClientSpectator(void)
{
flags |= FL_CLIENT;
}
#ifdef CLIENT
void
Spectator_ReadEntity(float new)

21
src/shared/NSEntity.h
View File

@ -16,9 +16,16 @@
enumflags
{
BASEFL_CHANGED_ORIGIN,
BASEFL_CHANGED_ANGLES,
BASEFL_CHANGED_MODELINDEX,
BASEFL_CHANGED_ORIGIN_X,
BASEFL_CHANGED_ORIGIN_Y,
BASEFL_CHANGED_ORIGIN_Z,
BASEFL_CHANGED_ANGLES_X,
BASEFL_CHANGED_ANGLES_Y,
BASEFL_CHANGED_ANGLES_Z,
BASEFL_CHANGED_VELOCITY_X,
BASEFL_CHANGED_VELOCITY_Y,
BASEFL_CHANGED_VELOCITY_Z,
BASEFL_CHANGED_SIZE,
BASEFL_CHANGED_FLAGS,
BASEFL_CHANGED_SOLID,
@ -26,12 +33,7 @@ enumflags
BASEFL_CHANGED_SKIN,
BASEFL_CHANGED_MOVETYPE,
BASEFL_CHANGED_EFFECTS,
BASEFL_CHANGED_BODY,
BASEFL_CHANGED_SCALE,
BASEFL_CHANGED_VELOCITY,
BASEFL_CHANGED_RENDERCOLOR,
BASEFL_CHANGED_RENDERAMT,
BASEFL_CHANGED_RENDERMODE,
};
/* NSEntity is the lowest, user accessible class.
@ -58,6 +60,8 @@ class NSEntity:NSTrigger
PREDICTED_VECTOR_N(angles);
PREDICTED_FLOAT_N(modelindex);
PREDICTED_VECTOR_N(size);
PREDICTED_VECTOR_N(mins);
PREDICTED_VECTOR_N(maxs);
PREDICTED_FLOAT_N(solid);
PREDICTED_FLOAT_N(movetype);
PREDICTED_FLOAT_N(scale);
@ -90,6 +94,9 @@ class NSEntity:NSTrigger
#ifdef SERVER
string m_parent;
string m_parent_attachment;
PREDICTED_FLOAT_N(frame);
PREDICTED_FLOAT_N(skin);
PREDICTED_FLOAT_N(effects);
virtual void(void) Show;
virtual void(void) Hide;

233
src/shared/NSEntity.qc
View File

@ -100,9 +100,9 @@ NSEntity::VisibleVec(vector org)
flDelta = normalize (org - origin);
flFoV = flDelta * v_forward;
if (flFoV > 0.3) {
if (flFoV > 0.3f) {
traceline(origin, org, TRUE, this);
if (trace_fraction == 1.0) {
if (trace_fraction == 1.0f) {
return (TRUE);
}
}
@ -127,9 +127,9 @@ NSEntity::Visible(entity ent)
flFoV = flDelta * v_forward;
/* is it in our field of view? */
if (flFoV > 0.3) {
if (flFoV > 0.3f) {
traceline(origin, ent.origin, MOVE_NORMAL, this);
if (trace_fraction == 1.0 || trace_ent == ent) {
if (trace_fraction == 1.0f || trace_ent == ent) {
print(sprintf("%s can see %s\n", classname, ent.classname));
return (true);
}
@ -203,7 +203,7 @@ NSEntity::TouchHandler(void)
{
#ifdef SERVER
if (g_grMode.IsTeamplay())
if (m_iTeam > 0)
if (m_iTeam > 0i)
if (m_iTeam != other.team) {
return;
}
@ -243,44 +243,29 @@ NSEntity::ReceiveEntity
void
NSEntity::ReceiveEntity(float flNew, float flChanged)
{
if (flChanged & BASEFL_CHANGED_ORIGIN) {
origin[0] = readcoord();
origin[1] = readcoord();
origin[2] = readcoord();
}
if (flChanged & BASEFL_CHANGED_ANGLES) {
angles[0] = readshort() / (32767 / 360);
angles[1] = readshort() / (32767 / 360);
angles[2] = readshort() / (32767 / 360);
}
if (flChanged & BASEFL_CHANGED_MODELINDEX) {
setmodelindex(this, readshort());
}
if (flChanged & BASEFL_CHANGED_SOLID) {
solid = readbyte();
}
if (flChanged & BASEFL_CHANGED_MOVETYPE) {
movetype = readbyte();
if (movetype == MOVETYPE_PHYSICS) {
movetype = MOVETYPE_NONE;
}
}
if (flChanged & BASEFL_CHANGED_SIZE) {
mins[0] = readcoord();
mins[1] = readcoord();
mins[2] = readcoord();
maxs[0] = readcoord();
maxs[1] = readcoord();
maxs[2] = readcoord();
setsize(this, mins, maxs);
}
if (flChanged & BASEFL_CHANGED_VELOCITY) {
velocity[0] = readfloat();
velocity[1] = readfloat();
velocity[2] = readfloat();
}
READENTITY_COORD(origin[0], BASEFL_CHANGED_ORIGIN_X)
READENTITY_COORD(origin[1], BASEFL_CHANGED_ORIGIN_Y)
READENTITY_COORD(origin[2], BASEFL_CHANGED_ORIGIN_Z)
READENTITY_ANGLE(angles[0], BASEFL_CHANGED_ANGLES_X)
READENTITY_ANGLE(angles[1], BASEFL_CHANGED_ANGLES_Y)
READENTITY_ANGLE(angles[2], BASEFL_CHANGED_ANGLES_Z)
READENTITY_SHORT(modelindex, BASEFL_CHANGED_MODELINDEX)
READENTITY_BYTE(solid, BASEFL_CHANGED_SOLID)
READENTITY_BYTE(movetype, BASEFL_CHANGED_FLAGS)
READENTITY_INT(flags, BASEFL_CHANGED_FLAGS)
READENTITY_COORD(mins[0], BASEFL_CHANGED_SIZE)
READENTITY_COORD(mins[1], BASEFL_CHANGED_SIZE)
READENTITY_COORD(mins[2], BASEFL_CHANGED_SIZE)
READENTITY_COORD(maxs[0], BASEFL_CHANGED_SIZE)
READENTITY_COORD(maxs[1], BASEFL_CHANGED_SIZE)
READENTITY_COORD(maxs[2], BASEFL_CHANGED_SIZE)
READENTITY_BYTE(frame, BASEFL_CHANGED_FRAME)
READENTITY_BYTE(skin, BASEFL_CHANGED_SKIN)
READENTITY_FLOAT(effects, BASEFL_CHANGED_EFFECTS)
READENTITY_FLOAT(scale, BASEFL_CHANGED_SCALE)
READENTITY_COORD(velocity[0], BASEFL_CHANGED_VELOCITY_X)
READENTITY_COORD(velocity[1], BASEFL_CHANGED_VELOCITY_Y)
READENTITY_COORD(velocity[2], BASEFL_CHANGED_VELOCITY_Z)
if (modelindex) {
drawmask = MASK_ENGINE;
@ -288,9 +273,12 @@ NSEntity::ReceiveEntity(float flNew, float flChanged)
drawmask = 0;
}
if (scale == 0.0)
if (scale == 0.0f)
scale = 1.0f;
if (flChanged & BASEFL_CHANGED_SIZE)
setsize(this, mins, maxs);
setorigin(this, origin);
}
@ -320,7 +308,7 @@ NSEntity::Hide(void)
/* Make sure StartFrame calls this */
float
NSEntity::SendEntity(entity ePEnt, float fChanged)
NSEntity::SendEntity(entity ePEnt, float flChanged)
{
if (!modelindex)
return (0);
@ -332,68 +320,32 @@ NSEntity::SendEntity(entity ePEnt, float fChanged)
return (0);
WriteByte(MSG_ENTITY, ENT_ENTITY);
/* newly popped into the PVS, sadly this is the only hacky way to check
* for this right now. convince the engine maintainer to make this more sensible */
if (fChanged == 0xFFFFFF) {
/* check for defaults. if these are predictable fields, don't even bother
* networking them! you're just wasting bandwidth. */
if (scale == 0.0 || scale == 1.0)
fChanged &= ~BASEFL_CHANGED_SCALE;
if (origin == [0,0,0])
fChanged &= ~BASEFL_CHANGED_ORIGIN;
if (angles == [0,0,0])
fChanged &= ~BASEFL_CHANGED_ANGLES;
if (velocity == [0,0,0])
fChanged &= ~BASEFL_CHANGED_VELOCITY;
if (mins == [0,0,0] && maxs == [0,0,0])
fChanged &= ~BASEFL_CHANGED_SIZE;
if (solid == SOLID_NOT)
fChanged &= ~BASEFL_CHANGED_SOLID;
if (movetype == MOVETYPE_NONE)
fChanged &= ~BASEFL_CHANGED_MOVETYPE;
}
/* don't network triggers unless provoked */
/*if (cvar("developer") == 0 && m_iRenderMode == RM_TRIGGER)
return (0);*/
/* broadcast how much data is expected to be read */
WriteFloat(MSG_ENTITY, fChanged);
WriteFloat(MSG_ENTITY, flChanged);
/* really trying to get our moneys worth with 23 bits of mantissa */
if (fChanged & BASEFL_CHANGED_ORIGIN) {
WriteCoord(MSG_ENTITY, origin[0]);
WriteCoord(MSG_ENTITY, origin[1]);
WriteCoord(MSG_ENTITY, origin[2]);
}
if (fChanged & BASEFL_CHANGED_ANGLES) {
WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
}
if (fChanged & BASEFL_CHANGED_MODELINDEX) {
WriteShort(MSG_ENTITY, modelindex);
}
if (fChanged & BASEFL_CHANGED_SOLID) {
WriteByte(MSG_ENTITY, solid);
}
if (fChanged & BASEFL_CHANGED_MOVETYPE) {
WriteByte(MSG_ENTITY, movetype);
}
if (fChanged & BASEFL_CHANGED_SIZE) {
WriteCoord(MSG_ENTITY, mins[0]);
WriteCoord(MSG_ENTITY, mins[1]);
WriteCoord(MSG_ENTITY, mins[2]);
WriteCoord(MSG_ENTITY, maxs[0]);
WriteCoord(MSG_ENTITY, maxs[1]);
WriteCoord(MSG_ENTITY, maxs[2]);
}
if (fChanged & BASEFL_CHANGED_VELOCITY) {
WriteFloat(MSG_ENTITY, velocity[0]);
WriteFloat(MSG_ENTITY, velocity[1]);
WriteFloat(MSG_ENTITY, velocity[2]);
}
SENDENTITY_COORD(origin[0], BASEFL_CHANGED_ORIGIN_X)
SENDENTITY_COORD(origin[1], BASEFL_CHANGED_ORIGIN_Y)
SENDENTITY_COORD(origin[2], BASEFL_CHANGED_ORIGIN_Z)
SENDENTITY_ANGLE(angles[0], BASEFL_CHANGED_ANGLES_X)
SENDENTITY_ANGLE(angles[1], BASEFL_CHANGED_ANGLES_Y)
SENDENTITY_ANGLE(angles[2], BASEFL_CHANGED_ANGLES_Z)
SENDENTITY_SHORT(modelindex, BASEFL_CHANGED_MODELINDEX)
SENDENTITY_BYTE(solid, BASEFL_CHANGED_SOLID)
SENDENTITY_BYTE(movetype, BASEFL_CHANGED_FLAGS)
SENDENTITY_INT(flags, BASEFL_CHANGED_FLAGS)
SENDENTITY_COORD(mins[0], BASEFL_CHANGED_SIZE)
SENDENTITY_COORD(mins[1], BASEFL_CHANGED_SIZE)
SENDENTITY_COORD(mins[2], BASEFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[0], BASEFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[1], BASEFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[2], BASEFL_CHANGED_SIZE)
SENDENTITY_BYTE(frame, BASEFL_CHANGED_FRAME)
SENDENTITY_BYTE(skin, BASEFL_CHANGED_SKIN)
SENDENTITY_FLOAT(effects, BASEFL_CHANGED_EFFECTS)
SENDENTITY_FLOAT(scale, BASEFL_CHANGED_SCALE)
SENDENTITY_COORD(velocity[0], BASEFL_CHANGED_VELOCITY_X)
SENDENTITY_COORD(velocity[1], BASEFL_CHANGED_VELOCITY_Y)
SENDENTITY_COORD(velocity[2], BASEFL_CHANGED_VELOCITY_Z)
return (1);
}
@ -401,52 +353,29 @@ NSEntity::SendEntity(entity ePEnt, float fChanged)
void
NSEntity::EvaluateEntity(void)
{
/* while the engine is still handling physics for these, we can't
* predict when origin/angle might change */
if (ATTR_CHANGED(origin)) {
SetSendFlags(BASEFL_CHANGED_ORIGIN);
}
if (ATTR_CHANGED(angles)) {
angles[0] = Math_FixDelta(angles[0]);
angles[1] = Math_FixDelta(angles[1]);
angles[2] = Math_FixDelta(angles[2]);
SetSendFlags(BASEFL_CHANGED_ANGLES);
}
if (ATTR_CHANGED(modelindex)) {
SetSendFlags(BASEFL_CHANGED_MODELINDEX);
}
if (ATTR_CHANGED(size)) {
SetSendFlags(BASEFL_CHANGED_SIZE);
}
if (ATTR_CHANGED(solid)) {
SetSendFlags(BASEFL_CHANGED_SOLID);
}
if (ATTR_CHANGED(movetype)) {
SetSendFlags(BASEFL_CHANGED_MOVETYPE);
}
if (ATTR_CHANGED(scale)) {
SetSendFlags(BASEFL_CHANGED_SCALE);
}
if (ATTR_CHANGED(velocity)) {
SetSendFlags(BASEFL_CHANGED_VELOCITY);
}
SAVE_STATE(origin);
angles = Math_FixDeltaVector(angles);
SAVE_STATE(angles);
SAVE_STATE(modelindex);
SAVE_STATE(size);
SAVE_STATE(solid);
SAVE_STATE(movetype);
SAVE_STATE(scale);
SAVE_STATE(velocity);
EVALUATE_VECTOR(origin, 0, BASEFL_CHANGED_ORIGIN_X)
EVALUATE_VECTOR(origin, 1, BASEFL_CHANGED_ORIGIN_Y)
EVALUATE_VECTOR(origin, 2, BASEFL_CHANGED_ORIGIN_Z)
EVALUATE_VECTOR(angles, 0, BASEFL_CHANGED_ANGLES_X)
EVALUATE_VECTOR(angles, 1, BASEFL_CHANGED_ANGLES_Y)
EVALUATE_VECTOR(angles, 2, BASEFL_CHANGED_ANGLES_Z)
EVALUATE_FIELD(modelindex, BASEFL_CHANGED_MODELINDEX)
EVALUATE_FIELD(solid, BASEFL_CHANGED_SOLID)
EVALUATE_FIELD(movetype, BASEFL_CHANGED_FLAGS)
EVALUATE_FIELD(flags, BASEFL_CHANGED_FLAGS)
EVALUATE_VECTOR(mins, 0, BASEFL_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 1, BASEFL_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 2, BASEFL_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 0, BASEFL_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 1, BASEFL_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 2, BASEFL_CHANGED_SIZE)
EVALUATE_FIELD(frame, BASEFL_CHANGED_FRAME)
EVALUATE_FIELD(skin, BASEFL_CHANGED_SKIN)
EVALUATE_FIELD(effects, BASEFL_CHANGED_EFFECTS)
EVALUATE_FIELD(scale, BASEFL_CHANGED_SCALE)
EVALUATE_VECTOR(velocity, 0, BASEFL_CHANGED_VELOCITY_X)
EVALUATE_VECTOR(velocity, 1, BASEFL_CHANGED_VELOCITY_Y)
EVALUATE_VECTOR(velocity, 2, BASEFL_CHANGED_VELOCITY_Z)
}
/* Make sure StartFrame calls this */
@ -638,7 +567,7 @@ NSEntity::SetSize(vector newMins, vector newMaxs)
m_vecMaxs = newMaxs;
/* 0.0 is never valid, if you want it to disappear do something else */
if (scale != 0.0)
if (scale != 0.0f)
flScale = scale;
setsize(this, newMins * flScale, newMaxs * flScale);

54
src/shared/NSIO.qc
View File

@ -14,6 +14,33 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSIO::NSIO(void)
{
#ifdef SERVER
/* Not in Deathmatch */
if (spawnflags & 2048) {
if (cvar("sv_playerslots") > 1) {
remove(this);
return;
}
}
/* null all of them */
m_strOnTrigger =
m_strOnUser1 =
m_strOnUser2 =
m_strOnUser3 =
m_strOnUser4 = __NULL__;
#else
isCSQC = TRUE;
effects |= EF_NOSHADOW;
#endif
/* called last */
Init();
}
void
NSIO::Respawn(void)
{
@ -339,30 +366,3 @@ NSIO::SpawnKey(string strKey, string strValue)
break;
}
}
void
NSIO::NSIO(void)
{
#ifdef SERVER
/* Not in Deathmatch */
if (spawnflags & 2048) {
if (cvar("sv_playerslots") > 1) {
remove(this);
return;
}
}
/* null all of them */
m_strOnTrigger =
m_strOnUser1 =
m_strOnUser2 =
m_strOnUser3 =
m_strOnUser4 = __NULL__;
#else
isCSQC = TRUE;
effects |= EF_NOSHADOW;
#endif
/* called last */
Init();
}

24
src/shared/NSMonster.h
View File

@ -14,6 +14,30 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
enumflags
{
MONFL_CHANGED_ORIGIN_X,
MONFL_CHANGED_ORIGIN_Y,
MONFL_CHANGED_ORIGIN_Z,
MONFL_CHANGED_ANGLES_X,
MONFL_CHANGED_ANGLES_Y,
MONFL_CHANGED_ANGLES_Z,
MONFL_CHANGED_MODELINDEX,
MONFL_CHANGED_SIZE,
MONFL_CHANGED_FLAGS,
MONFL_CHANGED_SOLID,
MONFL_CHANGED_FRAME,
MONFL_CHANGED_SKIN,
MONFL_CHANGED_MOVETYPE,
MONFL_CHANGED_EFFECTS,
MONFL_CHANGED_BODY,
MONFL_CHANGED_SCALE,
MONFL_CHANGED_VELOCITY,
MONFL_CHANGED_RENDERCOLOR,
MONFL_CHANGED_RENDERAMT,
MONFL_CHANGED_RENDERMODE,
};
typedef enum {
ACT_RESET = 0,
ACT_IDLE = 1i,

267
src/shared/NSMonster.qc
View File

@ -14,6 +14,18 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSMonster::NSMonster(void)
{
#ifdef SERVER
if (!HasSpawnFlags(MSF_MULTIPLAYER))
if (g_grMode.MonstersSpawn() == FALSE) {
remove(this);
return;
}
#endif
}
#ifdef SERVER
int
NSMonster::GetTriggerCondition(void)
@ -83,7 +95,7 @@ void
NSMonster::AnimPlay(float seq)
{
/* forces a client-side update */
SetSendFlags(BASEFL_CHANGED_FRAME);
SetSendFlags(MONFL_CHANGED_FRAME);
SetFrame(seq);
m_flAnimTime = time + frameduration(modelindex, frame);
@ -773,9 +785,44 @@ NSMonster::SpawnKey(string strKey, string strValue)
}
}
void
NSMonster::EvaluateEntity(void)
{
EVALUATE_VECTOR(origin, 0, MONFL_CHANGED_ORIGIN_X)
EVALUATE_VECTOR(origin, 1, MONFL_CHANGED_ORIGIN_Y)
EVALUATE_VECTOR(origin, 2, MONFL_CHANGED_ORIGIN_Z)
EVALUATE_VECTOR(angles, 0, MONFL_CHANGED_ANGLES_X)
EVALUATE_VECTOR(angles, 1, MONFL_CHANGED_ANGLES_Y)
EVALUATE_VECTOR(angles, 2, MONFL_CHANGED_ANGLES_Z)
EVALUATE_FIELD(modelindex, MONFL_CHANGED_MODELINDEX)
EVALUATE_FIELD(solid, MONFL_CHANGED_SOLID)
EVALUATE_FIELD(movetype, MONFL_CHANGED_FLAGS)
EVALUATE_FIELD(flags, MONFL_CHANGED_FLAGS)
EVALUATE_VECTOR(mins, 0, MONFL_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 1, MONFL_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 2, MONFL_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 0, MONFL_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 1, MONFL_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 2, MONFL_CHANGED_SIZE)
EVALUATE_FIELD(frame, MONFL_CHANGED_FRAME)
EVALUATE_FIELD(skin, MONFL_CHANGED_SKIN)
EVALUATE_FIELD(effects, MONFL_CHANGED_EFFECTS)
EVALUATE_FIELD(m_iBody, MONFL_CHANGED_BODY)
EVALUATE_FIELD(scale, MONFL_CHANGED_SCALE)
EVALUATE_VECTOR(velocity, 0, MONFL_CHANGED_VELOCITY)
EVALUATE_VECTOR(velocity, 1, MONFL_CHANGED_VELOCITY)
EVALUATE_VECTOR(velocity, 2, MONFL_CHANGED_VELOCITY)
EVALUATE_FIELD(m_iRenderMode, MONFL_CHANGED_RENDERMODE)
EVALUATE_FIELD(m_iRenderFX, MONFL_CHANGED_RENDERMODE)
EVALUATE_VECTOR(m_vecRenderColor, 0, MONFL_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(m_vecRenderColor, 1, MONFL_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(m_vecRenderColor, 2, MONFL_CHANGED_RENDERCOLOR)
EVALUATE_FIELD(m_flRenderAmt, MONFL_CHANGED_RENDERAMT)
}
/* Make sure StartFrame calls this */
float
NSMonster::SendEntity(entity ePEnt, float fChanged)
NSMonster::SendEntity(entity ePEnt, float flChanged)
{
if (!modelindex)
return (0);
@ -790,70 +837,38 @@ NSMonster::SendEntity(entity ePEnt, float fChanged)
return (0);*/
/* broadcast how much data is expected to be read */
WriteFloat(MSG_ENTITY, fChanged);
WriteFloat(MSG_ENTITY, flChanged);
/* really trying to get our moneys worth with 23 bits of mantissa */
if (fChanged & BASEFL_CHANGED_ORIGIN) {
WriteCoord(MSG_ENTITY, origin[0]);
WriteCoord(MSG_ENTITY, origin[1]);
WriteCoord(MSG_ENTITY, origin[2]);
}
if (fChanged & BASEFL_CHANGED_ANGLES) {
WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
}
if (fChanged & BASEFL_CHANGED_MODELINDEX) {
WriteShort(MSG_ENTITY, modelindex);
}
if (fChanged & BASEFL_CHANGED_SOLID) {
WriteByte(MSG_ENTITY, solid);
}
if (fChanged & BASEFL_CHANGED_MOVETYPE) {
WriteByte(MSG_ENTITY, movetype);
}
if (fChanged & BASEFL_CHANGED_SIZE) {
WriteCoord(MSG_ENTITY, mins[0]);
WriteCoord(MSG_ENTITY, mins[1]);
WriteCoord(MSG_ENTITY, mins[2]);
WriteCoord(MSG_ENTITY, maxs[0]);
WriteCoord(MSG_ENTITY, maxs[1]);
WriteCoord(MSG_ENTITY, maxs[2]);
}
if (fChanged & BASEFL_CHANGED_FRAME) {
WriteByte(MSG_ENTITY, frame);
WriteFloat(MSG_ENTITY, frame1time);
}
if (fChanged & BASEFL_CHANGED_SKIN) {
WriteByte(MSG_ENTITY, skin + 128);
}
if (fChanged & BASEFL_CHANGED_EFFECTS) {
WriteFloat(MSG_ENTITY, effects);
}
if (fChanged & BASEFL_CHANGED_BODY) {
WriteByte(MSG_ENTITY, m_iBody);
}
if (fChanged & BASEFL_CHANGED_SCALE) {
WriteFloat(MSG_ENTITY, scale);
}
if (fChanged & BASEFL_CHANGED_VELOCITY) {
WriteFloat(MSG_ENTITY, velocity[0]);
WriteFloat(MSG_ENTITY, velocity[1]);
WriteFloat(MSG_ENTITY, velocity[2]);
}
if (fChanged & BASEFL_CHANGED_RENDERMODE) {
WriteByte(MSG_ENTITY, m_iRenderMode);
WriteByte(MSG_ENTITY, m_iRenderFX);
}
if (fChanged & BASEFL_CHANGED_RENDERCOLOR) {
WriteFloat(MSG_ENTITY, m_vecRenderColor[0]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[1]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[2]);
}
if (fChanged & BASEFL_CHANGED_RENDERAMT) {
WriteFloat(MSG_ENTITY, m_flRenderAmt);
}
SENDENTITY_COORD(origin[0], MONFL_CHANGED_ORIGIN_X)
SENDENTITY_COORD(origin[1], MONFL_CHANGED_ORIGIN_Y)
SENDENTITY_COORD(origin[2], MONFL_CHANGED_ORIGIN_Z)
SENDENTITY_ANGLE(angles[0], MONFL_CHANGED_ANGLES_X)
SENDENTITY_ANGLE(angles[1], MONFL_CHANGED_ANGLES_Y)
SENDENTITY_ANGLE(angles[2], MONFL_CHANGED_ANGLES_Z)
SENDENTITY_SHORT(modelindex, MONFL_CHANGED_MODELINDEX)
SENDENTITY_BYTE(solid, MONFL_CHANGED_SOLID)
SENDENTITY_BYTE(movetype, MONFL_CHANGED_FLAGS)
SENDENTITY_INT(flags, MONFL_CHANGED_FLAGS)
SENDENTITY_COORD(mins[0], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(mins[1], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(mins[2], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[0], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[1], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[2], MONFL_CHANGED_SIZE)
SENDENTITY_BYTE(frame, MONFL_CHANGED_FRAME)
SENDENTITY_BYTE(skin, MONFL_CHANGED_SKIN)
SENDENTITY_FLOAT(effects, MONFL_CHANGED_EFFECTS)
SENDENTITY_BYTE(m_iBody, MONFL_CHANGED_BODY)
SENDENTITY_FLOAT(scale, MONFL_CHANGED_SCALE)
SENDENTITY_COORD(velocity[0], MONFL_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[1], MONFL_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[2], MONFL_CHANGED_VELOCITY)
SENDENTITY_BYTE(m_iRenderMode, MONFL_CHANGED_RENDERMODE)
SENDENTITY_BYTE(m_iRenderFX, MONFL_CHANGED_RENDERMODE)
SENDENTITY_ANGLE(m_vecRenderColor[0], MONFL_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[1], MONFL_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[2], MONFL_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_flRenderAmt, MONFL_CHANGED_RENDERAMT)
return (1);
}
@ -896,99 +911,51 @@ NSMonster::ReceiveEntity
void
NSMonster::ReceiveEntity(float flNew, float flChanged)
{
if (flChanged & BASEFL_CHANGED_ORIGIN) {
origin[0] = readcoord();
origin[1] = readcoord();
origin[2] = readcoord();
}
if (flChanged & BASEFL_CHANGED_ANGLES) {
angles[0] = readshort() / (32767 / 360);
angles[1] = readshort() / (32767 / 360);
angles[2] = readshort() / (32767 / 360);
}
if (flChanged & BASEFL_CHANGED_MODELINDEX) {
setmodelindex(this, readshort());
}
if (flChanged & BASEFL_CHANGED_SOLID) {
solid = readbyte();
}
if (flChanged & BASEFL_CHANGED_MOVETYPE) {
movetype = readbyte();
if (movetype == MOVETYPE_PHYSICS) {
movetype = MOVETYPE_NONE;
}
}
if (flChanged & BASEFL_CHANGED_SIZE) {
mins[0] = readcoord();
mins[1] = readcoord();
mins[2] = readcoord();
maxs[0] = readcoord();
maxs[1] = readcoord();
maxs[2] = readcoord();
setsize(this, mins, maxs);
}
if (flChanged & BASEFL_CHANGED_FRAME) {
frame = readbyte();
frame1time = readfloat();
}
if (flChanged & BASEFL_CHANGED_SKIN) {
skin = readbyte() - 128;
}
if (flChanged & BASEFL_CHANGED_EFFECTS) {
effects = readfloat();
}
if (flChanged & BASEFL_CHANGED_BODY) {
m_iBody = readbyte();
setcustomskin(this, "", sprintf("geomset 1 %i\n", m_iBody));
}
if (flChanged & BASEFL_CHANGED_SCALE) {
scale = readfloat();
}
if (flChanged & BASEFL_CHANGED_VELOCITY) {
velocity[0] = readfloat();
velocity[1] = readfloat();
velocity[2] = readfloat();
}
if (flChanged & BASEFL_CHANGED_RENDERMODE) {
m_iRenderMode = readbyte();
m_iRenderFX = readbyte();
}
if (flChanged & BASEFL_CHANGED_RENDERCOLOR) {
m_vecRenderColor[0] = readfloat();
m_vecRenderColor[1] = readfloat();
m_vecRenderColor[2] = readfloat();
}
if (flChanged & BASEFL_CHANGED_RENDERAMT) {
m_flRenderAmt = readfloat();
}
if (modelindex) {
drawmask = MASK_ENGINE;
} else {
drawmask = 0;
}
READENTITY_COORD(origin[0], MONFL_CHANGED_ORIGIN_X)
READENTITY_COORD(origin[1], MONFL_CHANGED_ORIGIN_Y)
READENTITY_COORD(origin[2], MONFL_CHANGED_ORIGIN_Z)
READENTITY_ANGLE(angles[0], MONFL_CHANGED_ANGLES_X)
READENTITY_ANGLE(angles[1], MONFL_CHANGED_ANGLES_Y)
READENTITY_ANGLE(angles[2], MONFL_CHANGED_ANGLES_Z)
READENTITY_SHORT(modelindex, MONFL_CHANGED_MODELINDEX)
READENTITY_BYTE(solid, MONFL_CHANGED_SOLID)
READENTITY_BYTE(movetype, MONFL_CHANGED_FLAGS)
READENTITY_INT(flags, MONFL_CHANGED_FLAGS)
READENTITY_COORD(mins[0], MONFL_CHANGED_SIZE)
READENTITY_COORD(mins[1], MONFL_CHANGED_SIZE)
READENTITY_COORD(mins[2], MONFL_CHANGED_SIZE)
READENTITY_COORD(maxs[0], MONFL_CHANGED_SIZE)
READENTITY_COORD(maxs[1], MONFL_CHANGED_SIZE)
READENTITY_COORD(maxs[2], MONFL_CHANGED_SIZE)
READENTITY_BYTE(frame, MONFL_CHANGED_FRAME)
READENTITY_BYTE(skin, MONFL_CHANGED_SKIN)
READENTITY_FLOAT(effects, MONFL_CHANGED_EFFECTS)
READENTITY_BYTE(m_iBody, MONFL_CHANGED_BODY)
READENTITY_FLOAT(scale, MONFL_CHANGED_SCALE)
READENTITY_COORD(velocity[0], MONFL_CHANGED_VELOCITY)
READENTITY_COORD(velocity[1], MONFL_CHANGED_VELOCITY)
READENTITY_COORD(velocity[2], MONFL_CHANGED_VELOCITY)
READENTITY_BYTE(m_iRenderMode, MONFL_CHANGED_RENDERMODE)
READENTITY_BYTE(m_iRenderFX, MONFL_CHANGED_RENDERMODE)
READENTITY_ANGLE(m_vecRenderColor[0], MONFL_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[1], MONFL_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[2], MONFL_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_flRenderAmt, MONFL_CHANGED_RENDERAMT)
if (scale == 0.0)
scale = 1.0f;
if (flChanged & MONFL_CHANGED_FRAME)
frame1time = 0.0f;
if (flChanged & MONFL_CHANGED_SIZE)
setsize(this, mins * scale, maxs * scale);
if (flChanged & MONFL_CHANGED_BODY)
setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
setorigin(this, origin);
}
#endif
void
NSMonster::NSMonster(void)
{
#ifdef SERVER
if (!HasSpawnFlags(MSF_MULTIPLAYER))
if (g_grMode.MonstersSpawn() == FALSE) {
remove(this);
return;
}
#endif
}
#ifdef CLIENT
void
NSMonster_ReadEntity(float new)

24
src/shared/NSNavAI.qc
View File

@ -14,6 +14,17 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSNavAI::NSNavAI(void)
{
#ifdef SERVER
m_iNodes = 0;
m_iCurNode = -1;
m_pRoute = __NULL__;
m_vecLastNode = [0,0,0];
m_vecTurnAngle = [0,0,0];
#endif
}
#ifdef SERVER
void
@ -237,17 +248,4 @@ NSNavAI::RouteClear(void)
memfree(m_pRoute);
print(sprintf("%s cleared his route.\n", netname));
}
#endif
void
NSNavAI::NSNavAI(void)
{
#ifdef SERVER
m_iNodes = 0;
m_iCurNode = -1;
m_pRoute = __NULL__;
m_vecLastNode = [0,0,0];
m_vecTurnAngle = [0,0,0];
#endif
}

24
src/shared/NSPhysicsEntity.qc
View File

@ -14,6 +14,20 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSPhysicsEntity::NSPhysicsEntity(void)
{
mass = 1.0f;
m_flInertiaScale = 1.0f;
m_iEnabled = 0i;
m_iShape = PHYSM_BOX;
m_iMaterial = 0i;
m_iFlags = 0i;
cvar_set("physics_ode_iterationsperframe", "1");
cvar_set("physics_ode_movelimit", "0.1");
}
#ifdef SERVER
void
@ -729,16 +743,6 @@ NSPhysicsEntity::SpawnKey(string strKey, string strValue)
}
}
void
NSPhysicsEntity::NSPhysicsEntity(void)
{
mass = 1.0f;
m_flInertiaScale = 1.0f;
cvar_set("physics_ode_iterationsperframe", "1");
cvar_set("physics_ode_movelimit", "0.1");
}
#ifdef CLIENT
void
NSPhysicsEntity_ReadEntity(bool new)

27
src/shared/NSProjectile.qc
View File

@ -14,6 +14,21 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSProjectile::NSProjectile(void)
{
m_iProjectileAnimEnd = 0i;
m_iProjectileAnimStart = 0i;
m_flProjectileFramerate = 0.1f; /* default to 10 hz */
touch = ProjectileTouch;
SetMovetype(MOVETYPE_FLY);
SetRenderColor([1,1,1]);
SetRenderAmt(1.0);
SetSolid(SOLID_BBOX);
hitcontentsmaski |= CONTENTBIT_PROJECTILE;
}
void
NSProjectile::ProjectileTouch(void)
{
@ -57,15 +72,3 @@ NSProjectile::Animate(int startframe, int endframe, float framerate)
think = AnimateThink;
nextthink = time + m_flProjectileFramerate;
}
void
NSProjectile::NSProjectile(void)
{
touch = ProjectileTouch;
SetMovetype(MOVETYPE_FLY);
SetRenderColor([1,1,1]);
SetRenderAmt(1.0);
SetSolid(SOLID_BBOX);
hitcontentsmaski |= CONTENTBIT_PROJECTILE;
}

4
src/shared/NSRenderableEntity.h
View File

@ -111,10 +111,8 @@ class NSRenderableEntity:NSEntity
PREDICTED_FLOAT(m_flBoneControl4);
PREDICTED_FLOAT(m_flBoneControl5);
PREDICTED_INT(m_iBody);
PREDICTED_FLOAT_N(frame);
PREDICTED_FLOAT_N(colormap);
PREDICTED_FLOAT_N(skin);
PREDICTED_FLOAT_N(effects);
PREDICTED_VECTOR_N(glowmod);
/* model events */
float m_flBaseTime;

514
src/shared/NSRenderableEntity.qc
View File

@ -14,6 +14,29 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSRenderableEntity::NSRenderableEntity(void)
{
m_iRenderMode = RM_NORMAL;
m_iRenderFX = RFX_NORMAL;
m_vecRenderColor[0] = 1.0f;
m_vecRenderColor[1] = 1.0f;
m_vecRenderColor[2] = 1.0f;
m_flRenderAmt = 1.0f;
m_flBoneControl1 = 0.5f;
m_flBoneControl2 = 0.5f;
m_flBoneControl3 = 0.5f;
m_flBoneControl4 = 0.5f;
m_flBoneControl5 = 0.5f;
m_iBody = 0i;
effects |= EF_NOSHADOW;
#ifdef CLIENT
drawmask = MASK_ENGINE;
#endif
}
/*
============
NSRenderableEntity::MakeStatic
@ -49,115 +72,50 @@ NSRenderableEntity::MakeStatic(void)
void
NSRenderableEntity::EvaluateEntity(void)
{
if (VEC_CHANGED(origin,0)) {
SetSendFlags(RDENT_CHANGED_ORIGIN_X);
}
if (VEC_CHANGED(origin,1)) {
SetSendFlags(RDENT_CHANGED_ORIGIN_Y);
}
if (VEC_CHANGED(origin,2)) {
SetSendFlags(RDENT_CHANGED_ORIGIN_Z);
}
if (VEC_CHANGED(angles,0)) {
SetSendFlags(RDENT_CHANGED_ANGLES_X);
}
if (VEC_CHANGED(angles,1)) {
SetSendFlags(RDENT_CHANGED_ANGLES_Y);
}
if (VEC_CHANGED(angles,2)) {
SetSendFlags(RDENT_CHANGED_ANGLES_Z);
}
if (ATTR_CHANGED(modelindex)) {
SetSendFlags(RDENT_CHANGED_MODELINDEX);
}
if (ATTR_CHANGED(solid)) {
SetSendFlags(RDENT_CHANGED_SOLID);
}
if (ATTR_CHANGED(movetype)) {
SetSendFlags(RDENT_CHANGED_MOVETYPE);
}
if (ATTR_CHANGED(size)) {
SetSendFlags(RDENT_CHANGED_SIZE);
}
if (ATTR_CHANGED(frame)) {
SetSendFlags(RDENT_CHANGED_FRAME);
}
if (ATTR_CHANGED(skin)) {
SetSendFlags(RDENT_CHANGED_SKIN);
}
if (ATTR_CHANGED(effects)) {
SetSendFlags(RDENT_CHANGED_EFFECTS);
}
if (ATTR_CHANGED(m_iBody)) {
SetSendFlags(RDENT_CHANGED_BODY);
}
if (ATTR_CHANGED(scale)) {
SetSendFlags(RDENT_CHANGED_SCALE);
}
if (ATTR_CHANGED(velocity)) {
SetSendFlags(RDENT_CHANGED_VELOCITY);
}
if (ATTR_CHANGED(colormap)) {
SetSendFlags(RDENT_CHANGED_MODELINDEX);
}
if (ATTR_CHANGED(m_flBoneControl1)) {
SetSendFlags(RDENT_CHANGED_CONTROLLER);
}
if (ATTR_CHANGED(m_flBoneControl2)) {
SetSendFlags(RDENT_CHANGED_CONTROLLER);
}
if (ATTR_CHANGED(m_flBoneControl3)) {
SetSendFlags(RDENT_CHANGED_CONTROLLER);
}
if (ATTR_CHANGED(m_flBoneControl4)) {
SetSendFlags(RDENT_CHANGED_CONTROLLER);
}
if (ATTR_CHANGED(m_flBoneControl5)) {
SetSendFlags(RDENT_CHANGED_CONTROLLER);
}
SAVE_STATE(origin);
angles = Math_FixDeltaVector(angles);
SAVE_STATE(angles);
SAVE_STATE(modelindex);
SAVE_STATE(colormap);
SAVE_STATE(solid);
SAVE_STATE(movetype);
SAVE_STATE(size);
SAVE_STATE(frame);
SAVE_STATE(skin);
SAVE_STATE(effects);
SAVE_STATE(m_iBody);
SAVE_STATE(scale);
SAVE_STATE(velocity);
SAVE_STATE(m_flBoneControl1);
SAVE_STATE(m_flBoneControl2);
SAVE_STATE(m_flBoneControl3);
SAVE_STATE(m_flBoneControl4);
SAVE_STATE(m_flBoneControl5);
if (ATTR_CHANGED(m_iRenderMode)) {
SetSendFlags(RDENT_CHANGED_RENDERMODE);
}
if (ATTR_CHANGED(m_iRenderFX)) {
SetSendFlags(RDENT_CHANGED_RENDERMODE);
}
if (ATTR_CHANGED(m_vecRenderColor)) {
SetSendFlags(RDENT_CHANGED_RENDERCOLOR);
}
if (ATTR_CHANGED(m_flRenderAmt)) {
SetSendFlags(RDENT_CHANGED_RENDERAMT);
}
SAVE_STATE(m_iRenderMode);
SAVE_STATE(m_iRenderFX);
SAVE_STATE(m_vecRenderColor);
SAVE_STATE(m_flRenderAmt);
EVALUATE_VECTOR(origin, 0, RDENT_CHANGED_ORIGIN_X)
EVALUATE_VECTOR(origin, 1, RDENT_CHANGED_ORIGIN_Y)
EVALUATE_VECTOR(origin, 2, RDENT_CHANGED_ORIGIN_Z)
EVALUATE_VECTOR(angles, 0, RDENT_CHANGED_ANGLES_X)
EVALUATE_VECTOR(angles, 1, RDENT_CHANGED_ANGLES_Y)
EVALUATE_VECTOR(angles, 2, RDENT_CHANGED_ANGLES_Z)
EVALUATE_FIELD(modelindex, RDENT_CHANGED_MODELINDEX)
EVALUATE_FIELD(colormap, RDENT_CHANGED_MODELINDEX)
EVALUATE_FIELD(solid, RDENT_CHANGED_SOLID)
EVALUATE_FIELD(movetype, RDENT_CHANGED_FLAGS)
EVALUATE_FIELD(flags, RDENT_CHANGED_FLAGS)
EVALUATE_VECTOR(mins, 0, RDENT_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 1, RDENT_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 2, RDENT_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 0, RDENT_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 1, RDENT_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 2, RDENT_CHANGED_SIZE)
EVALUATE_FIELD(frame, RDENT_CHANGED_FRAME)
EVALUATE_FIELD(skin, RDENT_CHANGED_SKIN)
EVALUATE_FIELD(effects, RDENT_CHANGED_EFFECTS)
EVALUATE_FIELD(m_iBody, RDENT_CHANGED_BODY)
EVALUATE_FIELD(scale, RDENT_CHANGED_SCALE)
EVALUATE_VECTOR(velocity, 0, RDENT_CHANGED_VELOCITY)
EVALUATE_VECTOR(velocity, 1, RDENT_CHANGED_VELOCITY)
EVALUATE_VECTOR(velocity, 2, RDENT_CHANGED_VELOCITY)
EVALUATE_FIELD(m_iRenderMode, RDENT_CHANGED_RENDERMODE)
EVALUATE_FIELD(m_iRenderFX, RDENT_CHANGED_RENDERMODE)
EVALUATE_VECTOR(m_vecRenderColor, 0, RDENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(m_vecRenderColor, 1, RDENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(m_vecRenderColor, 2, RDENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(glowmod, 0, RDENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(glowmod, 1, RDENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(glowmod, 2, RDENT_CHANGED_RENDERCOLOR)
EVALUATE_FIELD(m_flRenderAmt, RDENT_CHANGED_RENDERAMT)
EVALUATE_FIELD(m_flBoneControl1, RDENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl2, RDENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl3, RDENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl4, RDENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl5, RDENT_CHANGED_CONTROLLER)
}
/* Make sure StartFrame calls this */
float
NSRenderableEntity::SendEntity(entity ePEnt, float fChanged)
NSRenderableEntity::SendEntity(entity ePEnt, float flChanged)
{
if (!modelindex)
return (0);
@ -167,142 +125,110 @@ NSRenderableEntity::SendEntity(entity ePEnt, float fChanged)
WriteByte(MSG_ENTITY, ENT_ENTITYRENDERABLE);
#if 0
/* newly popped into the PVS, sadly this is the only hacky way to check
* for this right now. convince the engine maintainer to make this more sensible */
if (fChanged == 0xFFFFFF) {
/* check for defaults. if these are predictable fields, don't even bother
* networking them! you're just wasting bandwidth. */
if (frame == 0)
fChanged &= ~RDENT_CHANGED_FRAME;
if (skin == 0)
fChanged &= ~RDENT_CHANGED_SKIN;
if (effects == 0)
fChanged &= ~RDENT_CHANGED_EFFECTS;
if (m_iBody == 0)
fChanged &= ~RDENT_CHANGED_BODY;
if (scale == 0.0 || scale == 1.0)
fChanged &= ~RDENT_CHANGED_SCALE;
if (origin[0] == 0)
fChanged &= ~RDENT_CHANGED_ORIGIN_X;
if (origin[1] == 0)
fChanged &= ~RDENT_CHANGED_ORIGIN_Y;
if (origin[2] == 0)
fChanged &= ~RDENT_CHANGED_ORIGIN_Z;
if (angles[0] == 0)
fChanged &= ~RDENT_CHANGED_ANGLES_X;
if (angles[1] == 0)
fChanged &= ~RDENT_CHANGED_ANGLES_Y;
if (angles[2] == 0)
fChanged &= ~RDENT_CHANGED_ANGLES_Z;
if (velocity == [0,0,0])
fChanged &= ~RDENT_CHANGED_VELOCITY;
if (mins == [0,0,0] && maxs == [0,0,0])
fChanged &= ~RDENT_CHANGED_SIZE;
if (solid == SOLID_NOT)
fChanged &= ~RDENT_CHANGED_SOLID;
if (movetype == MOVETYPE_NONE)
fChanged &= ~RDENT_CHANGED_MOVETYPE;
if (m_iRenderMode == RM_NORMAL)
fChanged &= ~RDENT_CHANGED_RENDERMODE;
}
#endif
/* don't network triggers unless provoked */
/*if (cvar("developer") == 0 && m_iRenderMode == RM_TRIGGER)
return (0);*/
/* broadcast how much data is expected to be read */
WriteFloat(MSG_ENTITY, fChanged);
WriteFloat(MSG_ENTITY, flChanged);
//print(sprintf("rendent send: %s %x %d\n", classname, fChanged, fChanged));
/* really trying to get our moneys worth with 23 bits of mantissa */
if (fChanged & RDENT_CHANGED_ORIGIN_X) {
WriteCoord(MSG_ENTITY, origin[0]);
}
if (fChanged & RDENT_CHANGED_ORIGIN_Y) {
WriteCoord(MSG_ENTITY, origin[1]);
}
if (fChanged & RDENT_CHANGED_ORIGIN_Z) {
WriteCoord(MSG_ENTITY, origin[2]);
}
if (fChanged & RDENT_CHANGED_ANGLES_X) {
WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
}
if (fChanged & RDENT_CHANGED_ANGLES_Y) {
WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
}
if (fChanged & RDENT_CHANGED_ANGLES_Z) {
WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
}
if (fChanged & RDENT_CHANGED_MODELINDEX) {
WriteShort(MSG_ENTITY, modelindex);
WriteByte(MSG_ENTITY, colormap);
}
if (fChanged & RDENT_CHANGED_SOLID) {
WriteByte(MSG_ENTITY, solid);
}
if (fChanged & RDENT_CHANGED_MOVETYPE) {
WriteByte(MSG_ENTITY, movetype);
}
if (fChanged & RDENT_CHANGED_SIZE) {
WriteCoord(MSG_ENTITY, mins[0]);
WriteCoord(MSG_ENTITY, mins[1]);
WriteCoord(MSG_ENTITY, mins[2]);
WriteCoord(MSG_ENTITY, maxs[0]);
WriteCoord(MSG_ENTITY, maxs[1]);
WriteCoord(MSG_ENTITY, maxs[2]);
}
if (fChanged & RDENT_CHANGED_FRAME) {
WriteByte(MSG_ENTITY, frame);
WriteByte(MSG_ENTITY, frame1time);
}
if (fChanged & RDENT_CHANGED_SKIN) {
WriteByte(MSG_ENTITY, skin + 128);
}
if (fChanged & RDENT_CHANGED_EFFECTS) {
WriteFloat(MSG_ENTITY, effects);
}
if (fChanged & RDENT_CHANGED_BODY) {
WriteByte(MSG_ENTITY, m_iBody);
}
if (fChanged & RDENT_CHANGED_SCALE) {
WriteFloat(MSG_ENTITY, scale);
}
if (fChanged & RDENT_CHANGED_VELOCITY) {
WriteFloat(MSG_ENTITY, velocity[0]);
WriteFloat(MSG_ENTITY, velocity[1]);
WriteFloat(MSG_ENTITY, velocity[2]);
}
if (fChanged & RDENT_CHANGED_RENDERMODE) {
WriteByte(MSG_ENTITY, m_iRenderMode);
WriteByte(MSG_ENTITY, m_iRenderFX);
}
if (fChanged & RDENT_CHANGED_RENDERCOLOR) {
WriteFloat(MSG_ENTITY, m_vecRenderColor[0]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[1]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[2]);
WriteFloat(MSG_ENTITY, glowmod[0]);
WriteFloat(MSG_ENTITY, glowmod[1]);
WriteFloat(MSG_ENTITY, glowmod[2]);
}
if (fChanged & RDENT_CHANGED_RENDERAMT) {
WriteFloat(MSG_ENTITY, m_flRenderAmt);
}
if (fChanged & RDENT_CHANGED_CONTROLLER) {
WriteShort(MSG_ENTITY, m_flBoneControl1 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl2 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl3 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl4 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl5 * 32767 / 360);
}
SENDENTITY_COORD(origin[0], RDENT_CHANGED_ORIGIN_X)
SENDENTITY_COORD(origin[1], RDENT_CHANGED_ORIGIN_Y)
SENDENTITY_COORD(origin[2], RDENT_CHANGED_ORIGIN_Z)
SENDENTITY_ANGLE(angles[0], RDENT_CHANGED_ANGLES_X)
SENDENTITY_ANGLE(angles[1], RDENT_CHANGED_ANGLES_Y)
SENDENTITY_ANGLE(angles[2], RDENT_CHANGED_ANGLES_Z)
SENDENTITY_SHORT(modelindex, RDENT_CHANGED_MODELINDEX)
SENDENTITY_BYTE(colormap, RDENT_CHANGED_MODELINDEX)
SENDENTITY_BYTE(solid, RDENT_CHANGED_SOLID)
SENDENTITY_BYTE(movetype, RDENT_CHANGED_FLAGS)
SENDENTITY_INT(flags, RDENT_CHANGED_FLAGS)
SENDENTITY_COORD(mins[0], RDENT_CHANGED_SIZE)
SENDENTITY_COORD(mins[1], RDENT_CHANGED_SIZE)
SENDENTITY_COORD(mins[2], RDENT_CHANGED_SIZE)
SENDENTITY_COORD(maxs[0], RDENT_CHANGED_SIZE)
SENDENTITY_COORD(maxs[1], RDENT_CHANGED_SIZE)
SENDENTITY_COORD(maxs[2], RDENT_CHANGED_SIZE)
SENDENTITY_BYTE(frame, RDENT_CHANGED_FRAME)
SENDENTITY_BYTE(skin, RDENT_CHANGED_SKIN)
SENDENTITY_FLOAT(effects, RDENT_CHANGED_EFFECTS)
SENDENTITY_BYTE(m_iBody, RDENT_CHANGED_BODY)
SENDENTITY_FLOAT(scale, RDENT_CHANGED_SCALE)
SENDENTITY_COORD(velocity[0], RDENT_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[1], RDENT_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[2], RDENT_CHANGED_VELOCITY)
SENDENTITY_BYTE(m_iRenderMode, RDENT_CHANGED_RENDERMODE)
SENDENTITY_BYTE(m_iRenderFX, RDENT_CHANGED_RENDERMODE)
SENDENTITY_ANGLE(m_vecRenderColor[0], RDENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[1], RDENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[2], RDENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(glowmod[0], RDENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(glowmod[1], RDENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(glowmod[2], RDENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_flRenderAmt, RDENT_CHANGED_RENDERAMT)
SENDENTITY_ANGLE(m_flBoneControl1, RDENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl2, RDENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl3, RDENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl4, RDENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl5, RDENT_CHANGED_CONTROLLER)
return (1);
}
#else
/*
============
NSRenderableEntity::ReceiveEntity
============
*/
void
NSRenderableEntity::ReceiveEntity(float flNew, float flChanged)
{
READENTITY_COORD(origin[0], RDENT_CHANGED_ORIGIN_X)
READENTITY_COORD(origin[1], RDENT_CHANGED_ORIGIN_Y)
READENTITY_COORD(origin[2], RDENT_CHANGED_ORIGIN_Z)
READENTITY_ANGLE(angles[0], RDENT_CHANGED_ANGLES_X)
READENTITY_ANGLE(angles[1], RDENT_CHANGED_ANGLES_Y)
READENTITY_ANGLE(angles[2], RDENT_CHANGED_ANGLES_Z)
READENTITY_SHORT(modelindex, RDENT_CHANGED_MODELINDEX)
READENTITY_BYTE(colormap, RDENT_CHANGED_MODELINDEX)
READENTITY_BYTE(solid, RDENT_CHANGED_SOLID)
READENTITY_BYTE(movetype, RDENT_CHANGED_FLAGS)
READENTITY_INT(flags, RDENT_CHANGED_FLAGS)
READENTITY_COORD(mins[0], RDENT_CHANGED_SIZE)
READENTITY_COORD(mins[1], RDENT_CHANGED_SIZE)
READENTITY_COORD(mins[2], RDENT_CHANGED_SIZE)
READENTITY_COORD(maxs[0], RDENT_CHANGED_SIZE)
READENTITY_COORD(maxs[1], RDENT_CHANGED_SIZE)
READENTITY_COORD(maxs[2], RDENT_CHANGED_SIZE)
READENTITY_BYTE(frame, RDENT_CHANGED_FRAME)
READENTITY_BYTE(skin, RDENT_CHANGED_SKIN)
READENTITY_FLOAT(effects, RDENT_CHANGED_EFFECTS)
READENTITY_BYTE(m_iBody, RDENT_CHANGED_BODY)
READENTITY_FLOAT(scale, RDENT_CHANGED_SCALE)
READENTITY_COORD(velocity[0], RDENT_CHANGED_VELOCITY)
READENTITY_COORD(velocity[1], RDENT_CHANGED_VELOCITY)
READENTITY_COORD(velocity[2], RDENT_CHANGED_VELOCITY)
READENTITY_BYTE(m_iRenderMode, RDENT_CHANGED_RENDERMODE)
READENTITY_BYTE(m_iRenderFX, RDENT_CHANGED_RENDERMODE)
READENTITY_ANGLE(m_vecRenderColor[0], RDENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[1], RDENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[2], RDENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(glowmod[0], RDENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(glowmod[1], RDENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(glowmod[2], RDENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_flRenderAmt, RDENT_CHANGED_RENDERAMT)
READENTITY_ANGLE(m_flBoneControl1, RDENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl2, RDENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl3, RDENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl4, RDENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl5, RDENT_CHANGED_CONTROLLER)
if (scale == 0.0)
scale = 1.0f;
if (flChanged & RDENT_CHANGED_SIZE)
setsize(this, mins * scale, maxs * scale);
if (flChanged & RDENT_CHANGED_BODY)
setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
setorigin(this, origin);
}
/*
============
@ -358,7 +284,7 @@ NSRenderableEntity::RenderFXPass(void)
/* If we can't trace against the player, or are two close, fade out */
if (trace_fraction < 1.0f || vlen(origin - vecPlayer) < 128)
alpha -= clframetime;
alpha -= clframetime;
else
alpha += clframetime;
@ -524,112 +450,6 @@ NSRenderableEntity::RenderFXPass(void)
}
}
/*
============
NSRenderableEntity::ReceiveEntity
============
*/
void
NSRenderableEntity::ReceiveEntity(float flNew, float flChanged)
{
if (flChanged & RDENT_CHANGED_ORIGIN_X) {
origin[0] = readcoord();
}
if (flChanged & RDENT_CHANGED_ORIGIN_Y) {
origin[1] = readcoord();
}
if (flChanged & RDENT_CHANGED_ORIGIN_Z) {
origin[2] = readcoord();
}
if (flChanged & RDENT_CHANGED_ANGLES_X) {
angles[0] = readshort() / (32767 / 360);
}
if (flChanged & RDENT_CHANGED_ANGLES_Y) {
angles[1] = readshort() / (32767 / 360);
}
if (flChanged & RDENT_CHANGED_ANGLES_Z) {
angles[2] = readshort() / (32767 / 360);
}
if (flChanged & RDENT_CHANGED_MODELINDEX) {
setmodelindex(this, readshort());
colormap = readbyte();
}
if (flChanged & RDENT_CHANGED_SOLID) {
solid = readbyte();
}
if (flChanged & RDENT_CHANGED_MOVETYPE) {
movetype = readbyte();
if (movetype == MOVETYPE_PHYSICS) {
movetype = MOVETYPE_NONE;
}
}
if (flChanged & RDENT_CHANGED_SIZE) {
mins[0] = readcoord();
mins[1] = readcoord();
mins[2] = readcoord();
maxs[0] = readcoord();
maxs[1] = readcoord();
maxs[2] = readcoord();
}
if (flChanged & RDENT_CHANGED_FRAME) {
frame = readbyte();
frame1time =
frame2time = readbyte();
}
if (flChanged & RDENT_CHANGED_SKIN) {
skin = readbyte() - 128;
}
if (flChanged & RDENT_CHANGED_EFFECTS) {
effects = readfloat();
}
if (flChanged & RDENT_CHANGED_BODY) {
m_iBody = readbyte();
setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
}
if (flChanged & RDENT_CHANGED_SCALE) {
scale = readfloat();
}
if (flChanged & RDENT_CHANGED_VELOCITY) {
velocity[0] = readfloat();
velocity[1] = readfloat();
velocity[2] = readfloat();
}
if (flChanged & RDENT_CHANGED_RENDERMODE) {
m_iRenderMode = readbyte();
m_iRenderFX = readbyte();
}
if (flChanged & RDENT_CHANGED_RENDERCOLOR) {
m_vecRenderColor[0] = readfloat();
m_vecRenderColor[1] = readfloat();
m_vecRenderColor[2] = readfloat();
glowmod[0] = readfloat();
glowmod[1] = readfloat();
glowmod[2] = readfloat();
}
if (flChanged & RDENT_CHANGED_RENDERAMT) {
m_flRenderAmt = readfloat();
}
if (flChanged & RDENT_CHANGED_CONTROLLER) {
m_flBoneControl1 = readshort() / (32767 / 360);
m_flBoneControl2 = readshort() / (32767 / 360);
m_flBoneControl3 = readshort() / (32767 / 360);
m_flBoneControl4 = readshort() / (32767 / 360);
m_flBoneControl5 = readshort() / (32767 / 360);
}
if (scale == 0.0)
scale = 1.0f;
if (flChanged & RDENT_CHANGED_SIZE)
setsize(this, mins * scale, maxs * scale);
setorigin(this, origin);
}
void
NSRenderableEntity::RenderDebugSkeleton(void)
{
@ -1001,16 +821,6 @@ NSRenderableEntity::SpawnKey(string strKey, string strValue)
}
}
void
NSRenderableEntity::NSRenderableEntity(void)
{
effects |= EF_NOSHADOW;
#ifdef CLIENT
drawmask = MASK_ENGINE;
#endif
}
#ifdef CLIENT
void
NSRenderableEntity_ReadEntity(bool new)

8
src/shared/NSSurfacePropEntity.h
View File

@ -16,8 +16,12 @@
enumflags
{
SRFENT_CHANGED_ORIGIN,
SRFENT_CHANGED_ANGLES,
SRFENT_CHANGED_ORIGIN_X,
SRFENT_CHANGED_ORIGIN_Y,
SRFENT_CHANGED_ORIGIN_Z,
SRFENT_CHANGED_ANGLES_X,
SRFENT_CHANGED_ANGLES_Y,
SRFENT_CHANGED_ANGLES_Z,
SRFENT_CHANGED_MODELINDEX,
SRFENT_CHANGED_SIZE,
SRFENT_CHANGED_FLAGS,

453
src/shared/NSSurfacePropEntity.qc
View File

@ -14,6 +14,25 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSSurfacePropEntity::NSSurfacePropEntity(void)
{
m_flBurnNext = 0.0f;
#ifdef SERVER
m_iPropData = -1i;
m_iMaterial = -1i;
max_health = 100;
m_strOnBreak = __NULL__;
m_eBurner= __NULL__;
m_iBurnWeapon = 0i;
m_flBurnTime = 0.0f;
m_flBurnDmgTime = 0.0f;
m_oldHealth = 0;
string m_strSurfData = __NULL__;
string m_strPropData = __NULL__;
#endif
}
vector
NSSurfacePropEntity::GetEyePos(void)
{
@ -45,7 +64,7 @@ NSSurfacePropEntity::IsAlive(void)
return (health > 0) ? true : false;
}
#if INDEV
#if 0
typedef enum
{
NETFIELD_BYTE,
@ -69,19 +88,22 @@ typedef struct
const netinfo_t n_NSSurfacePropEntity[] =
{
{origin[0], NSEntity::origin_net[0], SRFENT_CHANGED_ORIGIN, 0, NETFIELD_COORD},
{origin[1], NSEntity::origin_net[1], SRFENT_CHANGED_ORIGIN, 0, NETFIELD_COORD},
{origin[2], NSEntity::origin_net[2], SRFENT_CHANGED_ORIGIN, 0, NETFIELD_COORD},
{angles[0], NSEntity::angles_net[0], SRFENT_CHANGED_ANGLES, 0, NETFIELD_ANGLE},
{angles[1], NSEntity::angles_net[1], SRFENT_CHANGED_ANGLES, 0, NETFIELD_ANGLE},
{angles[2], NSEntity::angles_net[2], SRFENT_CHANGED_ANGLES, 0, NETFIELD_ANGLE},
{origin[0], NSEntity::origin_net[0], SRFENT_CHANGED_ORIGIN_X, 0, NETFIELD_COORD},
{origin[1], NSEntity::origin_net[1], SRFENT_CHANGED_ORIGIN_Y, 0, NETFIELD_COORD},
{origin[2], NSEntity::origin_net[2], SRFENT_CHANGED_ORIGIN_Z, 0, NETFIELD_COORD},
{angles[0], NSEntity::angles_net[0], SRFENT_CHANGED_ANGLES_X, 0, NETFIELD_ANGLE},
{angles[1], NSEntity::angles_net[1], SRFENT_CHANGED_ANGLES_Y, 0, NETFIELD_ANGLE},
{angles[2], NSEntity::angles_net[2], SRFENT_CHANGED_ANGLES_Z, 0, NETFIELD_ANGLE},
{modelindex, NSEntity::modelindex_net, SRFENT_CHANGED_MODELINDEX, 0, NETFIELD_SHORT},
{solid, NSEntity::solid_net, SRFENT_CHANGED_SOLID, 0, NETFIELD_BYTE},
{movetype, NSEntity::movetype_net, SRFENT_CHANGED_MOVETYPE, 0, NETFIELD_BYTE},
{flags, NSEntity::flags_net, SRFENT_CHANGED_FLAGS, 0, NETFIELD_FLOAT},
{size[0], NSEntity::size_net[0], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{size[1], NSEntity::size_net[1], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{size[2], NSEntity::size_net[2], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{mins[0], NSEntity::mins_net[0], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{mins[1], NSEntity::mins_net[1], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{mins[2], NSEntity::mins_net[2], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{maxs[0], NSEntity::maxs_net[0], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{maxs[1], NSEntity::maxs_net[1], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{maxs[2], NSEntity::maxs_net[2], SRFENT_CHANGED_SIZE, 0, NETFIELD_SHORT},
{frame, NSRenderableEntity::frame_net, SRFENT_CHANGED_FRAME, 0, NETFIELD_SHORT},
{skin, NSRenderableEntity::skin_net, SRFENT_CHANGED_SKIN, 0, NETFIELD_BYTE},
{effects, NSRenderableEntity::effects_net, SRFENT_CHANGED_EFFECTS, 0, NETFIELD_SHORT},
@ -98,40 +120,15 @@ void
NSSurfacePropEntity::EvaluateEntity(void)
{
for (int i = 0; i < n_NSSurfacePropEntity.length; i++) {
if (this.(n_NSSurfacePropEntity[i].field) != this.(n_NSSurfacePropEntity[i].field_net))
if (this.(n_NSSurfacePropEntity[i].field) != this.(n_NSSurfacePropEntity[i].field_net)) {
SetSendFlags(n_NSSurfacePropEntity[i].changedflag);
print(sprintf("uhh %i\n", i));
}
this.(n_NSSurfacePropEntity[i].field_net) = this.(n_NSSurfacePropEntity[i].field);
}
}
#endif
void
NSSurfacePropEntity::EvaluateEntity(void)
{
EVALUATE_FIELD(origin, SRFENT_CHANGED_ORIGIN)
EVALUATE_FIELD(angles, SRFENT_CHANGED_ANGLES)
EVALUATE_FIELD(modelindex, SRFENT_CHANGED_MODELINDEX)
EVALUATE_FIELD(solid, SRFENT_CHANGED_SOLID)
EVALUATE_FIELD(movetype, SRFENT_CHANGED_FLAGS)
EVALUATE_FIELD(flags, SRFENT_CHANGED_FLAGS)
EVALUATE_FIELD(size, SRFENT_CHANGED_SIZE)
EVALUATE_FIELD(frame, SRFENT_CHANGED_FRAME)
EVALUATE_FIELD(skin, SRFENT_CHANGED_SKIN)
EVALUATE_FIELD(effects, SRFENT_CHANGED_EFFECTS)
EVALUATE_FIELD(m_iBody, SRFENT_CHANGED_BODY)
EVALUATE_FIELD(scale, SRFENT_CHANGED_SCALE)
EVALUATE_FIELD(velocity, SRFENT_CHANGED_VELOCITY)
EVALUATE_FIELD(m_iRenderMode, SRFENT_CHANGED_RENDERMODE)
EVALUATE_FIELD(m_iRenderFX, SRFENT_CHANGED_RENDERMODE)
EVALUATE_FIELD(m_vecRenderColor, SRFENT_CHANGED_RENDERCOLOR)
EVALUATE_FIELD(m_flRenderAmt, SRFENT_CHANGED_RENDERAMT)
EVALUATE_FIELD(m_flBoneControl1, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl2, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl3, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl4, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl5, SRFENT_CHANGED_CONTROLLER)
}
/* Make sure StartFrame calls this */
float
@ -145,128 +142,151 @@ NSSurfacePropEntity::SendEntity(entity ePEnt, float fChanged)
WriteByte(MSG_ENTITY, ENT_SURFPROP);
//print(sprintf("%s %x\n", classname, fChanged));
#if 0
/* newly popped into the PVS, sadly this is the only hacky way to check
* for this right now. convince the engine maintainer to make this more sensible */
if (fChanged == 0xFFFFFF) {
/* check for defaults. if these are predictable fields, don't even bother
* networking them! you're just wasting bandwidth. */
if (frame == 0)
fChanged &= ~SRFENT_CHANGED_FRAME;
if (skin == 0)
fChanged &= ~SRFENT_CHANGED_SKIN;
if (effects == 0)
fChanged &= ~SRFENT_CHANGED_EFFECTS;
if (m_iBody == 0)
fChanged &= ~SRFENT_CHANGED_BODY;
if (scale == 0.0 || scale == 1.0)
fChanged &= ~SRFENT_CHANGED_SCALE;
if (origin == [0,0,0])
fChanged &= ~SRFENT_CHANGED_ORIGIN;
if (angles == [0,0,0])
fChanged &= ~SRFENT_CHANGED_ANGLES;
if (velocity == [0,0,0])
fChanged &= ~SRFENT_CHANGED_VELOCITY;
if (mins == [0,0,0] && maxs == [0,0,0])
fChanged &= ~SRFENT_CHANGED_SIZE;
if (solid == SOLID_NOT)
fChanged &= ~SRFENT_CHANGED_SOLID;
if (movetype == MOVETYPE_NONE)
fChanged &= ~SRFENT_CHANGED_MOVETYPE;
if (m_iRenderMode == RM_NORMAL)
fChanged &= ~SRFENT_CHANGED_RENDERMODE;
}
#endif
/* don't network triggers unless provoked */
/*if (cvar("developer") == 0 && m_iRenderMode == RM_TRIGGER)
return (0);*/
#if 0
if (fChanged == 0xFFFFFF) {
for (int i = 0; i < n_NSSurfacePropEntity.length; i++) {
/* unflag everything that's the default value */
if (this.(n_NSSurfacePropEntity[i].field) == this.(n_NSSurfacePropEntity[i].defaultvalue))
fChanged &= ~n_NSSurfacePropEntity[i].changedflag;
}
}
#endif
/* broadcast how much data is expected to be read */
WriteFloat(MSG_ENTITY, fChanged);
/* really trying to get our moneys worth with 23 bits of mantissa */
if (fChanged & SRFENT_CHANGED_ORIGIN) {
WriteCoord(MSG_ENTITY, origin[0]);
WriteCoord(MSG_ENTITY, origin[1]);
WriteCoord(MSG_ENTITY, origin[2]);
}
if (fChanged & SRFENT_CHANGED_ANGLES) {
WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
}
if (fChanged & SRFENT_CHANGED_MODELINDEX) {
WriteShort(MSG_ENTITY, modelindex);
WriteByte(MSG_ENTITY, colormap);
}
if (fChanged & SRFENT_CHANGED_SOLID) {
WriteByte(MSG_ENTITY, solid);
}
if (fChanged & SRFENT_CHANGED_MOVETYPE) {
WriteByte(MSG_ENTITY, movetype);
}
if (fChanged & SRFENT_CHANGED_FLAGS) {
WriteFloat(MSG_ENTITY, flags);
}
if (fChanged & SRFENT_CHANGED_SIZE) {
WriteCoord(MSG_ENTITY, mins[0]);
WriteCoord(MSG_ENTITY, mins[1]);
WriteCoord(MSG_ENTITY, mins[2]);
WriteCoord(MSG_ENTITY, maxs[0]);
WriteCoord(MSG_ENTITY, maxs[1]);
WriteCoord(MSG_ENTITY, maxs[2]);
}
if (fChanged & SRFENT_CHANGED_FRAME) {
WriteByte(MSG_ENTITY, frame);
WriteByte(MSG_ENTITY, frame1time);
}
if (fChanged & SRFENT_CHANGED_SKIN) {
WriteByte(MSG_ENTITY, skin + 128);
}
if (fChanged & SRFENT_CHANGED_EFFECTS) {
WriteFloat(MSG_ENTITY, effects);
}
if (fChanged & SRFENT_CHANGED_BODY) {
WriteByte(MSG_ENTITY, m_iBody);
}
if (fChanged & SRFENT_CHANGED_SCALE) {
WriteFloat(MSG_ENTITY, scale);
}
if (fChanged & SRFENT_CHANGED_VELOCITY) {
WriteFloat(MSG_ENTITY, velocity[0]);
WriteFloat(MSG_ENTITY, velocity[1]);
WriteFloat(MSG_ENTITY, velocity[2]);
}
if (fChanged & SRFENT_CHANGED_RENDERMODE) {
WriteByte(MSG_ENTITY, m_iRenderMode);
WriteByte(MSG_ENTITY, m_iRenderFX);
}
if (fChanged & SRFENT_CHANGED_RENDERCOLOR) {
WriteFloat(MSG_ENTITY, m_vecRenderColor[0]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[1]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[2]);
WriteFloat(MSG_ENTITY, glowmod[0]);
WriteFloat(MSG_ENTITY, glowmod[1]);
WriteFloat(MSG_ENTITY, glowmod[2]);
}
if (fChanged & SRFENT_CHANGED_RENDERAMT) {
WriteFloat(MSG_ENTITY, m_flRenderAmt);
}
if (fChanged & SRFENT_CHANGED_CONTROLLER) {
WriteShort(MSG_ENTITY, m_flBoneControl1 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl2 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl3 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl4 * 32767 / 360);
WriteShort(MSG_ENTITY, m_flBoneControl5 * 32767 / 360);
for (int i = 0; i < n_NSSurfacePropEntity.length; i++) {
if (fChanged & n_NSSurfacePropEntity[i].changedflag) {
switch (n_NSSurfacePropEntity[i].type) {
case NETFIELD_BYTE:
WriteByte(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
case NETFIELD_SHORT:
WriteShort(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
case NETFIELD_FLOAT:
WriteFloat(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
case NETFIELD_INT:
WriteInt(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
case NETFIELD_COORD:
WriteCoord(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
case NETFIELD_ANGLE:
WriteShort(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field) * 32767 / 360);
break;
case NETFIELD_ENTITY:
WriteEntity(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
case NETFIELD_STRING:
WriteString(MSG_ENTITY, this.(n_NSSurfacePropEntity[i].field));
break;
}
}
}
return (1);
}
#else
void
NSSurfacePropEntity::EvaluateEntity(void)
{
EVALUATE_VECTOR(origin, 0, SRFENT_CHANGED_ORIGIN_X)
EVALUATE_VECTOR(origin, 1, SRFENT_CHANGED_ORIGIN_Y)
EVALUATE_VECTOR(origin, 2, SRFENT_CHANGED_ORIGIN_Z)
EVALUATE_VECTOR(angles, 0, SRFENT_CHANGED_ANGLES_X)
EVALUATE_VECTOR(angles, 1, SRFENT_CHANGED_ANGLES_Y)
EVALUATE_VECTOR(angles, 2, SRFENT_CHANGED_ANGLES_Z)
EVALUATE_FIELD(modelindex, SRFENT_CHANGED_MODELINDEX)
EVALUATE_FIELD(solid, SRFENT_CHANGED_SOLID)
EVALUATE_FIELD(movetype, SRFENT_CHANGED_FLAGS)
EVALUATE_FIELD(flags, SRFENT_CHANGED_FLAGS)
EVALUATE_VECTOR(mins, 0, SRFENT_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 1, SRFENT_CHANGED_SIZE)
EVALUATE_VECTOR(mins, 2, SRFENT_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 0, SRFENT_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 1, SRFENT_CHANGED_SIZE)
EVALUATE_VECTOR(maxs, 2, SRFENT_CHANGED_SIZE)
EVALUATE_FIELD(frame, SRFENT_CHANGED_FRAME)
EVALUATE_FIELD(skin, SRFENT_CHANGED_SKIN)
EVALUATE_FIELD(effects, SRFENT_CHANGED_EFFECTS)
EVALUATE_FIELD(m_iBody, SRFENT_CHANGED_BODY)
EVALUATE_FIELD(scale, SRFENT_CHANGED_SCALE)
EVALUATE_VECTOR(velocity, 0, SRFENT_CHANGED_VELOCITY)
EVALUATE_VECTOR(velocity, 1, SRFENT_CHANGED_VELOCITY)
EVALUATE_VECTOR(velocity, 2, SRFENT_CHANGED_VELOCITY)
EVALUATE_FIELD(m_iRenderMode, SRFENT_CHANGED_RENDERMODE)
EVALUATE_FIELD(m_iRenderFX, SRFENT_CHANGED_RENDERMODE)
EVALUATE_VECTOR(m_vecRenderColor, 0, SRFENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(m_vecRenderColor, 1, SRFENT_CHANGED_RENDERCOLOR)
EVALUATE_VECTOR(m_vecRenderColor, 2, SRFENT_CHANGED_RENDERCOLOR)
EVALUATE_FIELD(m_flRenderAmt, SRFENT_CHANGED_RENDERAMT)
EVALUATE_FIELD(m_flBoneControl1, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl2, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl3, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl4, SRFENT_CHANGED_CONTROLLER)
EVALUATE_FIELD(m_flBoneControl5, SRFENT_CHANGED_CONTROLLER)
}
/* Make sure StartFrame calls this */
float
NSSurfacePropEntity::SendEntity(entity ePEnt, float flChanged)
{
if (!modelindex)
return (0);
if (clienttype(ePEnt) != CLIENTTYPE_REAL)
return (0);
WriteByte(MSG_ENTITY, ENT_SURFPROP);
/* broadcast how much data is expected to be read */
WriteFloat(MSG_ENTITY, flChanged);
SENDENTITY_COORD(origin[0], SRFENT_CHANGED_ORIGIN_X)
SENDENTITY_COORD(origin[1], SRFENT_CHANGED_ORIGIN_Y)
SENDENTITY_COORD(origin[2], SRFENT_CHANGED_ORIGIN_Z)
SENDENTITY_ANGLE(angles[0], SRFENT_CHANGED_ANGLES_X)
SENDENTITY_ANGLE(angles[1], SRFENT_CHANGED_ANGLES_Y)
SENDENTITY_ANGLE(angles[2], SRFENT_CHANGED_ANGLES_Z)
SENDENTITY_SHORT(modelindex, SRFENT_CHANGED_MODELINDEX)
SENDENTITY_BYTE(solid, SRFENT_CHANGED_SOLID)
SENDENTITY_BYTE(movetype, SRFENT_CHANGED_FLAGS)
SENDENTITY_INT(flags, SRFENT_CHANGED_FLAGS)
SENDENTITY_COORD(mins[0], SRFENT_CHANGED_SIZE)
SENDENTITY_COORD(mins[1], SRFENT_CHANGED_SIZE)
SENDENTITY_COORD(mins[2], SRFENT_CHANGED_SIZE)
SENDENTITY_COORD(maxs[0], SRFENT_CHANGED_SIZE)
SENDENTITY_COORD(maxs[1], SRFENT_CHANGED_SIZE)
SENDENTITY_COORD(maxs[2], SRFENT_CHANGED_SIZE)
SENDENTITY_BYTE(frame, SRFENT_CHANGED_FRAME)
SENDENTITY_BYTE(skin, SRFENT_CHANGED_SKIN)
SENDENTITY_FLOAT(effects, SRFENT_CHANGED_EFFECTS)
SENDENTITY_BYTE(m_iBody, SRFENT_CHANGED_BODY)
SENDENTITY_FLOAT(scale, SRFENT_CHANGED_SCALE)
SENDENTITY_COORD(velocity[0], SRFENT_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[1], SRFENT_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[2], SRFENT_CHANGED_VELOCITY)
SENDENTITY_BYTE(m_iRenderMode, SRFENT_CHANGED_RENDERMODE)
SENDENTITY_BYTE(m_iRenderFX, SRFENT_CHANGED_RENDERMODE)
SENDENTITY_ANGLE(m_vecRenderColor[0], SRFENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[1], SRFENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[2], SRFENT_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_flRenderAmt, SRFENT_CHANGED_RENDERAMT)
SENDENTITY_ANGLE(m_flBoneControl1, SRFENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl2, SRFENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl3, SRFENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl4, SRFENT_CHANGED_CONTROLLER)
SENDENTITY_ANGLE(m_flBoneControl5, SRFENT_CHANGED_CONTROLLER)
return (1);
}
#endif
#else
/*
============
@ -276,99 +296,49 @@ NSSurfacePropEntity::ReceiveEntity
void
NSSurfacePropEntity::ReceiveEntity(float flNew, float flChanged)
{
if (flChanged & SRFENT_CHANGED_ORIGIN) {
origin[0] = readcoord();
origin[1] = readcoord();
origin[2] = readcoord();
}
if (flChanged & SRFENT_CHANGED_ANGLES) {
angles[0] = readshort() / (32767 / 360);
angles[1] = readshort() / (32767 / 360);
angles[2] = readshort() / (32767 / 360);
}
if (flChanged & SRFENT_CHANGED_MODELINDEX) {
setmodelindex(this, readshort());
colormap = readbyte();
}
if (flChanged & SRFENT_CHANGED_SOLID) {
solid = readbyte();
}
if (flChanged & SRFENT_CHANGED_MOVETYPE) {
movetype = readbyte();
if (movetype == MOVETYPE_PHYSICS) {
movetype = MOVETYPE_NONE;
}
}
if (flChanged & SRFENT_CHANGED_FLAGS) {
flags = readfloat();
}
if (flChanged & SRFENT_CHANGED_SIZE) {
mins[0] = readcoord();
mins[1] = readcoord();
mins[2] = readcoord();
maxs[0] = readcoord();
maxs[1] = readcoord();
maxs[2] = readcoord();
}
if (flChanged & SRFENT_CHANGED_FRAME) {
frame = readbyte();
frame1time =
frame2time = readbyte();
}
if (flChanged & SRFENT_CHANGED_SKIN) {
skin = readbyte() - 128;
}
if (flChanged & SRFENT_CHANGED_EFFECTS) {
effects = readfloat();
}
if (flChanged & SRFENT_CHANGED_BODY) {
m_iBody = readbyte();
setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
}
if (flChanged & SRFENT_CHANGED_SCALE) {
scale = readfloat();
}
if (flChanged & SRFENT_CHANGED_VELOCITY) {
velocity[0] = readfloat();
velocity[1] = readfloat();
velocity[2] = readfloat();
}
if (flChanged & SRFENT_CHANGED_RENDERMODE) {
m_iRenderMode = readbyte();
m_iRenderFX = readbyte();
}
if (flChanged & SRFENT_CHANGED_RENDERCOLOR) {
m_vecRenderColor[0] = readfloat();
m_vecRenderColor[1] = readfloat();
m_vecRenderColor[2] = readfloat();
glowmod[0] = readfloat();
glowmod[1] = readfloat();
glowmod[2] = readfloat();
}
if (flChanged & SRFENT_CHANGED_RENDERAMT) {
m_flRenderAmt = readfloat();
}
if (flChanged & SRFENT_CHANGED_CONTROLLER) {
m_flBoneControl1 = readshort() / (32767 / 360);
m_flBoneControl2 = readshort() / (32767 / 360);
m_flBoneControl3 = readshort() / (32767 / 360);
m_flBoneControl4 = readshort() / (32767 / 360);
m_flBoneControl5 = readshort() / (32767 / 360);
}
if (modelindex) {
drawmask = MASK_ENGINE;
} else {
drawmask = 0;
}
READENTITY_COORD(origin[0], SRFENT_CHANGED_ORIGIN_X)
READENTITY_COORD(origin[1], SRFENT_CHANGED_ORIGIN_Y)
READENTITY_COORD(origin[2], SRFENT_CHANGED_ORIGIN_Z)
READENTITY_ANGLE(angles[0], SRFENT_CHANGED_ANGLES_X)
READENTITY_ANGLE(angles[1], SRFENT_CHANGED_ANGLES_Y)
READENTITY_ANGLE(angles[2], SRFENT_CHANGED_ANGLES_Z)
READENTITY_SHORT(modelindex, SRFENT_CHANGED_MODELINDEX)
READENTITY_BYTE(solid, SRFENT_CHANGED_SOLID)
READENTITY_BYTE(movetype, SRFENT_CHANGED_FLAGS)
READENTITY_INT(flags, SRFENT_CHANGED_FLAGS)
READENTITY_COORD(mins[0], SRFENT_CHANGED_SIZE)
READENTITY_COORD(mins[1], SRFENT_CHANGED_SIZE)
READENTITY_COORD(mins[2], SRFENT_CHANGED_SIZE)
READENTITY_COORD(maxs[0], SRFENT_CHANGED_SIZE)
READENTITY_COORD(maxs[1], SRFENT_CHANGED_SIZE)
READENTITY_COORD(maxs[2], SRFENT_CHANGED_SIZE)
READENTITY_BYTE(frame, SRFENT_CHANGED_FRAME)
READENTITY_BYTE(skin, SRFENT_CHANGED_SKIN)
READENTITY_FLOAT(effects, SRFENT_CHANGED_EFFECTS)
READENTITY_BYTE(m_iBody, SRFENT_CHANGED_BODY)
READENTITY_FLOAT(scale, SRFENT_CHANGED_SCALE)
READENTITY_COORD(velocity[0], SRFENT_CHANGED_VELOCITY)
READENTITY_COORD(velocity[1], SRFENT_CHANGED_VELOCITY)
READENTITY_COORD(velocity[2], SRFENT_CHANGED_VELOCITY)
READENTITY_BYTE(m_iRenderMode, SRFENT_CHANGED_RENDERMODE)
READENTITY_BYTE(m_iRenderFX, SRFENT_CHANGED_RENDERMODE)
READENTITY_ANGLE(m_vecRenderColor[0], SRFENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[1], SRFENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[2], SRFENT_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_flRenderAmt, SRFENT_CHANGED_RENDERAMT)
READENTITY_ANGLE(m_flBoneControl1, SRFENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl2, SRFENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl3, SRFENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl4, SRFENT_CHANGED_CONTROLLER)
READENTITY_ANGLE(m_flBoneControl5, SRFENT_CHANGED_CONTROLLER)
if (scale == 0.0)
scale = 1.0f;
if (flChanged & SRFENT_CHANGED_SIZE)
setsize(this, mins * scale, maxs * scale);
if (flChanged & SRFENT_CHANGED_BODY)
setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
setorigin(this, origin);
}
@ -710,17 +680,6 @@ NSSurfacePropEntity::SetModel(string newModel)
#endif
}
void
NSSurfacePropEntity::NSSurfacePropEntity(void)
{
#ifdef SERVER
m_iPropData = -1;
m_iMaterial = -1;
max_health = 100;
m_strOnBreak = __NULL__;
#endif
}
#ifdef CLIENT
void
NSSurfacePropEntity_ReadEntity(bool new)

262
src/shared/NSTalkMonster.qc
View File

@ -14,6 +14,50 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSTalkMonster::NSTalkMonster(void)
{
#ifdef SERVER
m_eFollowing = world;
float m_flPitch = 1.0f;
float m_flNextSentence = 0.0f;
int m_iFlags = 0i;
m_eFollowingChain = __NULL__;
m_vecLastUserPos = [0,0,0];
m_flChangePath = 0.0f;
m_flTraceTime = 0.0f;
m_flFollowSpeedChanged = 0.0f;
m_flFollowSpeed = 0.0f;
m_talkAnswer = __NULL__;
m_talkAsk = __NULL__;
m_talkAllyShot = __NULL__;
m_talkGreet = __NULL__;
m_talkIdle = __NULL__;
m_talkPanic = __NULL__;
m_talkHearing = __NULL__;
m_talkSmelling = __NULL__;
m_talkStare = __NULL__;
m_talkSurvived = __NULL__;
m_talkWounded = __NULL__;
m_talkPlayerAsk = __NULL__;
m_talkPlayerGreet = __NULL__;
m_talkPlayerIdle = __NULL__;
m_talkPlayerWounded1 = __NULL__;
m_talkPlayerWounded2 = __NULL__;
m_talkPlayerWounded3 = __NULL__;
m_talkUnfollow = __NULL__;
m_talkFollow = __NULL__;
m_talkStopFollow = __NULL__;
#else
m_flSentenceTime = 0.0f;
m_pSentenceQue = __NULL__;
m_iSentenceCount = 0i;
m_iSentencePos = 0i;
m_sndVoiceOffs = 0.0f;
m_bWasPaused = false;
#endif
}
#ifdef SERVER
void
NSTalkMonster::Save(float handle)
@ -552,7 +596,7 @@ NSTalkMonster::Hide(void)
}
float
NSTalkMonster::SendEntity(entity ePEnt, float fChanged)
NSTalkMonster::SendEntity(entity ePEnt, float flChanged)
{
if (!modelindex)
return (0);
@ -567,71 +611,38 @@ NSTalkMonster::SendEntity(entity ePEnt, float fChanged)
return (0);*/
/* broadcast how much data is expected to be read */
WriteFloat(MSG_ENTITY, fChanged);
WriteFloat(MSG_ENTITY, flChanged);
/* really trying to get our moneys worth with 23 bits of mantissa */
if (fChanged & BASEFL_CHANGED_ORIGIN) {
WriteCoord(MSG_ENTITY, origin[0]);
WriteCoord(MSG_ENTITY, origin[1]);
WriteCoord(MSG_ENTITY, origin[2]);
}
if (fChanged & BASEFL_CHANGED_ANGLES) {
WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
}
if (fChanged & BASEFL_CHANGED_MODELINDEX) {
WriteShort(MSG_ENTITY, modelindex);
}
if (fChanged & BASEFL_CHANGED_SOLID) {
WriteByte(MSG_ENTITY, solid);
}
if (fChanged & BASEFL_CHANGED_MOVETYPE) {
WriteByte(MSG_ENTITY, movetype);
}
if (fChanged & BASEFL_CHANGED_SIZE) {
WriteCoord(MSG_ENTITY, mins[0]);
WriteCoord(MSG_ENTITY, mins[1]);
WriteCoord(MSG_ENTITY, mins[2]);
WriteCoord(MSG_ENTITY, maxs[0]);
WriteCoord(MSG_ENTITY, maxs[1]);
WriteCoord(MSG_ENTITY, maxs[2]);
}
if (fChanged & BASEFL_CHANGED_FRAME) {
WriteByte(MSG_ENTITY, frame);
WriteFloat(MSG_ENTITY, frame1time);
}
if (fChanged & BASEFL_CHANGED_SKIN) {
WriteByte(MSG_ENTITY, skin + 128);
}
if (fChanged & BASEFL_CHANGED_EFFECTS) {
WriteFloat(MSG_ENTITY, effects);
}
if (fChanged & BASEFL_CHANGED_BODY) {
WriteByte(MSG_ENTITY, m_iBody);
}
if (fChanged & BASEFL_CHANGED_SCALE) {
WriteFloat(MSG_ENTITY, scale);
}
if (fChanged & BASEFL_CHANGED_VELOCITY) {
WriteFloat(MSG_ENTITY, velocity[0]);
WriteFloat(MSG_ENTITY, velocity[1]);
WriteFloat(MSG_ENTITY, velocity[2]);
}
if (fChanged & BASEFL_CHANGED_RENDERMODE) {
WriteByte(MSG_ENTITY, m_iRenderMode);
WriteByte(MSG_ENTITY, m_iRenderFX);
}
if (fChanged & BASEFL_CHANGED_RENDERCOLOR) {
WriteFloat(MSG_ENTITY, m_vecRenderColor[0]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[1]);
WriteFloat(MSG_ENTITY, m_vecRenderColor[2]);
}
if (fChanged & BASEFL_CHANGED_RENDERAMT) {
WriteFloat(MSG_ENTITY, m_flRenderAmt);
}
SENDENTITY_COORD(origin[0], MONFL_CHANGED_ORIGIN_X)
SENDENTITY_COORD(origin[1], MONFL_CHANGED_ORIGIN_Y)
SENDENTITY_COORD(origin[2], MONFL_CHANGED_ORIGIN_Z)
SENDENTITY_ANGLE(angles[0], MONFL_CHANGED_ANGLES_X)
SENDENTITY_ANGLE(angles[1], MONFL_CHANGED_ANGLES_Y)
SENDENTITY_ANGLE(angles[2], MONFL_CHANGED_ANGLES_Z)
SENDENTITY_SHORT(modelindex, MONFL_CHANGED_MODELINDEX)
SENDENTITY_BYTE(solid, MONFL_CHANGED_SOLID)
SENDENTITY_BYTE(movetype, MONFL_CHANGED_FLAGS)
SENDENTITY_INT(flags, MONFL_CHANGED_FLAGS)
SENDENTITY_COORD(mins[0], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(mins[1], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(mins[2], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[0], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[1], MONFL_CHANGED_SIZE)
SENDENTITY_COORD(maxs[2], MONFL_CHANGED_SIZE)
SENDENTITY_BYTE(frame, MONFL_CHANGED_FRAME)
SENDENTITY_BYTE(skin, MONFL_CHANGED_SKIN)
SENDENTITY_FLOAT(effects, MONFL_CHANGED_EFFECTS)
SENDENTITY_BYTE(m_iBody, MONFL_CHANGED_BODY)
SENDENTITY_FLOAT(scale, MONFL_CHANGED_SCALE)
SENDENTITY_COORD(velocity[0], MONFL_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[1], MONFL_CHANGED_VELOCITY)
SENDENTITY_COORD(velocity[2], MONFL_CHANGED_VELOCITY)
SENDENTITY_BYTE(m_iRenderMode, MONFL_CHANGED_RENDERMODE)
SENDENTITY_BYTE(m_iRenderFX, MONFL_CHANGED_RENDERMODE)
SENDENTITY_ANGLE(m_vecRenderColor[0], MONFL_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[1], MONFL_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_vecRenderColor[2], MONFL_CHANGED_RENDERCOLOR)
SENDENTITY_ANGLE(m_flRenderAmt, MONFL_CHANGED_RENDERAMT)
return (1);
}
@ -762,84 +773,47 @@ NSTalkMonster::ReceiveEntity
void
NSTalkMonster::ReceiveEntity(float flNew, float flChanged)
{
if (flChanged & BASEFL_CHANGED_ORIGIN) {
origin[0] = readcoord();
origin[1] = readcoord();
origin[2] = readcoord();
}
if (flChanged & BASEFL_CHANGED_ANGLES) {
angles[0] = readshort() / (32767 / 360);
angles[1] = readshort() / (32767 / 360);
angles[2] = readshort() / (32767 / 360);
}
if (flChanged & BASEFL_CHANGED_MODELINDEX) {
setmodelindex(this, readshort());
}
if (flChanged & BASEFL_CHANGED_SOLID) {
solid = readbyte();
}
if (flChanged & BASEFL_CHANGED_MOVETYPE) {
movetype = readbyte();
if (movetype == MOVETYPE_PHYSICS) {
movetype = MOVETYPE_NONE;
}
}
if (flChanged & BASEFL_CHANGED_SIZE) {
mins[0] = readcoord();
mins[1] = readcoord();
mins[2] = readcoord();
maxs[0] = readcoord();
maxs[1] = readcoord();
maxs[2] = readcoord();
setsize(this, mins, maxs);
}
if (flChanged & BASEFL_CHANGED_FRAME) {
frame = readbyte();
frame1time = readfloat();
frame2time = frame1time;
}
if (flChanged & BASEFL_CHANGED_SKIN) {
skin = readbyte() - 128;
}
if (flChanged & BASEFL_CHANGED_EFFECTS) {
effects = readfloat();
}
if (flChanged & BASEFL_CHANGED_BODY) {
m_iBody = readbyte();
setcustomskin(this, "", sprintf("geomset 1 %i\n", m_iBody));
}
if (flChanged & BASEFL_CHANGED_SCALE) {
scale = readfloat();
}
if (flChanged & BASEFL_CHANGED_VELOCITY) {
velocity[0] = readfloat();
velocity[1] = readfloat();
velocity[2] = readfloat();
}
if (flChanged & BASEFL_CHANGED_RENDERMODE) {
m_iRenderMode = readbyte();
m_iRenderFX = readbyte();
}
if (flChanged & BASEFL_CHANGED_RENDERCOLOR) {
m_vecRenderColor[0] = readfloat();
m_vecRenderColor[1] = readfloat();
m_vecRenderColor[2] = readfloat();
}
if (flChanged & BASEFL_CHANGED_RENDERAMT) {
m_flRenderAmt = readfloat();
}
if (modelindex) {
drawmask = MASK_ENGINE;
} else {
drawmask = 0;
}
READENTITY_COORD(origin[0], MONFL_CHANGED_ORIGIN_X)
READENTITY_COORD(origin[1], MONFL_CHANGED_ORIGIN_Y)
READENTITY_COORD(origin[2], MONFL_CHANGED_ORIGIN_Z)
READENTITY_ANGLE(angles[0], MONFL_CHANGED_ANGLES_X)
READENTITY_ANGLE(angles[1], MONFL_CHANGED_ANGLES_Y)
READENTITY_ANGLE(angles[2], MONFL_CHANGED_ANGLES_Z)
READENTITY_SHORT(modelindex, MONFL_CHANGED_MODELINDEX)
READENTITY_BYTE(solid, MONFL_CHANGED_SOLID)
READENTITY_BYTE(movetype, MONFL_CHANGED_FLAGS)
READENTITY_INT(flags, MONFL_CHANGED_FLAGS)
READENTITY_COORD(mins[0], MONFL_CHANGED_SIZE)
READENTITY_COORD(mins[1], MONFL_CHANGED_SIZE)
READENTITY_COORD(mins[2], MONFL_CHANGED_SIZE)
READENTITY_COORD(maxs[0], MONFL_CHANGED_SIZE)
READENTITY_COORD(maxs[1], MONFL_CHANGED_SIZE)
READENTITY_COORD(maxs[2], MONFL_CHANGED_SIZE)
READENTITY_BYTE(frame, MONFL_CHANGED_FRAME)
READENTITY_BYTE(skin, MONFL_CHANGED_SKIN)
READENTITY_FLOAT(effects, MONFL_CHANGED_EFFECTS)
READENTITY_BYTE(m_iBody, MONFL_CHANGED_BODY)
READENTITY_FLOAT(scale, MONFL_CHANGED_SCALE)
READENTITY_COORD(velocity[0], MONFL_CHANGED_VELOCITY)
READENTITY_COORD(velocity[1], MONFL_CHANGED_VELOCITY)
READENTITY_COORD(velocity[2], MONFL_CHANGED_VELOCITY)
READENTITY_BYTE(m_iRenderMode, MONFL_CHANGED_RENDERMODE)
READENTITY_BYTE(m_iRenderFX, MONFL_CHANGED_RENDERMODE)
READENTITY_ANGLE(m_vecRenderColor[0], MONFL_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[1], MONFL_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_vecRenderColor[2], MONFL_CHANGED_RENDERCOLOR)
READENTITY_ANGLE(m_flRenderAmt, MONFL_CHANGED_RENDERAMT)
if (scale == 0.0)
scale = 1.0f;
if (flChanged & MONFL_CHANGED_FRAME)
frame1time = 0.0f;
if (flChanged & MONFL_CHANGED_SIZE)
setsize(this, mins * scale, maxs * scale);
if (flChanged & MONFL_CHANGED_BODY)
setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
setorigin(this, origin);
}
@ -869,18 +843,8 @@ NSTalkMonster_ParseSentence(void)
NSLog("^3 NSTalkMonster_ParseSentence ^7: Entity %d not in PVS", e);
}
}
#endif
void
NSTalkMonster::NSTalkMonster(void)
{
#ifdef SERVER
m_eFollowing = world;
#endif
}
#ifdef CLIENT
void
NSTalkMonster_ReadEntity(float new)

20
src/shared/NSTrigger.qc
View File

@ -14,6 +14,21 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSTrigger::NSTrigger(void)
{
#ifdef SERVER
m_oldstrTarget = __NULL__;
m_strGlobalState = 0;
m_strKillTarget = __NULL__;
m_strMessage = __NULL__;
m_strMaster = __NULL__;
m_iUseType = 0;
m_iTeam = 0;
m_iValue = 0;
#endif
}
#ifdef SERVER
/* legacy trigger architecture */
void
@ -202,8 +217,3 @@ NSTrigger::SpawnKey(string strKey, string strValue)
break;
}
}
void
NSTrigger::NSTrigger(void)
{
}

12
src/shared/NSVehicle.qc
View File

@ -14,6 +14,12 @@
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
void
NSVehicle::NSVehicle(void)
{
m_eDriver = __NULL__;
}
#ifdef SERVER
void
NSVehicle::Save(float handle)
@ -444,12 +450,6 @@ NSVehicle::PlayerLeave(NSClientPlayer pl)
SetSendFlags(VEHFL_CHANGED_DRIVER);
}
void
NSVehicle::NSVehicle(void)
{
m_eDriver = __NULL__;
}
#ifdef CLIENT
void
basevehicle_readentity(float isnew)

12
src/shared/NSWeapon.qc
View File

@ -1,3 +1,9 @@
void
NSWeapon::NSWeapon(void)
{
}
/* calls */
void
NSWeapon::Precache(void)
@ -188,9 +194,3 @@ NSWeapon::HasAmmo(void)
{
return false;
}
void
NSWeapon::NSWeapon(void)
{
}

1
src/shared/defs.h
View File

@ -29,6 +29,7 @@
#define ROLL_BACK(x) x = x ##_net
#define SAVE_STATE(x) x ##_net = x
#define SAVE_STATE_FIELD(x, y) x ##_net[y] = x[y]
#define ATTR_CHANGED(x) (x ##_net != x)
#define VEC_CHANGED(x,y) (x ##_net[y] != x[y])