void
PrintHelper::contestmanager_print(const ContestManager &man,
const Trace &trace_full,
const Trace &trace_triangle,
const Trace &trace_sprint)
{
Directory::Create(_T("output/results"));
{
std::ofstream fs("output/results/res-olc-trace.txt");
TracePointVector v;
trace_full.GetPoints(v);
for (auto it = v.begin(); it != v.end(); ++it)
fs << it->GetLocation().longitude << " " << it->GetLocation().latitude
<< " " << it->GetAltitude() << " " << it->GetTime()
<< "\n";
}
{
std::ofstream fs("output/results/res-olc-trace_triangle.txt");
TracePointVector v;
trace_triangle.GetPoints(v);
for (auto it = v.begin(); it != v.end(); ++it)
fs << it->GetLocation().longitude << " " << it->GetLocation().latitude
<< " " << it->GetAltitude() << " " << it->GetTime()
<< "\n";
}
{
std::ofstream fs("output/results/res-olc-trace_sprint.txt");
TracePointVector v;
trace_sprint.GetPoints(v);
for (auto it = v.begin(); it != v.end(); ++it)
fs << it->GetLocation().longitude << " " << it->GetLocation().latitude
<< " " << it->GetAltitude() << " " << it->GetTime()
<< "\n";
}
std::ofstream fs("output/results/res-olc-solution.txt");
if (man.stats.solution[0].empty()) {
fs << "# no solution\n";
return;
}
if (positive(man.stats.result[0].time)) {
for (auto it = man.stats.solution[0].begin();
it != man.stats.solution[0].end(); ++it) {
fs << it->GetLocation().longitude << " " << it->GetLocation().latitude
<< " " << it->GetTime()
<< "\n";
}
}
}
static std::pair<double, double>
GetMinMax(TrailSettings::Type type, const TracePointVector &trace)
{
double value_min, value_max;
if (type == TrailSettings::Type::ALTITUDE) {
value_max = 1000;
value_min = 500;
for (auto it = trace.begin(); it != trace.end(); ++it) {
value_max = std::max(it->GetAltitude(), value_max);
value_min = std::min(it->GetAltitude(), value_min);
}
} else {
value_max = 0.75;
value_min = -2.0;
for (auto it = trace.begin(); it != trace.end(); ++it) {
value_max = std::max(it->GetVario(), value_max);
value_min = std::min(it->GetVario(), value_min);
}
value_max = std::min(7.5, value_max);
value_min = std::max(-5.0, value_min);
}
return std::make_pair(value_min, value_max);
}
static std::pair<fixed, fixed>
GetMinMax(TrailSettings::Type type, const TracePointVector &trace)
{
fixed value_min, value_max;
if (type == TrailSettings::Type::ALTITUDE) {
value_max = fixed(1000);
value_min = fixed(500);
for (auto it = trace.begin(); it != trace.end(); ++it) {
value_max = std::max(it->GetAltitude(), value_max);
value_min = std::min(it->GetAltitude(), value_min);
}
} else {
value_max = fixed(0.75);
value_min = fixed(-2.0);
for (auto it = trace.begin(); it != trace.end(); ++it) {
value_max = std::max(it->GetVario(), value_max);
value_min = std::min(it->GetVario(), value_min);
}
value_max = std::min(fixed(7.5), value_max);
value_min = std::max(fixed(-5.0), value_min);
}
return std::make_pair(value_min, value_max);
}
//TODO: reimplement to cast a ray from postition in a direction
int VoxelSceneNode::GetAltitude(const irr::core::vector3df & Position)
{
return GetAltitude(irr::core::vector3d<int>(
(int) Position.X,
(int) Position.Y,
(int) Position.Z
));
}
bool
AirspaceAltitude::IsBelow(const AltitudeState &state, const fixed margin) const
{
return GetAltitude(state) <= state.altitude + margin ||
/* special case: GND is always "below" the aircraft, even if the
aircraft's AGL altitude turns out to be negative due to terrain
file inaccuracies */
IsTerrain();
}
//
// Return the eye position of an object
//
F32 EyePosition(UnitObj *u)
{
// Viewing position is the top of the bounding box
F32 y = u->Mesh().Origin().y + u->UnitType()->GetSeeingHeight();
// Clamp it to at least a litle above the level of the center
// of the cell that the unit is on.
return (Max<F32>(y, GetAltitude(u->cellX, u->cellZ, NULL) + 0.1F));
}
void
PrintHelper::contestmanager_print(const ContestManager& man)
{
{
std::ofstream fs("results/res-olc-trace.txt");
TracePointVector v;
man.trace_full.get_trace_points(v);
for (auto it = v.begin(); it != v.end(); ++it)
fs << it->get_location().longitude << " " << it->get_location().latitude
<< " " << it->GetAltitude() << " " << it->GetTime()
<< "\n";
}
{
std::ofstream fs("results/res-olc-trace_sprint.txt");
TracePointVector v;
man.trace_sprint.get_trace_points(v);
for (auto it = v.begin(); it != v.end(); ++it)
fs << it->get_location().longitude << " " << it->get_location().latitude
<< " " << it->GetAltitude() << " " << it->GetTime()
<< "\n";
}
std::ofstream fs("results/res-olc-solution.txt");
if (man.stats.solution[0].empty()) {
fs << "# no solution\n";
return;
}
if (positive(man.stats.result[0].time)) {
for (const TracePoint* it = man.stats.solution[0].begin();
it != man.stats.solution[0].end(); ++it) {
fs << it->get_location().longitude << " " << it->get_location().latitude
<< " " << it->GetAltitude() << " " << it->GetTime()
<< "\n";
}
}
}
//
// Fill gradient map for given quadrant, rotated 90 degrees
//
void FillGradMapRotated()
{
for (z = 0, z2 = 0, dz = 0; z2 < r2; z2 += 2 * z + 1, ++z, dz += quadrantZ)
{
for (x = 0, x2 = 0, dx = 0; x2 + z2 < r2; x2 += 2 * x + 1, ++x, dx += quadrantX)
{
// Calculate the altitude difference at the cell x,z
F32 altd = GetAltitude(cellX - dz, cellZ - dx, unit) - eyePos;
idx = x > z ? x : z;
// Gradient on ground at cell x,y
gradMap[z][x] = invRadTbl[idx] * altd;
// Gradient "visibleAlt" metres above ground
gradMapU[z][x] = invRadTbl[idx] * (altd + VisAlt);
}
}
maxGradMap[0][0] = gradMap[0][0];
}
int Game_Vehicle::GetScreenY() const {
return Game_Character::GetScreenY() - GetAltitude();
}
jint JNICALL Java_ardrone_ARDrone_getAltitude(JNIEnv *env, jclass cls)
{
return GetAltitude();
}
int Game_Vehicle::GetScreenY(bool apply_shift) const {
return Game_Character::GetScreenY(apply_shift) - GetAltitude();
}
bool
AirspaceAltitude::IsAbove(const AltitudeState &state, const fixed margin) const
{
return GetAltitude(state) >= state.altitude - margin;
}
void Saturn1b::AutoPilot(double autoT)
{
TRACESETUP("Saturn1b::AutoPilot");
const double GRAVITY=6.67259e-11;
static int first_time=1;
static int t = 0;
static int out_level=0;
double level=0.;
double altitude;
double pitch;
double pitch_c;
double heading;
double bank;
VECTOR3 rhoriz;
double TO_HDG = agc.GetDesiredAzimuth();
AltitudePREV = altitude = GetAltitude();
VESSELSTATUS vsp;
GetStatus(vsp);
double totalRot=0;
totalRot=vsp.vrot.x+vsp.vrot.y+vsp.vrot.z;
if (fabs(totalRot) >= 0.0025){
StopRot = true;
}
// This vector rotation will be used to tell if heads up (rhoriz.z<0) or heads down.
HorizonRot(_V(1,0,0), rhoriz);
//
// Shut down the engines when we reach the desired
// orbit.
//
double apogee, perigee;
OBJHANDLE ref = GetGravityRef();
GetApDist(apogee);
GetPeDist(perigee);
apogee = (apogee - oapiGetSize(ref)) / 1000.;
perigee = (perigee - oapiGetSize(ref)) / 1000.;
// We're aiming for periapsis and shutdown when apoapsis is reached at the opposite side of the orbit
if (apogee >= agc.GetDesiredApogee() && perigee >= agc.GetDesiredPerigee() - 0.1) {
// See Saturn::CheckForLaunchShutdown()
if (GetThrusterLevel(th_main[0]) > 0){
SetThrusterLevel(th_main[0], 0);
if (oapiGetTimeAcceleration() > 1.0)
oapiSetTimeAcceleration(1.0);
agc.LaunchShutdown();
// Reset autopilot commands
AtempP = 0;
AtempY = 0;
AtempR = 0;
}
return;
}
// navigation
pitch = GetPitch();
pitch = pitch*180./PI;
//sprintf(oapiDebugString(), "Autopilot %f", altitude);
// guidance
pitch_c = GetCPitch(autoT);
// control
if (altitude > 4500) {
// Damp roll motion
bank = GetBank();
bank = bank *180. / PI;
if (bank > 90) bank = bank - 180.;
else if (bank < -90) bank = bank + 180.;
AtempR = -bank / 20.0;
if (fabs(bank) < 0.3) AtempR = 0;
// navigation
pitch = GetPitch();
pitch = pitch * 180. / PI;
if (IGMEnabled) {
VECTOR3 target;
double pit, yaw;
double bradius = oapiGetSize(ref);
double bmass = oapiGetMass(ref);
double mu = GRAVITY * bmass;
// Aim for periapsis
double altco = agc.GetDesiredPerigee() * 1000.;
double velo = sqrt(mu / (bradius + altco));
target.x = velo;
target.y = 0.0;
target.z = altco;
LinearGuidance(target, pit, yaw);
AtempP=(pit * DEG - pitch) / 30.0;
if (AtempP < -0.15) AtempP = -0.15;
if (AtempP > 0.15) AtempP = 0.15;
}
else {
// guidance
pitch_c = GetCPitch(autoT);
// control
double SatApo;
GetApDist(SatApo);
if ((SatApo >= ((agc.GetDesiredApogee() *.90) + ERADIUS)*1000) || MissionTime >= IGMStartTime)
IGMEnabled = true;
level = pitch_c - pitch;
//sprintf(oapiDebugString(), "Autopilot Pitch Mode%f", elemSaturn1B.a );
if (fabs(level)<10 && StopRot){ // above atmosphere, soft correction
AtempP = 0.0;
AtempR = 0.0;
AtempY = 0.0;
StopRot = false;
}
if (fabs(level)<0.05){ // above atmosphere, soft correction
AtempP = 0.0;
AtempR = 0.0;
AtempY = 0.0;
}
else if (level>0 && fabs(vsp.vrot.z) < 0.09){
AtempP = -(fabs(level) / 10.);
if (AtempP < -1.0)AtempP = -1.0;
if (rhoriz.z>0) AtempP = -AtempP;
}
else if (level<0 && fabs(vsp.vrot.z) < 0.09) {
AtempP = (fabs(level) / 10.);
if (AtempP > 1.0) AtempP = 1.0;
if (rhoriz.z>0) AtempP = -AtempP;
}
else {
AtempP = 0.0;
AtempR = 0.0;
AtempY = 0.0;
}
// sprintf(oapiDebugString(), "autoT %f AtempP %f AtempR %f AtempY %f altitude %f pitch %f pitch_c %f",
// autoT, AtempP, AtempR, AtempY, altitude, pitch, pitch_c);
}
}
// sprintf(oapiDebugString(), "Alt %f Pitch %f Roll %f Yaw %f autoT %f", altitude, AtempP, AtempR, AtempY, autoT);
double slip;
VECTOR3 az;
VECTOR3 up, north, east, ygl, zgl, zerogl;
OBJHANDLE hbody=GetGravityRef();
double bradius=oapiGetSize(hbody);
// set up our reference frame
Local2Global(_V(0.0, 0.0, 0.0), zerogl);
Local2Global(_V(0.0, 1.0, 0.0), ygl);
Local2Global(_V(0.0, 0.0, 1.0), zgl);
ygl=ygl-zerogl;
zgl=zgl-zerogl;
oapiGetHeading(GetHandle(),&heading);
heading = heading*180./PI;
// Inclination control
static int incinit = 0;
static ELEMENTS elemlast;
static double incratelast;
ELEMENTS elem;
GetElements(ref, elem, 0, 0, FRAME_EQU);
double incrate = (elem.i - elemlast.i) / oapiGetSimStep();
double incraterate = (incrate - incratelast) / oapiGetSimStep();
double target = (agc.GetDesiredInclination() - elem.i * DEG) / (FirstStageShutdownTime - MissionTime);
if (agc.GetDesiredInclination() != 0 && autoT > 45) {
if (incinit < 2) {
incinit++;
AtempY = 0;
} else {
if (autoT < FirstStageShutdownTime - 10) {
AtempY = (incrate * DEG - target) / 0.7 + incraterate * DEG / 2.;
if (AtempY < -0.1) AtempY = -0.1;
if (AtempY > 0.1) AtempY = 0.1;
} else if (autoT < FirstStageShutdownTime + 10) {
AtempY = 0;
} else {
AtempY = (elem.i * DEG - agc.GetDesiredInclination()) / 7. + (incrate * DEG ) / 1.;
if (AtempY < -0.01) AtempY = -0.01;
if (AtempY > 0.01) AtempY = 0.01;
}
}
}
elemlast = elem;
incratelast = incrate;
// stage handling
switch (stage){
case LAUNCH_STAGE_ONE:
GetRelativePos(hbody, up);
up=Normalize(up);
agc.EquToRel(PI/2.0, 0.0, bradius, north);
north=Normalize(north);
east=Normalize(CrossProduct(north, up));
north=Normalize(CrossProduct(up, east));
az=east*sin(TO_HDG*RAD)-north*cos(TO_HDG*RAD);
if(autoT < 60.0) normal=Normalize(CrossProduct(up, az));
slip=GetSlipAngle()*DEG;
if(autoT < 10.) {
AtempR=0.0;
AtempY=0.0;
// cancel out the yaw maneuver...
AtempY=(-0.4+asin(zgl*normal)*DEG)/20.0;
}
if(autoT > 10.0 && autoT < 30.0) {
// roll program
AtempR=asin(ygl*normal)*DEG/20.0;
AtempY=asin(zgl*normal)*DEG/20.0;
if (AtempR < -0.25) AtempR = -0.25;
if (AtempR > 0.25) AtempR = 0.25;
}
if(autoT > 30.0 && autoT < 45.0) {
//pitch and adjust for relative wind
AtempR=asin(ygl*normal)*DEG/20.0;
//AtempY=(slip+asin(zgl*normal)*DEG)/20.0;
AtempY=(TO_HDG-(heading+slip))/20.0;
if (AtempR < -0.25) AtempR = -0.25;
if (AtempR > 0.25) AtempR = 0.25;
}
pitch = GetPitch();
pitch=pitch*180./PI;
pitch_c=GetCPitch(autoT);
AtempP = (pitch_c - pitch);
// Fix for LC 39
if (autoT < 10 && heading > 180)
AtempP = -(180. - pitch_c - pitch);
if (AtempP > 1.0) AtempP = 1.0;
if (AtempP < -1.0) AtempP = -1.0;
// zero angle-of-attack...
if(autoT > 45.0 && autoT < 115.0) {
/// \todo Disabled for now, the Saturn 1B doesn't seem to do that...
//double aoa=GetAOA()*DEG;
//pitch_c=pitch+aoa-0.3;
AtempP=(pitch_c - pitch) / 5.0;
if(AtempP < -0.2) AtempP = -0.2;
if(AtempP > 0.2) AtempP = 0.2;
// sprintf(oapiDebugString(), " pitch=%.3f pc=%.3f ap=%.3f", pitch, pitch_c, AtempP);
}
if (autoT > 115.0) {
if (autoT < 120.0) {
if (AtempP < -0.1) AtempP = -0.1;
if (AtempP > 0.1) AtempP = 0.1;
} else {
if (AtempP < -0.2) AtempP = -0.2;
if (AtempP > 0.2) AtempP = 0.2;
}
normal=Normalize(CrossProduct(Normalize(vsp.rpos), Normalize(vsp.rvel)));
}
// sprintf(oapiDebugString(), "roll=%.3f yaw=%.3f slip=%.3f sum=%.3f hdg+slip=%.3f hdg=%.3f ay=%.3f",
// asin(ygl*normal)*DEG, asin(zgl*normal)*DEG, slip, slip+asin(zgl*normal)*DEG, heading+slip, heading, AtempY);
// sprintf(oapiDebugString(), "autoT %f AtempP %f AtempR %f AtempY %f altitude %f pitch %f pitch_c %f rhoriz.z %f",
// autoT, AtempP, AtempR, AtempY, altitude, pitch, pitch_c, rhoriz.z);
/*
char buffer[80];
sprintf(buffer,"AtempP %f AtempR %f AtempY %f", AtempP, AtempR, AtempY);
TRACE(buffer);
*/
AttitudeLaunch1();
break;
case LAUNCH_STAGE_SIVB:
AttitudeLaunchSIVB();
break;
}
// sprintf(oapiDebugString(), "AP - inc %f rate %f target %f raterate %f AtempP %f AtempR %f AtempY %f", elem.i * DEG, incrate * DEG, target, incraterate * DEG, AtempP, AtempR, AtempY);
// sprintf(oapiDebugString(), "AP - pitch %f pitch_c %f heading %f AtempP %f AtempR %f AtempY %f", pitch, pitch_c, heading, AtempP, AtempR, AtempY);
}
void
TrailRenderer::Draw(Canvas &canvas, const TraceComputer &trace_computer,
const WindowProjection &projection, unsigned min_time,
bool enable_traildrift, const RasterPoint pos,
const NMEAInfo &basic, const DerivedInfo &calculated,
const TrailSettings &settings)
{
if (settings.length == TrailSettings::Length::OFF)
return;
if (!LoadTrace(trace_computer, min_time, projection))
return;
if (!calculated.wind_available)
enable_traildrift = false;
GeoPoint traildrift;
if (enable_traildrift) {
GeoPoint tp1 = FindLatitudeLongitude(basic.location,
calculated.wind.bearing,
calculated.wind.norm);
traildrift = basic.location - tp1;
}
auto minmax = GetMinMax(settings.type, trace);
auto value_min = minmax.first;
auto value_max = minmax.second;
bool scaled_trail = settings.scaling_enabled &&
projection.GetMapScale() <= 6000;
const GeoBounds bounds = projection.GetScreenBounds().Scale(4);
RasterPoint last_point = RasterPoint(0, 0);
bool last_valid = false;
for (auto it = trace.begin(), end = trace.end(); it != end; ++it) {
const GeoPoint gp = enable_traildrift
? it->GetLocation().Parametric(traildrift,
it->CalculateDrift(basic.time))
: it->GetLocation();
if (!bounds.IsInside(gp)) {
/* the point is outside of the MapWindow; don't paint it */
last_valid = false;
continue;
}
RasterPoint pt = projection.GeoToScreen(gp);
if (last_valid) {
if (settings.type == TrailSettings::Type::ALTITUDE) {
unsigned index = GetAltitudeColorIndex(it->GetAltitude(),
value_min, value_max);
canvas.Select(look.trail_pens[index]);
canvas.DrawLinePiece(last_point, pt);
} else {
unsigned color_index = GetSnailColorIndex(it->GetVario(),
value_min, value_max);
if (it->GetVario() < 0 &&
(settings.type == TrailSettings::Type::VARIO_1_DOTS ||
settings.type == TrailSettings::Type::VARIO_2_DOTS ||
settings.type == TrailSettings::Type::VARIO_DOTS_AND_LINES)) {
canvas.SelectNullPen();
canvas.Select(look.trail_brushes[color_index]);
canvas.DrawCircle((pt.x + last_point.x) / 2, (pt.y + last_point.y) / 2,
look.trail_widths[color_index]);
} else {
// positive vario case
if (settings.type == TrailSettings::Type::VARIO_DOTS_AND_LINES) {
canvas.Select(look.trail_brushes[color_index]);
canvas.Select(look.trail_pens[color_index]); //fixed-width pen
canvas.DrawCircle((pt.x + last_point.x) / 2, (pt.y + last_point.y) / 2,
look.trail_widths[color_index]);
} else if (scaled_trail)
// width scaled to vario
canvas.Select(look.scaled_trail_pens[color_index]);
else
// fixed-width pen
canvas.Select(look.trail_pens[color_index]);
canvas.DrawLinePiece(last_point, pt);
}
}
}
last_point = pt;
last_valid = true;
}
if (last_valid)
canvas.DrawLine(last_point, pos);
}
void UVaOceanBuoyancyComponent::PerformWaveReaction(float DeltaTime)
{
AActor* MyOwner = GetOwner();
if (!UpdatedComponent || MyOwner == NULL)
{
return;
}
UPrimitiveComponent* OldPrimitive = Cast<UPrimitiveComponent>(UpdatedComponent);
const FVector OldLocation = MyOwner->GetActorLocation();
const FRotator OldRotation = MyOwner->GetActorRotation();
const FVector OldLinearVelocity = OldPrimitive->GetPhysicsLinearVelocity();
const FVector OldAngularVelocity = OldPrimitive->GetPhysicsAngularVelocity();
const FVector OldCenterOfMassWorld = OldLocation + OldRotation.RotateVector(COMOffset);
const FVector OwnerScale = MyOwner->GetActorScale();
// XYZ === Throttle, Steering, Rise == Forwards, Sidewards, Upwards
FVector X, Y, Z;
GetAxes(OldRotation, X, Y, Z);
// Process tension dots and get torque from wind/waves
for (FVector TensionDot : TensionDots)
{
// Translate point to world coordinates
FVector TensionDotDisplaced = OldRotation.RotateVector(TensionDot + COMOffset);
FVector TensionDotWorld = OldLocation + TensionDotDisplaced;
// Get point depth
float DotAltitude = GetAltitude(TensionDotWorld);
// Don't process dots above water
if (DotAltitude > 0)
{
continue;
}
// Surface normal (not modified!)
FVector DotSurfaceNormal = GetSurfaceNormal(TensionDotWorld) * GetSurfaceWavesNum();
// Modify normal with real Z value and normalize it
DotSurfaceNormal.Z = GetOceanLevel(TensionDotWorld);
DotSurfaceNormal.Normalize();
// Point dynamic pressure [http://en.wikipedia.org/wiki/Dynamic_pressure]
// rho = 1.03f for ocean water
FVector WaveVelocity = GetWaveVelocity(TensionDotWorld);
float DotQ = 0.515f * FMath::Square(WaveVelocity.Size());
FVector WaveForce = FVector(0.0,0.0,1.0) * DotQ /* DotSurfaceNormal*/ * (-DotAltitude) * TensionDepthFactor;
// We don't want Z to be affected by DotQ
WaveForce.Z /= DotQ;
// Scale to DeltaTime to break FPS addiction
WaveForce *= DeltaTime;
// Apply actor scale
WaveForce *= OwnerScale.X;// *OwnerScale.Y * OwnerScale.Z;
OldPrimitive->AddForceAtLocation(WaveForce * Mass, TensionDotWorld);
}
// Static metacentric forces (can be useful on small waves)
if (bUseMetacentricForces)
{
FVector TensionTorqueResult = FVector(0.0f, 0.0f, 0.0f);
// Calc recovering torque (transverce)
FRotator RollRot = FRotator(0.0f, 0.0f, 0.0f);
RollRot.Roll = OldRotation.Roll;
FVector MetacenterDisplaced = RollRot.RotateVector(TransverseMetacenter + COMOffset);
TensionTorqueResult += X * FVector::DotProduct((TransverseMetacenter - MetacenterDisplaced),
FVector(0.0f, -1.0f, 0.0f)) * TensionTorqueRollFactor;
// Calc recovering torque (longitude)
FRotator PitchRot = FRotator(0.0f, 0.0f, 0.0f);
PitchRot.Pitch = OldRotation.Pitch;
MetacenterDisplaced = PitchRot.RotateVector(LongitudinalMetacenter + COMOffset);
TensionTorqueResult += Y * FVector::DotProduct((LongitudinalMetacenter - MetacenterDisplaced),
FVector(1.0f, 0.0f, 0.0f)) * TensionTorquePitchFactor;
// Apply torque
TensionTorqueResult *= DeltaTime;
TensionTorqueResult *= OwnerScale.X;// *OwnerScale.Y * OwnerScale.Z;
OldPrimitive->AddTorque(TensionTorqueResult);
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineDropship::PrescheduleThink( void )
{
BaseClass::PrescheduleThink();
// keep track of think time deltas for burn calc below
float dt = gpGlobals->curtime - m_flLastTime;
m_flLastTime = gpGlobals->curtime;
switch( m_iLandState )
{
case LANDING_NO:
{
if ( IsActivityFinished() && (GetActivity() != ACT_DROPSHIP_FLY_IDLE_EXAGG && GetActivity() != ACT_DROPSHIP_FLY_IDLE_CARGO) )
{
if ( m_hContainer )
{
SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_CARGO );
}
else
{
SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_EXAGG );
}
}
DoRotorWash();
}
break;
case LANDING_LEVEL_OUT:
{
// Approach the drop point
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
float flDistance = vecToTarget.Length();
// If we're slowing, make it look like we're slowing
/*
if ( IsActivityFinished() && GetActivity() != ACT_DROPSHIP_DESCEND_IDLE )
{
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
*/
// Are we there yet?
float flSpeed = GetAbsVelocity().Length();
if ( flDistance < 70 && flSpeed < 100 )
{
m_flLandingSpeed = flSpeed;
m_iLandState = LANDING_DESCEND;
// save off current angles so we can work them out over time
QAngle angles = GetLocalAngles();
m_existPitch = angles.x;
m_existRoll = angles.z;
}
DoRotorWash();
}
break;
case LANDING_DESCEND:
{
float flAltitude;
SetLocalAngularVelocity( vec3_angle );
// Ensure we land on the drop point
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
float flDistance = vecToTarget.Length();
float flRampedSpeed = m_flLandingSpeed * (flDistance / 70);
Vector vecVelocity = (flRampedSpeed / flDistance) * vecToTarget;
vecVelocity.z = -75;
SetAbsVelocity( vecVelocity );
flAltitude = GetAltitude();
if ( IsActivityFinished() && GetActivity() != ACT_DROPSHIP_DESCEND_IDLE )
{
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
if ( flAltitude < 72 )
{
QAngle angles = GetLocalAngles();
// Level out quickly.
angles.x = UTIL_Approach( 0.0, angles.x, 0.2 );
angles.z = UTIL_Approach( 0.0, angles.z, 0.2 );
SetLocalAngles( angles );
}
else
{
// randomly move as if buffeted by ground effects
// gently flatten ship from starting pitch/yaw
m_existPitch = UTIL_Approach( 0.0, m_existPitch, 1 );
m_existRoll = UTIL_Approach( 0.0, m_existRoll, 1 );
QAngle angles = GetLocalAngles();
angles.x = m_existPitch + ( sin( gpGlobals->curtime * 3.5f ) * DROPSHIP_MAX_LAND_TILT );
angles.z = m_existRoll + ( sin( gpGlobals->curtime * 3.75f ) * DROPSHIP_MAX_LAND_TILT );
SetLocalAngles( angles );
// figure out where to face (nav point)
Vector targetDir = GetDesiredPosition() - GetAbsOrigin();
// NDebugOverlay::Cross3D( m_pGoalEnt->GetAbsOrigin(), -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 20 );
QAngle targetAngles = GetAbsAngles();
targetAngles.y += UTIL_AngleDiff(UTIL_VecToYaw( targetDir ), targetAngles.y);
// orient ship towards path corner on the way down
angles = GetAbsAngles();
angles.y = UTIL_Approach(targetAngles.y, angles.y, 2 );
SetAbsAngles( angles );
}
if ( flAltitude <= 0.5f )
{
m_iLandState = LANDING_TOUCHDOWN;
// upon landing, make sure ship is flat
QAngle angles = GetLocalAngles();
angles.x = 0;
angles.z = 0;
SetLocalAngles( angles );
// TODO: Release cargo anim
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
DoRotorWash();
// place danger sounds 1 foot above ground to get troops to scatter if they are below dropship
Vector vecBottom = GetAbsOrigin();
vecBottom.z += WorldAlignMins().z;
Vector vecSpot = vecBottom + Vector(0, 0, -1) * (GetAltitude() - 12 );
CSoundEnt::InsertSound( SOUND_DANGER, vecSpot, 400, 0.2, this, 0 );
CSoundEnt::InsertSound( SOUND_PHYSICS_DANGER, vecSpot, 400, 0.2, this, 1 );
// NDebugOverlay::Cross3D( vecSpot, -Vector(4,4,4), Vector(4,4,4), 255, 0, 255, false, 10.0f );
// now check to see if player is below us, if so, cause heat damage to them (i.e. get them to move)
trace_t tr;
Vector vecBBoxMin = CRATE_BBOX_MIN; // use flat box for check
vecBBoxMin.z = -5;
Vector vecBBoxMax = CRATE_BBOX_MAX;
vecBBoxMax.z = 5;
Vector pEndPoint = vecBottom + Vector(0, 0, -1) * ( GetAltitude() - 12 );
AI_TraceHull( vecBottom, pEndPoint, vecBBoxMin, vecBBoxMax, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0f )
{
if ( tr.GetEntityIndex() == 1 ) // player???
{
CTakeDamageInfo info( this, this, 20 * dt, DMG_BURN );
CBasePlayer *pPlayer = UTIL_PlayerByIndex(1);
pPlayer->TakeDamage( info );
}
}
}
break;
case LANDING_TOUCHDOWN:
{
if ( IsActivityFinished() && ( GetActivity() != ACT_DROPSHIP_DESCEND_IDLE ) )
{
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
m_iLandState = LANDING_UNLOADING;
m_flTroopDeployPause = gpGlobals->curtime + DROPSHIP_PAUSE_B4_TROOP_UNLOAD;
m_flTimeTakeOff = m_flTroopDeployPause + DROPSHIP_DEPLOY_TIME;
}
break;
case LANDING_UNLOADING:
{
// pause before dropping troops
if ( gpGlobals->curtime > m_flTroopDeployPause )
{
if ( m_hContainer ) // don't drop troops if we don't have a crate any more
{
SpawnTroops();
m_flTroopDeployPause = m_flTimeTakeOff + 2; // only drop once
}
}
// manage engine wash and volume
if ( m_flTimeTakeOff - gpGlobals->curtime < 0.5f )
{
m_engineThrust = UTIL_Approach( 1.0f, m_engineThrust, 0.1f );
DoRotorWash();
}
else
{
float idleVolume = 0.2f;
m_engineThrust = UTIL_Approach( idleVolume, m_engineThrust, 0.04f );
if ( m_engineThrust > idleVolume )
{
DoRotorWash(); // make sure we're kicking up dust/water as long as engine thrust is up
}
}
if( gpGlobals->curtime > m_flTimeTakeOff )
{
m_iLandState = LANDING_LIFTOFF;
SetActivity( (Activity)ACT_DROPSHIP_LIFTOFF );
m_engineThrust = 1.0f; // ensure max volume once we're airborne
if ( m_bIsFiring )
{
StopCannon(); // kill cannon sounds if they are on
}
// detach container from ship
if ( m_hContainer && m_leaveCrate )
{
m_hContainer->SetParent(NULL);
m_hContainer->SetMoveType( (MoveType_t)m_iContainerMoveType );
// If the container has a physics object, remove it's shadow
IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->RemoveShadowController();
}
m_hContainer = NULL;
}
}
}
break;
case LANDING_LIFTOFF:
{
// give us some clearance before changing back to larger hull -- keeps ship from getting stuck on
// things like the player, etc since we "pop" the hull...
if ( GetAltitude() > 120 )
{
m_OnFinishedDropoff.FireOutput( this, this );
m_iLandState = LANDING_NO;
// change bounding box back to normal ship hull
Vector vecBBMin, vecBBMax;
ExtractBbox( SelectHeaviestSequence( ACT_DROPSHIP_DEPLOY_IDLE ), vecBBMin, vecBBMax );
UTIL_SetSize( this, vecBBMin, vecBBMax );
Relink();
}
}
break;
case LANDING_SWOOPING:
{
// Did we lose our pickup target?
if ( !m_hPickupTarget )
{
m_iLandState = LANDING_NO;
}
else
{
// Decrease altitude and speed to hit the target point.
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
float flDistance = vecToTarget.Length();
// Start cheating when we get near it
if ( flDistance < 50 )
{
/*
if ( flDistance > 10 )
{
// Cheat and ensure we touch the target
float flSpeed = GetAbsVelocity().Length();
Vector vecVelocity = vecToTarget;
VectorNormalize( vecVelocity );
SetAbsVelocity( vecVelocity * min(flSpeed,flDistance) );
}
else
*/
{
// Grab the target
m_hContainer = m_hPickupTarget;
m_hPickupTarget = NULL;
m_iContainerMoveType = m_hContainer->GetMoveType();
// If the container has a physics object, move it to shadow
IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->SetShadow( Vector(1e4,1e4,1e4), AngularImpulse(1e4,1e4,1e4), false, false );
pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
}
int iIndex = 0;//LookupAttachment("Cargo");
/*
Vector vecOrigin;
QAngle vecAngles;
GetAttachment( iIndex, vecOrigin, vecAngles );
m_hContainer->SetAbsOrigin( vecOrigin );
m_hContainer->SetAbsAngles( vec3_angle );
*/
m_hContainer->SetAbsOrigin( GetAbsOrigin() );
m_hContainer->SetParent(this, iIndex);
m_hContainer->SetMoveType( MOVETYPE_PUSH );
m_hContainer->RemoveFlag( FL_ONGROUND );
m_hContainer->Relink();
m_hContainer->SetAbsAngles( vec3_angle );
m_OnFinishedPickup.FireOutput( this, this );
m_iLandState = LANDING_NO;
}
}
}
DoRotorWash();
}
break;
}
DoCombatStuff();
if ( GetActivity() != GetIdealActivity() )
{
//Msg( "setactivity" );
SetActivity( GetIdealActivity() );
}
}
