HS_BOOL8 CHSSysEngines::GetAttributeValue(const HS_INT8 * pcAttrName,
CHSVariant & rvarValue, HS_BOOL8 bAdjusted, HS_BOOL8 bLocalOnly)
{
// Determine attribute, and return the value.
if (!_stricmp(pcAttrName, "EFFICIENCY"))
{
if (m_puiEfficiency)
{
rvarValue = *m_puiEfficiency;
}
else if (!bLocalOnly)
{
rvarValue = GetEfficiency();
}
else
{
return false;
}
return true;
}
else if (!_stricmp(pcAttrName, "MAX VELOCITY"))
{
if (m_puiMaxVelocity)
{
rvarValue = *m_puiMaxVelocity;
}
else if (!bLocalOnly)
{
rvarValue = GetMaxVelocity();
}
else
{
return false;
}
return true;
}
else if (!_stricmp(pcAttrName, "ACCELERATION"))
{
if (m_puiAcceleration)
{
rvarValue = *m_puiAcceleration;
}
else if (!bLocalOnly)
{
rvarValue = GetAcceleration();
}
else
{
return false;
}
return true;
}
else if (!_stricmp(pcAttrName, "DESIRED SPEED"))
{
rvarValue = m_desired_speed;
return true;
}
else if (!_stricmp(pcAttrName, "CURRENT SPEED"))
{
rvarValue = m_current_speed;
return true;
}
else if (!_stricmp(pcAttrName, "CAN AFTERBURN"))
{
if (m_pbCanAfterburn)
{
rvarValue = *m_pbCanAfterburn;
}
else if (!bLocalOnly)
{
rvarValue = CanBurn();
}
else
{
return false;
}
return true;
}
else if (!_stricmp(pcAttrName, "AFTERBURNING"))
{
rvarValue = m_afterburning;
return true;
}
else if (!_stricmp(pcAttrName, "AFTERBURN RATIO"))
{
rvarValue = m_iAfterburnRatio;
return true;
}
else
{
return CHSEngSystem::GetAttributeValue(pcAttrName, rvarValue,
bAdjusted, bLocalOnly);
}
}
// Handles slowing or speeding up the engines
void CHSSysEngines::ChangeSpeed()
{
HS_UINT32 uMax;
HS_UINT32 uAccel;
// Grab maximum velocity
uMax = GetMaxVelocity();
// If afterburning, max is increased by some ratio.
if (m_afterburning)
{
uMax *= m_iAfterburnRatio; //HSCONF.afterburn_ratio;
}
// Make sure the desired speed doesn't currently
// exceed the maximum speed limits.
if (m_desired_speed > uMax)
{
m_desired_speed = (float) uMax;
}
else if (m_desired_speed < (uMax * -.5))
{
m_desired_speed = uMax * (float) -.5;
}
// This has to come after the checking of uMax. Otherwise,
// the ship could be at top speed, power is taken away from
// engines, but the speed doesn't change because the desired
// and current speed are already equal.
if (m_desired_speed == m_current_speed)
{
return;
}
// Change the speed closer to the desired speed
if (m_current_speed > m_desired_speed)
{
// Grab deceleration rate, which is always the
// same as maximum acceleration. Deceleration is
// not affected by engine damage or power.
uAccel = GetAcceleration(false);
m_current_speed -= uAccel;
if (m_desired_speed < 0)
{
m_current_speed += m_desired_speed;
}
// Did we go too far?
if (m_current_speed < m_desired_speed)
{
m_current_speed = m_desired_speed;
}
}
else if (m_current_speed < m_desired_speed)
{
// Grab the acceleration rate, which is affected
// by power and damage.
uAccel = GetAcceleration(true);
m_current_speed += uAccel;
// Did we go too far?
if (m_current_speed > m_desired_speed)
{
m_current_speed = m_desired_speed;
}
}
}
void CHelicopter::MoveStep()
{
Fvector dir, pathDir;
float desired_H = m_movement.currPathH;
float desired_P;
if(m_movement.type != eMovNone) {
float dist = m_movement.currP.distance_to(m_movement.desiredPoint);
dir.sub(m_movement.desiredPoint,m_movement.currP);
dir.normalize_safe();
pathDir = dir;
dir.getHP(desired_H, desired_P);
float speed_ = _min(m_movement.GetSpeedInDestPoint(), GetMaxVelocity() );
static float ang = pSettings->r_float (cNameSect(),"magic_angle");
if(m_movement.curLinearSpeed>GetMaxVelocity() || angle_difference(m_movement.currPathH,desired_H)>ang)
m_movement.curLinearAcc = -m_movement.LinearAcc_bk;
else
m_movement.curLinearAcc = GetCurrAcc( m_movement.curLinearSpeed,
speed_,
dist*0.95f,
m_movement.LinearAcc_fw,
-m_movement.LinearAcc_bk);
angle_lerp (m_movement.currPathH, desired_H, m_movement.GetAngSpeedHeading(m_movement.curLinearSpeed), STEP);
angle_lerp (m_movement.currPathP, desired_P, m_movement.GetAngSpeedPitch(m_movement.curLinearSpeed), STEP);
dir.setHP(m_movement.currPathH, m_movement.currPathP);
float vp = m_movement.curLinearSpeed*STEP+(m_movement.curLinearAcc*STEP*STEP)/2.0f;
m_movement.currP.mad (dir, vp);
m_movement.curLinearSpeed += m_movement.curLinearAcc*STEP;
static bool aaa = false;
if(aaa)
Log("1-m_movement.curLinearSpeed=",m_movement.curLinearSpeed);
clamp(m_movement.curLinearSpeed,0.0f,1000.0f);
if(aaa)
Log("2-m_movement.curLinearSpeed=",m_movement.curLinearSpeed);
} else { //go stopping
if( !fis_zero(m_movement.curLinearSpeed) ) {
m_movement.curLinearAcc = -m_movement.LinearAcc_bk;
float vp = m_movement.curLinearSpeed*STEP+(m_movement.curLinearAcc*STEP*STEP)/2.0f;
dir.setHP(m_movement.currPathH, m_movement.currPathP);
dir.normalize_safe();
m_movement.currP.mad (dir, vp);
m_movement.curLinearSpeed += m_movement.curLinearAcc*STEP;
clamp(m_movement.curLinearSpeed,0.0f,1000.0f);
// clamp(m_movement.curLinearSpeed,0.0f,m_movement.maxLinearSpeed);
} else {
m_movement.curLinearAcc = 0.0f;
m_movement.curLinearSpeed = 0.0f;
}
};
if( m_body.b_looking_at_point) {
Fvector desired_dir;
desired_dir.sub(m_body.looking_point, m_movement.currP ).normalize_safe();
float center_desired_H,tmp_P;
desired_dir.getHP(center_desired_H, tmp_P);
angle_lerp (m_body.currBodyHPB.x, center_desired_H, m_movement.GetAngSpeedHeading(m_movement.curLinearSpeed), STEP);
} else {
angle_lerp (m_body.currBodyHPB.x, m_movement.currPathH, m_movement.GetAngSpeedHeading(m_movement.curLinearSpeed), STEP);
}
float needBodyP = -m_body.model_pitch_k*m_movement.curLinearSpeed;
if(m_movement.curLinearAcc < 0) needBodyP*=-1;
angle_lerp (m_body.currBodyHPB.y, needBodyP, m_body.model_angSpeedPitch, STEP);
float sign;
Fvector cp;
cp.crossproduct (pathDir,dir);
(cp.y>0.0)?sign=1.0f:sign=-1.0f;
float ang_diff = angle_difference (m_movement.currPathH, desired_H);
float needBodyB = -ang_diff*sign*m_body.model_bank_k*m_movement.curLinearSpeed;
angle_lerp (m_body.currBodyHPB.z, needBodyB, m_body.model_angSpeedBank, STEP);
XFORM().setHPB(m_body.currBodyHPB.x,m_body.currBodyHPB.y,m_body.currBodyHPB.z);
XFORM().translate_over(m_movement.currP);
}
