void CStereoZoom::PrintDebugOutput()
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoScreenDist");
float dist;
if ( pICVar != NULL)
{
dist = pICVar->GetFVal();
}
else
{
dist = -10.f;
}
pICVar = gEnv->pConsole->GetCVar("r_StereoEyeDist");
float eyedist;
if ( pICVar != NULL)
{
eyedist = pICVar->GetFVal();
}
else
{
eyedist = -10.f;
}
IRenderer* pRenderer = gEnv->pRenderer;
static float color[4] = {1,1,1,1};
float y=50.f, step1=15.f, step2=20.f, size1=1.3f, size2=1.5f;
pRenderer->Draw2dLabel(5.0f, y , size2, color, false, "Current PlaneDist: %f", dist);
pRenderer->Draw2dLabel(5.0f, y += step1, size2, color, false, "Current EyeDist : %f", eyedist);
}
// ------------------------------------------------------------------------
void CInputDevice::CDebugPressedButtons::DebugRender()
{
if (g_pInputCVars->i_debugDigitalButtons)
{
static float deltaY = 15.f;
static float startX = 50;
static float startY = 400.f;
static float fontSize = 1.2f;
IRenderer* pRenderer = gEnv->pRenderer;
if (pRenderer)
{
ColorF colDefault(1.f, 1.f, 0.f,1.f);
m_textPos2d.x = startX;
m_textPos2d.y = startY;
pRenderer->Draw2dLabel(m_textPos2d.x, m_textPos2d.y, 1.1f, ColorF(0.f,1.f,0.f,1.f), false, "Controller's Digital Buttons Activity"); m_textPos2d.y+= deltaY;
pRenderer->Draw2dLabel(m_textPos2d.x, m_textPos2d.y, 1.1f, ColorF(1.f,1.f,1.f,1.f), false, string().Format("CurrentFrame:[%d]", m_frameCnt)); m_textPos2d.y+= deltaY;
for (size_t i=0, kSize=m_history.size(); i< kSize; ++i)
{
string s = string().Format("[%d] %s [%s]", m_history[i].frame, m_history[i].key.c_str(), m_history[i].state.c_str());
pRenderer->Draw2dLabel(m_textPos2d.x, m_textPos2d.y, fontSize, m_history[i].color, false, s.c_str());
m_textPos2d.y+= deltaY;
}
++m_frameCnt;
}
}
}
void CRateOfDeathHelper_HealthThreshold::DebugDraw( float& drawPosY )
{
IRenderer* pRenderer = gEnv->pRenderer;
const float color[ 4 ] = { 1, 1, 1, 1 };
pRenderer->Draw2dLabel( 20, drawPosY, 1.2f, color, false, "Stay Alive Time: %f", m_stayAliveTime );
drawPosY += 15;
pRenderer->Draw2dLabel( 20, drawPosY, 1.2f, color, false, "Normalized Health: %f", m_normalizedHealth );
drawPosY += 15;
pRenderer->Draw2dLabel( 20, drawPosY, 1.2f, color, false, "Normalized Health Threshold: %f", m_normalizedHealthThreshold );
drawPosY += 15;
}
void CRateOfDeathSimple::DebugDraw()
{
IRenderer* pRenderer = gEnv->pRenderer;
const float color[ 4 ] = { 1, 1, 1, 1 };
float drawPosY = 20;
pRenderer->Draw2dLabel( 5, drawPosY, 1.2f, color, false, "Rate of Death '%s'", m_pOwner->GetName() );
drawPosY += 15;
m_rateOfDeathTarget.DebugDraw( drawPosY );
drawPosY += 15;
pRenderer->Draw2dLabel( 5, drawPosY, 1.2f, color, false, "Can damage? %s", m_canDamageTarget ? "yes" : "no" );
drawPosY += 15;
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Target Offset <%f, %f, %f>", m_targetOffset.x, m_targetOffset.y, m_targetOffset.z );
drawPosY += 15;
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Miss Offset Update [%f/%f] [time left/ update interval]", m_missOffsetNextUpdateSeconds, m_missOffsetIntervalSeconds );
drawPosY += 15;
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Miss Range [%f-%f]", m_missMinRange, m_missMaxRange );
drawPosY += 15;
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Hit Offset Update [%f/%f] [time left/ update interval]", m_hitOffsetNextUpdateSeconds, m_hitOffsetIntervalSeconds );
drawPosY += 15;
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Hit Range [%f-%f]", m_hitMinRange, m_hitMaxRange );
drawPosY += 15;
}
void CRateOfDeathHelper_Target::DebugDraw( float& drawPosY )
{
IRenderer* pRenderer = gEnv->pRenderer;
const float color[ 4 ] = { 1, 1, 1, 1 };
if ( m_pTarget )
{
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Target '%s'", m_pTarget->GetName() );
}
else
{
pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "No Target" );
}
drawPosY += 15;
pRenderer->Draw2dLabel( 15, drawPosY, 1.2f, color, false, "Stance: %s", GetStanceName( m_stance ) );
drawPosY += 15;
pRenderer->Draw2dLabel( 15, drawPosY, 1.2f, color, false, "Zone: %s", GetZoneName( m_zone ) );
drawPosY += 15;
pRenderer->Draw2dLabel( 15, drawPosY, 1.2f, color, false, "In vehicle: %s", m_isInVehicle ? "yes" : "no" );
drawPosY += 15;
pRenderer->Draw2dLabel( 15, drawPosY, 1.2f, color, false, "Stay alive time factor: %f", m_stayAliveTimeFactor );
drawPosY += 15;
m_healthThresholdHelper.DebugDraw( drawPosY );
drawPosY += 5;
}
void CGameTokenSystem::DrawToken( const char* pTokenName, const char* pTokenValue, const CTimeValue& timeChanged, int line )
{
IRenderer * pRenderer = gEnv->pRenderer;
float notChanged[]={1.0f, 1.0f, 1.0f, 1.0f};
float changed[]={1.0f, 0.0f, 0.0f, 1.0f};
float color[]={0.f, 0.f, 0.f, 0.f};
string buf;
buf.Format("%s = %s", pTokenName, pTokenValue );
float dt=(gEnv->pTimer->GetFrameStartTime()-timeChanged).GetSeconds();
const float COLOR_TIME_LAPSE = 10; // seconds
{
float timeNorm = min ( 1.f, dt / COLOR_TIME_LAPSE );
for (int i=0; i<4; i++)
color[i] = min(1.f, (timeNorm*notChanged[i] + (1.f-timeNorm)*changed[i]) );
}
pRenderer->Draw2dLabel(20.0f+m_CVarPosX,20.0f+m_CVarPosY+12.0f*(float)line, 1.2f, color, false, buf.c_str());
}
//------------------------------------------------------------------------
void CVehicleMovementHelicopter::Update(const float deltaTime)
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
CVehicleMovementBase::Update(deltaTime);
CryAutoCriticalSection lk(m_lock);
if(m_isTouchingGround)
{
m_timeOnTheGround += deltaTime;
m_isTouchingGround = false;
}
else
{
m_timeOnTheGround = 0.0f;
}
// ai specific sound matter
if(m_soundMasterVolume != m_vehicleVolume)
{
float vol = m_soundMasterVolume;
if(m_vehicleVolume == 0)
CVehicleMovementBase::SetSoundMasterVolume(m_vehicleVolume);
else if(vol < m_vehicleVolume)
{
vol +=deltaTime;
if(vol > m_vehicleVolume)
vol = m_vehicleVolume;
CVehicleMovementBase::SetSoundMasterVolume(vol);
}
else if(vol > m_vehicleVolume)
{
vol -=deltaTime;
if(vol < m_vehicleVolume)
vol = m_vehicleVolume;
CVehicleMovementBase::SetSoundMasterVolume(vol);
}
}
// update animation
if(m_isEngineGoingOff)
{
if(m_enginePower > 0.0f)
{
UpdateEngine(deltaTime);
}
else
{
m_enginePower = 0.0f;
}
}
SetAnimationSpeed(eVMA_Engine, (m_enginePower / m_enginePowerMax));
#if ENABLE_VEHICLE_DEBUG
IActor *pActor = m_pActorSystem->GetActor(m_actorId);
int profile = g_pGameCVars->v_profileMovement;
if((profile == 1 && pActor && pActor->IsClient()) || profile == 2)
{
IRenderer *pRenderer = gEnv->pRenderer;
float color[4] = {1,1,1,1};
Ang3 localAngles = m_pEntity->GetWorldAngles();
m_mass = m_statusDyn.mass;
Vec3 &velocity = m_statusDyn.v;
Vec3 &angVelocity = m_statusDyn.w;
pRenderer->Draw2dLabel(5.0f, 0.0f, 2.0f, color, false, "Helicopter movement");
Vec3 i;
i = m_control.impulse.GetNormalizedSafe();
pRenderer->Draw2dLabel(5.0f, 85.0f, 1.5f, color, false, "impulse: %f, %f, %f (%f, %f, %f)", m_control.impulse.x, m_control.impulse.y, m_control.impulse.z, i.x, i.y, i.z);
pRenderer->Draw2dLabel(5.0f, 100.0f, 1.5f, color, false, "angImpulse: %f, %f, %f", m_control.angImpulse.x, m_control.angImpulse.y, m_control.angImpulse.z);
i = velocity.GetNormalizedSafe();
pRenderer->Draw2dLabel(5.0f, 115.0f, 1.5f, color, false, "velocity: %f, %f, %f (%f) (%f, %f, %f)", velocity.x, velocity.y, velocity.z, velocity.GetLength(), i.x, i.y, i.z);
pRenderer->Draw2dLabel(5.0f, 130.0f, 1.5f, color, false, "angular velocity: %f, %f, %f", RAD2DEG(angVelocity.x), RAD2DEG(angVelocity.y), RAD2DEG(angVelocity.z));
pRenderer->Draw2dLabel(5.0f, 160.0f, 1.5f, color, false, "angles: %f, %f, %f (%f, %f, %f)", RAD2DEG(localAngles.x), localAngles.y, localAngles.z, RAD2DEG(localAngles.x), RAD2DEG(localAngles.y), RAD2DEG(localAngles.z));
pRenderer->Draw2dLabel(5.0f, 175.0f, 1.5f, color, false, "m_rpmScale: %f, damage: %f, damageActual: %f, turbulence: %f", m_rpmScale, m_damage, m_damageActual, m_turbulence);
pRenderer->Draw2dLabel(5.0f, 190.0f, 1.5f, color, false, "m_turnAction: %f, actionYaw: %f, targetRotation: %f, %f, %f", m_turnAction, m_actionYaw, RAD2DEG(m_rotateTarget.x), RAD2DEG(m_rotateTarget.y), RAD2DEG(m_rotateTarget.z));
pRenderer->Draw2dLabel(5.0f, 220.0f, 1.5f, color, false, "lift: %f, engineForce: %f, hoveringPower: %f, desiredHeight: %f, boost: %d, fwdAction: %f", m_liftAction, m_engineForce, m_hoveringPower, m_desiredHeight, Boosting(), m_forwardAction);
pRenderer->Draw2dLabel(5.0f, 235.0f, 1.5f, color, false, "pitchAction: %f, rollAction: %f", m_actionPitch, m_actionRoll);
pRenderer->Draw2dLabel(5.0f, 250.0f, 1.5f, color, false, "desiredPitch: %f, desiredRoll: %f", m_desiredPitch, m_desiredRoll);
Vec3 direction = m_pEntity->GetWorldTM().GetColumn(1);
pRenderer->Draw2dLabel(5.0f, 270.0f, 1.5f, color, false, "fwd direction: %.2f, %.2f, %.2f", direction.x, direction.y, direction.z);
pRenderer->Draw2dLabel(5.0f, 285.0f, 1.5f, color, false, "workingUpDir: %.2f, %.2f, %.2f", m_workingUpDir.x, m_workingUpDir.y, m_workingUpDir.z);
pRenderer->Draw2dLabel(5.0f, 300.0f, 1.5f, color, false, "accel: %f", m_playerAcceleration);
}
#endif
}
void CPersistantDebug::PostUpdate( float frameTime )
{
bool bUseUIDraw = true;
IUIDraw* pUIDraw = CCryAction::GetCryAction()->GetIUIDraw();
if (bUseUIDraw && pUIDraw==0)
{
m_2DTexts.clear();
return;
}
IRenderer* pRenderer = gEnv->pRenderer;
const float x = bUseUIDraw ? 0.0f : pRenderer->ScaleCoordX(400.0f);
float y = 400.0f;
// Post update entity tags
for (MapListObj::iterator iterMap = m_objects.begin(); iterMap != m_objects.end(); ++iterMap)
{
for (ListObj::iterator iterList = iterMap->second.begin(); iterList != iterMap->second.end(); ++iterList)
{
if (eOT_EntityTag == iterList->obj)
{
PostUpdateTags(frameTime, *iterList);
}
}
}
if (bUseUIDraw)
pUIDraw->PreRender();
// now draw 2D texts overlay
for (ListObjText2D::iterator iter = m_2DTexts.begin(); iter != m_2DTexts.end();)
{
STextObj2D& textObj = *iter;
ColorF clr = textObj.clr;
clr.a *= textObj.timeRemaining / textObj.totalTime;
if (bUseUIDraw)
{
static const float TEXT_SPACING = 2;
float textSize = textObj.size * 12.f;
float sizeX,sizeY;
const string *pTextLabel = &textObj.text;
string localizedString;
if (!pTextLabel->empty() && pTextLabel->at(0) == '@')
{
gEnv->pSystem->GetLocalizationManager()->LocalizeString(*pTextLabel, localizedString);
pTextLabel = &localizedString;
}
pUIDraw->GetTextDim(m_pDefaultFont,&sizeX, &sizeY, textSize, textSize, pTextLabel->c_str());
pUIDraw->DrawText(m_pDefaultFont,x, y, textSize, textSize, pTextLabel->c_str(), clr.a, clr.r, clr.g, clr.b,
UIDRAWHORIZONTAL_CENTER,UIDRAWVERTICAL_TOP,UIDRAWHORIZONTAL_CENTER,UIDRAWVERTICAL_TOP);
y+=sizeY+TEXT_SPACING;
}
else
{
pRenderer->Draw2dLabel(x, y, textObj.size, &clr[0], true, "%s", textObj.text.c_str());
y+=18.0f;
}
textObj.timeRemaining -= frameTime;
const bool bDelete = textObj.timeRemaining <= 0.0f;
if (bDelete)
{
ListObjText2D::iterator toDelete = iter;
++iter;
m_2DTexts.erase(toDelete);
}
else
++iter;
}
if (bUseUIDraw)
pUIDraw->PostRender();
}
//------------------------------------------------------------------------
void CDebugGun::Update( SEntityUpdateContext& ctx, int update)
{
if (!IsSelected())
return;
static float drawColor[4] = {1,1,1,1};
static const int dx = 5;
static const int dy = 15;
static const float font = 1.2f;
static const float fontLarge = 1.4f;
IRenderer* pRenderer = gEnv->pRenderer;
IRenderAuxGeom* pAuxGeom = pRenderer->GetIRenderAuxGeom();
pAuxGeom->SetRenderFlags(e_Def3DPublicRenderflags);
pRenderer->Draw2dLabel(pRenderer->GetWidth()/5.f, pRenderer->GetHeight()-35, fontLarge, drawColor, false, "Firemode: %s (%.1f)", m_fireModes[m_fireMode].first.c_str(), m_fireModes[m_fireMode].second);
ray_hit rayhit;
int hits = 0;
unsigned int flags = rwi_stop_at_pierceable|rwi_colltype_any;
if (m_fireModes[m_fireMode].first == "pierceability")
{
flags = (unsigned int)m_fireModes[m_fireMode].second & rwi_pierceability_mask;
}
// use cam, no need for firing pos/dir
CCamera& cam = GetISystem()->GetViewCamera();
if (hits = gEnv->pPhysicalWorld->RayWorldIntersection(cam.GetPosition()+cam.GetViewdir(), cam.GetViewdir()*HIT_RANGE, ent_all, flags, &rayhit, 1))
{
IMaterialManager* pMatMan = gEnv->p3DEngine->GetMaterialManager();
IActorSystem* pActorSystem = g_pGame->GetIGameFramework()->GetIActorSystem();
IVehicleSystem* pVehicleSystem = g_pGame->GetIGameFramework()->GetIVehicleSystem();
int x = (int)(pRenderer->GetWidth() *0.5f) + dx;
int y = (int)(pRenderer->GetHeight()*0.5f) + dx - dy;
// draw normal
ColorB colNormal(200,0,0,128);
Vec3 end = rayhit.pt + 0.75f*rayhit.n;
pAuxGeom->DrawLine(rayhit.pt, colNormal, end, colNormal);
pAuxGeom->DrawCone(end, rayhit.n, 0.1f, 0.2f, colNormal);
IEntity * pEntity = (IEntity*)rayhit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
if(pEntity)
{
pRenderer->Draw2dLabel(x, y+=dy, fontLarge, drawColor, false, pEntity->GetName());
}
// material
const char* matName = pMatMan->GetSurfaceType(rayhit.surface_idx)->GetName();
if (matName[0])
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%s (%i)", matName, rayhit.surface_idx);
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.1f m", rayhit.dist);
if (pEntity)
{
IScriptTable* pScriptTable = pEntity->GetScriptTable();
// physics
if (IPhysicalEntity* pPhysEnt = pEntity->GetPhysics())
{
pe_status_dynamics status;
if (pPhysEnt->GetStatus(&status))
{
if (status.mass > 0.f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.1f kg", status.mass);
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "pe_type: %i", pPhysEnt->GetType());
if (status.submergedFraction > 0.f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.2f submerged", status.submergedFraction);
if (status.v.len2() > 0.0001f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.2f m/s", status.v.len());
}
}
if (pScriptTable)
{
HSCRIPTFUNCTION func = 0;
if (pScriptTable->GetValue("GetFrozenAmount", func) && func)
{
float frozen = 0.f;
Script::CallReturn(gEnv->pScriptSystem, func, pScriptTable, frozen);
gEnv->pScriptSystem->ReleaseFunc(func);
if (frozen > 0.f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "Frozen: %.2f", frozen);
}
}
// class-specific stuff
if (IActor* pActor = pActorSystem->GetActor(pEntity->GetId()))
{
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%i health", pActor->GetHealth());
}
else if (IVehicle* pVehicle = pVehicleSystem->GetVehicle(pEntity->GetId()))
{
const SVehicleStatus& status = pVehicle->GetStatus();
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.0f%% health", 100.f*status.health);
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%i passengers", status.passengerCount);
if (pVehicle->GetMovement() && pVehicle->GetMovement()->IsPowered())
{
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "Running");
}
}
else
{
if (pScriptTable)
{
HSCRIPTFUNCTION func = 0;
if (pScriptTable->GetValue("GetHealth", func) && func)
{
float health = 0.f;
if (Script::CallReturn(gEnv->pScriptSystem, func, pScriptTable, health))
{
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.0f health", health);
}
gEnv->pScriptSystem->ReleaseFunc(func);
}
}
}
}
}
}
//-----------------------------------------------------------------------------
void CHomingMissile::UpdateControlledMissile(float frameTime)
{
bool isServer = gEnv->bServer;
bool isClient = gEnv->bClient;
CActor *pClientActor=0;
if (gEnv->bClient)
pClientActor=static_cast<CActor *>(g_pGame->GetIGameFramework()->GetClientActor());
bool isOwner = ((!m_ownerId && isServer) || (isClient && pClientActor && (pClientActor->GetEntityId() == m_ownerId) && pClientActor->IsPlayer()));
IRenderer* pRenderer = gEnv->pRenderer;
IRenderAuxGeom* pGeom = pRenderer->GetIRenderAuxGeom();
float color[4] = {1,1,1,1};
const static float step = 15.f;
float y = 20.f;
bool bDebug = g_pGameCVars->i_debug_projectiles > 0;
if (isOwner || isServer)
{
//If there's a target, follow the target
if(isServer)
{
if (m_targetId)
{
if (m_lockedTimer>0.0f)
m_lockedTimer=m_lockedTimer-frameTime;
else
{
// If we are here, there's a target
IEntity* pTarget = gEnv->pEntitySystem->GetEntity(m_targetId);
if (pTarget)
{
AABB box;
pTarget->GetWorldBounds(box);
Vec3 finalDes = box.GetCenter();
SetDestination(finalDes);
//SetDestination( box.GetCenter() );
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "Target Entity: %s", pTarget->GetName());
}
m_lockedTimer+=0.05f;
}
}
else if(m_autoControlled)
return;
}
if (m_controlled && !m_autoControlled && isOwner && !m_targetId)
{
//Check if the weapon is still selected
CWeapon *pWeapon = GetWeapon();
if(!pWeapon || !pWeapon->IsSelected())
return;
if (m_controlledTimer>0.0f)
m_controlledTimer=m_controlledTimer-frameTime;
else if (pClientActor && pClientActor->IsPlayer()) //Follow the crosshair
{
if (IMovementController *pMC=pClientActor->GetMovementController())
{
Vec3 eyePos(ZERO);
Vec3 eyeDir(ZERO);
IVehicle* pVehicle = pClientActor->GetLinkedVehicle();
if(!pVehicle)
{
SMovementState state;
pMC->GetMovementState(state);
eyePos = state.eyePosition;
eyeDir = state.eyeDirection;
}
else
{
SViewParams viewParams;
pVehicle->UpdateView(viewParams, pClientActor->GetEntityId());
eyePos = viewParams.position;
eyeDir = viewParams.rotation * Vec3(0,1,0);
//eyeDir = (viewParams.targetPos - viewParams.position).GetNormalizedSafe();
}
int pierceability=7;
if (IPhysicalEntity *pPE=GetEntity()->GetPhysics())
{
if (pPE->GetType()==PE_PARTICLE)
{
pe_params_particle pp;
if (pPE->GetParams(&pp))
pierceability=pp.iPierceability;
}
}
static const int objTypes = ent_all;
static const int flags = (geom_colltype_ray << rwi_colltype_bit) | rwi_colltype_any | (pierceability & rwi_pierceability_mask) | (geom_colltype14 << rwi_colltype_bit);
IPhysicalWorld* pWorld = gEnv->pPhysicalWorld;
static IPhysicalEntity* pSkipEnts[10];
int numSkip = CSingle::GetSkipEntities(pWeapon, pSkipEnts, 10);
ray_hit hit;
int hits = 0;
float range=m_maxTargetDistance;
hits = pWorld->RayWorldIntersection(eyePos + 1.5f*eyeDir, eyeDir*range, objTypes, flags, &hit, 1, pSkipEnts, numSkip);
while (hits)
{
if (gEnv->p3DEngine->RefineRayHit(&hit, eyeDir*range))
break;
eyePos = hit.pt+eyeDir*0.003f;
range -= hit.dist+0.003f;
hits = pWorld->RayWorldIntersection(eyePos, eyeDir*range, objTypes, flags, &hit, 1, pSkipEnts, numSkip);
}
DestinationParams params;
if(hits)
params.pt=hit.pt;
else
params.pt=(eyePos+m_maxTargetDistance*eyeDir); //Some point in the sky...
GetGameObject()->InvokeRMI(SvRequestDestination(), params, eRMI_ToServer);
if (bDebug)
{
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "PlayerView eye direction: %.3f %.3f %.3f", eyeDir.x, eyeDir.y, eyeDir.z);
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "PlayerView Target: %.3f %.3f %.3f", hit.pt.x, hit.pt.y, hit.pt.z);
pRenderer->GetIRenderAuxGeom()->DrawCone(m_destination, Vec3(0,0,-1), 2.5f, 7.f, ColorB(255,0,0,255));
}
}
m_controlledTimer+=0.0f;
}
}
}
//This code is shared by both modes above (auto and controlled)
if(!m_destination.IsZero())
{
pe_status_dynamics status;
if (!GetEntity()->GetPhysics()->GetStatus(&status))
{
CryLogAlways("couldn't get physics status!");
return;
}
pe_status_pos pos;
if (!GetEntity()->GetPhysics()->GetStatus(&pos))
{
CryLogAlways("couldn't get physics pos!");
return;
}
float currentSpeed = status.v.len();
if (currentSpeed>0.001f)
{
Vec3 currentVel = status.v;
Vec3 currentPos = pos.pos;
Vec3 goalDir(ZERO);
assert(!_isnan(currentSpeed));
assert(!_isnan(currentVel.x) && !_isnan(currentVel.y) && !_isnan(currentVel.z));
//Just a security check
if((currentPos-m_destination).len2()<(m_detonationRadius*m_detonationRadius))
{
Explode(true, true, m_destination, -currentVel.normalized(), currentVel, m_targetId);
return;
}
goalDir = m_destination - currentPos;
goalDir.Normalize();
//Turn more slowly...
currentVel.Normalize();
if(bDebug)
{
pRenderer->Draw2dLabel(50,55,2.0f,color,false, " Destination: %.3f, %.3f, %.3f",m_destination.x,m_destination.y,m_destination.z);
pRenderer->Draw2dLabel(50,80,2.0f,color,false, " Current Dir: %.3f, %.3f, %.3f",currentVel.x,currentVel.y,currentVel.z);
pRenderer->Draw2dLabel(50,105,2.0f,color,false," Goal Dir: %.3f, %.3f, %.3f",goalDir.x,goalDir.y,goalDir.z);
}
float cosine = currentVel.Dot(goalDir);
cosine = CLAMP(cosine,-1.0f,1.0f);
float totalAngle = RAD2DEG(cry_acosf(cosine));
assert(totalAngle>=0);
if (cosine<0.99)
{
float maxAngle = m_turnSpeed*frameTime;
if (maxAngle>totalAngle)
maxAngle=totalAngle;
float t=(maxAngle/totalAngle)*m_lazyness;
assert(t>=0.0 && t<=1.0);
goalDir = Vec3::CreateSlerp(currentVel, goalDir, t);
goalDir.Normalize();
}
if(bDebug)
pRenderer->Draw2dLabel(50,180,2.0f,color,false,"Corrected Dir: %.3f, %.3f, %.3f",goalDir.x,goalDir.y,goalDir.z);
pe_action_set_velocity action;
action.v = goalDir * currentSpeed;
GetEntity()->GetPhysics()->Action(&action);
}
}
}
void CCodeCheckpointDebugMgr::DrawDebugInfo()
{
int displayLevel = m_debug_ccoverage;
IRenderer* pRenderer = gEnv->pRenderer;
int totalHit = (int) std::count_if(m_unwatchedPoints.begin(), m_unwatchedPoints.end(), RecordHasHits);
int watchedHit = (int) std::count_if(m_watchedPoints.begin(), m_watchedPoints.end(), RecordHasHits);
totalHit += watchedHit;
TCheckpointDebugVector outputPoints;
outputPoints.reserve(m_watchedPoints.size() + m_unwatchedPoints.size());
//Get the sorted output points. For now assume you want to sort based on time
//Only show watched
if(displayLevel == 1)
{
outputPoints.assign(m_watchedPoints.begin(), m_watchedPoints.end());
std::sort(outputPoints.begin(), outputPoints.end(), SortDebugRecord);
}
//Only show unwatched
else if(displayLevel == 2)
{
outputPoints.assign(m_unwatchedPoints.begin(), m_unwatchedPoints.end());
std::sort(outputPoints.begin(), outputPoints.end(), SortDebugRecord);
}
//Show both with watched having priority
else if(displayLevel == 3)
{
///Retrieve and sort watched
TCheckpointDebugVector watchedPts;
watchedPts.assign(m_watchedPoints.begin(), m_watchedPoints.end());
std::sort(watchedPts.begin(), watchedPts.end(), SortDebugRecord);
///Retrieve and sort unwatched
TCheckpointDebugVector unwatchedPts;
unwatchedPts.assign(m_unwatchedPoints.begin(), m_unwatchedPoints.end());
std::sort(unwatchedPts.begin(), unwatchedPts.end(), SortDebugRecord);
///Combined with watched first
outputPoints.assign(watchedPts.begin(), watchedPts.end());
outputPoints.insert(outputPoints.end(),unwatchedPts.begin(), unwatchedPts.end());
}
//Show both with equal priority
else if(displayLevel == 4)
{
///Combine sort
outputPoints.assign(m_unwatchedPoints.begin(), m_unwatchedPoints.end());
outputPoints.insert(outputPoints.end(), m_watchedPoints.begin(), m_watchedPoints.end());
std::sort(outputPoints.begin(), outputPoints.end(), SortDebugRecord);
}
float percHit = 0.0f;
if(!m_watchedPoints.empty())
percHit = (float) watchedHit / m_watchedPoints.size();
static float statusColor[] = {1.0f, 1.0f, 1.0f, 1.0f};
float height = (float) 0.05 * pRenderer->GetHeight();
pRenderer->Draw2dLabel(30.f, height, 2.f, statusColor, false,
"THit: %i | TWatched: %" PRISIZE_T " | WatchedHit: %i | %% WatchedHit: %.2f",
totalHit, m_watchedPoints.size(), watchedHit, percHit * 100.0f );
//Output the interesting lines
float outputOffset = 0.08f;
int numberOutput = 0;
int maxNumberOutput = m_debug_ccoverage_maxlines;
for(TCheckpointDebugVector::iterator outputIt = outputPoints.begin();
outputIt != outputPoints.end() && numberOutput < maxNumberOutput;
++outputIt)
{
static float watchedColor[] = {1.0f, 0.0f, 1.0f, 1.0f};
static float unwatchedColor[] = {0.0f, 0.0f, 1.0f, 1.0f};
//Check filters and skip outputting of ones that don't qualify
int filterMin = m_debug_ccoverage_filter_mincount, filterMax = m_debug_ccoverage_filter_maxcount;
if(filterMax && (int)outputIt->m_currHitcount > filterMax)
continue;
else if(filterMin && (int)outputIt->m_currHitcount < filterMin)
continue;
pRenderer->Draw2dLabel(30.f, outputOffset * pRenderer->GetHeight(), 2.f, outputIt->m_queried? watchedColor : unwatchedColor, false,
"CheckPoint: %s Count:%i", outputIt->m_name.c_str(), outputIt->m_currHitcount);
//Update the display output height
outputOffset += 0.03f;
++numberOutput;
}
}
void CGameTokenSystem::DebugDraw()
{
#ifdef _GAMETOKENSDEBUGINFO
static bool drawnLastFrame = false;
float color[]={1.0f, 1.0f, 1.0f, 1.0f};
if (CGameTokenSystem::m_CVarShowDebugInfo==0 || CGameTokenSystem::m_CVarShowDebugInfo==3)
{
drawnLastFrame = false;
return;
}
if (!drawnLastFrame)
ClearDebugHistory();
drawnLastFrame = true;
if (gEnv->pConsole->IsOpened())
return;
IRenderer * pRenderer = gEnv->pRenderer;
if(!pRenderer)
return;
int linesDrawn = 0;
{
TDebugListMap::iterator iter = m_debugList.begin();
int i = 0;
while (iter != m_debugList.end())
{
CGameToken* pToken = GetToken( iter->c_str() );
DrawToken( iter->c_str(), GetTokenDebugString( pToken ), pToken ? pToken->GetLastChangeTime() : CTimeValue(), i );
++iter;
++i;
}
linesDrawn = i;
}
{
int numHistoryLines = GetHistoryBufferSize();
if (numHistoryLines>0)
{
string buf;
pRenderer->Draw2dLabel(20.0f+m_CVarPosX,20.0f+m_CVarPosY+12.0f*(float)linesDrawn, 1.2f, color, false, "---------------HISTORY----------------");
linesDrawn++;
for (int i=0; i<numHistoryLines; i++)
{
uint index = ( m_historyStart + i ) % numHistoryLines;
SDebugHistoryEntry& entry = m_debugHistory[index];
DrawToken( entry.tokenName, entry.value, entry.timeChanged, linesDrawn+i );
}
}
}
#endif
}
//------------------------------------------------------------------------
void CVehicleMovementStdBoat::Update(const float deltaTime)
{
CVehicleMovementBase::Update(deltaTime);
SetAnimationSpeed(eVMA_Engine, abs(m_rpmScaleSgn));
if (m_inWater)
{
SetSoundParam(eSID_Run, "slip", 0.2f*abs(m_localSpeed.x));
}
#if ENABLE_VEHICLE_DEBUG
if (IsProfilingMovement() && g_pGameCVars->v_profileMovement != 2)
{
IEntity* pEntity = m_pVehicle->GetEntity();
const Matrix34& wTM = pEntity->GetWorldTM();
Matrix34 wTMInv = wTM.GetInvertedFast();
const SVehiclePhysicsStatus* physStatus = &m_physStatus[k_mainThread];
Vec3 localW = physStatus->q * physStatus->w;
float speed = physStatus->v.len2() > 0.001f ? physStatus->v.len() : 0.f;
float speedRatio = min(1.f, speed/(m_maxSpeed*m_factorMaxSpeed));
float absPedal = abs(m_movementAction.power);
float absSteer = abs(m_movementAction.rotateYaw);
static const float fSubmergedMin = 0.01f;
static const float fWaterLevelMaxDiff = 0.15f; // max allowed height difference between propeller center and water level
Vec3 worldPropPos = wTM * m_pushOffset;
float waterLevelWorld = gEnv->p3DEngine->GetWaterLevel( &worldPropPos );
float fWaterLevelDiff = worldPropPos.z - waterLevelWorld;
// wave stuff
float waveFreq = 1.f;
waveFreq += 3.f*speedRatio;
float kx = m_waveIdleStrength.x*(m_waveRandomMult+0.3f) * (1.f-speedRatio + m_waveSpeedMult*speedRatio);
float ky = m_waveIdleStrength.y * (1.f - 0.5f*absPedal - 0.5f*absSteer);
Vec3 waveLoc = m_massOffset;
waveLoc.y += speedRatio*min(0.f, m_pushOffset.y-m_massOffset.y);
waveLoc = wTM * waveLoc;
IRenderer* pRenderer = gEnv->pRenderer;
static float color[4] = {1,1,1,1};
float colorRed[4] = {1,0,0,1};
float colorGreen[4] = {0,1,0,1};
float y=50.f, step1=15.f, step2=20.f, size1=1.3f, size2=1.5f;
pRenderer->Draw2dLabel(5.0f, y, size2, color, false, "Boat movement");
pRenderer->Draw2dLabel(5.0f, y+=step2, size1, color, false, "Speed: %.1f (%.1f km/h)", speed, speed*3.6f);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "LocalW.z norm: %.2f", abs(localW.z)/m_turnRateMax);
if (m_velLift > 0.f)
{
pRenderer->Draw2dLabel(5.0f, y+=step2, size1, m_lifted ? colorGreen : color, false, m_lifted ? "Lifted" : "not lifted");
//pRenderer->Draw2dLabel(5.0f, y+=step2, size1, color, false, "Impulse lift: %.0f", liftImp.impulse.len());
}
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, physStatus->submergedFraction > fSubmergedMin ? color : colorRed, false, "Submerged: %.2f", physStatus->submergedFraction);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, fWaterLevelDiff < fWaterLevelMaxDiff ? color : colorRed, false, "WaterLevel: %.2f (max: %.2f)", fWaterLevelDiff, fWaterLevelMaxDiff);
pRenderer->Draw2dLabel(5.0f, y+=step2, size2, color, false, "Driver input");
pRenderer->Draw2dLabel(5.0f, y+=step2, size1, color, false, "power: %.2f", m_movementAction.power);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "steer: %.2f", m_movementAction.rotateYaw);
pRenderer->Draw2dLabel(5.0f, y+=step2, size2, color, false, "Propelling");
//pRenderer->Draw2dLabel(5.0f, y+=step2, size1, color, false, "turnAccel (norm/real): %.2f / %.2f", turnAccelNorm, turnAccel);
//pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "Impulse acc: %.0f", linearImp.impulse.len());
//pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "Impulse steer/damp: %.0f", angularImp.angImpulse.len());
//pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "Impulse corner: %.0f", dampImp.impulse.len());
pRenderer->Draw2dLabel(5.0f, y+=step2, size2, color, false, "Waves");
pRenderer->Draw2dLabel(5.0f, y+=step2, size1, color, false, "timer: %.1f", m_waveTimer);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "frequency: %.2f", waveFreq);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "random: %.2f", m_waveRandomMult);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "kX: %.2f", kx);
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "kY: %.2f", ky);
if (Boosting())
pRenderer->Draw2dLabel(5.0f, y+=step1, size1, color, false, "Boost: %.2f", m_boostCounter);
IRenderAuxGeom* pGeom = pRenderer->GetIRenderAuxGeom();
ColorB colorB(0,255,0,255);
pRenderer->DrawLabel(worldPropPos, 1.3f, "WL: %.2f", waterLevelWorld);
pGeom->DrawSphere(worldPropPos, 0.15f, colorB);
pGeom->DrawSphere(waveLoc, 0.25f, colorB);
pGeom->DrawLine(waveLoc, colorB, waveLoc+Vec3(0,0,2), colorB);
// impulses
//DrawImpulse(linearImp, Vec3(0,0,1), 3.f/deltaTime, ColorB(255,0,0,255));
//DrawImpulse(angularImp, Vec3(0,0,1), 2.f/deltaTime, ColorB(128,0,0,255));
//DrawImpulse(liftImp, Vec3(0,0,6), 2.f/deltaTime, ColorB(0,0,255,255));
}
#endif
}
//------------------------------------------------------------------------
void CGunTurret::ServerUpdate(SEntityUpdateContext &ctx, int update)
{
//update parameters. SNH: cache these in MP since they never change.
if(!gEnv->bMultiplayer)
{
UpdateEntityProperties();
}
IEntity *pCurrentTarget = gEnv->pEntitySystem->GetEntity(m_targetId);
IActor *pCurrentActor = GetActor(m_targetId);
bool mg=false;
bool rocket=false;
if(IsOperational())
{
bool renew_target = false;
//do this before, cause it's more important
if(m_turretparams.TAC_check_time != 0.f)
{
if(m_checkTACTimer>m_turretparams.TAC_check_time)
{
m_checkTACTimer = 0.0f;
IEntity *pClosest = GetClosestTACShell();
if(pClosest)
{
ChangeTargetTo(pClosest);
pCurrentTarget = pClosest;
}
}
else
m_checkTACTimer += ctx.fFrameTime;
}
//actually if(...), break at end
while(pCurrentTarget)
{
if(InternalIsFiring(false))
m_burstTimer += ctx.fFrameTime;
else
m_burstTimer = 0.f;
ETargetClass t_class = GetTargetClass(pCurrentTarget);
bool validClass = (t_class!=eTC_NotATarget);
Vec3 tpos = PredictTargetPos(pCurrentTarget,false);
bool inrange = IsInRange(tpos, t_class);
if(m_rayTimer <= 0.f)
{
m_canShoot = IsTargetShootable(pCurrentTarget);
m_rayTimer = (m_canShoot) ? 0.5f : 0.2f;
}
else
m_rayTimer -= ctx.fFrameTime;
if(!(validClass && inrange && m_canShoot))
{
m_abandonTargetTimer += ctx.fFrameTime;
}
else
m_abandonTargetTimer = 0.0f;
if(m_abandonTargetTimer > m_turretparams.abandon_target_time + m_randoms[eRV_AbandonTarget].val)
{
renew_target = true;
m_randoms[eRV_AbandonTarget].New();
break;
}
bool aim = inrange&&m_canShoot&&IsAiming(tpos, m_turretparams.aim_tolerance);
mg = aim && !m_turretparams.search_only && IsTargetMGable(tpos);
bool burst = (m_turretparams.burst_time == 0.f || UpdateBurst(ctx.fFrameTime));
mg &= burst;
// a bit less tolerant for rockets
aim=aim&&IsAiming(tpos, m_turretparams.aim_tolerance*0.5f);
rocket = aim && !m_turretparams.search_only && m_fm2 && t_class == eTC_Vehicle && IsTargetRocketable(tpos);
if(g_pGameCVars->i_debug_turrets)
{
IRenderer *pRenderer = gEnv->pRenderer;
static float white[4] = {1,1,1,1};
float x = 5.f, y = 50.f, step1 = 15.f, /*step2 = 20.f, */size=1.3f;
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "Target: %s", pCurrentTarget->GetName());
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "InRange: %i", inrange);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "CanShoot: %i", m_canShoot);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "IsAiming: %i", aim);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "Burst: %i", burst);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "MG: %i", mg);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "BurstTimer: %.2f", m_burstTimer);
//pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "Rocket: %i", rocket);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "TargetPos: %.1f %.1f %.1f", tpos.x, tpos.y, tpos.z);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "Abandon: %.2f", m_abandonTargetTimer);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "Update: %.2f", m_updateTargetTimer);
pRenderer->Draw2dLabel(x, y+=step1, size, white, false, "GoalYaw: %.2f, GoalPitch: %.2f", m_goalYaw, m_goalPitch);
}
break;
}
m_updateTargetTimer += ctx.fFrameTime;
if(renew_target || m_updateTargetTimer > m_turretparams.update_target_time+m_randoms[eRV_UpdateTarget].Val())
{
IEntity *pClosestTAC = GetClosestTACShell();
IEntity *pClosest = (pClosestTAC) ? pClosestTAC : GetClosestTarget();
// change target if tac shell, or other target closer than current
// otherwise, only change after abandoning time is exceeded
if(pClosestTAC || (pClosest && pClosest->GetId()!=m_targetId) || (!pClosest && !(m_abandonTargetTimer>0.f && m_abandonTargetTimer<=m_turretparams.abandon_target_time)))
{
ChangeTargetTo(pClosest);
pCurrentTarget = pClosest;
}
m_updateTargetTimer = 0.f;
m_randoms[eRV_UpdateTarget].New();
}
if(pCurrentTarget)
{
if(m_turretparams.surveillance || IsTargetShootable(pCurrentTarget))
UpdateGoal(pCurrentTarget, ctx.fFrameTime);
}
else
{
if(m_turretparams.searching)
{
UpdateSearchingGoal(ctx.fFrameTime);
}
}
}
if(m_fm && mg != InternalIsFiring(false))
{
if(mg)
InternalStartFire(false);
else
InternalStopFire(false);
}
if(m_fm2 && rocket != InternalIsFiring(true))
{
if(rocket)
InternalStartFire(true);
else
InternalStopFire(true);
}
}
//----------------------------------------------------------------------------
void CHomingMissile::UpdateCruiseMissile(float frameTime)
{
IRenderer* pRenderer = gEnv->pRenderer;
IRenderAuxGeom* pGeom = pRenderer->GetIRenderAuxGeom();
float color[4] = {1,1,1,1};
const static float step = 15.f;
float y = 20.f;
bool bDebug = g_pGameCVars->i_debug_projectiles > 0;
if (m_targetId)
{
IEntity* pTarget = gEnv->pEntitySystem->GetEntity(m_targetId);
if (pTarget)
{
AABB box;
pTarget->GetWorldBounds(box);
SetDestination( box.GetCenter() );
//if (bDebug)
//pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "Target Entity: %s", pTarget->GetName());
}
}
else
{
// update destination pos from weapon
static IItemSystem* pItemSystem = g_pGame->GetIGameFramework()->GetIItemSystem();
IItem* pItem = pItemSystem->GetItem(m_weaponId);
if (pItem && pItem->GetIWeapon())
{
const Vec3& dest = pItem->GetIWeapon()->GetDestination();
SetDestination( dest );
//if (bDebug)
//pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "Weapon Destination: (%.1f %.1f %.1f)", dest.x, dest.y, dest.z);
}
}
pe_status_dynamics status;
if (!GetEntity()->GetPhysics()->GetStatus(&status))
return;
float currentSpeed = status.v.len();
Vec3 currentPos = GetEntity()->GetWorldPos();
Vec3 goalDir(ZERO);
if (!m_destination.IsZero())
{
if((currentPos-m_destination).len2()<(m_detonationRadius*m_detonationRadius))
{
Explode(true, true, m_destination, -status.v.normalized(), status.v, m_targetId);
return;
}
if (bDebug)
pGeom->DrawCone(m_destination, Vec3(0,0,-1), 2.5f, 7.f, ColorB(255,0,0,255));
float heightDiff = (m_cruiseAltitude-m_alignAltitude) - currentPos.z;
if (!m_isCruising && heightDiff * sgn(status.v.z) > 0.f)
{
// if heading towards align altitude (but not yet reached) accelerate to max speed
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] accelerating (%.1f / %.1f)", currentSpeed, m_maxSpeed);
}
else if (!m_isCruising && heightDiff * sgnnz(status.v.z) < 0.f && (status.v.z<0 || status.v.z>0.25f))
{
// align to cruise
if (currentSpeed != 0)
{
goalDir = status.v;
goalDir.z = 0;
goalDir.normalize();
}
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] aligning");
}
else
{
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] cruising...");
// cruise
m_isCruising = true;
if (!m_destination.IsZero())
{
float groundDistSq = m_destination.GetSquaredDistance2D(currentPos);
float distSq = m_destination.GetSquaredDistance(currentPos);
float descendDistSq = sqr(m_descendDistance);
if (m_isDescending || groundDistSq <= descendDistSq)
{
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] descending!");
if (distSq != 0)
goalDir = (m_destination - currentPos).normalized();
else
goalDir.zero();
m_isDescending = true;
}
else
{
Vec3 airPos = m_destination;
airPos.z = currentPos.z;
goalDir = airPos - currentPos;
if (goalDir.len2() != 0)
goalDir.Normalize();
}
}
}
}
float desiredSpeed = currentSpeed;
if (currentSpeed < m_maxSpeed-0.1f)
{
desiredSpeed = min(m_maxSpeed, desiredSpeed + m_accel*frameTime);
}
Vec3 currentDir = status.v.GetNormalizedSafe(FORWARD_DIRECTION);
Vec3 dir = currentDir;
if (!goalDir.IsZero())
{
float cosine = max(min(currentDir.Dot(goalDir), 0.999f), -0.999f);
float goalAngle = RAD2DEG(acos_tpl(cosine));
float maxAngle = m_turnSpeed * frameTime;
if (bDebug)
{
pGeom->DrawCone( currentPos, goalDir, 0.4f, 12.f, ColorB(255,0,0,255) );
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] goalAngle: %.2f", goalAngle);
}
if (goalAngle > maxAngle+0.05f)
dir = (Vec3::CreateSlerp(currentDir, goalDir, maxAngle/goalAngle)).normalize();
else //if (goalAngle < 0.005f)
dir = goalDir;
}
pe_action_set_velocity action;
action.v = dir * desiredSpeed;
GetEntity()->GetPhysics()->Action(&action);
if (bDebug)
{
pGeom->DrawCone( currentPos, dir, 0.4f, 12.f, ColorB(128,128,0,255) );
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] currentSpeed: %.1f (max: %.1f)", currentSpeed, m_maxSpeed);
}
}
//------------------------------------------------------------------------
void CVehicleMovementHelicopter::ProcessActionsLift(float deltaTime)
{
Ang3 angles = m_pEntity->GetWorldAngles();
// const float& currentPitch = angles.x;
const float ¤tRoll = angles.y;
float boost = Boosting() ? m_boostMult : 1.0f;
float workingUpDirZ = max(0.90f, min(1.0f, m_workingUpDir.z));
float pitchRatio = (workingUpDirZ - 0.95f) / 0.05f;
float liftAction = 0.0f;
if(pitchRatio > -0.0001f)
liftAction = m_liftAction * sinf(pitchRatio * gf_PI * 0.5f);
float fwdAction = 0.0f;
if(pitchRatio < -0.0001f)
fwdAction = m_liftAction * cosf(pitchRatio * gf_PI * 0.5f);
if(m_liftAction < 0.0f && pitchRatio < 0.0f)
{
liftAction = m_liftAction * (-max(-1.0f, pitchRatio) * 0.5f);
fwdAction = 0.0f;
}
m_noHoveringTimer = 0.0f;
float gravity;
pe_simulation_params paramsSim;
if(GetPhysics()->GetParams(¶msSim))
gravity = abs(paramsSim.gravity.z);
else
gravity = 9.8f;
// hovering force
m_control.impulse += Vec3(m_workingUpDir.x, m_workingUpDir.y, min(1.0f, m_workingUpDir.z)) * gravity * (boost);
m_control.impulse += m_workingUpDir * m_enginePower * gravity * liftAction * boost;
// forward force
m_control.impulse += Vec3(m_workingUpDir.x, m_workingUpDir.y, 0.0f) * gravity * m_enginePower * fwdAction;
if(abs(m_desiredRoll) > 0.0001)
{
float side = 1.0f;
if(currentRoll < 0.0f)
side = -1.0f;
else if(currentRoll > 0.0f)
side = 1.0f;
else
side = 0.0f;
m_control.impulse += m_currentLeftDir * m_enginePower * (m_liftAction + (m_desiredRoll * side)) * boost;
}
// force damping
float horizDamp = m_velDamp;
float vertDamp = 1.0f;
if(Boosting())
horizDamp *= 0.25f;
float turbulenceMult = 1.0f - min(m_turbulenceMultMax, m_turbulence);
m_control.impulse.x -= m_PhysDyn.v.x * horizDamp;
m_control.impulse.y -= m_PhysDyn.v.y * horizDamp;
m_control.impulse.z -= m_PhysDyn.v.z * vertDamp;
#if ENABLE_VEHICLE_DEBUG
IActor *pActor = m_pActorSystem->GetActor(m_actorId);
int profile = g_pGameCVars->v_profileMovement;
if((profile == 1 && pActor && pActor->IsClient()) || profile == 2)
{
IRenderer *pRenderer = gEnv->pRenderer;
float color[4] = {1,1,1,1};
Ang3 localAngles = m_pEntity->GetWorldAngles();
pRenderer->Draw2dLabel(5.0f, 350.0f, 1.5f, color, false, "pitchRatio: %f, liftAction: %f, fwdAction: %f", pitchRatio, liftAction, fwdAction);
}
#endif
}
float CGameStateRecorder::RenderInfo(float y, bool bRecording)
{
float retY = 0;
IRenderer *pRenderer = gEnv->pRenderer;
if (bRecording)
{
float fColor[4] = {1,0,0,1};
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Recording game state");
retY +=15;
}
else
{
const float xp = 300;
const float xr = 400;
const float xri = 600;
float fColor[4] = {0,1,0,1};
float fColorWarning[4] = {1,1,0,1};
const char* actorName = m_demo_actorInfo->GetString();
CActor *pActor = GetActorOfName(actorName);
if(pActor)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Game state - Actor: %s --------------------------------------------------",pActor->GetEntity()? pActor->GetEntity()->GetName(): "(no entity)");
retY +=15;
if(m_itSingleActorGameState != m_GameStates.end() && pActor->GetEntity() && m_itSingleActorGameState->first == pActor->GetEntity()->GetId())
{
ICVar *pVar = gEnv->pConsole->GetCVar( "demo_force_game_state" );
if(pVar)
{
int demo_forceGameState = pVar->GetIVal();
if(demo_forceGameState)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false,demo_forceGameState==1 ?
" Override mode = (health, suit energy)" : " Override mode = (all)");
retY +=15;
}
}
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor,false,"Current");
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, fColor,false,"Recorded");
retY +=15;
SActorGameState& gstate = m_itSingleActorGameState->second;
float recordedHealth = (float)gstate.health;
float health = (float)pActor->GetHealth();
bool bError = CHECK_MISMATCH(health, recordedHealth,10);
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Health:");
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",(int)health);
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",(int)recordedHealth);
retY +=15;
// items
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," Inventory ---------------------------------------------------------------------------------------");
retY +=15;
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor,false,"Current");
pRenderer->Draw2dLabel( xri,y+retY, 1.3f, fColor,false,"Recorded");
retY +=15;
CInventory *pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
int nInvItems = pInventory->GetCount();
TItemContainer& Items = gstate.Items;
int nRecItems = Items.size();
int maxItems = max(nRecItems,nInvItems);
int i=0;
EntityId curSelectedId = pActor->GetCurrentItemId();
TItemName curSelClass = GetItemName(curSelectedId);
bool bSelectedError = !equal_strings(gstate.itemSelected,curSelClass);
for(; i< nInvItems; i++)
{
IItem *pItem = g_pGame->GetIGameFramework()->GetIItemSystem()->GetItem(pInventory->GetItem(i));
if(pItem)
{
TItemName szItemName = GetItemName(pItem->GetEntityId());
TItemContainer::iterator it = Items.find(szItemName);
bError = it==Items.end();
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," %2d)",i+1);
EntityId curId = pItem->GetEntityId();
TItemName curClass = GetItemName(curId);
if(equal_strings(curClass,curSelClass) )
pRenderer->Draw2dLabel( xp-16,y+retY, 1.3f,bSelectedError ? fColorWarning:fColor, false, "[]");
if(equal_strings(szItemName, gstate.itemSelected))
pRenderer->Draw2dLabel( xri-16,y+retY, 1.3f,bSelectedError ? fColorWarning:fColor, false, "[]");
char itemName[32];
const char* originalItemName = pItem->GetEntity() ? pItem->GetEntity()->GetName():"(null)";
int length = strlen(originalItemName);
length = min(length,31);
strncpy(itemName,originalItemName,length);
itemName[length]=0;
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," %s",itemName);
if(bError)
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColorWarning, false, "Missing");
else
{
SItemProperties& recItem = it->second;
CWeapon *pWeapon = (CWeapon*)(pItem->GetIWeapon());
IEntityClass* pItemClass = pItem->GetEntity()->GetClass();
if(pItemClass && !strcmpi(pItemClass->GetName(),"binoculars"))
pWeapon = NULL; // no fire mode or ammo recorded for binocular (which is a weapon)
if(pWeapon)
{
int idx = 0;
// ammo
float xa = 0;
for(SWeaponAmmo weaponAmmo = pWeapon->GetFirstAmmo(); weaponAmmo.pAmmoClass ; weaponAmmo = pWeapon->GetNextAmmo())
{
int ammoCount = weaponAmmo.count;
const char* ammoClass;
if(weaponAmmo.pAmmoClass && (ammoClass = weaponAmmo.pAmmoClass->GetName()))
{
TAmmoContainer::iterator it = recItem.Ammo.find(ammoClass);
if(it!=recItem.Ammo.end())
{
int recAmmoCount = recItem.Ammo[ammoClass];
bool bError2 = ammoCount!=recAmmoCount;
pRenderer->Draw2dLabel( xp+xa,y+retY, 1.3f, bError2? fColorWarning : fColor, false,"Am%d:%d",idx,ammoCount);
pRenderer->Draw2dLabel( xri+xa,y+retY, 1.3f, bError2? fColorWarning : fColor, false,"Am%d:%d",idx,recAmmoCount);
xa += 50;
++idx;
if(idx%5 ==0)
{
xa=0;
retY+=15;
}
}
}
}
// current fire mode
int curFireModeIdx = pWeapon->GetCurrentFireMode();
int recFireModeIdx = recItem.fireMode;
bool bError3 = curFireModeIdx!= recFireModeIdx;
pRenderer->Draw2dLabel( xp+xa,y+retY, 1.3f, bError3? fColorWarning : fColor, false,"FMode:%d",curFireModeIdx);
pRenderer->Draw2dLabel( xri+xa,y+retY, 1.3f, bError3? fColorWarning : fColor, false,"FMode:%d",recFireModeIdx);
}
else
{
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor, false, "Ok");
}
}
}
retY +=15;
}
/// Accessories
int nInvAccessories = pInventory->GetAccessoryCount();
TAccessoryContainer& Accessories = gstate.Accessories;
int nRecAccessories = Accessories.size();
if(nRecAccessories)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," Accessories");
retY +=15;
}
for(int j=0 ; j< nInvAccessories; j++,i++)
{
const char* accessory = pInventory->GetAccessory(j);
if(accessory && strlen(accessory))
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessory);
if(pClass)
{
TItemName szItemName = pClass->GetName();
TAccessoryContainer::iterator it = Accessories.find(szItemName);
bError = it==Accessories.end();
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false," %2d)",i+1);
char itemName[32];
int length = strlen(accessory);
length = min(length,31);
strncpy(itemName,accessory,length);
itemName[length]=0;
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," %s",itemName);
if(bError)
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColorWarning, false, "Missing");
else
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, fColor, false, "Ok");
retY +=15;
}
}
}
/// Ammo Mags
TAmmoContainer& Ammo = gstate.AmmoMags;
int nRecAmmo = Ammo.size();
int nInvAmmo = pInventory->GetAmmoPackCount();
if(nInvAmmo)
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," Ammo Packs");
retY +=15;
}
pInventory->AmmoIteratorFirst();
for(int j=0 ; !pInventory->AmmoIteratorEnd(); j++, pInventory->AmmoIteratorNext())
{
TAmmoContainer& Mags = gstate.AmmoMags;
const IEntityClass* pAmmoClass = pInventory->AmmoIteratorGetClass();
if(pAmmoClass)
{
int invAmmoCount = pInventory->AmmoIteratorGetCount();
const char* ammoClassName = pAmmoClass->GetName();
bool bNotFound = Mags.find(ammoClassName) == Mags.end();
int recAmmoCount = bNotFound ? 0 :Mags[ammoClassName];
bool bError = bNotFound || invAmmoCount!= recAmmoCount;
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, bError? fColorWarning : fColor, false," %s:",ammoClassName);
pRenderer->Draw2dLabel( xp,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",invAmmoCount);
if(bNotFound)
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, fColorWarning, false,"NotRecd");
else
pRenderer->Draw2dLabel( xr,y+retY, 1.3f, bError? fColorWarning : fColor, false,"%d",recAmmoCount);
retY +=15;
}
}
}
}
else // m_itSingleActorGameState != m_GameStates.end()
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false, "<<Not Recorded>>");
retY +=15;
}
}
else // pActor
{
pRenderer->Draw2dLabel( 1,y+retY, 1.3f, fColor,false, "<<Actor %s not in the map>>",actorName ? actorName:"(no name)");
retY +=15;
}
}
return retY;
}
virtual void ProcessEvent( EFlowEvent event,SActivationInfo *pActInfo )
{
IVehicleSystem * pVehicleSystem = NULL;
IVehicle * pVehicle = NULL;
switch(event)
{
case eFE_Initialize:
{
pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
break;
}
case eFE_Activate:
{
if (!pActInfo->pEntity)
return;
pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
pVehicle = pVehicleSystem->GetVehicle(pActInfo->pEntity->GetId());
if (!pVehicleSystem || !pVehicle)
return;
string givenString = GetPortString(pActInfo, IN_PARTS);
currentParam = givenString.substr(0,givenString.find_first_of(":"));
currentSetting = givenString.substr(givenString.find_first_of(":")+1,(givenString.length()-givenString.find_first_of(":")));
column1 = 10.f;
column2 = 100.f;
if (IsPortActive(pActInfo,IN_SHOW))
pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
break;
}
case eFE_Update:
{
IRenderer * pRenderer = gEnv->pRenderer;
pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
pVehicle = pVehicleSystem->GetVehicle(pActInfo->pEntity->GetId());
if(!pVehicleSystem || !pActInfo->pEntity || !pVehicle)
return;
pRenderer->Draw2dLabel(column1,10,GetPortFloat(pActInfo,IN_SIZE)+2.f,Col_Cyan,false,pActInfo->pEntity->GetName());
if(currentParam=="Seats")
{
loops = 0;
for(uint32 i=0;i<pVehicle->GetSeatCount();i++)
{
IVehicleSeat * currentSeat;
if(currentSetting=="All")
{
currentSeat = pVehicle->GetSeatById(i+1);
}
else
{
currentSeat = pVehicle->GetSeatById(pVehicle->GetSeatId(currentSetting));
i = pVehicle->GetSeatCount()-1;
}
loops += 1;
// column 1
string pMessage = ("%s:", currentSeat->GetSeatName());
if (column2<pMessage.size()*8*GetPortFloat(pActInfo, IN_SIZE))
column2=pMessage.size()*8*GetPortFloat(pActInfo, IN_SIZE);
pRenderer->Draw2dLabel(column1,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessage);
// column 2
if(currentSeat->GetPassenger(true))
{
pMessage = ("- %s", gEnv->pEntitySystem->GetEntity(currentSeat->GetPassenger(true))->GetName());
pRenderer->Draw2dLabel(column2,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessage);
}
}
}
else if(currentParam=="Wheels")
{
pRenderer->Draw2dLabel(column1,50.f,GetPortFloat(pActInfo,IN_SIZE)+1.f,Col_Red,false,"!");
}
else if(currentParam=="Weapons")
{
loops = 0;
for(int i=0;i<pVehicle->GetWeaponCount();i++)
{
IItemSystem * pItemSystem = gEnv->pGame->GetIGameFramework()->GetIItemSystem();
IWeapon * currentWeapon;
EntityId currentEntityId;
IItem * pItem;
if(currentSetting=="All")
{
currentEntityId = pVehicle->GetWeaponId(i+1);
}
else
{
currentEntityId = gEnv->pEntitySystem->FindEntityByName(currentSetting)->GetId();
i = pVehicle->GetWeaponCount()-1;
}
if(!pItemSystem->GetItem(currentEntityId))
return;
pItem = pItemSystem->GetItem(currentEntityId);
currentWeapon = pItem->GetIWeapon();
loops += 1;
// column 1
string pMessageName = string().Format("%s", gEnv->pEntitySystem->GetEntity(currentEntityId)->GetName());
pRenderer->Draw2dLabel(column1,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessageName);
if (column2<pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE))
column2=pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE);
// column 2
string pMessageValue = string().Format("seat: %s firemode: %i", pVehicle->GetWeaponParentSeat(currentEntityId)->GetSeatName(), currentWeapon->GetCurrentFireMode()).c_str();
pRenderer->Draw2dLabel(column2,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessageValue);
}
}
else if(currentParam=="Components")
{
loops = 0;
for(int i=0;i<pVehicle->GetComponentCount();i++)
{
IVehicleComponent * currentComponent;
if(currentSetting=="All")
{
currentComponent = pVehicle->GetComponent(i);
}
else
{
currentComponent = pVehicle->GetComponent(currentSetting);
i = pVehicle->GetComponentCount()-1;
}
loops += 1;
ColorF labelColor;
labelColor = ColorF(currentComponent->GetDamageRatio(),(1.f-currentComponent->GetDamageRatio()),0.f);
// column 1
string pMessageName = string().Format("%s", currentComponent->GetComponentName()).c_str();
pRenderer->Draw2dLabel(column1,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),labelColor,false,pMessageName);
if (column2<pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE))
column2=pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE);
// column 2
string pMessageValue = string().Format("%5.2f (%3.2f)", currentComponent->GetDamageRatio()*currentComponent->GetMaxDamage(), currentComponent->GetDamageRatio()).c_str();
pRenderer->Draw2dLabel(column2,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),labelColor,false,pMessageValue);
}
}
else
{
pRenderer->Draw2dLabel(column1,50.f,GetPortFloat(pActInfo,IN_SIZE)+1.f,Col_Red,false,"no component selected!");
}
break;
}
}
};