void AISenseRecord::Load(ILTMessage_Read *pMsg)
{
LOAD_DWORD_CAST(eSenseType, EnumAISenseType);
EnumAIStimulusType eStimulus;
LOAD_DWORD_CAST(eStimulus, EnumAIStimulusType);
if(eStimulus != kStim_InvalidType)
{
pAIBM_Last_Stimulus = g_pAIButeMgr->GetStimulus(eStimulus);
}
LOAD_HOBJECT(hLastStimulusSource);
LOAD_HOBJECT(hLastStimulusTarget);
LOAD_DWORD_CAST(eLastTargetMatchID, EnumAITargetMatchID);
LOAD_VECTOR(vLastStimulusPos);
LOAD_VECTOR(vLastStimulusDir);
LOAD_DWORD(nLastStimulusAlarmLevel);
LOAD_DWORD_CAST(eLastStimulusID, EnumAIStimulusID);
LOAD_FLOAT(fSenseDistance);
LOAD_FLOAT(fSenseDistanceSqr);
LOAD_FLOAT(fCurStimulation);
LOAD_FLOAT(fMaxStimulation);
LOAD_FLOAT(fReactionDelayTimer);
LOAD_FLOAT(fReactionDelayTime);
LOAD_TIME(fLastStimulationTime);
LOAD_DWORD(nCycle);
LOAD_BYTE(cFalseStimulation);
LOAD_INT(ptSightGrid.x);
LOAD_INT(ptSightGrid.y);
}
void CAISensorMgr::Load(ILTMessage_Read *pMsg)
{
LOAD_COBJECT(m_pAI, CAI);
int nSensorCount = 0;
LOAD_INT(nSensorCount);
{for (int n = 0; n < nSensorCount; ++n)
{
EnumAISensorType eSensor;
LOAD_INT_CAST(eSensor, EnumAISensorType);
CAISensorAbstract* pSensor = AI_FACTORY_NEW_Sensor( eSensor );
pSensor->Load(pMsg);
m_lstAISensors.push_back(pSensor);
}}
LOAD_bool(m_bSensorDeleted);
LOAD_INT(m_iSensorToUpdate);
LOAD_bool(m_bDoneProcessingStimuli);
LOAD_TIME( m_fStimulusListNewIterationTime );
int nProcessedStimuli = 0;
LOAD_INT(nProcessedStimuli);
{for (int n = 0; n < nProcessedStimuli; ++n)
{
EnumAIStimulusID eStimulusID;
LOAD_INT_CAST(eStimulusID, EnumAIStimulusID);
m_lstProcessedStimuli.push_back(eStimulusID);
}}
LOAD_INT(m_cIntersectSegmentCount);
}
int psi_show(struct seq_file *m, struct psi_group *group, enum psi_res res)
{
int full;
if (static_branch_likely(&psi_disabled))
return -EOPNOTSUPP;
update_stats(group);
for (full = 0; full < 2 - (res == PSI_CPU); full++) {
unsigned long avg[3];
u64 total;
int w;
for (w = 0; w < 3; w++)
avg[w] = group->avg[res * 2 + full][w];
total = div_u64(group->total[res * 2 + full], NSEC_PER_USEC);
seq_printf(m, "%s avg10=%lu.%02lu avg60=%lu.%02lu avg300=%lu.%02lu total=%llu\n",
full ? "full" : "some",
LOAD_INT(avg[0]), LOAD_FRAC(avg[0]),
LOAD_INT(avg[1]), LOAD_FRAC(avg[1]),
LOAD_INT(avg[2]), LOAD_FRAC(avg[2]),
total);
}
return 0;
}
int uptime_main(int argc, char **argv)
{
int updays, uphours, upminutes;
struct sysinfo info;
struct tm *current_time;
time_t current_secs;
time(¤t_secs);
current_time = localtime(¤t_secs);
sysinfo(&info);
printf(" %02d:%02d:%02d up ",
current_time->tm_hour, current_time->tm_min, current_time->tm_sec);
updays = (int) info.uptime / (60*60*24);
if (updays)
printf("%d day%s, ", updays, (updays != 1) ? "s" : "");
upminutes = (int) info.uptime / 60;
uphours = (upminutes / 60) % 24;
upminutes %= 60;
if (uphours)
printf("%2d:%02d, ", uphours, upminutes);
else
printf("%d min, ", upminutes);
printf("load average: %ld.%02ld, %ld.%02ld, %ld.%02ld\n",
LOAD_INT(info.loads[0]), LOAD_FRAC(info.loads[0]),
LOAD_INT(info.loads[1]), LOAD_FRAC(info.loads[1]),
LOAD_INT(info.loads[2]), LOAD_FRAC(info.loads[2]));
return EXIT_SUCCESS;
}
static int loadavg_proc_show(struct seq_file *m, void *v)
{
unsigned long avnrun[3], nr_runnable = 0;
struct cpumask cpus_allowed;
int i;
rcu_read_lock();
if (task_in_nonroot_cpuacct(current) &&
in_noninit_pid_ns(current->nsproxy->pid_ns)) {
get_avenrun_from_tsk(current, avnrun, FIXED_1/200, 0);
cpumask_copy(&cpus_allowed, cpu_possible_mask);
if (task_subsys_state(current, cpuset_subsys_id)) {
memset(&cpus_allowed, 0, sizeof(cpus_allowed));
get_tsk_cpu_allowed(current, &cpus_allowed);
}
for_each_cpu_and(i, cpu_possible_mask, &cpus_allowed)
nr_runnable += task_ca_running(current, i);
} else {
get_avenrun(avnrun, FIXED_1/200, 0);
nr_runnable = nr_running();
}
rcu_read_unlock();
seq_printf(m, "%lu.%02lu %lu.%02lu %lu.%02lu %ld/%d %d\n",
LOAD_INT(avnrun[0]), LOAD_FRAC(avnrun[0]),
LOAD_INT(avnrun[1]), LOAD_FRAC(avnrun[1]),
LOAD_INT(avnrun[2]), LOAD_FRAC(avnrun[2]),
nr_running(), nr_threads,
task_active_pid_ns(current)->last_pid);
return 0;
}
void CAISenseSeeEnemy::Load(HMESSAGEREAD hRead)
{
CAISense::Load(hRead);
LOAD_INT(m_nGridX);
LOAD_INT(m_nGridY);
LOAD_RANGE_CAST(m_rngGridX, int);
LOAD_RANGE_CAST(m_rngGridY, int);
}
int main(int argc,char **argv) {
struct sysinfo si;
sysinfo(&si);
printf("%ld.%02ld,%ld.%02ld,%ld.%02ld\n",
LOAD_INT(si.loads[0]), LOAD_FRAC(si.loads[0]),
LOAD_INT(si.loads[1]), LOAD_FRAC(si.loads[1]),
LOAD_INT(si.loads[2]), LOAD_FRAC(si.loads[2]));
exit(0);
}
void offsetGen(int nbIterations, int *offsets) {
int i;
int sum = 0;
for (i = 0; i < nbIterations; i++) {
int modulo;
int value = 2 * sum + 1;
STORE_INT(&offsets[i], &value);
sum += LOAD_INT(&offsets[i]);
modulo = LOAD_INT(&offsets[i]) % 32;
STORE_INT(&offsets[i], &modulo);
}
}
static int get_loadavg(char * buffer)
{
int a, b, c;
a = avenrun[0] + (FIXED_1/200);
b = avenrun[1] + (FIXED_1/200);
c = avenrun[2] + (FIXED_1/200);
return sprintf(buffer,"%d.%02d %d.%02d %d.%02d\n",
LOAD_INT(a), LOAD_FRAC(a),
LOAD_INT(b), LOAD_FRAC(b),
LOAD_INT(c), LOAD_FRAC(c));
}
static int get_loadavg(char * buffer)
{
int a, b, c;
a = avenrun[0] + (FIXED_1/200);
b = avenrun[1] + (FIXED_1/200);
c = avenrun[2] + (FIXED_1/200);
return sprintf(buffer,"%d.%02d %d.%02d %d.%02d %d/%d %d\n",
LOAD_INT(a), LOAD_FRAC(a),
LOAD_INT(b), LOAD_FRAC(b),
LOAD_INT(c), LOAD_FRAC(c),
nr_running, nr_tasks, last_pid);
}
static int loadavg_proc_show(struct seq_file *m, void *v)
{
unsigned long avnrun[3];
get_avenrun(avnrun, FIXED_1/200, 0);
seq_printf(m, "%lu.%02lu %lu.%02lu %lu.%02lu %ld/%d %d\n",
LOAD_INT(avnrun[0]), LOAD_FRAC(avnrun[0]),
LOAD_INT(avnrun[1]), LOAD_FRAC(avnrun[1]),
LOAD_INT(avnrun[2]), LOAD_FRAC(avnrun[2]),
nr_running(), nr_threads,
task_active_pid_ns(current)->last_pid);
return 0;
}
void CAnimationContext::Load(HMESSAGEREAD hRead)
{
m_Props.Load(hRead);
LOAD_DWORD_CAST(m_eState, State);
LOAD_INT(m_iAnimation);
LOAD_INT(m_iAnimationFrom);
LOAD_INT(m_iTransition);
LOAD_BOOL(m_bLocked);
LOAD_BOOL(m_bHackToAvoidTheUsualOneFrameOffBullshit);
LOAD_FLOAT(m_fPitchTarget);
LOAD_FLOAT(m_fPitch);
}
void computeWeights(int height, int width, int horOrVert, int *offset,
unsigned char *rgbL, float *weights) {
int i, j;
// hOffset of vOffset depending on the computed weights
int hOffset = (horOrVert == 0) ? LOAD_INT(offset) : 0;
int vOffset = (horOrVert == 1) ? LOAD_INT(offset) : 0;
// Distance coeff
float distanceCoeff = -(float) (LOAD_INT(offset)) / 36.0;
//distanceCoeff *= -1;
// Scan the pixels of the rgb image
for (j = 0; j < height; j++) {
for (i = 0; i < width; i++) {
float r0, g0, b0, r, g, b;
float weightM, weightP, weightO;
// Compute the weights
r0 = rgbL[3*(j*width+i)];
g0 = rgbL[3*(j*width+i)+1];
b0 = rgbL[3*(j*width+i)+2];
r = rgbL[3*(max(j-vOffset,0)*width+max(i-hOffset,0))];
g = rgbL[3*(max(j-vOffset,0)*width+max(i-hOffset,0))+1];
b = rgbL[3*(max(j-vOffset,0)*width+max(i-hOffset,0))+2];
weightM = sqrtf((r0-r)*(r0-r)+(g0-g)*(g0-g)+(b0-b)*(b0-b))* R_gamaC;
r = rgbL[3*(min(j+vOffset,height-1)*width+min(i+hOffset,width-1))];
g = rgbL[3*(min(j+vOffset,height-1)*width+min(i+hOffset,width-1))+1];
b = rgbL[3*(min(j+vOffset,height-1)*width+min(i+hOffset,width-1))+2];
weightP = sqrtf((r0-r)*(r0-r)+(g0-g)*(g0-g)+(b0-b)*(b0-b))* R_gamaC;
weightM = exp(distanceCoeff - weightM);
weightP = exp(distanceCoeff - weightP);
weightO = 1 / (weightM + weightP + 1);
weightM = weightM * weightO;
weightP = weightP * weightO;
// Store the three weights one after the other in the
// output buffer;
STORE_FLOAT(&weights[3*(j*width+i)+0], &weightO);
STORE_FLOAT(&weights[3*(j*width+i)+1], &weightM);
STORE_FLOAT(&weights[3*(j*width+i)+2], &weightP);
}
}
}
void CGrenade::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
if (!hRead) return;
CProjectile::Load(hRead, dwLoadFlags);
m_bSpinGrenade = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_bUpdating = (LTBOOL) g_pLTServer->ReadFromMessageByte(hRead);
m_eContainerCode = (ContainerCode) g_pLTServer->ReadFromMessageByte(hRead);
m_eLastHitSurface = (SurfaceType) g_pLTServer->ReadFromMessageByte(hRead);
m_fPitch = g_pLTServer->ReadFromMessageFloat(hRead);
m_fYaw = g_pLTServer->ReadFromMessageFloat(hRead);
m_fRoll = g_pLTServer->ReadFromMessageFloat(hRead);
m_fPitchVel = g_pLTServer->ReadFromMessageFloat(hRead);
m_fYawVel = g_pLTServer->ReadFromMessageFloat(hRead);
m_fRollVel = g_pLTServer->ReadFromMessageFloat(hRead);
LOAD_BOOL(m_bRotatedToRest);
LOAD_INT(m_cBounces);
if ( m_bRotatedToRest )
{
g_lstGrenades.Add(this);
}
}
void CAIGoalMgr::Load(ILTMessage_Read *pMsg)
{
LOAD_COBJECT(m_pAI, CAI);
int nGoals = 0;
LOAD_INT(nGoals);
for (int i = 0; i < nGoals; ++i)
{
EnumAIGoalType eGoalClass;
LOAD_INT_CAST(eGoalClass, EnumAIGoalType);
CAIGoalAbstract* pGoal = AI_FACTORY_NEW_Goal(eGoalClass);
pGoal->Load(pMsg);
m_lstGoals.push_back(pGoal);
}
EnumAIGoalType eCurrentGoalType;
LOAD_INT_CAST(eCurrentGoalType, EnumAIGoalType);
m_pCurGoal = FindGoalByType(eCurrentGoalType);
std::string strGoalSet;
LOAD_STDSTRING( strGoalSet );
m_iGoalSet = g_pAIDB->GetAIGoalSetRecordID( strGoalSet.c_str() );
LOAD_DOUBLE(m_fGoalSetTime);
}
void _fun2_fp(_VALUE thisframe, int64_t pc) {
printval(thisframe);
LOAD(CL_n);
LOAD_INT(1);
APPLY_NUM_TO_BOOL_BINOP(>);
if (GET_BOOL()) {
LOAD(CL_n);
LOAD(CL_SS);
GET_FIELD(CL_fac);
LOAD(CL_n);
LOAD_INT(1);
APPLY_NUM_TO_NUM_BINOP(-);
CALL_FUNCTION_FRESH(1);
APPLY_NUM_TO_NUM_BINOP(*);
STORE_RETURN;
} else {
void CAIWeaponMelee::Load(ILTMessage_Read *pMsg)
{
super::Load(pMsg);
LOAD_DOUBLE(m_fBurstInterval);
LOAD_INT(m_nBurstShots);
LOAD_INT(m_Context.m_cHits);
LOAD_INT(m_Context.m_cMisses);
LOAD_INT(m_Context.m_iHit);
LOAD_INT(m_Context.m_iMiss);
LOAD_bool(m_bForceHit);
m_hLastUserAnimation = pMsg->ReadHMODELANIM();
}
static int loadavg_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
int a, b, c;
int len;
a = avenrun[0] + (FIXED_1/200);
b = avenrun[1] + (FIXED_1/200);
c = avenrun[2] + (FIXED_1/200);
len = sprintf(page,"%d.%02d %d.%02d %d.%02d %d/%d %d\n",
LOAD_INT(a), LOAD_FRAC(a),
LOAD_INT(b), LOAD_FRAC(b),
LOAD_INT(c), LOAD_FRAC(c),
nr_running, nr_threads, last_pid);
return proc_calc_metrics(page, start, off, count, eof, len);
}
static int get_loadavg(void)
{
unsigned long this = this_cpu_load();
return LOAD_INT(this) * 10 + LOAD_FRAC(this) / 10;
}
void CAIPlan::Load(ILTMessage_Read *pMsg)
{
int nSteps = 0;
LOAD_INT(nSteps);
m_lstAIPlanSteps.reserve(nSteps);
for (int i = 0; i < nSteps; ++i)
{
CAIPlanStep* pPlanStep = AI_FACTORY_NEW( CAIPlanStep );
pPlanStep->wsWorldState.Load(pMsg);
LOAD_INT_CAST(pPlanStep->eAIAction, EnumAIActionType);
m_lstAIPlanSteps.push_back(pPlanStep);
}
LOAD_INT(m_iPlanStep);
LOAD_COBJECT(m_pAI, CAI);
LOAD_TIME(m_fPlanActivationTime);
}
void WeaponItem::Load(ILTMessage_Read *pMsg, uint32 dwLoadFlags)
{
if (!pMsg) return;
LOAD_BYTE(m_nWeaponId);
LOAD_BYTE(m_nAmmoId);
LOAD_INT(m_nAmmo);
}
void CAISensorAbstract::Load(ILTMessage_Read *pMsg)
{
LOAD_INT_CAST(m_eSensorType, EnumAISensorType);
LOAD_DOUBLE(m_fNextSensorUpdateTime);
LOAD_INT(m_cSensorRefCount);
LOAD_COBJECT(m_pAI, CAI);
m_pSensorRecord = g_pAIDB->GetAISensorRecord( m_eSensorType );
}
void CommandObject::Load( ILTMessage_Read *pMsg )
{
GameBaseLite::Load( pMsg );
m_Timer.Load( pMsg );
LOAD_FLOAT( m_fTotalTime );
LOAD_HSTRING( m_hstrFinishedCmd );
LOAD_bool( m_bLocked );
LOAD_INT( m_nNumActivations );
LOAD_INT( m_nNumTimesActivated );
// Free any event commands we already have...
EVENT_CMD_LIST::iterator iter;
EVENT_CMD_STRUCT *pEvntCmdStruct = LTNULL;
for( iter = m_lstEventCmds.begin(); iter != m_lstEventCmds.end(); ++iter )
{
pEvntCmdStruct = *iter;
FREE_HSTRING( pEvntCmdStruct->m_hstrCommand );
debug_delete( pEvntCmdStruct );
pEvntCmdStruct = LTNULL;
}
m_lstEventCmds.clear();
// Load all event commands...
int nNumEventCmds = 0;
LOAD_INT( nNumEventCmds );
for( int i = 0; i < nNumEventCmds; ++i )
{
pEvntCmdStruct = debug_new( EVENT_CMD_STRUCT );
m_lstEventCmds.push_back( pEvntCmdStruct );
LOAD_FLOAT( pEvntCmdStruct->m_fTime );
LOAD_BOOL( pEvntCmdStruct->m_bProcessed );
LOAD_HSTRING( pEvntCmdStruct->m_hstrCommand );
}
}
void CAIVolumeNeighbor::Load(HMESSAGEREAD hRead)
{
LOAD_INT(m_iVolume);
LOAD_VECTOR(m_vConnectionPos);
LOAD_VECTOR(m_avConnectionEndpoints[0]);
LOAD_VECTOR(m_avConnectionEndpoints[1]);
LOAD_VECTOR(m_vConnectionPerpDir);
LOAD_VECTOR(m_vConnectionDir);
LOAD_FLOAT(m_fConnectionLength);
}
void TransitionArea::Load( ILTMessage_Read *pMsg, uint32 dwSaveFlags )
{
if( !pMsg ) return;
LOAD_DWORD( m_dwFlags );
LOAD_INT( m_nTransLevel );
LOAD_ROTATION( m_tfWorld.m_rRot );
LOAD_VECTOR( m_tfWorld.m_vPos );
}
static unsigned long determine_loadavg(void)
{
unsigned long avg = 0;
unsigned long avnrun[3];
get_avenrun(avnrun, FIXED_1 / 200, 0);
avg += (LOAD_INT(avnrun[0]) * 100) + (LOAD_FRAC(avnrun[0]) % 100);
return avg;
}
void AI_Helicopter::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
CAIVehicle::Load(hRead, dwLoadFlags);
// Load state...
uint32 dwState;
LOAD_DWORD(dwState);
if (dwState != (DWORD)-1)
{
SetState((CAIHelicopterState::AIHelicopterStateType)dwState);
if (m_pHelicopterState)
{
m_pHelicopterState->Load(hRead);
}
}
LOAD_FLOAT(m_fSpeed);
LOAD_FLOAT(m_fFlySpeed);
LOAD_ROTATION(m_rRotSearchlight);
LOAD_VECTOR(m_vPosSearchlight);
LOAD_INT(m_iObjectSearchLight);
LOAD_ROTATION(m_rRotGunner);
LOAD_VECTOR(m_vPosGunner);
LOAD_INT(m_iObjectGunner);
LOAD_BOOL(m_bWantsRightDoorOpened);
LOAD_BOOL(m_bWantsRightDoorClosed);
LOAD_BOOL(m_bRightDoorOpened);
LOAD_BOOL(m_bWantsLeftDoorOpened);
LOAD_BOOL(m_bWantsLeftDoorClosed);
LOAD_BOOL(m_bLeftDoorOpened);
LOAD_FLOAT(m_fDeathDelay);
LOAD_HSTRING(m_hstrDeathMessage);
LOAD_HSTRING(m_hstrDeath2_3rdMessage);
LOAD_HSTRING(m_hstrDeath1_3rdMessage);
LOAD_HSTRING(m_hstrDeath0_3rdMessage);
LOAD_BOOL(m_bExploded);
}
void CMusicMgr::Load(ILTMessage_Read *pMsg)
{
for ( uint32 iMood = 0 ; iMood < kNumMoods ; iMood++ )
{
LOAD_FLOAT(m_afMoods[iMood]);
}
LOAD_BOOL(m_bLockedMood);
LOAD_BOOL(m_bLockedEvent);
LOAD_INT(m_iRestoreMusicIntensity);
}
int GetLoadAvg( void )
{
#ifndef CYG
struct sysinfo info;
info.loads[0] = 0;
sysinfo(&info);
return LOAD_INT( info.loads[0] );
#else
return 0;
#endif
}
void CAIActivityAbstract::Load(ILTMessage_Read *pMsg)
{
LOAD_INT_CAST(m_eActStatus, ENUM_AIACTIVITY_STATUS);
LOAD_INT(m_nActivityPriority);
LOAD_FLOAT(m_fActivityUpdateRate);
LOAD_TIME(m_fNextActivityUpdateTime);
LOAD_TIME(m_fActivityActivateTime);
LOAD_TIME(m_fActivityTimeOut);
LOAD_TIME(m_fActivityExpirationTime);
LOAD_INT(m_cPotentialParticipants);
for (int i = 0; i < MAX_PARTICIPANTS; ++i)
{
LOAD_HOBJECT(m_aPotentialParticipants[i]);
}
m_pSquad = 0;
}
