public void TickCollisions(TickCollisionsEvent _)
{
// TODO: Do this via collision detection instead.
// TODO: Clean this up.
// Keeps sword rested on the ground.
if (this.stateMachine_.IsOnGround)
{
var bladeFromGroundY = -(this.playerRigidbody_.CenterY -
this.playerRigidbody_.BottomY);
bladeFromGroundY -= MathF.Abs(
TrigMath.LenDegY(this.handDis_, this.handDeg_));
var minAngle = MathF.Acos(bladeFromGroundY / this.bladeLength_) /
MathF.PI *
180;
var diffToGround = TrigMath.DifferenceInDegrees(this.swordDeg_, 270);
if (FloatMath.Abs(diffToGround) <= minAngle)
{
this.swordDeg_ = 270 + FloatMath.Sign(diffToGround) * minAngle;
if (FloatMath.Abs(this.swordDevVel_) > 2)
{
this.swordDevVel_ *= -.5f;
}
else
{
this.swordDevVel_ = 0;
}
}
}
}
public void ProcessInputs(ProcessInputsEvent _)
{
var secondaryAnalogStick = this.gamepad_[AnalogStickType.SECONDARY];
var secStickX = secondaryAnalogStick.RawAxes.X;
var secStickY = secondaryAnalogStick.RawAxes.Y;
var secStickMag = TrigMath.DistanceBetween(0, 0, secStickX, secStickY);
if (secStickMag < GamepadConstants.DEADZONE)
{
secStickMag = 0;
}
var wasShieldOut = this.isShieldOut_;
this.isShieldOut_ = secStickMag > 0;
if (this.isShieldOut_)
{
var secStickDeg = TrigMath.DegreesBetween(0, 0, secStickX, secStickY);
var toHandDeg = secStickDeg;
var maxHorizontalHandDis = this.playerRigidbody_.Width / 2 + 2;
var maxVerticalHandDis = this.playerRigidbody_.Height / 2 + 2;
var maxHandDis =
FloatMath.Abs(
TrigMath.LenDegX(maxHorizontalHandDis, secStickDeg)) +
FloatMath.Abs(
TrigMath.LenDegY(maxVerticalHandDis, secStickDeg));
var toHandDis = maxHandDis * secStickMag;
if (!wasShieldOut)
{
this.handDis_ = toHandDis;
this.handDeg_ = toHandDeg;
}
else
{
var accFactor = 3;
this.handDis_ += (toHandDis - this.handDis_) / accFactor;
this.handDeg_ +=
TrigMath.DifferenceInDegrees(toHandDeg, this.handDeg_) /
accFactor;
}
}
}
public void ProcessInputs(ProcessInputsEvent _)
{
if (this.whipTimeFraction_ >= 1)
{
this.isWhipping_ = false;
}
if (this.isWhipping_)
{
this.whipTimeFraction_ = MathF.Min(this.whipTimeFraction_ + .1f, 1);
return;
}
var secondaryAnalogStick = this.gamepad_[AnalogStickType.SECONDARY];
var secStickX = secondaryAnalogStick.RawAxes.X;
var secStickY = secondaryAnalogStick.RawAxes.Y;
var secStickMag = TrigMath.DistanceBetween(0, 0, secStickX, secStickY);
if (secStickMag < GamepadConstants.DEADZONE)
{
secStickMag = 0;
}
this.isStoring_ = secStickMag > .8f;
if (this.isStoring_)
{
var secStickDeg = TrigMath.DegreesBetween(0, 0, secStickX, secStickY);
this.storedWhipTimer_ = 5;
this.whipStrength_ = secStickMag;
this.whipDeg_ = secStickDeg + 180;
}
var wasFlicked = this.storedWhipTimer_-- > 0 && secStickMag == 0;
if (wasFlicked)
{
this.isStoring_ = false;
this.storedWhipTimer_ = -1;
this.isWhipping_ = true;
this.whipTimeFraction_ = 0;
// TODO: Move this out.
this.playerSounds_.PlayWhipSound();
}
}
// TODO: Remove this.
public void UpdateMatrices()
{
if (this.parent_ == null)
{
this.endImpl_.X = this.startImpl_.X = this.Transform.X;
this.endImpl_.Y = this.startImpl_.Y = this.Transform.Y;
this.transform_.GlobalDeg = this.Transform.RelativeDeg;
return;
}
var startX = this.startImpl_.X = this.parent_.End.X + this.Transform.X;
var startY = this.startImpl_.Y = this.parent_.End.Y + this.Transform.Y;
var length = this.transform_.Length;
var globDeg = this.transform_.GlobalDeg =
this.parent_.transform_.GlobalDeg +
this.transform_.RelativeDeg;
this.endImpl_.X = startX + TrigMath.LenDegX(length, globDeg);
this.endImpl_.Y = startY - TrigMath.LenDegY(length, globDeg);
}
private void ProcessManualInputs_()
{
var secondaryAnalogStick = this.gamepad_[AnalogStickType.SECONDARY];
var secStickX = secondaryAnalogStick.RawAxes.X;
var secStickY = secondaryAnalogStick.RawAxes.Y;
var secStickMag = TrigMath.DistanceBetween(0, 0, secStickX, secStickY);
if (secStickMag < GamepadConstants.DEADZONE)
{
secStickMag = 0;
}
var secStickDeg = TrigMath.DegreesBetween(0, 0, secStickX, secStickY);
var isResting = secStickMag == 0;
// TODO: Detect arcs?
/*if (isResting) {
* var xVel = this.playerRigidbody_.XVelocity;
* if (xVel != 0) {
* var sign = FloatMath.Sign(xVel);
*
* this.handDis_ = this.maxHandDis_;
*
* if (this.stateMachine_.State == PlayerState.WALKING) {
* this.handDeg_ = 90 - sign * (90 + 45);
* this.swordDeg_ = 90 - sign * 45;
* } else if (this.stateMachine_.State == PlayerState.RUNNING) {
* this.handDeg_ = 90 + sign * (90 + 22);
* this.swordDeg_ = 90 + sign * (90 + 22);
* }
* }
* return;
* }*/
// Stick moves hands to lift sword. Angle needs to be closer to have
// more of an effect.
var diffToHeld =
TrigMath.DifferenceInDegrees(secStickDeg, this.handDeg_);
var normalizedDiffToHeld = MathF.Abs(diffToHeld / 180);
var moveFactor = 1 - normalizedDiffToHeld;
var diffToTop = TrigMath.DifferenceInDegrees(90, this.handDeg_);
var isLifting = FloatMath.Sign(diffToTop) == FloatMath.Sign(diffToHeld);
var moveForce = 0f;
var liftFactor = secStickMag * MathF.Pow(moveFactor, 5); // 4, 6, 7
if (isLifting)
{
var liftForce = .6f * diffToHeld * liftFactor; // .5f
moveForce = liftForce;
}
else
{
var dropFactor = secStickMag;
var dropForce = .8f * diffToHeld * dropFactor;
moveForce = dropForce;
}
var initDiffToGround = TrigMath.DifferenceInDegrees(270, this.handDeg_);
var gravitationalForce = 3 * FloatMath.Sign(initDiffToGround);
var forceOnHands = moveForce + gravitationalForce;
// TODO: Use euler method?
this.handDegVel_ += forceOnHands;
this.handDeg_ += this.handDegVel_;
var minAngle = 45;
var finalDiffToGround = TrigMath.DifferenceInDegrees(this.handDeg_, 270);
if (FloatMath.Abs(finalDiffToGround) < minAngle)
{
this.handDeg_ = 270 + FloatMath.Sign(finalDiffToGround) * minAngle;
if (FloatMath.Abs(this.handDegVel_) > 2)
{
this.handDegVel_ *= -.5f;
}
else
{
this.handDegVel_ = 0;
}
}
// TODO: This line should theoretically not be here??
//this.handDeg_ += diffToHeld * liftFactor;
this.handDeg_ %= 360;
// TODO: Keep this value when the player lets go of the stick
this.handDis_ = 16 * secStickMag;
// TODO: Should be based on velocity instead.
// If lifting sword, sword angle lags behind.
//this.swordDeg_ = this.handDeg_;
var swordDegAccFac = 1 / (1 + MathF.Abs(this.handDegVel_));
this.swordDeg_ +=
TrigMath.DifferenceInDegrees(this.handDeg_, this.swordDeg_) * swordDegAccFac;
}
private void TickAnimation_(TickAnimationEvent _)
{
var xVel = this.playerRigidbody_.XVelocity;
var xVelSign = MathF.Sign(xVel);
if (xVelSign != 0)
{
this.xDir_ = xVelSign;
}
var isStanding = this.stateMachine_.State == PlayerState.STANDING;
var isWalking = this.stateMachine_.State == PlayerState.WALKING;
var isRealRunning = this.stateMachine_.State == PlayerState.RUNNING;
if (isStanding)
{
this.frameFraction_.Value += .01f;
}
if (isWalking)
{
var walkFraction = FloatMath.Abs(this.playerRigidbody_.XVelocity) /
PlayerConstants.UPRIGHT_MAX_SLOW_XSPD;
var animationSpeed = FloatMath.Max(.01f, .02f * walkFraction);
this.frameFraction_.Value += animationSpeed;
}
if (isRealRunning)
{
var runFraction = FloatMath.Abs(this.playerRigidbody_.XVelocity) /
PlayerConstants.UPRIGHT_MAX_FAST_XSPD;
var animationSpeed = FloatMath.Max(.01f, .04f * runFraction);
this.frameFraction_.Value += animationSpeed;
}
var frameFraction = this.frameFraction_.Value;
var frameAngle = this.frameFraction_.Value * 360;
var hipWidth = PlayerConstants.HSIZE * .6f;
var backHipWidth = .4f * hipWidth;
var frontHipWidth = hipWidth - backHipWidth;
if (isStanding)
{
this.hipCenter_.Transform.RelativeDeg = 0;
this.hipLeft_.Transform.Length = frontHipWidth;
this.hipRight_.Transform.Length = backHipWidth;
var leanAngle = this.OscillateAround_(15, 15, frameAngle);
this.upperLegLeft_.Transform.RelativeDeg = 90 + leanAngle;
this.upperLegRight_.Transform.RelativeDeg = -90 + leanAngle;
this.lowerLegLeft_.Transform.RelativeDeg = -leanAngle;
this.lowerLegRight_.Transform.RelativeDeg = -leanAngle;
}
if (isWalking)
{
var hipAngle = TrigMath.LenDegX(15, -20 + frameAngle);
this.hipCenter_.Transform.RelativeDeg = hipAngle;
this.hipLeft_.Transform.Length =
frontHipWidth * this.OscillateAround_(1, .5f, hipAngle + 180);
this.hipRight_.Transform.Length =
backHipWidth * this.OscillateAround_(1, .5f, hipAngle);
var upperLegRange = 20;
this.upperLegLeft_.Transform.RelativeDeg =
90 + TrigMath.LenDegX(upperLegRange / 2, frameAngle);
this.upperLegRight_.Transform.RelativeDeg =
-90 + TrigMath.LenDegX(upperLegRange / 2, frameAngle + 180);
var lowerLegAngle = -15 + frameAngle;
var lowerLegRange = 30;
this.lowerLegLeft_.Transform.RelativeDeg =
-lowerLegRange / 2 +
TrigMath.LenDegX(lowerLegRange / 2, lowerLegAngle);
this.lowerLegRight_.Transform.RelativeDeg =
-lowerLegRange / 2 +
TrigMath.LenDegX(lowerLegRange / 2, lowerLegAngle + 180);
}
if (isRealRunning)
{
var hipAngle = TrigMath.LenDegX(15, -45 + frameAngle);
this.hipCenter_.Transform.RelativeDeg = hipAngle;
this.hipLeft_.Transform.Length =
frontHipWidth * this.OscillateAround_(1, .5f, hipAngle + 180);
this.hipRight_.Transform.Length =
backHipWidth * this.OscillateAround_(1, .5f, hipAngle);
this.upperLegLeft_.Transform.RelativeDeg =
180 + this.CalcUpperBoneAngle_(frameFraction, false);
this.upperLegRight_.Transform.RelativeDeg =
this.CalcUpperBoneAngle_(frameFraction, true);
this.lowerLegLeft_.Transform.RelativeDeg =
this.CalcLowerBoneAngle_(frameFraction, false);
this.lowerLegRight_.Transform.RelativeDeg =
this.CalcLowerBoneAngle_(frameFraction, true);
}
// TODO: Should this happen automatically?
this.ForEachBone_(bone => bone.UpdateMatrices());
var leftHeight =
FloatMath.Abs(TrigMath.LenDegY(this.upperLegLeft_.Transform.Length,
this.upperLegLeft_.Transform
.GlobalDeg)) +
FloatMath.Abs(TrigMath.LenDegY(this.lowerLegLeft_.Transform.Length,
this.lowerLegLeft_.Transform
.GlobalDeg));
var rightHeight =
FloatMath.Abs(TrigMath.LenDegY(this.upperLegRight_.Transform.Length,
this.upperLegRight_.Transform
.GlobalDeg)) +
FloatMath.Abs(TrigMath.LenDegY(this.lowerLegRight_.Transform.Length,
this.lowerLegRight_.Transform
.GlobalDeg));
this.legHeight_ = FloatMath.Max(leftHeight, rightHeight);
}
