public void Simulate(double alt, double pressure, double time) { switch (state) { case ModuleParachute.deploymentStates.STOWED: if (alt < 3 * p.deployAltitude) { state = ModuleParachute.deploymentStates.ACTIVE; } break; case ModuleParachute.deploymentStates.ACTIVE: if (pressure >= p.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; } break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (alt < p.deployAltitude) { state = ModuleParachute.deploymentStates.DEPLOYED; openningTime = time; } break; } }
private void Init(ModuleParachute mp, double startTime, int limitChutesStage) { this.para = mp; this.state = mp.deploymentState; willDeploy = limitChutesStage != -1 && para.part.inverseStage >= limitChutesStage; // Work out when the chute was put into its current state based on the current drag as compared to the stowed, semi deployed and fully deployed drag double timeSinceDeployment = 0; switch (mp.deploymentState) { case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (mp.Anim.isPlaying) { timeSinceDeployment = mp.Anim[mp.semiDeployedAnimation].time; } else { timeSinceDeployment = 10000000; } break; case ModuleParachute.deploymentStates.DEPLOYED: if (mp.Anim.isPlaying) { timeSinceDeployment = mp.Anim[mp.fullyDeployedAnimation].time; } else { timeSinceDeployment = 10000000; } break; case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: // If the parachute is stowed then for some reason para.parachuteDrag does not reflect the stowed drag. set this up by hand. timeSinceDeployment = 10000000; break; default: // otherwise set the time since deployment to be a very large number to indcate that it has been in that state for a long time (although we do not know how long! timeSinceDeployment = 10000000; break; } this.openningTime = startTime - timeSinceDeployment; #if false Log.dbg("Parachute {0} parachuteDrag:{1} stowedDrag:{2} semiDeployedDrag:{3} fullyDeployedDrag:{4} part.maximum_drag:{5} part.minimum_drag:{6} semiDeploymentSpeed:{7} deploymentSpeed:{8} deploymentState:{9} timeSinceDeployment:{10}", para.name, this.parachuteDrag, para.stowedDrag, para.semiDeployedDrag, para.fullyDeployedDrag, para.part.maximum_drag, para.part.minimum_drag, para.semiDeploymentSpeed, para.deploymentSpeed, para.deploymentState, timeSinceDeployment); // Keep that test code until they fix the bug in the new parachute module if ((realDrag / parachuteDrag) > 1.01d || (realDrag / parachuteDrag) < 0.99d) { Log.dbg("Parachute {0} parachuteDrag:{1:0.000} RealDrag:{2:0.000} MinDrag:{3:0.000} MaxDrag:{4:0.000}", para.name, this.parachuteDrag, realDrag, para.part.minimum_drag, para.part.maximum_drag); } #endif }
public SimulatedParachute(ModuleParachute p, double startTime) { this.p = p; this.state = p.deploymentState; // Work out when the chute was put into its current state based on the current drag as compared to the stoed, semi deployed and fully deployed drag double timeSinceDeployment = 0; switch (p.deploymentState) { case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (p.Anim.isPlaying) { timeSinceDeployment = p.Anim[p.semiDeployedAnimation].time; } else { timeSinceDeployment = 10000000; } break; case ModuleParachute.deploymentStates.DEPLOYED: if (p.Anim.isPlaying) { timeSinceDeployment = p.Anim[p.fullyDeployedAnimation].time; } else { timeSinceDeployment = 10000000; } break; case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: // If the parachute is stowed then for some reason p.parachuteDrag does not reflect the stowed drag. set this up by hand. timeSinceDeployment = 10000000; break; default: // otherwise set the time since deployment to be a very large number to indcate that it has been in that state for a long time (although we do not know how long! timeSinceDeployment = 10000000; break; } this.openningTime = startTime - timeSinceDeployment; // This is the current drag for the parachute only this.parachuteDrag = p.part.maximum_drag - p.part.minimum_drag; //Debug.Log("Parachute " + p.name + " parachuteDrag:" + this.parachuteDrag + " stowedDrag:" + p.stowedDrag + " semiDeployedDrag:" + p.semiDeployedDrag + " fullyDeployedDrag:" + p.fullyDeployedDrag + " part.maximum_drag:" + p.part.maximum_drag + " part.minimum_drag:" + p.part.minimum_drag + " semiDeploymentSpeed:" + p.semiDeploymentSpeed + " deploymentSpeed:" + p.deploymentSpeed + " deploymentState:" + p.deploymentState + " timeSinceDeployment:" + timeSinceDeployment); // Keep that test code until they fix the bug in the new parachute module //if ((realDrag / parachuteDrag) > 1.01d || (realDrag / parachuteDrag) < 0.99d) // Debug.Log("Parachute " + p.name + " parachuteDrag:" + this.parachuteDrag.ToString("F3") + " RealDrag:" + realDrag.ToString("F3") + " MinDrag:" + p.part.minimum_drag.ToString("F3") + " MaxDrag:" + p.part.maximum_drag.ToString("F3")); }
public SimulatedParachute(ModuleParachute mp, SimCurves simCurve, double startTime, int limitChutesStage) : base(mp.part, simCurve) { this.para = mp; this.state = mp.deploymentState; willDeploy = limitChutesStage != -1 && para.part.inverseStage >= limitChutesStage; // Work out when the chute was put into its current state based on the current drag as compared to the stowed, semi deployed and fully deployed drag double timeSinceDeployment = 0; switch (mp.deploymentState) { case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (mp.Anim.isPlaying) { timeSinceDeployment = mp.Anim[mp.semiDeployedAnimation].time; } else { timeSinceDeployment = 10000000; } break; case ModuleParachute.deploymentStates.DEPLOYED: if (mp.Anim.isPlaying) { timeSinceDeployment = mp.Anim[mp.fullyDeployedAnimation].time; } else { timeSinceDeployment = 10000000; } break; case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: // If the parachute is stowed then for some reason para.parachuteDrag does not reflect the stowed drag. set this up by hand. timeSinceDeployment = 10000000; break; default: // otherwise set the time since deployment to be a very large number to indcate that it has been in that state for a long time (although we do not know how long! timeSinceDeployment = 10000000; break; } this.openningTime = startTime - timeSinceDeployment; }
public void Set(ModuleParachute mp, double startTime, int limitChutesStage) { this.para = mp; this.state = mp.deploymentState; willDeploy = limitChutesStage != -1 && para.part.inverseStage >= limitChutesStage; // Work out when the chute was put into its current state based on the current drag as compared to the stowed, semi deployed and fully deployed drag double timeSinceDeployment = 0; switch (mp.deploymentState) { case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (mp.Anim.isPlaying) timeSinceDeployment = mp.Anim[mp.semiDeployedAnimation].time; else timeSinceDeployment = 10000000; break; case ModuleParachute.deploymentStates.DEPLOYED: if (mp.Anim.isPlaying) timeSinceDeployment = mp.Anim[mp.fullyDeployedAnimation].time; else timeSinceDeployment = 10000000; break; case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: // If the parachute is stowed then for some reason para.parachuteDrag does not reflect the stowed drag. set this up by hand. timeSinceDeployment = 10000000; break; default: // otherwise set the time since deployment to be a very large number to indcate that it has been in that state for a long time (although we do not know how long! timeSinceDeployment = 10000000; break; } this.openningTime = startTime - timeSinceDeployment; //Debug.Log("Parachute " + para.name + " parachuteDrag:" + this.parachuteDrag + " stowedDrag:" + para.stowedDrag + " semiDeployedDrag:" + para.semiDeployedDrag + " fullyDeployedDrag:" + para.fullyDeployedDrag + " part.maximum_drag:" + para.part.maximum_drag + " part.minimum_drag:" + para.part.minimum_drag + " semiDeploymentSpeed:" + para.semiDeploymentSpeed + " deploymentSpeed:" + para.deploymentSpeed + " deploymentState:" + para.deploymentState + " timeSinceDeployment:" + timeSinceDeployment); // Keep that test code until they fix the bug in the new parachute module //if ((realDrag / parachuteDrag) > 1.01d || (realDrag / parachuteDrag) < 0.99d) // Debug.Log("Parachute " + para.name + " parachuteDrag:" + this.parachuteDrag.ToString("F3") + " RealDrag:" + realDrag.ToString("F3") + " MinDrag:" + para.part.minimum_drag.ToString("F3") + " MaxDrag:" + para.part.maximum_drag.ToString("F3")); }
public SimulatedParachute(ModuleParachute p) { this.p = p; this.state = p.deploymentState; // Work out when the chute was put into its current state based on the current drag as compared to the stoed, semi deployed and fully deployed drag double timeSinceDeployment = 0; this.targetDrag = p.targetDrag; this.parachuteDrag = p.parachuteDrag; switch (p.deploymentState) { case ModuleParachute.deploymentStates.SEMIDEPLOYED: // If the parachute is semi deployed calculate when it was semideployed by comparing the actual drag with the stowed drag and the semideployed drag. timeSinceDeployment = (p.parachuteDrag - p.stowedDrag) / (p.semiDeployedDrag - p.stowedDrag) * p.semiDeploymentSpeed; // TODO there is an error in this, because the (semi)deployment does not increase the drag in a linear way. However this will only cause a problem for simulations run during the deployment and in unlikely to cause an error in the landing location. break; case ModuleParachute.deploymentStates.DEPLOYED: // If the parachute is deployed calculate when it was deployed by comparing the actual drag with the semideployed drag and the deployed drag. timeSinceDeployment = (p.parachuteDrag - p.semiDeployedDrag) / (p.fullyDeployedDrag - p.semiDeployedDrag) * p.deploymentSpeed; // TODO there is an error in this, because the (semi)deployment does not increase the drag in a linear way. However this will only cause a problem for simulations run during the deployment and in unlikely to cause an error in the landing location. break; case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: // If the parachute is stowed then for some reason p.parachuteDrag does not reflect the stowed drag. set this up by hand. this.parachuteDrag = this.targetDrag = p.stowedDrag; timeSinceDeployment = 10000000; break; default: // otherwise set the time since deployment to be a very large number to indcate that it has been in that state for a long time (although we do not know how long! timeSinceDeployment = 10000000; break; } this.openningTime = -timeSinceDeployment; // Debug.Log("Parachute " + p.name + " parachuteDrag:" + p.parachuteDrag + " targetDrag:" + p.targetDrag + " stowedDrag:" + p.stowedDrag + " semiDeployedDrag:" + p.semiDeployedDrag + " fullyDeployedDrag:" + p.fullyDeployedDrag + " part.maximum_drag:" + p.part.maximum_drag + " part.minimum_drag:" + p.part.minimum_drag + " semiDeploymentSpeed:" + p.semiDeploymentSpeed + " deploymentSpeed:" + p.deploymentSpeed + " deploymentState:" + p.deploymentState + " timeSinceDeployment:" + timeSinceDeployment); }
public static ParachuteState ToParachuteState(this ModuleParachute.deploymentStates state) { switch (state) { case ModuleParachute.deploymentStates.ACTIVE: return(ParachuteState.Active); case ModuleParachute.deploymentStates.CUT: return(ParachuteState.Cut); case ModuleParachute.deploymentStates.DEPLOYED: return(ParachuteState.Deployed); case ModuleParachute.deploymentStates.SEMIDEPLOYED: return(ParachuteState.SemiDeployed); case ModuleParachute.deploymentStates.STOWED: return(ParachuteState.Stowed); default: throw new ArgumentOutOfRangeException(nameof(state)); } }
public void Simulate(double alt, double pressure, double time) { switch (state) { case ModuleParachute.deploymentStates.STOWED: if (alt < 3 * p.deployAltitude) state = ModuleParachute.deploymentStates.ACTIVE; break; case ModuleParachute.deploymentStates.ACTIVE: if (pressure >= p.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; } break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (alt < p.deployAltitude) { state = ModuleParachute.deploymentStates.DEPLOYED; openningTime = time; } break; } }
public SimulatedParachute(ModuleParachute p) { this.p = p; state = p.deploymentState; }
// Consider activating, semi deploying or deploying a parachute. returns true if the state has changed public bool Simulate(double altATGL, double altASL, double endASL, double pressure, double time, double semiDeployMultiplier) { bool stateChanged = false; switch (state) { case ModuleParachute.deploymentStates.STOWED: if (altATGL < semiDeployMultiplier * p.deployAltitude) { state = ModuleParachute.deploymentStates.ACTIVE; stateChanged = true; activatedAGL = altATGL; activatedASL = altASL; // Immediately check to see if the parachute should be semi deployed, rather than waiting for another iteration. if (pressure >= p.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; semiDeployAGL = altATGL; semiDeployASL = altASL; targetASLAtSemiDeploy = endASL; } } break; case ModuleParachute.deploymentStates.ACTIVE: if (pressure >= p.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; stateChanged = true; openningTime = time; semiDeployAGL = altATGL; semiDeployASL = altASL; targetASLAtSemiDeploy = endASL; } break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (altATGL < p.deployAltitude) { state = ModuleParachute.deploymentStates.DEPLOYED; stateChanged = true; openningTime = time; fullDeployAGL = altATGL; fullDeployASL = altASL; targetASLAtFullDeploy = endASL; } break; } // Now that we have potentially changed states calculate the current drag or the parachute in whatever state (or transition to a state) that it is in. float normalizedTime; // Depending on the state that we are in consider if we are part way through a deployment. if (state == ModuleParachute.deploymentStates.SEMIDEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / p.semiDeploymentSpeed, 1); } else if (state == ModuleParachute.deploymentStates.DEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / p.deploymentSpeed, 1); } else { normalizedTime = 1; } // Are we deploying in any way? We know if we are deploying or not if normalized time is less than 1 if (normalizedTime < 1) { this.deploying = true; } else { this.deploying = false; } // If we are deploying or semi deploying then use Lerp to replicate the way the game increases the drag as we deploy. if (state == ModuleParachute.deploymentStates.SEMIDEPLOYED) { this.parachuteDrag = Mathf.Lerp(p.stowedDrag, p.semiDeployedDrag, Mathf.Pow(normalizedTime, p.deploymentCurve)); } else if (state == ModuleParachute.deploymentStates.DEPLOYED) { this.parachuteDrag = Mathf.Lerp(p.semiDeployedDrag, p.fullyDeployedDrag, normalizedTime); } return(stateChanged); }
// Consider activating, semi deploying or deploying a parachute. returns true if the state has changed public override bool Simulate(double altATGL, double altASL, double endASL, double pressure, double shockTemp, double time, double semiDeployMultiplier) { if (!willDeploy) { return(false); } switch (state) { case ModuleParachute.deploymentStates.STOWED: if (altATGL < semiDeployMultiplier * para.deployAltitude && shockTemp * para.machHeatMult < para.chuteMaxTemp * para.safeMult) { state = ModuleParachute.deploymentStates.ACTIVE; //activatedAGL = altATGL; //activatedASL = altASL; // Immediately check to see if the parachute should be semi deployed, rather than waiting for another iteration. if (pressure >= para.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; //semiDeployAGL = altATGL; //semiDeployASL = altASL; //targetASLAtSemiDeploy = endASL; } } break; case ModuleParachute.deploymentStates.ACTIVE: if (pressure >= para.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; //semiDeployAGL = altATGL; //semiDeployASL = altASL; //targetASLAtSemiDeploy = endASL; } break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (altATGL < para.deployAltitude) { state = ModuleParachute.deploymentStates.DEPLOYED; openningTime = time; //fullDeployAGL = altATGL; //fullDeployASL = altASL; //targetASLAtFullDeploy = endASL; } break; } // Now that we have potentially changed states calculate the current drag or the parachute in whatever state (or transition to a state) that it is in. float normalizedTime; // Depending on the state that we are in consider if we are part way through a deployment. if (state == ModuleParachute.deploymentStates.SEMIDEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / para.semiDeploymentSpeed, 1); } else if (state == ModuleParachute.deploymentStates.DEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / para.deploymentSpeed, 1); } else { normalizedTime = 1; } // Are we deploying in any way? We know if we are deploying or not if normalized time is less than 1 if (normalizedTime < 1) { this.deploying = true; } else { this.deploying = false; } // If we are deploying or semi deploying then use Lerp to replicate the way the game increases the drag as we deploy. if (deploying && (state == ModuleParachute.deploymentStates.SEMIDEPLOYED || state == ModuleParachute.deploymentStates.DEPLOYED)) { this.deployLevel = Mathf.Pow(normalizedTime, para.deploymentCurve); } else { this.deployLevel = 1; } switch (state) { case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: case ModuleParachute.deploymentStates.CUT: SetCubeWeight("PACKED", 1f); SetCubeWeight("SEMIDEPLOYED", 0f); SetCubeWeight("DEPLOYED", 0f); break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: SetCubeWeight("PACKED", 1f - deployLevel); SetCubeWeight("SEMIDEPLOYED", deployLevel); SetCubeWeight("DEPLOYED", 0f); break; case ModuleParachute.deploymentStates.DEPLOYED: SetCubeWeight("PACKED", 0f); SetCubeWeight("SEMIDEPLOYED", 1f - deployLevel); SetCubeWeight("DEPLOYED", deployLevel); break; } return(deploying); }
public SimulatedParachute(ModuleParachute p) { this.p = p; state = p.deploymentState; }
// Consider activating, semi deploying or deploying a parachute. returns true if the state has changed public bool Simulate(double altATGL, double altASL, double endASL ,double pressure, double time, double semiDeployMultiplier) { bool stateChanged = false; switch (state) { case ModuleParachute.deploymentStates.STOWED: if (altATGL < semiDeployMultiplier * p.deployAltitude) { state = ModuleParachute.deploymentStates.ACTIVE; stateChanged = true; activatedAGL = altATGL; activatedASL = altASL; // Immediately check to see if the parachute should be semi deployed, rather than waiting for another iteration. if (pressure >= p.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; semiDeployAGL = altATGL; semiDeployASL = altASL; targetASLAtSemiDeploy = endASL; this.targetDrag = p.semiDeployedDrag; } } break; case ModuleParachute.deploymentStates.ACTIVE: if (pressure >= p.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; stateChanged = true; openningTime = time; semiDeployAGL = altATGL; semiDeployASL = altASL; targetASLAtSemiDeploy = endASL; this.targetDrag = p.semiDeployedDrag; } break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (altATGL < p.deployAltitude) { state = ModuleParachute.deploymentStates.DEPLOYED; stateChanged = true; openningTime = time; fullDeployAGL = altATGL; fullDeployASL = altASL; targetASLAtFullDeploy = endASL; this.targetDrag = p.fullyDeployedDrag; } break; } // Now that we have potentially changed states calculate the current drag or the parachute in whatever state (or transition to a state) that it is in. float normalizedTime; // Depending on the state that we are in consider if we are part way through a deployment. if (state == ModuleParachute.deploymentStates.SEMIDEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / p.semiDeploymentSpeed, 1); } else if (state == ModuleParachute.deploymentStates.DEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / p.deploymentSpeed, 1); } else { normalizedTime = 1; } // Are we deploying in any way? We know if we are deploying or not if normalized time is less than 1 if (normalizedTime < 1) { this.deploying = true; } else { this.deploying = false; } // If we are deploying or semi deploying then use Lerp to replicate the way the game increases the drag as we deploy. if (state == ModuleParachute.deploymentStates.DEPLOYED || state == ModuleParachute.deploymentStates.SEMIDEPLOYED) { this.parachuteDrag = Mathf.Lerp((float)this.parachuteDrag, (float)this.targetDrag, normalizedTime); } return (stateChanged); }
public SimulatedParachute(ModuleParachute p) { this.p = p; this.state = p.deploymentState; // Work out when the chute was put into its current state based on the current drag as compared to the stoed, semi deployed and fully deployed drag double timeSinceDeployment = 0; this.targetDrag = p.targetDrag; this.parachuteDrag = p.parachuteDrag; switch (p.deploymentState) { case ModuleParachute.deploymentStates.SEMIDEPLOYED: // If the parachute is semi deployed calculate when it was semideployed by comparing the actual drag with the stowed drag and the semideployed drag. timeSinceDeployment = (p.parachuteDrag - p.stowedDrag) / (p.semiDeployedDrag - p.stowedDrag) * p.semiDeploymentSpeed; // TODO there is an error in this, because the (semi)deployment does not increase the drag in a linear way. However this will only cause a problem for simulations run during the deployment and in unlikely to cause an error in the landing location. break; case ModuleParachute.deploymentStates.DEPLOYED: // If the parachute is deployed calculate when it was deployed by comparing the actual drag with the semideployed drag and the deployed drag. timeSinceDeployment = (p.parachuteDrag - p.semiDeployedDrag) / (p.fullyDeployedDrag - p.semiDeployedDrag) * p.deploymentSpeed; // TODO there is an error in this, because the (semi)deployment does not increase the drag in a linear way. However this will only cause a problem for simulations run during the deployment and in unlikely to cause an error in the landing location. break; case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: // If the parachute is stowed then for some reason p.parachuteDrag does not reflect the stowed drag. set this up by hand. this.parachuteDrag = this.targetDrag = p.stowedDrag; timeSinceDeployment = 10000000; break; default: // otherwise set the time since deployment to be a very large number to indcate that it has been in that state for a long time (although we do not know how long! timeSinceDeployment = 10000000; break; } this.openningTime = -timeSinceDeployment; // Debug.Log("Parachute " + p.name + " parachuteDrag:" + p.parachuteDrag + " targetDrag:" + p.targetDrag + " stowedDrag:" + p.stowedDrag + " semiDeployedDrag:" + p.semiDeployedDrag + " fullyDeployedDrag:" + p.fullyDeployedDrag + " part.maximum_drag:" + p.part.maximum_drag + " part.minimum_drag:" + p.part.minimum_drag + " semiDeploymentSpeed:" + p.semiDeploymentSpeed + " deploymentSpeed:" + p.deploymentSpeed + " deploymentState:" + p.deploymentState + " timeSinceDeployment:" + timeSinceDeployment); }
// Consider activating, semi deploying or deploying a parachute. returns true if the state has changed public override bool Simulate(double altATGL, double altASL, double endASL, double pressure, double time, double semiDeployMultiplier) { if (!willDeploy) return false; switch (state) { case ModuleParachute.deploymentStates.STOWED: if (altATGL < semiDeployMultiplier * para.deployAltitude) { state = ModuleParachute.deploymentStates.ACTIVE; activatedAGL = altATGL; activatedASL = altASL; // Immediately check to see if the parachute should be semi deployed, rather than waiting for another iteration. if (pressure >= para.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; semiDeployAGL = altATGL; semiDeployASL = altASL; targetASLAtSemiDeploy = endASL; } } break; case ModuleParachute.deploymentStates.ACTIVE: if (pressure >= para.minAirPressureToOpen) { state = ModuleParachute.deploymentStates.SEMIDEPLOYED; openningTime = time; semiDeployAGL = altATGL; semiDeployASL = altASL; targetASLAtSemiDeploy = endASL; } break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: if (altATGL < para.deployAltitude) { state = ModuleParachute.deploymentStates.DEPLOYED; openningTime = time; fullDeployAGL = altATGL; fullDeployASL = altASL; targetASLAtFullDeploy = endASL; } break; } // Now that we have potentially changed states calculate the current drag or the parachute in whatever state (or transition to a state) that it is in. float normalizedTime; // Depending on the state that we are in consider if we are part way through a deployment. if (state == ModuleParachute.deploymentStates.SEMIDEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / para.semiDeploymentSpeed, 1); } else if (state == ModuleParachute.deploymentStates.DEPLOYED) { normalizedTime = (float)Math.Min((time - openningTime) / para.deploymentSpeed, 1); } else { normalizedTime = 1; } // Are we deploying in any way? We know if we are deploying or not if normalized time is less than 1 if (normalizedTime < 1) { this.deploying = true; } else { this.deploying = false; } // If we are deploying or semi deploying then use Lerp to replicate the way the game increases the drag as we deploy. if (deploying && (state == ModuleParachute.deploymentStates.SEMIDEPLOYED || state == ModuleParachute.deploymentStates.DEPLOYED)) { this.deployLevel = Mathf.Pow(normalizedTime, para.deploymentCurve); } else { this.deployLevel = 1; } switch (state) { case ModuleParachute.deploymentStates.STOWED: case ModuleParachute.deploymentStates.ACTIVE: case ModuleParachute.deploymentStates.CUT: SetCubeWeight("PACKED", 1f); SetCubeWeight("SEMIDEPLOYED", 0f); SetCubeWeight("DEPLOYED", 0f); break; case ModuleParachute.deploymentStates.SEMIDEPLOYED: SetCubeWeight("PACKED", 1f - deployLevel); SetCubeWeight("SEMIDEPLOYED", deployLevel); SetCubeWeight("DEPLOYED", 0f); break; case ModuleParachute.deploymentStates.DEPLOYED: SetCubeWeight("PACKED", 0f); SetCubeWeight("SEMIDEPLOYED", 1f - deployLevel); SetCubeWeight("DEPLOYED", deployLevel); break; } return deploying; }