void CBaseButton::Spawn(void)
{
char *pszSound = ButtonSound(m_sounds);
PRECACHE_SOUND(pszSound);
pev->noise = ALLOC_STRING(pszSound);
Precache();
if (FBitSet(pev->spawnflags, SF_BUTTON_SPARK_IF_OFF))
{
SetThink(&CBaseButton::ButtonSpark);
pev->nextthink = gpGlobals->time + 0.5;
}
SetMovedir(pev);
pev->movetype = MOVETYPE_PUSH;
pev->solid = SOLID_BSP;
SET_MODEL(ENT(pev), STRING(pev->model));
if (!pev->speed)
pev->speed = 40;
if (pev->health > 0)
pev->takedamage = DAMAGE_YES;
if (!m_flWait)
m_flWait = 1;
if (!m_flLip)
m_flLip = 4;
m_toggle_state = TS_AT_BOTTOM;
m_vecPosition1 = pev->origin;
m_vecPosition2 = m_vecPosition1 + (pev->movedir * (fabs(pev->movedir.x * (pev->size.x - 2)) + fabs(pev->movedir.y * (pev->size.y - 2)) + fabs(pev->movedir.z * (pev->size.z - 2)) - m_flLip));
if (((m_vecPosition2 - m_vecPosition1).Length() < 1) || (pev->spawnflags & SF_BUTTON_DONTMOVE))
m_vecPosition2 = m_vecPosition1;
m_fStayPushed = m_flWait == -1 ? TRUE : FALSE;
m_fRotating = FALSE;
if (FBitSet(pev->spawnflags, SF_BUTTON_TOUCH_ONLY))
{
SetTouch(&CBaseButton::ButtonTouch);
}
else
{
SetTouch(NULL);
SetUse(&CBaseButton::ButtonUse);
}
}
void CEnvGlobal::KeyValue( KeyValueData *pkvd )
{
//TODO: what if the keyvalue isn't handled? - Solokiller
pkvd->fHandled = true;
if( FStrEq( pkvd->szKeyName, "globalstate" ) ) // State name
m_globalstate = ALLOC_STRING( pkvd->szValue );
else if( FStrEq( pkvd->szKeyName, "triggermode" ) )
m_triggermode = static_cast<TriggerMode>( atoi( pkvd->szValue ) );
else if( FStrEq( pkvd->szKeyName, "initialstate" ) )
m_initialstate = atoi( pkvd->szValue );
else
CPointEntity::KeyValue( pkvd );
}
void CMultiSource::KeyValue(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "style") || FStrEq(pkvd->szKeyName, "height") || FStrEq(pkvd->szKeyName, "killtarget") || FStrEq(pkvd->szKeyName, "value1") || FStrEq(pkvd->szKeyName, "value2") || FStrEq(pkvd->szKeyName, "value3"))
{
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "globalstate"))
{
m_globalstate = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CPointEntity::KeyValue(pkvd);
}
/*
* RCsprintf - do sprintf with a format string from a resource
*/
int RCsprintf( char *buf, msg_id fmtid, ... )
{
va_list al;
char *fmtstr;
int ret;
va_start( al, fmtid );
fmtstr = ALLOC_STRING( fmtid );
ret = vsprintf( buf, fmtstr, al );
FREE_STRING( fmtstr );
va_end( al );
return( ret );
} /* RCsprintf */
//=========================================================
//=========================================================
void CWeaponBox :: KeyValue( KeyValueData *pkvd )
{
if ( m_cAmmoTypes < MAX_AMMO_SLOTS )
{
PackAmmo( ALLOC_STRING(pkvd->szKeyName), atoi(pkvd->szValue) );
m_cAmmoTypes++;// count this new ammo type.
pkvd->fHandled = TRUE;
}
else
{
ALERT ( at_debug, "WeaponBox too full! only %d ammotypes allowed\n", MAX_AMMO_SLOTS );
}
}
//
// CyclerUse - starts a rotation trend
//
void CCycler :: Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( FClassnameIs ( pev, "info_commentary" ) )
{
pev->skin = 1;
//stop previous sound
if (pev->message)
EMIT_SOUND(ENT(pev), CHAN_ITEM, "common/null.wav", 0.1, ATTN_NORM );
//stop previous message (BUGBUG: This doesn't clear the message)
UTIL_ShowMessageAll( STRING(ALLOC_STRING("BLANK")));
//play it everywhere
if (pev->message)
EMIT_SOUND(ENT(pev), CHAN_ITEM, STRING(pev->message), 1, ATTN_NORM );
//send message
UTIL_ShowMessageAll( STRING(pev->message) ); //strings code
/*
if(!bIsPlaying)
{
pev->skin = 1;
bIsPlaying = TRUE;
//play it everywhere
if (pev->message)
EMIT_SOUND(ENT(pev), CHAN_ITEM, STRING(pev->message), 1, ATTN_NORM );
UTIL_ShowMessageAll( STRING(pev->message) ); //strings code
}
else
{
pev->skin = 0;
bIsPlaying = FALSE;
}
*/
}
else
{
m_animate = !m_animate;
if (m_animate)
pev->framerate = 1.0;
else
pev->framerate = 0.0;
}
}
void CGenericMonster::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "m_bloodColor"))
{
m_bloodColor = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iszGibModel"))
{
m_iszGibModel = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseMonster::KeyValue( pkvd );
}
/* <18356f> ../cstrike/dlls/subs.cpp:149 */
void CBaseDelay::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "delay"))
{
m_flDelay = Q_atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "killtarget"))
{
m_iszKillTarget = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseEntity::KeyValue(pkvd);
}
static void copy_enum_values_to_allocated_buffer(struct trace_type_definition *type_definition, struct trace_enum_value **enum_values,
char **string_table)
{
struct trace_enum_value *enum_value = type_definition->enum_values;
while (enum_value->name != NULL) {
memcpy(*enum_values, enum_value, sizeof(*enum_value));
ALLOC_STRING((*enum_values)->name, enum_value->name);
(*enum_values)++;
enum_value++;
}
// Copy the sentinel enum value
memcpy(*enum_values, enum_value, sizeof(*enum_value));
(*enum_values)++;
}
static cell AMX_NATIVE_CALL entity_set_model(AMX *amx, cell *params)
{
int iEnt = params[1];
CHECK_ENTITY_SIMPLE(iEnt);
edict_t *pEnt = INDEXENT2(iEnt);
int iLen;
char *szModel = MF_GetAmxString(amx, params[2], 0, &iLen);
const char *szStatic = STRING(ALLOC_STRING(szModel));
SET_MODEL(pEnt, szStatic);
return 1;
}
cell Call_Void_Str_Bool(AMX *amx, cell *params)
{
SETUP(2);
const char *sz3=STRING(ALLOC_STRING(MF_GetAmxString(amx, params[3], 0, NULL)));
bool b4=*MF_GetAmxAddr(amx, params[4]) ? true : false;
#if defined(_WIN32)
reinterpret_cast<void (__fastcall *)(void*, int, const char *, bool)>(__func)(pv, 0, sz3, b4);
#elif defined(__linux__) || defined(__APPLE__)
reinterpret_cast<void (*)(void *, const char *, bool)>(__func)(pv, sz3, b4);
#endif
return 1;
}
void CBaseDelay :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "delay"))
{
m_flDelay = atof( pkvd->szValue );
pkvd->fHandled = true;
}
else if (FStrEq(pkvd->szKeyName, "killtarget"))
{
m_iszKillTarget = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = true;
}
else
{
CBaseEntity::KeyValue( pkvd );
}
}
static cell AMX_NATIVE_CALL dod_set_model(AMX *amx, cell *params) // player,model
{
int index = params[1];
CHECK_PLAYER(index);
CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
if(!pPlayer->ingame)
{
MF_LogError(amx, AMX_ERR_NATIVE, "Invalid Player, Not on Server");
return 0;
}
int length;
pPlayer->initModel((char*)STRING(ALLOC_STRING(MF_GetAmxString(amx, params[2], 1, &length))));
return true;
}
void EntvarsKeyvalue( entvars_t *pev, KeyValueData *pkvd )
{
const TYPEDESCRIPTION* pField;
for ( size_t i = 0; i < gEntvarsCount; i++ )
{
pField = &gEntvarsDescription[i];
if ( !stricmp( pField->fieldName, pkvd->szKeyName ) )
{
switch( pField->fieldType )
{
case FIELD_MODELNAME:
case FIELD_SOUNDNAME:
case FIELD_STRING:
(*(int *)((char *)pev + pField->fieldOffset)) = ALLOC_STRING( pkvd->szValue );
break;
case FIELD_TIME:
case FIELD_FLOAT:
(*(float *)((char *)pev + pField->fieldOffset)) = atof( pkvd->szValue );
break;
case FIELD_INTEGER:
(*(int *)((char *)pev + pField->fieldOffset)) = atoi( pkvd->szValue );
break;
case FIELD_POSITION_VECTOR:
case FIELD_VECTOR:
UTIL_StringToVector( (float *)((char *)pev + pField->fieldOffset), pkvd->szValue );
break;
default:
case FIELD_EVARS:
case FIELD_CLASSPTR:
case FIELD_EDICT:
case FIELD_ENTITY:
case FIELD_POINTER:
ALERT( at_error, "Bad field in entity!!\n" );
break;
}
pkvd->fHandled = true;
return;
}
}
}
//
// Cache user-entity-field values until spawn is called.
//
void CLight :: KeyValue( KeyValueData* pkvd)
{
if (FStrEq(pkvd->szKeyName, "m_iOnStyle"))
{
m_iOnStyle = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iOffStyle"))
{
m_iOffStyle = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iTurnOnStyle"))
{
m_iTurnOnStyle = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iTurnOffStyle"))
{
m_iTurnOffStyle = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iTurnOnTime"))
{
m_iTurnOnTime = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iTurnOffTime"))
{
m_iTurnOffTime = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pitch"))
{
pev->angles.x = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pattern"))
{
m_iszPattern = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else CBaseEntity::KeyValue( pkvd );
}
void CEnvGlobal :: KeyValue( KeyValueData *pkvd )
{
if( FStrEq( pkvd->szKeyName, "triggermode" ))
{
m_triggermode = Q_atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if( FStrEq( pkvd->szKeyName, "initialstate" ))
{
m_initialstate = Q_atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if( FStrEq( pkvd->szKeyName, "globalstate" ))
{
m_globalstate = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else BaseClass::KeyValue( pkvd );
}
void CMomentaryRotButton :: KeyValue( KeyValueData *pkvd )
{
if( FStrEq( pkvd->szKeyName, "returnspeed" ))
{
m_returnSpeed = Q_atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if( FStrEq( pkvd->szKeyName, "m_flStartPos" ))
{
m_startPosition = Q_atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if( FStrEq( pkvd->szKeyName, "sounds"))
{
m_sounds = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else BaseClass::KeyValue( pkvd );
}
void CRotButton::Spawn(void)
{
char *pszSound = ButtonSound(m_sounds);
PRECACHE_SOUND(pszSound);
pev->noise = ALLOC_STRING(pszSound);
CBaseToggle::AxisDir(pev);
if (FBitSet(pev->spawnflags, SF_DOOR_ROTATE_BACKWARDS))
pev->movedir = pev->movedir * -1;
pev->movetype = MOVETYPE_PUSH;
if (pev->spawnflags & SF_ROTBUTTON_NOTSOLID)
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
SET_MODEL(ENT(pev), STRING(pev->model));
if (!pev->speed)
pev->speed = 40;
if (!m_flWait)
m_flWait = 1;
if (pev->health > 0)
pev->takedamage = DAMAGE_YES;
m_toggle_state = TS_AT_BOTTOM;
m_vecAngle1 = pev->angles;
m_vecAngle2 = pev->angles + pev->movedir * m_flMoveDistance;
m_fStayPushed = m_flWait == -1 ? TRUE : FALSE;
m_fRotating = TRUE;
if (!FBitSet(pev->spawnflags, SF_BUTTON_TOUCH_ONLY))
{
SetTouch(NULL);
SetUse(&CBaseButton::ButtonUse);
}
else
SetTouch(&CBaseButton::ButtonTouch);
}
bool AvHSoundListManager::PrecacheSoundList(const string& inDirName)
{
bool theReturnValue = false;
// Check if we have a sound list with this name
SoundListType::iterator theIter = this->GetSoundList(inDirName);
// If so, return false
if(theIter == this->mSoundList.end())
{
// If not, read list of all sound files in this directory, add this to the list with theKey as a key
CStringList theNewSoundList;
if(this->BuildSoundList(inDirName, theNewSoundList))
{
// Save entry
this->mSoundList.push_back(make_pair(inDirName, theNewSoundList));
// NOW, precache each sound because it remembers the pointer, so it has to be the final version <sigh>
SoundListType::iterator theIter = this->GetSoundList(inDirName);
ASSERT(theIter != this->mSoundList.end());
// Get number of entries
CStringList& theList = theIter->second;
int theNumEntries = theList.size();
for(int i = 0; i < theNumEntries; i++)
{
CString& theSoundToPrecache = theIter->second[i];
int iString = ALLOC_STRING((char*)theSoundToPrecache);//: We cant do "(char*)theSoundToPrecache" directly cause it causes some wierd problems.
PRECACHE_UNMODIFIED_SOUND((char*)STRING(iString));
// Success
theReturnValue = true;
}
}
else
{
int a = 0;
}
}
return theReturnValue;
}
// Cache user-entity-field values until spawn is called.
void CLight::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "style"))
{
m_iStyle = Q_atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pitch"))
{
pev->angles.x = Q_atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pattern"))
{
m_iszPattern = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CPointEntity::KeyValue(pkvd);
}
void CEnvGlobal::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
{
pkvd->fHandled = TRUE;
// State name
if (FStrEq(pkvd->szKeyName, "globalstate"))
{
m_globalstate = ALLOC_STRING(pkvd->szValue);
}
else if (FStrEq(pkvd->szKeyName, "triggermode"))
{
m_triggermode = Q_atoi(pkvd->szValue);
}
else if (FStrEq(pkvd->szKeyName, "initialstate"))
{
m_initialstate = Q_atoi(pkvd->szValue);
}
else
CPointEntity::KeyValue(pkvd);
}
static cell AMX_NATIVE_CALL esf_set_model(AMX *amx, cell *params) // esf_set_model(index, const model[]); = 2 args
{
// Set player a new model
// params[1] = index
// params[2] = const model
// Check index
CHECK_PLAYER(params[ 1 ]);
// Fetch player pointer
edict_t* pPlayer = MF_GetPlayerEdict(params[ 1 ]);
int length;
// Setting new model to player [ .. ]
esfmodels[params[1]-1].szModel = (char*)STRING( ALLOC_STRING( MF_GetAmxString(amx, params[2], 1, &length) ) );
esfmodels[params[1]-1].bSet = true;
return 1;
}
void CMessage::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "messagesound"))
{
pev->noise = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "messagevolume"))
{
pev->scale = atof(pkvd->szValue) * 0.1;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "messageattenuation"))
{
pev->impulse = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CPointEntity::KeyValue( pkvd );
}
void CMonsterMaker :: KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "monstercount") )
{
m_cNumMonsters = atoi(pkvd->szValue);
pkvd->fHandled = true;
}
else if ( FStrEq(pkvd->szKeyName, "m_imaxlivechildren") )
{
m_iMaxLiveChildren = atoi(pkvd->szValue);
pkvd->fHandled = true;
}
else if ( FStrEq(pkvd->szKeyName, "monstertype") )
{
m_iszMonsterClassname = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = true;
}
else
CBaseMonster::KeyValue( pkvd );
}
void CEnvShooter :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "shootmodel"))
{
pev->model = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "shootsounds"))
{
int iNoise = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
switch( iNoise )
{
case 0:
m_iGibMaterial = matGlass;
break;
case 1:
m_iGibMaterial = matWood;
break;
case 2:
m_iGibMaterial = matMetal;
break;
case 3:
m_iGibMaterial = matFlesh;
break;
case 4:
m_iGibMaterial = matRocks;
break;
default:
case -1:
m_iGibMaterial = matNone;
break;
}
}
else
{
CGibShooter::KeyValue( pkvd );
}
}
void CMomentaryRotButton::__MAKE_VHOOK(Spawn)()
{
CBaseToggle::AxisDir(pev);
if (pev->speed == 0)
pev->speed = 100;
if (m_flMoveDistance < 0)
{
m_start = pev->angles + pev->movedir * m_flMoveDistance;
m_end = pev->angles;
// This will toggle to -1 on the first use()
m_direction = 1;
m_flMoveDistance = -m_flMoveDistance;
}
else
{
m_start = pev->angles;
m_end = pev->angles + pev->movedir * m_flMoveDistance;
// This will toggle to +1 on the first use()
m_direction = -1;
}
if (pev->spawnflags & SF_MOMENTARY_DOOR)
pev->solid = SOLID_BSP;
else
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(pev, pev->origin);
SET_MODEL(ENT(pev), STRING(pev->model));
char *pszSound = ButtonSound(m_sounds);
PRECACHE_SOUND(pszSound);
pev->noise = ALLOC_STRING(pszSound);
m_lastUsed = 0;
}
//
// Cache user-entity-field values until spawn is called.
//
void CLight :: KeyValue( KeyValueData* pkvd)
{
if (FStrEq(pkvd->szKeyName, "style"))
{
m_iStyle = atoi(pkvd->szValue);
pkvd->fHandled = true;
}
else if (FStrEq(pkvd->szKeyName, "pitch"))
{
pev->angles.x = atof(pkvd->szValue);
pkvd->fHandled = true;
}
else if (FStrEq(pkvd->szKeyName, "pattern"))
{
m_iszPattern = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = true;
}
else
{
CPointEntity::KeyValue( pkvd );
}
}
void CPointBaseCommand::KeyValue(KeyValueData *pkvd)
{
// add this field to the command list
if (m_uiCommandsCount < MAX_POINT_CMDS)
{
char command[128];
if (pkvd->szValue[0] != '\0' && Q_strcmp(pkvd->szValue, "-") != 0)
{
Q_snprintf(command, sizeof(command), "%s \"%s\"", pkvd->szKeyName, pkvd->szValue);
}
else
{
Q_strlcpy(command, pkvd->szKeyName);
}
m_iszCommands[m_uiCommandsCount++] = ALLOC_STRING(command);
pkvd->fHandled = TRUE;
return;
}
CPointEntity::KeyValue(pkvd);
}
void CGamePlayerEquip::KeyValue(KeyValueData *pkvd)
{
CRulePointEntity::KeyValue(pkvd);
if (!pkvd->fHandled)
{
for (int i = 0; i < MAX_EQUIP; i++)
{
if (!m_weaponNames[i])
{
char tmp[128];
UTIL_StripToken(pkvd->szKeyName, tmp);
m_weaponNames[i] = ALLOC_STRING(tmp);
m_weaponCount[i] = atoi(pkvd->szValue);
m_weaponCount[i] = max(1, m_weaponCount[i]);
pkvd->fHandled = TRUE;
break;
}
}
}
}
void SequencePrecache( void *pmodel, const char *pSequenceName )
{
int index = LookupSequence( pmodel, pSequenceName );
if ( index >= 0 )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if ( !pstudiohdr || index >= pstudiohdr->numseq )
return;
mstudioseqdesc_t *pseqdesc;
mstudioevent_t *pevent;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
for (int i = 0; i < pseqdesc->numevents; i++)
{
// Don't send client-side events to the server AI
if ( pevent[i].event >= EVENT_CLIENT )
continue;
// UNDONE: Add a callback to check to see if a sound is precached yet and don't allocate a copy
// of it's name if it is.
if ( IsSoundEvent( pevent[i].event ) )
{
if ( !strlen(pevent[i].options) )
{
ALERT( at_error, "Bad sound event %d in sequence %s :: %s (sound is \"%s\")\n", pevent[i].event, pstudiohdr->name, pSequenceName, pevent[i].options );
}
PRECACHE_SOUND( (char *)(gpGlobals->pStringBase + ALLOC_STRING(pevent[i].options) ) );
}
}
}
}
