public void Update()
{
UpdatedStatus = false;
UpdatedStride = false;
if (Stopped)
{
_State = LegState.Stopped;
}
if (TargetLeg == LegStatus.Lowered)
{
LandingGear.Lock();
}
UpdateMotor(Rotor1);
UpdateHinge(Hinge1);
UpdateHinge(Hinge2);
UpdateHinge(Hinge3);
UpdateHinge(Hinge4);
if (LandingGear.LockMode != LandingGearMode.Locked)
{
Rotor2.Enabled = true;
Rotor2.TargetVelocityRad = Rotor2.Angle / -2;
}
else
{
Rotor2.Enabled = false;
}
}
public void OnPickupRight(InputAction.CallbackContext ctx)
{
if (ctx.performed)
{
if (rightLegState == LegState.Down)
{
rightLegState = LegState.Request;
RequestLiftRightLeg();
}
rightHeightInput = ctx.ReadValue <float>() * 0.5f;
}
else if (ctx.canceled)
{
if (rightLegState == LegState.Up)
{
SetPosY(_rightLegTarget, rightTargetHeight);
rightLegState = LegState.Down;
RequestLiftLeftLeg();
FootDown.Invoke();
}
else
{
rightLegState = LegState.Down;
}
}
}
private void RequestLiftRightLeg()
{
if (rightLegState == LegState.Request && leftLegState == LegState.Down)
{
rightLegState = LegState.Up;
FootUp.Invoke();
}
}
private void UpdateInterpolator()
{
Vector3 point = interpolator.CalculateLegPosition(Time.deltaTime);
kinematics.Target(point);
if (point == foot)
{
this.state = LegState.Stationary;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void Start()
{
Transform lowerLeg = transform.Find("LowerLeg");
Transform upperLeg = transform.Find("UpperLeg");
this.kinematics = new InverseKinematics(lowerLeg, upperLeg);
this.foot = kinematics.Foot();
this.state = LegState.Stationary;
}
public void Drop()
{
Lower();
if (Direction == Base6Directions.Direction.Forward)
{
Rush();
}
else
{
Reverse();
}
_State = LegState.Lowering;
}
public void Return()
{
Raise();
if (Direction == Base6Directions.Direction.Forward)
{
Rush();
}
else
{
Reverse();
}
_State = LegState.Returning;
}
/* private void Update()
* {
* switch (state)
* {
* case LegState.Stationary:
* UpdateStationary();
* break;
* case LegState.Interpolating:
* UpdateInterpolator();
* break;
* }
* } */
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void UpdateStationary()
{
RaycastHit raycast;
if (Physics.Raycast(transform.position + step * Vector3.right, Vector3.down, out raycast))
{
Debug.DrawLine(transform.position, transform.position + step * Vector3.right, Color.red);
Debug.DrawLine(transform.position + step * Vector3.right, raycast.point, Color.red);
if (Vector3.Magnitude(foot - raycast.point) > Mathf.Abs(step))
{
this.interpolator = new LegInterpolator(foot, raycast.point);
this.foot = raycast.point;
state = LegState.Interpolating;
return;
}
kinematics.Target(foot);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public bool Step()
{
LegState priorState = state;
switch (state)
{
case LegState.Stationary:
UpdateStationary();
break;
case LegState.Interpolating:
UpdateInterpolator();
break;
}
if (priorState == LegState.Interpolating && state == LegState.Stationary)
{
return(true);
}
return(false);
}
public override void OnLoad(ConfigNode node)
{
base.OnLoad(node);
try
{
legState = (LegState)Enum.Parse(typeof(LegState), persistentState);
}
catch (Exception e)
{
print(e.Message);
}
if (legState == LegState.RETRACTING)
{
legState = LegState.RETRACTED;
}
else if (legState == LegState.DEPLOYING)
{
legState = LegState.DEPLOYED;
}
updateGuiControlsFromState();
}
private void ResetMotionStates() {
motionStates = new AnimationState[legC.motions.Length];
cycleMotionStates = new AnimationState[legC.cycleMotions.Length];
motionWeights = new float[legC.motions.Length];
cycleMotionWeights = new float[legC.cycleMotions.Length];
nonGroupMotionWeights = new float[legC.nonGroupMotions.Length];
// Create control motion state
controlMotionState = animation["LocomotionSystem"];
if (controlMotionState==null) {
// Create dummy animation state with control motion name
animation.AddClip(GetDummyClip(), "LocomotionSystem");
controlMotionState = animation["LocomotionSystem"];
}
controlMotionState.enabled = true;
controlMotionState.wrapMode = WrapMode.Loop;
controlMotionState.weight = 1;
controlMotionState.layer = 10000;
// Create motion states
motionGroupStates = new MotionGroupState[legC.motionGroups.Length];
int cm = 0;
for (int m=0; m<legC.motions.Length; m++) {
motionStates[m] = animation[legC.motions[m].name];
if (motionStates[m]==null) {
animation.AddClip(legC.motions[m].animation, legC.motions[m].name);
motionStates[m] = animation[legC.motions[m].name];
}
motionStates[m].wrapMode = WrapMode.Loop;
if (legC.motions[m].motionType==MotionType.WalkCycle) {
cycleMotionStates[cm] = motionStates[m];
cycleMotionStates[cm].speed = 0;
cm++;
}
}
// Create motion group states
for (int g=0; g<motionGroupStates.Length; g++) {
AnimationState controller = animation[legC.motionGroups[g].name];
if (controller==null) {
// Create dummy animation state with motion group name
animation.AddClip(GetDummyClip(), legC.motionGroups[g].name);
controller = animation[legC.motionGroups[g].name];
}
controller.enabled = true;
controller.wrapMode = WrapMode.Loop;
if (startAutomatically && g==0) controller.weight = 1;
// Create state for this motion group
motionGroupStates[g] = new MotionGroupState();
motionGroupStates[g].controller = controller;
motionGroupStates[g].motionStates = new AnimationState[legC.motionGroups[g].motions.Length];
motionGroupStates[g].relativeWeights = new float[legC.motionGroups[g].motions.Length];
for (int m=0; m<motionGroupStates[g].motionStates.Length; m++) {
motionGroupStates[g].motionStates[m] =
animation[legC.motionGroups[g].motions[m].name];
//motionGroupStates[g].motionStates[m].speed = 0;
//motionGroupStates[g].motionStates[m].wrapMode = WrapMode.Loop;
motionGroupStates[g].relativeWeights[m] = 0;
}
motionGroupStates[g].primaryMotionIndex = 0;
}
// Create list of motions states that are not in motions groups
nonGroupMotionStates = new AnimationState[legC.nonGroupMotions.Length];
for (int m=0; m<legC.nonGroupMotions.Length; m++) {
nonGroupMotionStates[m] = animation[legC.nonGroupMotions[m].name];
if (nonGroupMotionStates[m]==null) {
animation.AddClip(legC.nonGroupMotions[m].animation, legC.nonGroupMotions[m].name);
nonGroupMotionStates[m] = animation[legC.nonGroupMotions[m].name];
nonGroupMotionWeights[m] = nonGroupMotionStates[m].weight;
}
}
for (int leg=0; leg<legs.Length; leg++) {
legStates[leg] = new LegState();
}
}
private void setLegState(LegState newState)
{
LegState prevState = legState;
legState = newState;
persistentState = legState.ToString();
switch(newState)
{
case LegState.BROKEN:
{
enableWheelColliders(false);
enableFootColliders(false);
animationController.setToState(SSTUAnimState.STOPPED_START);
decompressTime = 0;
break;
}
case LegState.DEPLOYED:
{
animationController.setToState(SSTUAnimState.STOPPED_END);
decompressTime = 0;
if(HighLogic.LoadedSceneIsFlight)
{
enableWheelColliders(true);
enableFootColliders(false);
}
break;
}
case LegState.RETRACTED:
{
enableWheelColliders(false);
enableFootColliders(false);
decompressTime = 0;
animationController.setToState(SSTUAnimState.STOPPED_START);
break;
}
case LegState.DEPLOYING:
{
if(decompressTime>0)//decompress/retracting; just stop decompressing, disable foot colliders, and set state to deployed;
{
decompressTime = 0;
legState = LegState.DEPLOYED;
enableFootColliders(false);
enableWheelColliders(true);
break;
}
else
{
enableWheelColliders(false);
decompressTime = 0;
resetSuspensionPosition();//just in case something got fubard
if(HighLogic.LoadedSceneIsFlight)
{
enableFootColliders(true);
animationController.setToState(SSTUAnimState.PLAYING_FORWARD);
}
else//we are in editor
{
legState = LegState.DEPLOYED;
animationController.setToState(SSTUAnimState.STOPPED_END);
}
break;
}
}
case LegState.RETRACTING:
{
enableFootColliders(true);
if(prevState==LegState.DEPLOYED)//fix for 'instant retract' bug on newly loaded vessel
{
if(HighLogic.LoadedSceneIsFlight)
{
decompressTime = 1.0f;
//from here the decompress logic will trigger retract animation when it is needed...
}
else//else we are in editor, do not bother with retract decompress, go straight to playing animation;
{
//TODO instant-retract when in editor
resetSuspensionPosition();
animationController.setToState(SSTUAnimState.STOPPED_START);
legState=LegState.RETRACTED;
}
}
else
{
if(HighLogic.LoadedSceneIsFlight)
{
resetSuspensionPosition();
enableWheelColliders(false);
animationController.setToState(SSTUAnimState.PLAYING_BACKWARD);
}
else
{
resetSuspensionPosition();
animationController.setToState(SSTUAnimState.STOPPED_START);
legState=LegState.RETRACTED;
}
}
break;
}
}//end switch
updateGuiControlsFromState();
}
public override void OnLoad(ConfigNode node)
{
base.OnLoad (node);
try
{
legState = (LegState)Enum.Parse(typeof(LegState), persistentState);
}
catch(Exception e)
{
print (e.Message);
}
if(legState==LegState.RETRACTING)
{
legState=LegState.RETRACTED;
}
else if(legState==LegState.DEPLOYING)
{
legState=LegState.DEPLOYED;
}
updateGuiControlsFromState();
}
private void CheckInput()
{
bool walking = false;
bool hitX = false, hitY = false;
Rectangle newBounds = bounds;
Vector2 newPos = position;
if (InputManager.Instance.KeyPressed(Keys.LEFT))
{
newPos.X -= speed;
if (newPos.X < 0)
{
newPos.X = 0;
}
Direction = Directions.LEFT;
walking = true;
}
else if (InputManager.Instance.KeyPressed(Keys.RIGHT))
{
newPos.X += speed;
if (newPos.X > GameConstants.MAP_SIZE_HORIZONTAL * GameConstants.TILE_SIZE - bounds.Width)
{
newPos.X = GameConstants.MAP_SIZE_HORIZONTAL * GameConstants.TILE_SIZE - bounds.Width;
}
Direction = Directions.RIGHT;
walking = true;
}
if (newPos.X != position.X || newPos.Y != position.Y)
{
newBounds.X = (int)newPos.X + (int)legPos.X;
newBounds.Y = (int)newPos.Y + (int)legPos.Y;
Rectangle oldBounds = bounds;
bounds = newBounds;
if (game.CheckCollision(this))
{
bounds = oldBounds;
walking = false;
}
else
{
position = newPos;
}
}
if (InputManager.Instance.KeyPressed(Keys.UP))
{
newPos.Y -= speed;
if (newPos.Y < 0)
{
newPos.Y = 0;
}
walking = true;
}
else if (InputManager.Instance.KeyPressed(Keys.DOWN))
{
newPos.Y += speed;
if (newPos.Y > (GameConstants.MAP_SIZE_VERTICAL * GameConstants.TILE_SIZE))
{
newPos.Y = (GameConstants.MAP_SIZE_VERTICAL * GameConstants.TILE_SIZE);
}
walking = true;
}
if (newPos.X != position.X)
{
newBounds.X = (int)newPos.X + (int)legPos.X;
Rectangle oldBounds = bounds;
bounds = newBounds;
if (game.CheckCollision(this))
{
bounds = oldBounds;
hitX = true;
}
else
{
position = newPos;
}
}
if (newPos.Y != position.Y)
{
newBounds.Y = (int)newPos.Y + (int)legPos.Y;
Rectangle oldBounds = bounds;
bounds = newBounds;
if (game.CheckCollision(this))
{
bounds = oldBounds;
hitY = true;
}
else
{
position = newPos;
}
}
if (hitX && hitY)
{
walking = false;
}
if (walking)
{
CurrentLegState = LegState.Walk;
}
else
{
CurrentLegState = LegState.Idle;
}
}
private void setLegState(LegState newState)
{
LegState prevState = legState;
legState = newState;
persistentState = legState.ToString();
switch (newState)
{
case LegState.BROKEN:
{
enableWheelColliders(false);
enableFootColliders(false);
animationController.setToState(AnimState.STOPPED_START);
decompressTime = 0;
break;
}
case LegState.DEPLOYED:
{
animationController.setToState(AnimState.STOPPED_END);
decompressTime = 0;
if (HighLogic.LoadedSceneIsFlight)
{
enableWheelColliders(true);
enableFootColliders(false);
}
break;
}
case LegState.RETRACTED:
{
enableWheelColliders(false);
enableFootColliders(false);
decompressTime = 0;
animationController.setToState(AnimState.STOPPED_START);
break;
}
case LegState.DEPLOYING:
{
if (decompressTime > 0) //decompress/retracting; just stop decompressing, disable foot colliders, and set state to deployed;
{
decompressTime = 0;
legState = LegState.DEPLOYED;
enableFootColliders(false);
enableWheelColliders(true);
break;
}
else
{
enableWheelColliders(false);
decompressTime = 0;
resetSuspensionPosition(); //just in case something got fubard
if (HighLogic.LoadedSceneIsFlight)
{
enableFootColliders(true);
animationController.setToState(AnimState.PLAYING_FORWARD);
}
else //we are in editor
{
legState = LegState.DEPLOYED;
animationController.setToState(AnimState.STOPPED_END);
}
break;
}
}
case LegState.RETRACTING:
{
enableFootColliders(true);
if (prevState == LegState.DEPLOYED) //fix for 'instant retract' bug on newly loaded vessel
{
if (HighLogic.LoadedSceneIsFlight)
{
decompressTime = 1.0f;
//from here the decompress logic will trigger retract animation when it is needed...
}
else
{
//else we are in editor, go straight to retracted state
resetSuspensionPosition();
animationController.setToState(AnimState.STOPPED_START);
legState = LegState.RETRACTED;
}
}
else
{
if (HighLogic.LoadedSceneIsFlight)
{
resetSuspensionPosition();
enableWheelColliders(false);
animationController.setToState(AnimState.PLAYING_BACKWARD);
}
else
{
resetSuspensionPosition();
animationController.setToState(AnimState.STOPPED_START);
legState = LegState.RETRACTED;
}
}
break;
}
}//end switch
updateGuiControlsFromState();
}
