Skip to content

Instantly share code, notes, and snippets.

@alexguirre

alexguirre/EuphoriaMessages.cs

Last active November 9, 2017 17:16
Show Gist options
  • Save alexguirre/915f90002f44622e09dc5c793c18b3ef to your computer and use it in GitHub Desktop.
Save alexguirre/915f90002f44622e09dc5c793c18b3ef to your computer and use it in GitHub Desktop.
Download ZIP
Raw
EuphoriaMessages.cs
// Generated by GTA V Euphoria Behaviours Parser v1.2.0.0 by alexguirre
namespace Rage.Euphoria
{
using Rage;
using Rage.Euphoria;
using Rage.Attributes;
/// <summary>
///
/// </summary>
internal class EuphoriaMessageActivePose : EuphoriaMessage
{
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see notes for explanation)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
/// <summary>
/// Apply gravity compensation as well?
/// </summary>
[EuphoriaParameter(Name = "useGravityCompensation", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseGravityCompensation { get; set; } = default(bool);
/// <summary>
/// AnimSource 0 = CurrentItms, 1 = PreviousItms, 2 = AnimItms
/// </summary>
[EuphoriaParameter(Name = "animSource", Type = typeof(int), DefaultValue = default(int))]
public int AnimSource { get; set; } = default(int);
public EuphoriaMessageActivePose(bool startNow) : base("activePose", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageApplyImpulse : EuphoriaMessage
{
/// <summary>
/// 0 means straight impulse, 1 means multiply by the mass (change in velocity)
/// </summary>
[EuphoriaParameter(Name = "equalizeAmount", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float EqualizeAmount { get; set; } = 0.000f;
/// <summary>
/// index of part being hit. -1 apply impulse to COM.
/// </summary>
[EuphoriaParameter(Name = "partIndex", Type = typeof(int), DefaultValue = 0, MinimumValue = -1, MaximumValue = 28)]
public int PartIndex { get; set; } = 0;
/// <summary>
/// impulse vector (impulse is change in momentum)
/// </summary>
[EuphoriaParameter(Name = "impulse", Type = typeof(Vector3))]
public Vector3 Impulse { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// optional point on part where hit. If not supplied then the impulse is applied at the part centre.
/// </summary>
[EuphoriaParameter(Name = "hitPoint", Type = typeof(Vector3))]
public Vector3 HitPoint { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// hitPoint in local coordinates of bodyPart
/// </summary>
[EuphoriaParameter(Name = "localHitPointInfo", Type = typeof(bool), DefaultValue = default(bool))]
public bool LocalHitPointInfo { get; set; } = default(bool);
/// <summary>
/// impulse in local coordinates of bodyPart
/// </summary>
[EuphoriaParameter(Name = "localImpulseInfo", Type = typeof(bool), DefaultValue = default(bool))]
public bool LocalImpulseInfo { get; set; } = default(bool);
/// <summary>
/// impulse should be considered an angular impulse
/// </summary>
[EuphoriaParameter(Name = "angularImpulse", Type = typeof(bool), DefaultValue = default(bool))]
public bool AngularImpulse { get; set; } = default(bool);
public EuphoriaMessageApplyImpulse(bool startNow) : base("applyImpulse", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageApplyBulletImpulse : EuphoriaMessage
{
/// <summary>
/// 0 means straight impulse, 1 means multiply by the mass (change in velocity)
/// </summary>
[EuphoriaParameter(Name = "equalizeAmount", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float EqualizeAmount { get; set; } = 0.000f;
/// <summary>
/// index of part being hit.
/// </summary>
[EuphoriaParameter(Name = "partIndex", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 28)]
public int PartIndex { get; set; } = 0;
/// <summary>
/// impulse vector (impulse is change in momentum)
/// </summary>
[EuphoriaParameter(Name = "impulse", Type = typeof(Vector3))]
public Vector3 Impulse { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// optional point on part where hit
/// </summary>
[EuphoriaParameter(Name = "hitPoint", Type = typeof(Vector3))]
public Vector3 HitPoint { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// true = hitPoint is in local coordinates of bodyPart, false = hitpoint is in world coordinates
/// </summary>
[EuphoriaParameter(Name = "localHitPointInfo", Type = typeof(bool), DefaultValue = default(bool))]
public bool LocalHitPointInfo { get; set; } = default(bool);
/// <summary>
/// if not 0.0 then have an extra bullet applied to spine0 (approximates the COM). Uses setup from configureBulletsExtra. 0-1 shared 0.0 = no extra bullet, 0.5 = impulse split equally between extra and bullet, 1.0 only extra bullet. LT 0.0 then bullet + scaled extra bullet. Eg.-0.5 = bullet + 0.5 impulse extra bullet
/// </summary>
[EuphoriaParameter(Name = "extraShare", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -2.00f, MaximumValue = 1.00f)]
public float ExtraShare { get; set; } = 0.00f;
public EuphoriaMessageApplyBulletImpulse(bool startNow) : base("applyBulletImpulse", startNow)
{ }
}
/// <summary>
/// bodyRelax: Set the amount of relaxation across the whole body; Used to collapse the character into a rag-doll-like state.
/// </summary>
internal class EuphoriaMessageBodyRelax : EuphoriaMessage
{
/// <summary>
/// How relaxed the body becomes, in percentage relaxed. 100 being totally rag-dolled, 0 being very stiff and rigid.
/// </summary>
[EuphoriaParameter(Name = "relaxation", Type = typeof(float), DefaultValue = 50.000f, MinimumValue = 0.0f, MaximumValue = 100.0f)]
public float Relaxation { get; set; } = 50.000f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float Damping { get; set; } = 1.0f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
/// <summary>
/// automatically hold the current pose as the character relaxes - can be used to avoid relaxing into a t-pose
/// </summary>
[EuphoriaParameter(Name = "holdPose", Type = typeof(bool), DefaultValue = default(bool))]
public bool HoldPose { get; set; } = default(bool);
/// <summary>
/// sets the drive state to free - this reduces drifting on the ground
/// </summary>
[EuphoriaParameter(Name = "disableJointDriving", Type = typeof(bool), DefaultValue = default(bool))]
public bool DisableJointDriving { get; set; } = default(bool);
public EuphoriaMessageBodyRelax(bool startNow) : base("bodyRelax", startNow)
{ }
}
/// <summary>
/// configureBalance: This single message allows you to configure various parameters used on any behaviour that uses the dynamic balance.
/// </summary>
internal class EuphoriaMessageConfigureBalance : EuphoriaMessage
{
/// <summary>
/// maximum height that character steps vertically (above 0.2 is high...but ok for say underwater)
/// </summary>
[EuphoriaParameter(Name = "stepHeight", Type = typeof(float), DefaultValue = 0.100f, MinimumValue = 0.0f, MaximumValue = 0.40f)]
public float StepHeight { get; set; } = 0.100f;
/// <summary>
/// added to stepHeight if going up steps
/// </summary>
[EuphoriaParameter(Name = "stepHeightInc4Step", Type = typeof(float), DefaultValue = 0.100f, MinimumValue = 0.0f, MaximumValue = 0.40f)]
public float StepHeightInc4Step { get; set; } = 0.100f;
/// <summary>
/// if the legs end up more than (legsApartRestep + hipwidth) apart even though balanced, take another step
/// </summary>
[EuphoriaParameter(Name = "legsApartRestep", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = 0.0f, MaximumValue = 1.00f)]
public float LegsApartRestep { get; set; } = 0.200f;
/// <summary>
/// mmmm0.1 for drunk if the legs end up less than (hipwidth - legsTogetherRestep) apart even though balanced, take another step. A value of 1 will turn off this feature and the max value is hipWidth = 0.23f by default but is model dependent
/// </summary>
[EuphoriaParameter(Name = "legsTogetherRestep", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.00f)]
public float LegsTogetherRestep { get; set; } = 1.0f;
/// <summary>
/// FRICTION WORKAROUND: if the legs end up more than (legsApartMax + hipwidth) apart when balanced, adjust the feet positions to slide back so they are legsApartMax + hipwidth apart. Needs to be less than legsApartRestep to see any effect
/// </summary>
[EuphoriaParameter(Name = "legsApartMax", Type = typeof(float), DefaultValue = 2.000f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float LegsApartMax { get; set; } = 2.000f;
/// <summary>
/// does the knee strength reduce with angle
/// </summary>
[EuphoriaParameter(Name = "taperKneeStrength", Type = typeof(bool), DefaultValue = default(bool))]
public bool TaperKneeStrength { get; set; } = default(bool);
/// <summary>
/// stiffness of legs
/// </summary>
[EuphoriaParameter(Name = "legStiffness", Type = typeof(float), DefaultValue = 12.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float LegStiffness { get; set; } = 12.000f;
/// <summary>
/// damping of left leg during swing phase (mmmmDrunk used 1.25 to slow legs movement)
/// </summary>
[EuphoriaParameter(Name = "leftLegSwingDamping", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.20f, MaximumValue = 4.0f)]
public float LeftLegSwingDamping { get; set; } = 1.000f;
/// <summary>
/// damping of right leg during swing phase (mmmmDrunk used 1.25 to slow legs movement)
/// </summary>
[EuphoriaParameter(Name = "rightLegSwingDamping", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.20f, MaximumValue = 4.0f)]
public float RightLegSwingDamping { get; set; } = 1.000f;
/// <summary>
/// Gravity opposition applied to hips and knees
/// </summary>
[EuphoriaParameter(Name = "opposeGravityLegs", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.00f, MaximumValue = 4.0f)]
public float OpposeGravityLegs { get; set; } = 1.000f;
/// <summary>
/// Gravity opposition applied to ankles. General balancer likes 1.0. StaggerFall likes 0.1
/// </summary>
[EuphoriaParameter(Name = "opposeGravityAnkles", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.00f, MaximumValue = 4.0f)]
public float OpposeGravityAnkles { get; set; } = 1.000f;
/// <summary>
/// Multiplier on the floorAcceleration added to the lean
/// </summary>
[EuphoriaParameter(Name = "leanAcc", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LeanAcc { get; set; } = 0.00f;
/// <summary>
/// Multiplier on the floorAcceleration added to the leanHips
/// </summary>
[EuphoriaParameter(Name = "hipLeanAcc", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float HipLeanAcc { get; set; } = 0.50f;
/// <summary>
/// Max floorAcceleration allowed for lean and leanHips
/// </summary>
[EuphoriaParameter(Name = "leanAccMax", Type = typeof(float), DefaultValue = 5.000f, MinimumValue = 0.00f, MaximumValue = 10.0f)]
public float LeanAccMax { get; set; } = 5.000f;
/// <summary>
/// Level of cheat force added to character to resist the effect of floorAcceleration (anti-Acceleration) - added to upperbody.
/// </summary>
[EuphoriaParameter(Name = "resistAcc", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 2.0f)]
public float ResistAcc { get; set; } = 0.50f;
/// <summary>
/// Max floorAcceleration allowed for anti-Acceleration. If GT 20.0 then it is probably in a crash
/// </summary>
[EuphoriaParameter(Name = "resistAccMax", Type = typeof(float), DefaultValue = 3.00f, MinimumValue = 0.00f, MaximumValue = 20.0f)]
public float ResistAccMax { get; set; } = 3.00f;
/// <summary>
/// This parameter will be removed when footSlipCompensation preserves the foot angle on a moving floor]. If the character detects a moving floor and footSlipCompOnMovingFloor is false then it will turn off footSlipCompensation - at footSlipCompensation preserves the global heading of the feet. If footSlipCompensation is off then the character usually turns to the side in the end although when turning the vehicle turns it looks promising for a while
/// </summary>
[EuphoriaParameter(Name = "footSlipCompOnMovingFloor", Type = typeof(bool), DefaultValue = default(bool))]
public bool FootSlipCompOnMovingFloor { get; set; } = default(bool);
/// <summary>
/// ankle equilibrium angle used when static balancing
/// </summary>
[EuphoriaParameter(Name = "ankleEquilibrium", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = -1.00f, MaximumValue = 1.0f)]
public float AnkleEquilibrium { get; set; } = 0.000f;
/// <summary>
/// additional feet apart setting
/// </summary>
[EuphoriaParameter(Name = "extraFeetApart", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = -1.00f, MaximumValue = 1.0f)]
public float ExtraFeetApart { get; set; } = 0.000f;
/// <summary>
/// amount of time at the start of a balance before the character is allowed to start stepping
/// </summary>
[EuphoriaParameter(Name = "dontStepTime", Type = typeof(float), DefaultValue = 0.00f)]
public float DontStepTime { get; set; } = 0.00f;
/// <summary>
/// when the character gives up and goes into a fall. Larger values mean that the balancer can lean more before failing.
/// </summary>
[EuphoriaParameter(Name = "balanceAbortThreshold", Type = typeof(float), DefaultValue = 0.600f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float BalanceAbortThreshold { get; set; } = 0.600f;
/// <summary>
/// height between lowest foot and COM below which balancer will give up
/// </summary>
[EuphoriaParameter(Name = "giveUpHeight", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 1.50f)]
public float GiveUpHeight { get; set; } = 0.50f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "stepClampScale", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float StepClampScale { get; set; } = 1.000f;
/// <summary>
/// Variance in clamp scale every step. if negative only takes away from clampScale
/// </summary>
[EuphoriaParameter(Name = "stepClampScaleVariance", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float StepClampScaleVariance { get; set; } = 0.000f;
/// <summary>
/// amount of time (seconds) into the future that the character tries to move hip to (kind of). Will be controlled by balancer in future but can help recover spine quicker from bending forwards to much.
/// </summary>
[EuphoriaParameter(Name = "predictionTimeHip", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float PredictionTimeHip { get; set; } = 0.30f;
/// <summary>
/// amount of time (seconds) into the future that the character tries to step to. bigger values try to recover with fewer, bigger steps. smaller values recover with smaller steps, and generally recover less.
/// </summary>
[EuphoriaParameter(Name = "predictionTime", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float PredictionTime { get; set; } = 0.20f;
/// <summary>
/// Variance in predictionTime every step. if negative only takes away from predictionTime
/// </summary>
[EuphoriaParameter(Name = "predictionTimeVariance", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float PredictionTimeVariance { get; set; } = 0.00f;
/// <summary>
/// Maximum number of steps that the balancer will take.
/// </summary>
[EuphoriaParameter(Name = "maxSteps", Type = typeof(int), DefaultValue = 100)]
public int MaxSteps { get; set; } = 100;
/// <summary>
/// Maximum time(seconds) that the balancer will balance for.
/// </summary>
[EuphoriaParameter(Name = "maxBalanceTime", Type = typeof(float), DefaultValue = 50.0f)]
public float MaxBalanceTime { get; set; } = 50.0f;
/// <summary>
/// Allow the balancer to take this many more steps before hitting maxSteps. If negative nothing happens(safe default)
/// </summary>
[EuphoriaParameter(Name = "extraSteps", Type = typeof(int), DefaultValue = -1)]
public int ExtraSteps { get; set; } = -1;
/// <summary>
/// Allow the balancer to balance for this many more seconds before hitting maxBalanceTime. If negative nothing happens(safe default)
/// </summary>
[EuphoriaParameter(Name = "extraTime", Type = typeof(float), DefaultValue = -1.00f)]
public float ExtraTime { get; set; } = -1.00f;
/// <summary>
/// How to fall after maxSteps or maxBalanceTime: 0=rampDown stiffness, 1= 0 and dontChangeStep, 2= 0 and forceBalance, 3=0 and slump (BCR has to be active)
/// </summary>
[EuphoriaParameter(Name = "fallType", Type = typeof(int), DefaultValue = 0)]
public int FallType { get; set; } = 0;
/// <summary>
/// Multiply the rampDown of stiffness on falling by this amount ( GT 1 fall quicker)
/// </summary>
[EuphoriaParameter(Name = "fallMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 100.0f)]
public float FallMult { get; set; } = 1.0f;
/// <summary>
/// Reduce gravity compensation as the legs weaken on falling
/// </summary>
[EuphoriaParameter(Name = "fallReduceGravityComp", Type = typeof(bool), DefaultValue = default(bool))]
public bool FallReduceGravityComp { get; set; } = default(bool);
/// <summary>
/// bend over when falling after maxBalanceTime
/// </summary>
[EuphoriaParameter(Name = "rampHipPitchOnFail", Type = typeof(bool), DefaultValue = default(bool))]
public bool RampHipPitchOnFail { get; set; } = default(bool);
/// <summary>
/// Linear speed threshold for successful balance.
/// </summary>
[EuphoriaParameter(Name = "stableLinSpeedThresh", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.010f, MaximumValue = 10.0f)]
public float StableLinSpeedThresh { get; set; } = 0.250f;
/// <summary>
/// Rotational speed threshold for successful balance.
/// </summary>
[EuphoriaParameter(Name = "stableRotSpeedThresh", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.010f, MaximumValue = 10.0f)]
public float StableRotSpeedThresh { get; set; } = 0.250f;
/// <summary>
/// The upper body of the character must be colliding and other failure conditions met to fail
/// </summary>
[EuphoriaParameter(Name = "failMustCollide", Type = typeof(bool), DefaultValue = default(bool))]
public bool FailMustCollide { get; set; } = default(bool);
/// <summary>
/// Ignore maxSteps and maxBalanceTime and try to balance forever
/// </summary>
[EuphoriaParameter(Name = "ignoreFailure", Type = typeof(bool), DefaultValue = default(bool))]
public bool IgnoreFailure { get; set; } = default(bool);
/// <summary>
/// time not in contact (airborne) before step is changed. If -ve don't change step
/// </summary>
[EuphoriaParameter(Name = "changeStepTime", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.0f, MaximumValue = 5.0f)]
public float ChangeStepTime { get; set; } = -1.00f;
/// <summary>
/// Ignore maxSteps and maxBalanceTime and try to balance forever
/// </summary>
[EuphoriaParameter(Name = "balanceIndefinitely", Type = typeof(bool), DefaultValue = default(bool))]
public bool BalanceIndefinitely { get; set; } = default(bool);
/// <summary>
/// temporary variable to ignore movingFloor code that generally causes the character to fall over if the feet probe a moving object e.g. treading on a gun
/// </summary>
[EuphoriaParameter(Name = "movingFloor", Type = typeof(bool), DefaultValue = default(bool))]
public bool MovingFloor { get; set; } = default(bool);
/// <summary>
/// when airborne try to step. Set to false for e.g. shotGun reaction
/// </summary>
[EuphoriaParameter(Name = "airborneStep", Type = typeof(bool), DefaultValue = default(bool))]
public bool AirborneStep { get; set; } = default(bool);
/// <summary>
/// Velocity below which the balancer turns in the direction of the COM forward instead of the ComVel - for use with shot from running with high upright constraint use 1.9
/// </summary>
[EuphoriaParameter(Name = "useComDirTurnVelThresh", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float UseComDirTurnVelThresh { get; set; } = 0.0f;
/// <summary>
/// Minimum knee angle (-ve value will mean this functionality is not applied). 0.4 seems a good value
/// </summary>
[EuphoriaParameter(Name = "minKneeAngle", Type = typeof(float), DefaultValue = -0.50f, MinimumValue = -0.50f, MaximumValue = 1.50f)]
public float MinKneeAngle { get; set; } = -0.50f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "flatterSwingFeet", Type = typeof(bool), DefaultValue = default(bool))]
public bool FlatterSwingFeet { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "flatterStaticFeet", Type = typeof(bool), DefaultValue = default(bool))]
public bool FlatterStaticFeet { get; set; } = default(bool);
/// <summary>
/// If true then balancer tries to avoid leg2leg collisions/avoid crossing legs. Avoid tries to not step across a line of the inside of the stance leg's foot
/// </summary>
[EuphoriaParameter(Name = "avoidLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool AvoidLeg { get; set; } = default(bool);
/// <summary>
/// NB. Very sensitive. Avoid tries to not step across a line of the inside of the stance leg's foot. avoidFootWidth = how much inwards from the ankle this line is in (m).
/// </summary>
[EuphoriaParameter(Name = "avoidFootWidth", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float AvoidFootWidth { get; set; } = 0.10f;
/// <summary>
/// NB. Very sensitive. Avoid tries to not step across a line of the inside of the stance leg's foot. Avoid doesn't allow the desired stepping foot to cross the line. avoidFeedback = how much of the actual crossing of that line is fedback as an error.
/// </summary>
[EuphoriaParameter(Name = "avoidFeedback", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 2.0f)]
public float AvoidFeedback { get; set; } = 0.60f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "leanAgainstVelocity", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float LeanAgainstVelocity { get; set; } = 0.0f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "stepDecisionThreshold", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float StepDecisionThreshold { get; set; } = 0.0f;
/// <summary>
/// The balancer sometimes decides to step even if balanced
/// </summary>
[EuphoriaParameter(Name = "stepIfInSupport", Type = typeof(bool), DefaultValue = default(bool))]
public bool StepIfInSupport { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "alwaysStepWithFarthest", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysStepWithFarthest { get; set; } = default(bool);
/// <summary>
/// standup more with increased velocity
/// </summary>
[EuphoriaParameter(Name = "standUp", Type = typeof(bool), DefaultValue = default(bool))]
public bool StandUp { get; set; } = default(bool);
/// <summary>
/// Supposed to increase foot friction: Impact depth of a collision with the foot is changed when the balancer is running - impact.SetDepth(impact.GetDepth() - depthFudge)
/// </summary>
[EuphoriaParameter(Name = "depthFudge", Type = typeof(float), DefaultValue = 0.010f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float DepthFudge { get; set; } = 0.010f;
/// <summary>
/// Supposed to increase foot friction: Impact depth of a collision with the foot is changed when staggerFall is running - impact.SetDepth(impact.GetDepth() - depthFudgeStagger)
/// </summary>
[EuphoriaParameter(Name = "depthFudgeStagger", Type = typeof(float), DefaultValue = 0.010f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float DepthFudgeStagger { get; set; } = 0.010f;
/// <summary>
/// Foot friction multiplier is multiplied by this amount if balancer is running
/// </summary>
[EuphoriaParameter(Name = "footFriction", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.00f, MaximumValue = 40.0f)]
public float FootFriction { get; set; } = 1.0f;
/// <summary>
/// Foot friction multiplier is multiplied by this amount if staggerFall is running
/// </summary>
[EuphoriaParameter(Name = "footFrictionStagger", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.00f, MaximumValue = 40.0f)]
public float FootFrictionStagger { get; set; } = 1.0f;
/// <summary>
/// Backwards lean threshold to cut off stay upright forces. 0.0 Vertical - 1.0 horizontal. 0.6 is a sensible value. NB: the balancer does not fail in order to give stagger that extra step as it falls. A backwards lean of GT 0.6 will generally mean the balancer will soon fail without stayUpright forces.
/// </summary>
[EuphoriaParameter(Name = "backwardsLeanCutoff", Type = typeof(float), DefaultValue = 1.10f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float BackwardsLeanCutoff { get; set; } = 1.10f;
/// <summary>
/// if this value is different from giveUpHeight, actual giveUpHeight will be ramped toward this value
/// </summary>
[EuphoriaParameter(Name = "giveUpHeightEnd", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.50f)]
public float GiveUpHeightEnd { get; set; } = 0.50f;
/// <summary>
/// if this value is different from balanceAbortThreshold, actual balanceAbortThreshold will be ramped toward this value
/// </summary>
[EuphoriaParameter(Name = "balanceAbortThresholdEnd", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float BalanceAbortThresholdEnd { get; set; } = 0.60f;
/// <summary>
/// duration of ramp from start of behaviour for above two parameters. If smaller than 0, no ramp is applied
/// </summary>
[EuphoriaParameter(Name = "giveUpRampDuration", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 10.0f)]
public float GiveUpRampDuration { get; set; } = -1.00f;
/// <summary>
/// lean at which to send abort message when maxSteps or maxBalanceTime is reached
/// </summary>
[EuphoriaParameter(Name = "leanToAbort", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LeanToAbort { get; set; } = 0.60f;
public EuphoriaMessageConfigureBalance(bool startNow) : base("configureBalance", startNow)
{ }
}
/// <summary>
/// configureBalanceReset: reset the values configurable by the Configure Balance message to their defaults.
/// </summary>
internal class EuphoriaMessageConfigureBalanceReset : EuphoriaMessage
{
public EuphoriaMessageConfigureBalanceReset(bool startNow) : base("configureBalanceReset", startNow)
{ }
}
/// <summary>
/// configureSelfAvoidance: this single message allows to configure self avoidance for the character.BBDD Self avoidance tech.
/// </summary>
internal class EuphoriaMessageConfigureSelfAvoidance : EuphoriaMessage
{
/// <summary>
/// Enable or disable self avoidance tech.
/// </summary>
[EuphoriaParameter(Name = "useSelfAvoidance", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseSelfAvoidance { get; set; } = default(bool);
/// <summary>
/// Specify whether self avoidance tech should use original IK input target or the target that has been already modified by getStabilisedPos() tech i.e. function that compensates for rotational and linear velocity of shoulder/thigh.
/// </summary>
[EuphoriaParameter(Name = "overwriteDragReduction", Type = typeof(bool), DefaultValue = default(bool))]
public bool OverwriteDragReduction { get; set; } = default(bool);
/// <summary>
/// Place the adjusted target this much along the arc between effector (wrist) and target, value in range [0,1].
/// </summary>
[EuphoriaParameter(Name = "torsoSwingFraction", Type = typeof(float), DefaultValue = 0.750f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorsoSwingFraction { get; set; } = 0.750f;
/// <summary>
/// Max value on the effector (wrist) to adjusted target offset.
/// </summary>
[EuphoriaParameter(Name = "maxTorsoSwingAngleRad", Type = typeof(float), DefaultValue = 0.7580f, MinimumValue = 0.00f, MaximumValue = 1.570f)]
public float MaxTorsoSwingAngleRad { get; set; } = 0.7580f;
/// <summary>
/// Restrict self avoidance to operate on targets that are within character torso bounds only.
/// </summary>
[EuphoriaParameter(Name = "selfAvoidIfInSpineBoundsOnly", Type = typeof(bool), DefaultValue = default(bool))]
public bool SelfAvoidIfInSpineBoundsOnly { get; set; } = default(bool);
/// <summary>
/// Amount of self avoidance offset applied when angle from effector (wrist) to target is greater then right angle i.e. when total offset is a blend between where effector currently is to value that is a product of total arm length and selfAvoidAmount. SelfAvoidAmount is in a range between [0, 1].
/// </summary>
[EuphoriaParameter(Name = "selfAvoidAmount", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float SelfAvoidAmount { get; set; } = 0.50f;
/// <summary>
/// Overwrite desired IK twist with self avoidance procedural twist.
/// </summary>
[EuphoriaParameter(Name = "overwriteTwist", Type = typeof(bool), DefaultValue = default(bool))]
public bool OverwriteTwist { get; set; } = default(bool);
/// <summary>
/// Use the alternative self avoidance algorithm that is based on linear and polar target blending. WARNING: It only requires "radius" in terms of parametrization.
/// </summary>
[EuphoriaParameter(Name = "usePolarPathAlgorithm", Type = typeof(bool), DefaultValue = default(bool))]
public bool UsePolarPathAlgorithm { get; set; } = default(bool);
/// <summary>
/// Self avoidance radius, measured out from the spine axis along the plane perpendicular to that axis. The closer is the proximity of reaching target to that radius, the more polar (curved) motion is used for offsetting the target. WARNING: Parameter only used by the alternative algorithm that is based on linear and polar target blending.
/// </summary>
[EuphoriaParameter(Name = "radius", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Radius { get; set; } = 0.30f;
public EuphoriaMessageConfigureSelfAvoidance(bool startNow) : base("configureSelfAvoidance", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageConfigureBullets : EuphoriaMessage
{
/// <summary>
/// spreads impulse across parts. currently only for spine parts, not limbs.
/// </summary>
[EuphoriaParameter(Name = "impulseSpreadOverParts", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseSpreadOverParts { get; set; } = default(bool);
/// <summary>
/// for weaker characters subsequent impulses remain strong
/// </summary>
[EuphoriaParameter(Name = "impulseLeakageStrengthScaled", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseLeakageStrengthScaled { get; set; } = default(bool);
/// <summary>
/// duration that impulse is spread over (triangular shaped)
/// </summary>
[EuphoriaParameter(Name = "impulsePeriod", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulsePeriod { get; set; } = 0.10f;
/// <summary>
/// An impulse applied at a point on a body equivalent to an impulse at the centre of the body and a torque. This parameter scales the torque component. (The torque component seems to be excite the rage looseness bug which sends the character in a sometimes wildly different direction to an applied impulse)
/// </summary>
[EuphoriaParameter(Name = "impulseTorqueScale", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseTorqueScale { get; set; } = 1.00f;
/// <summary>
/// Fix the rage looseness bug by applying only the impulse at the centre of the body unless it is a spine part then apply the twist component only of the torque as well.
/// </summary>
[EuphoriaParameter(Name = "loosenessFix", Type = typeof(bool), DefaultValue = default(bool))]
public bool LoosenessFix { get; set; } = default(bool);
/// <summary>
/// time from hit before impulses are being applied
/// </summary>
[EuphoriaParameter(Name = "impulseDelay", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseDelay { get; set; } = 0.00f;
/// <summary>
/// by how much are subsequent impulses reduced (e.g. 0.0: no reduction, 0.1: 10% reduction each new hit)
/// </summary>
[EuphoriaParameter(Name = "impulseReductionPerShot", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseReductionPerShot { get; set; } = 0.00f;
/// <summary>
/// recovery rate of impulse strength per second (impulse strength from 0.0:1.0). At 60fps a impulseRecovery=60.0 will recover in 1 frame
/// </summary>
[EuphoriaParameter(Name = "impulseRecovery", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 60.00f)]
public float ImpulseRecovery { get; set; } = 0.00f;
/// <summary>
/// the minimum amount of impulse leakage allowed
/// </summary>
[EuphoriaParameter(Name = "impulseMinLeakage", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseMinLeakage { get; set; } = 0.20f;
/// <summary>
/// 0: Disabled | 1: character strength proportional (can reduce impulse amount) | 2: Additive (no reduction of impulse and not proportional to character strength)
/// </summary>
[EuphoriaParameter(Name = "torqueMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int TorqueMode { get; set; } = 0;
/// <summary>
/// 0: spin direction from impulse direction | 1: random direction | 2: direction flipped with each bullet (for burst effect)
/// </summary>
[EuphoriaParameter(Name = "torqueSpinMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int TorqueSpinMode { get; set; } = 0;
/// <summary>
/// 0: apply torque for every bullet | 1: only apply new torque if previous has finished | 2: Only apply new torque if its spin direction is different from previous torque
/// </summary>
[EuphoriaParameter(Name = "torqueFilterMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int TorqueFilterMode { get; set; } = 0;
/// <summary>
/// always apply torques to spine3 instead of actual part hit
/// </summary>
[EuphoriaParameter(Name = "torqueAlwaysSpine3", Type = typeof(bool), DefaultValue = default(bool))]
public bool TorqueAlwaysSpine3 { get; set; } = default(bool);
/// <summary>
/// time from hit before torques are being applied
/// </summary>
[EuphoriaParameter(Name = "torqueDelay", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorqueDelay { get; set; } = 0.00f;
/// <summary>
/// duration of torque
/// </summary>
[EuphoriaParameter(Name = "torquePeriod", Type = typeof(float), DefaultValue = 0.120f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorquePeriod { get; set; } = 0.120f;
/// <summary>
/// multiplies impulse magnitude to arrive at torque that is applied
/// </summary>
[EuphoriaParameter(Name = "torqueGain", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TorqueGain { get; set; } = 4.00f;
/// <summary>
/// minimum ratio of impulse that remains after converting to torque (if in strength-proportional mode)
/// </summary>
[EuphoriaParameter(Name = "torqueCutoff", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorqueCutoff { get; set; } = 0.00f;
/// <summary>
/// ratio of torque for next tick (e.g. 1.0: not reducing over time, 0.9: each tick torque is reduced by 10%)
/// </summary>
[EuphoriaParameter(Name = "torqueReductionPerTick", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorqueReductionPerTick { get; set; } = 0.00f;
/// <summary>
/// amount of lift (directly multiplies torque axis to give lift force)
/// </summary>
[EuphoriaParameter(Name = "liftGain", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LiftGain { get; set; } = 0.00f;
/// <summary>
/// time after impulse is applied that counter impulse is applied
/// </summary>
[EuphoriaParameter(Name = "counterImpulseDelay", Type = typeof(float), DefaultValue = 0.033330f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CounterImpulseDelay { get; set; } = 0.033330f;
/// <summary>
/// amount of the original impulse that is countered
/// </summary>
[EuphoriaParameter(Name = "counterImpulseMag", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CounterImpulseMag { get; set; } = 0.50f;
/// <summary>
/// applies the counter impulse counterImpulseDelay(secs) after counterImpulseMag of the Impulse has been applied
/// </summary>
[EuphoriaParameter(Name = "counterAfterMagReached", Type = typeof(bool), DefaultValue = default(bool))]
public bool CounterAfterMagReached { get; set; } = default(bool);
/// <summary>
/// add a counter impulse to the pelvis
/// </summary>
[EuphoriaParameter(Name = "doCounterImpulse", Type = typeof(bool), DefaultValue = default(bool))]
public bool DoCounterImpulse { get; set; } = default(bool);
/// <summary>
/// amount of the counter impulse applied to hips - the rest is applied to the part originally hit
/// </summary>
[EuphoriaParameter(Name = "counterImpulse2Hips", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CounterImpulse2Hips { get; set; } = 1.00f;
/// <summary>
/// amount to scale impulse by if the dynamicBalance is not OK. 1.0 means this functionality is not applied.
/// </summary>
[EuphoriaParameter(Name = "impulseNoBalMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseNoBalMult { get; set; } = 1.00f;
/// <summary>
/// 100% LE Start to impulseBalStabMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseBalStabStart", Type = typeof(float), DefaultValue = 3.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseBalStabStart { get; set; } = 3.00f;
/// <summary>
/// 100% LE Start to impulseBalStabMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseBalStabEnd", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseBalStabEnd { get; set; } = 10.00f;
/// <summary>
/// 100% LE Start to impulseBalStabMult*100% GT End. NB: leaving this as 1.0 means this functionality is not applied and Start and End have no effect.
/// </summary>
[EuphoriaParameter(Name = "impulseBalStabMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseBalStabMult { get; set; } = 1.00f;
/// <summary>
/// 100% GE Start to impulseSpineAngMult*100% LT End. NB: Start GT End. This the dot of hip2Head with up.
/// </summary>
[EuphoriaParameter(Name = "impulseSpineAngStart", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float ImpulseSpineAngStart { get; set; } = 0.70f;
/// <summary>
/// 100% GE Start to impulseSpineAngMult*100% LT End. NB: Start GT End. This the dot of hip2Head with up.
/// </summary>
[EuphoriaParameter(Name = "impulseSpineAngEnd", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float ImpulseSpineAngEnd { get; set; } = 0.20f;
/// <summary>
/// 100% GE Start to impulseSpineAngMult*100% LT End. NB: leaving this as 1.0 means this functionality is not applied and Start and End have no effect.
/// </summary>
[EuphoriaParameter(Name = "impulseSpineAngMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseSpineAngMult { get; set; } = 1.00f;
/// <summary>
/// 100% LE Start to impulseVelMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseVelStart", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseVelStart { get; set; } = 1.00f;
/// <summary>
/// 100% LE Start to impulseVelMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseVelEnd", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseVelEnd { get; set; } = 4.00f;
/// <summary>
/// 100% LE Start to impulseVelMult*100% GT End. NB: leaving this as 1.0 means this functionality is not applied and Start and End have no effect.
/// </summary>
[EuphoriaParameter(Name = "impulseVelMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseVelMult { get; set; } = 1.00f;
/// <summary>
/// amount to scale impulse by if the character is airborne and dynamicBalance is OK and impulse is above impulseAirMultStart
/// </summary>
[EuphoriaParameter(Name = "impulseAirMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseAirMult { get; set; } = 1.00f;
/// <summary>
/// if impulse is above this value scale it by impulseAirMult
/// </summary>
[EuphoriaParameter(Name = "impulseAirMultStart", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseAirMultStart { get; set; } = 100.0f;
/// <summary>
/// amount to clamp impulse to if character is airborne and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseAirMax", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseAirMax { get; set; } = 100.0f;
/// <summary>
/// if impulse is above this amount then do not scale/clamp just let it through as is - it's a shotgun or cannon
/// </summary>
[EuphoriaParameter(Name = "impulseAirApplyAbove", Type = typeof(float), DefaultValue = 399.0f)]
public float ImpulseAirApplyAbove { get; set; } = 399.0f;
/// <summary>
/// scale and/or clamp impulse if the character is airborne and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseAirOn", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseAirOn { get; set; } = default(bool);
/// <summary>
/// amount to scale impulse by if the character is contacting with one foot only and dynamicBalance is OK and impulse is above impulseAirMultStart
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseOneLegMult { get; set; } = 1.00f;
/// <summary>
/// if impulse is above this value scale it by impulseOneLegMult
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegMultStart", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseOneLegMultStart { get; set; } = 100.0f;
/// <summary>
/// amount to clamp impulse to if character is contacting with one foot only and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegMax", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseOneLegMax { get; set; } = 100.0f;
/// <summary>
/// if impulse is above this amount then do not scale/clamp just let it through as is - it's a shotgun or cannon
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegApplyAbove", Type = typeof(float), DefaultValue = 399.0f)]
public float ImpulseOneLegApplyAbove { get; set; } = 399.0f;
/// <summary>
/// scale and/or clamp impulse if the character is contacting with one leg only and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegOn", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseOneLegOn { get; set; } = default(bool);
/// <summary>
/// 0.0 no rigidBody response, 0.5 half partForce half rigidBody, 1.0 = no partForce full rigidBody
/// </summary>
[EuphoriaParameter(Name = "rbRatio", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbRatio { get; set; } = 0.000f;
/// <summary>
/// rigid body response is shared between the upper and lower body (rbUpperShare = 1-rbLowerShare). rbLowerShare=0.5 gives upper and lower share scaled by mass. i.e. if 70% ub mass and 30% lower mass then rbLowerShare=0.5 gives actualrbShare of 0.7ub and 0.3lb. rbLowerShare GT 0.5 scales the ub share down from 0.7 and the lb up from 0.3.
/// </summary>
[EuphoriaParameter(Name = "rbLowerShare", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbLowerShare { get; set; } = 0.50f;
/// <summary>
/// 0.0 only force, 0.5 = force and half the rigid body moment applied, 1.0 = force and full rigidBody moment
/// </summary>
[EuphoriaParameter(Name = "rbMoment", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbMoment { get; set; } = 1.000f;
/// <summary>
/// Maximum twist arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxTwistMomentArm", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxTwistMomentArm { get; set; } = 0.50f;
/// <summary>
/// Maximum broom((everything but the twist) arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxBroomMomentArm", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxBroomMomentArm { get; set; } = 1.00f;
/// <summary>
/// if Airborne: 0.0 no rigidBody response, 0.5 half partForce half rigidBody, 1.0 = no partForce full rigidBody
/// </summary>
[EuphoriaParameter(Name = "rbRatioAirborne", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbRatioAirborne { get; set; } = 0.000f;
/// <summary>
/// if Airborne: 0.0 only force, 0.5 = force and half the rigid body moment applied, 1.0 = force and full rigidBody moment
/// </summary>
[EuphoriaParameter(Name = "rbMomentAirborne", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbMomentAirborne { get; set; } = 1.000f;
/// <summary>
/// if Airborne: Maximum twist arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxTwistMomentArmAirborne", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxTwistMomentArmAirborne { get; set; } = 0.50f;
/// <summary>
/// if Airborne: Maximum broom((everything but the twist) arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxBroomMomentArmAirborne", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxBroomMomentArmAirborne { get; set; } = 1.00f;
/// <summary>
/// if only one leg in contact: 0.0 no rigidBody response, 0.5 half partForce half rigidBody, 1.0 = no partForce full rigidBody
/// </summary>
[EuphoriaParameter(Name = "rbRatioOneLeg", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbRatioOneLeg { get; set; } = 0.000f;
/// <summary>
/// if only one leg in contact: 0.0 only force, 0.5 = force and half the rigid body moment applied, 1.0 = force and full rigidBody moment
/// </summary>
[EuphoriaParameter(Name = "rbMomentOneLeg", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbMomentOneLeg { get; set; } = 1.000f;
/// <summary>
/// if only one leg in contact: Maximum twist arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxTwistMomentArmOneLeg", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxTwistMomentArmOneLeg { get; set; } = 0.50f;
/// <summary>
/// if only one leg in contact: Maximum broom((everything but the twist) arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxBroomMomentArmOneLeg", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxBroomMomentArmOneLeg { get; set; } = 1.00f;
/// <summary>
/// Twist axis 0=World Up, 1=CharacterCOM up
/// </summary>
[EuphoriaParameter(Name = "rbTwistAxis", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 1)]
public int RbTwistAxis { get; set; } = 0;
/// <summary>
/// if false pivot around COM always, if true change pivot depending on foot contact: to feet centre if both feet in contact, or foot position if 1 foot in contact or COM position if no feet in contact
/// </summary>
[EuphoriaParameter(Name = "rbPivot", Type = typeof(bool), DefaultValue = default(bool))]
public bool RbPivot { get; set; } = default(bool);
public EuphoriaMessageConfigureBullets(bool startNow) : base("configureBullets", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageConfigureBulletsExtra : EuphoriaMessage
{
/// <summary>
/// spreads impulse across parts. currently only for spine parts, not limbs.
/// </summary>
[EuphoriaParameter(Name = "impulseSpreadOverParts", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseSpreadOverParts { get; set; } = default(bool);
/// <summary>
/// duration that impulse is spread over (triangular shaped)
/// </summary>
[EuphoriaParameter(Name = "impulsePeriod", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulsePeriod { get; set; } = 0.10f;
/// <summary>
/// An impulse applied at a point on a body equivalent to an impulse at the centre of the body and a torque. This parameter scales the torque component. (The torque component seems to be excite the rage looseness bug which sends the character in a sometimes wildly different direction to an applied impulse)
/// </summary>
[EuphoriaParameter(Name = "impulseTorqueScale", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseTorqueScale { get; set; } = 1.00f;
/// <summary>
/// Fix the rage looseness bug by applying only the impulse at the centre of the body unless it is a spine part then apply the twist component only of the torque as well.
/// </summary>
[EuphoriaParameter(Name = "loosenessFix", Type = typeof(bool), DefaultValue = default(bool))]
public bool LoosenessFix { get; set; } = default(bool);
/// <summary>
/// time from hit before impulses are being applied
/// </summary>
[EuphoriaParameter(Name = "impulseDelay", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseDelay { get; set; } = 0.00f;
/// <summary>
/// 0: Disabled | 1: character strength proportional (can reduce impulse amount) | 2: Additive (no reduction of impulse and not proportional to character strength)
/// </summary>
[EuphoriaParameter(Name = "torqueMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int TorqueMode { get; set; } = 0;
/// <summary>
/// 0: spin direction from impulse direction | 1: random direction | 2: direction flipped with each bullet (for burst effect)
/// </summary>
[EuphoriaParameter(Name = "torqueSpinMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int TorqueSpinMode { get; set; } = 0;
/// <summary>
/// 0: apply torque for every bullet | 1: only apply new torque if previous has finished | 2: Only apply new torque if its spin direction is different from previous torque
/// </summary>
[EuphoriaParameter(Name = "torqueFilterMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int TorqueFilterMode { get; set; } = 0;
/// <summary>
/// always apply torques to spine3 instead of actual part hit
/// </summary>
[EuphoriaParameter(Name = "torqueAlwaysSpine3", Type = typeof(bool), DefaultValue = default(bool))]
public bool TorqueAlwaysSpine3 { get; set; } = default(bool);
/// <summary>
/// time from hit before torques are being applied
/// </summary>
[EuphoriaParameter(Name = "torqueDelay", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorqueDelay { get; set; } = 0.00f;
/// <summary>
/// duration of torque
/// </summary>
[EuphoriaParameter(Name = "torquePeriod", Type = typeof(float), DefaultValue = 0.120f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorquePeriod { get; set; } = 0.120f;
/// <summary>
/// multiplies impulse magnitude to arrive at torque that is applied
/// </summary>
[EuphoriaParameter(Name = "torqueGain", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TorqueGain { get; set; } = 4.00f;
/// <summary>
/// minimum ratio of impulse that remains after converting to torque (if in strength-proportional mode)
/// </summary>
[EuphoriaParameter(Name = "torqueCutoff", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorqueCutoff { get; set; } = 0.00f;
/// <summary>
/// ratio of torque for next tick (e.g. 1.0: not reducing over time, 0.9: each tick torque is reduced by 10%)
/// </summary>
[EuphoriaParameter(Name = "torqueReductionPerTick", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TorqueReductionPerTick { get; set; } = 0.00f;
/// <summary>
/// amount of lift (directly multiplies torque axis to give lift force)
/// </summary>
[EuphoriaParameter(Name = "liftGain", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LiftGain { get; set; } = 0.00f;
/// <summary>
/// time after impulse is applied that counter impulse is applied
/// </summary>
[EuphoriaParameter(Name = "counterImpulseDelay", Type = typeof(float), DefaultValue = 0.033330f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CounterImpulseDelay { get; set; } = 0.033330f;
/// <summary>
/// amount of the original impulse that is countered
/// </summary>
[EuphoriaParameter(Name = "counterImpulseMag", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CounterImpulseMag { get; set; } = 0.50f;
/// <summary>
/// applies the counter impulse counterImpulseDelay(secs) after counterImpulseMag of the Impulse has been applied
/// </summary>
[EuphoriaParameter(Name = "counterAfterMagReached", Type = typeof(bool), DefaultValue = default(bool))]
public bool CounterAfterMagReached { get; set; } = default(bool);
/// <summary>
/// add a counter impulse to the pelvis
/// </summary>
[EuphoriaParameter(Name = "doCounterImpulse", Type = typeof(bool), DefaultValue = default(bool))]
public bool DoCounterImpulse { get; set; } = default(bool);
/// <summary>
/// amount of the counter impulse applied to hips - the rest is applied to the part originally hit
/// </summary>
[EuphoriaParameter(Name = "counterImpulse2Hips", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CounterImpulse2Hips { get; set; } = 1.00f;
/// <summary>
/// amount to scale impulse by if the dynamicBalance is not OK. 1.0 means this functionality is not applied.
/// </summary>
[EuphoriaParameter(Name = "impulseNoBalMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseNoBalMult { get; set; } = 1.00f;
/// <summary>
/// 100% LE Start to impulseBalStabMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseBalStabStart", Type = typeof(float), DefaultValue = 3.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseBalStabStart { get; set; } = 3.00f;
/// <summary>
/// 100% LE Start to impulseBalStabMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseBalStabEnd", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseBalStabEnd { get; set; } = 10.00f;
/// <summary>
/// 100% LE Start to impulseBalStabMult*100% GT End. NB: leaving this as 1.0 means this functionality is not applied and Start and End have no effect.
/// </summary>
[EuphoriaParameter(Name = "impulseBalStabMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseBalStabMult { get; set; } = 1.00f;
/// <summary>
/// 100% GE Start to impulseSpineAngMult*100% LT End. NB: Start GT End. This the dot of hip2Head with up.
/// </summary>
[EuphoriaParameter(Name = "impulseSpineAngStart", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float ImpulseSpineAngStart { get; set; } = 0.70f;
/// <summary>
/// 100% GE Start to impulseSpineAngMult*100% LT End. NB: Start GT End. This the dot of hip2Head with up.
/// </summary>
[EuphoriaParameter(Name = "impulseSpineAngEnd", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float ImpulseSpineAngEnd { get; set; } = 0.20f;
/// <summary>
/// 100% GE Start to impulseSpineAngMult*100% LT End. NB: leaving this as 1.0 means this functionality is not applied and Start and End have no effect.
/// </summary>
[EuphoriaParameter(Name = "impulseSpineAngMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseSpineAngMult { get; set; } = 1.00f;
/// <summary>
/// 100% LE Start to impulseVelMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseVelStart", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseVelStart { get; set; } = 4.00f;
/// <summary>
/// 100% LE Start to impulseVelMult*100% GT End. NB: Start LT End
/// </summary>
[EuphoriaParameter(Name = "impulseVelEnd", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float ImpulseVelEnd { get; set; } = 4.00f;
/// <summary>
/// 100% LE Start to impulseVelMult*100% GT End. NB: leaving this as 1.0 means this functionality is not applied and Start and End have no effect.
/// </summary>
[EuphoriaParameter(Name = "impulseVelMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseVelMult { get; set; } = 1.00f;
/// <summary>
/// amount to scale impulse by if the character is airborne and dynamicBalance is OK and impulse is above impulseAirMultStart
/// </summary>
[EuphoriaParameter(Name = "impulseAirMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseAirMult { get; set; } = 1.00f;
/// <summary>
/// if impulse is above this value scale it by impulseAirMult
/// </summary>
[EuphoriaParameter(Name = "impulseAirMultStart", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseAirMultStart { get; set; } = 100.0f;
/// <summary>
/// amount to clamp impulse to if character is airborne and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseAirMax", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseAirMax { get; set; } = 100.0f;
/// <summary>
/// if impulse is above this amount then do not scale/clamp just let it through as is - it's a shotgun or cannon
/// </summary>
[EuphoriaParameter(Name = "impulseAirApplyAbove", Type = typeof(float), DefaultValue = 399.0f)]
public float ImpulseAirApplyAbove { get; set; } = 399.0f;
/// <summary>
/// scale and/or clamp impulse if the character is airborne and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseAirOn", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseAirOn { get; set; } = default(bool);
/// <summary>
/// amount to scale impulse by if the character is contacting with one foot only and dynamicBalance is OK and impulse is above impulseAirMultStart
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpulseOneLegMult { get; set; } = 1.00f;
/// <summary>
/// if impulse is above this value scale it by impulseOneLegMult
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegMultStart", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseOneLegMultStart { get; set; } = 100.0f;
/// <summary>
/// amount to clamp impulse to if character is contacting with one foot only and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegMax", Type = typeof(float), DefaultValue = 100.0f)]
public float ImpulseOneLegMax { get; set; } = 100.0f;
/// <summary>
/// if impulse is above this amount then do not scale/clamp just let it through as is - it's a shotgun or cannon
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegApplyAbove", Type = typeof(float), DefaultValue = 399.0f)]
public float ImpulseOneLegApplyAbove { get; set; } = 399.0f;
/// <summary>
/// scale and/or clamp impulse if the character is contacting with one leg only and dynamicBalance is OK
/// </summary>
[EuphoriaParameter(Name = "impulseOneLegOn", Type = typeof(bool), DefaultValue = default(bool))]
public bool ImpulseOneLegOn { get; set; } = default(bool);
/// <summary>
/// 0.0 no rigidBody response, 0.5 half partForce half rigidBody, 1.0 = no partForce full rigidBody
/// </summary>
[EuphoriaParameter(Name = "rbRatio", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbRatio { get; set; } = 0.000f;
/// <summary>
/// rigid body response is shared between the upper and lower body (rbUpperShare = 1-rbLowerShare). rbLowerShare=0.5 gives upper and lower share scaled by mass. i.e. if 70% ub mass and 30% lower mass then rbLowerShare=0.5 gives actualrbShare of 0.7ub and 0.3lb. rbLowerShare GT 0.5 scales the ub share down from 0.7 and the lb up from 0.3.
/// </summary>
[EuphoriaParameter(Name = "rbLowerShare", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbLowerShare { get; set; } = 0.50f;
/// <summary>
/// 0.0 only force, 0.5 = force and half the rigid body moment applied, 1.0 = force and full rigidBody moment
/// </summary>
[EuphoriaParameter(Name = "rbMoment", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbMoment { get; set; } = 1.000f;
/// <summary>
/// Maximum twist arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxTwistMomentArm", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxTwistMomentArm { get; set; } = 0.50f;
/// <summary>
/// Maximum broom((everything but the twist) arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxBroomMomentArm", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxBroomMomentArm { get; set; } = 1.00f;
/// <summary>
/// if Airborne: 0.0 no rigidBody response, 0.5 half partForce half rigidBody, 1.0 = no partForce full rigidBody
/// </summary>
[EuphoriaParameter(Name = "rbRatioAirborne", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbRatioAirborne { get; set; } = 0.000f;
/// <summary>
/// if Airborne: 0.0 only force, 0.5 = force and half the rigid body moment applied, 1.0 = force and full rigidBody moment
/// </summary>
[EuphoriaParameter(Name = "rbMomentAirborne", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbMomentAirborne { get; set; } = 1.000f;
/// <summary>
/// if Airborne: Maximum twist arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxTwistMomentArmAirborne", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxTwistMomentArmAirborne { get; set; } = 0.50f;
/// <summary>
/// if Airborne: Maximum broom((everything but the twist) arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxBroomMomentArmAirborne", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxBroomMomentArmAirborne { get; set; } = 1.00f;
/// <summary>
/// if only one leg in contact: 0.0 no rigidBody response, 0.5 half partForce half rigidBody, 1.0 = no partForce full rigidBody
/// </summary>
[EuphoriaParameter(Name = "rbRatioOneLeg", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbRatioOneLeg { get; set; } = 0.000f;
/// <summary>
/// if only one leg in contact: 0.0 only force, 0.5 = force and half the rigid body moment applied, 1.0 = force and full rigidBody moment
/// </summary>
[EuphoriaParameter(Name = "rbMomentOneLeg", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float RbMomentOneLeg { get; set; } = 1.000f;
/// <summary>
/// if only one leg in contact: Maximum twist arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxTwistMomentArmOneLeg", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxTwistMomentArmOneLeg { get; set; } = 0.50f;
/// <summary>
/// if only one leg in contact: Maximum broom((everything but the twist) arm moment of bullet applied
/// </summary>
[EuphoriaParameter(Name = "rbMaxBroomMomentArmOneLeg", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RbMaxBroomMomentArmOneLeg { get; set; } = 1.00f;
/// <summary>
/// Twist axis 0=World Up, 1=CharacterCOM up
/// </summary>
[EuphoriaParameter(Name = "rbTwistAxis", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 1)]
public int RbTwistAxis { get; set; } = 0;
/// <summary>
/// if false pivot around COM always, if true change pivot depending on foot contact: to feet centre if both feet in contact, or foot position if 1 foot in contact or COM position if no feet in contact
/// </summary>
[EuphoriaParameter(Name = "rbPivot", Type = typeof(bool), DefaultValue = default(bool))]
public bool RbPivot { get; set; } = default(bool);
public EuphoriaMessageConfigureBulletsExtra(bool startNow) : base("configureBulletsExtra", startNow)
{ }
}
/// <summary>
/// configureLimits: Enable/disable/edit character limits in real time. This adjusts limits in RAGE-native space and will *not* reorient the joint.
/// </summary>
internal class EuphoriaMessageConfigureLimits : EuphoriaMessage
{
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value for joint limits to configure. Ignored if index != -1.
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
/// <summary>
/// If false, disable (set all to PI, -PI) limits.
/// </summary>
[EuphoriaParameter(Name = "enable", Type = typeof(bool), DefaultValue = default(bool))]
public bool Enable { get; set; } = default(bool);
/// <summary>
/// If true, set limits to accommodate current desired angles
/// </summary>
[EuphoriaParameter(Name = "toDesired", Type = typeof(bool), DefaultValue = default(bool))]
public bool ToDesired { get; set; } = default(bool);
/// <summary>
/// Return to cached defaults?
/// </summary>
[EuphoriaParameter(Name = "restore", Type = typeof(bool), DefaultValue = default(bool))]
public bool Restore { get; set; } = default(bool);
/// <summary>
/// If true, set limits to the current animated limits
/// </summary>
[EuphoriaParameter(Name = "toCurAnimation", Type = typeof(bool), DefaultValue = default(bool))]
public bool ToCurAnimation { get; set; } = default(bool);
/// <summary>
/// Index of effector to configure. Set to -1 to use mask.
/// </summary>
[EuphoriaParameter(Name = "index", Type = typeof(int), DefaultValue = -1)]
public int Index { get; set; } = -1;
/// <summary>
/// Custom limit values to use if not setting limits to desired. Limits are RAGE-native, not NM-wrapper-native.
/// </summary>
[EuphoriaParameter(Name = "lean1", Type = typeof(float), DefaultValue = 1.570796f, MinimumValue = 0.0f, MaximumValue = 3.141593f)]
public float Lean1 { get; set; } = 1.570796f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "lean2", Type = typeof(float), DefaultValue = 1.570796f, MinimumValue = 0.0f, MaximumValue = 3.141593f)]
public float Lean2 { get; set; } = 1.570796f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "twist", Type = typeof(float), DefaultValue = 1.570796f, MinimumValue = 0.0f, MaximumValue = 3.141593f)]
public float Twist { get; set; } = 1.570796f;
/// <summary>
/// Joint limit margin to add to current animation limits when using those to set runtime limits.
/// </summary>
[EuphoriaParameter(Name = "margin", Type = typeof(float), DefaultValue = 0.196350f, MinimumValue = 0.0f, MaximumValue = 3.141593f)]
public float Margin { get; set; } = 0.196350f;
public EuphoriaMessageConfigureLimits(bool startNow) : base("configureLimits", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageConfigureSoftLimit : EuphoriaMessage
{
/// <summary>
/// Select limb that the soft limit is going to be applied to
/// </summary>
[EuphoriaParameter(Name = "index", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 3)]
public int Index { get; set; } = 0;
/// <summary>
/// Stiffness of the soft limit. Parameter is used to calculate spring term that contributes to the desired acceleration.
/// </summary>
[EuphoriaParameter(Name = "stiffness", Type = typeof(float), DefaultValue = 15.00f, MinimumValue = 0.00f, MaximumValue = 30.00f)]
public float Stiffness { get; set; } = 15.00f;
/// <summary>
/// Damping of the soft limit. Parameter is used to calculate damper term that contributes to the desired acceleration. To have the system critically dampened set it to 1.0.
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.90f, MaximumValue = 1.10f)]
public float Damping { get; set; } = 1.00f;
/// <summary>
/// Soft limit angle. Positive angle in RAD, measured relatively either from hard limit maxAngle (approach direction = -1) or minAngle (approach direction = 1). This angle will be clamped if outside the joint hard limit range.
/// </summary>
[EuphoriaParameter(Name = "limitAngle", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 6.283185f)]
public float LimitAngle { get; set; } = 0.40f;
/// <summary>
/// Limit angle can be measured relatively to joints hard limit minAngle or maxAngle. Set approachDirection to +1 to measure soft limit angle relatively to hard limit minAngle that corresponds to the maximum stretch of the elbow. Set it to -1 to measure soft limit angle relatively to hard limit maxAngle that corresponds to the maximum stretch of the knee.
/// </summary>
[EuphoriaParameter(Name = "approachDirection", Type = typeof(int), DefaultValue = 1, MinimumValue = -1, MaximumValue = 1)]
public int ApproachDirection { get; set; } = 1;
/// <summary>
/// Scale stiffness based on character angular velocity.
/// </summary>
[EuphoriaParameter(Name = "velocityScaled", Type = typeof(bool), DefaultValue = default(bool))]
public bool VelocityScaled { get; set; } = default(bool);
public EuphoriaMessageConfigureSoftLimit(bool startNow) : base("configureSoftLimit", startNow)
{ }
}
/// <summary>
/// configureShotInjuredArm: This single message allows you to configure the injured arm reaction during shot
/// </summary>
internal class EuphoriaMessageConfigureShotInjuredArm : EuphoriaMessage
{
/// <summary>
/// length of the reaction
/// </summary>
[EuphoriaParameter(Name = "injuredArmTime", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float InjuredArmTime { get; set; } = 0.250f;
/// <summary>
/// Amount of hip twist. (Negative values twist into bullet direction - probably not what is wanted)
/// </summary>
[EuphoriaParameter(Name = "hipYaw", Type = typeof(float), DefaultValue = 0.80f, MinimumValue = -2.00f, MaximumValue = 2.00f)]
public float HipYaw { get; set; } = 0.80f;
/// <summary>
/// Amount of hip roll
/// </summary>
[EuphoriaParameter(Name = "hipRoll", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -2.00f, MaximumValue = 2.00f)]
public float HipRoll { get; set; } = 0.00f;
/// <summary>
/// Additional height added to stepping foot
/// </summary>
[EuphoriaParameter(Name = "forceStepExtraHeight", Type = typeof(float), DefaultValue = 0.070f, MinimumValue = 0.00f, MaximumValue = 0.70f)]
public float ForceStepExtraHeight { get; set; } = 0.070f;
/// <summary>
/// force a step to be taken whether pushed out of balance or not
/// </summary>
[EuphoriaParameter(Name = "forceStep", Type = typeof(bool), DefaultValue = default(bool))]
public bool ForceStep { get; set; } = default(bool);
/// <summary>
/// turn the character using the balancer
/// </summary>
[EuphoriaParameter(Name = "stepTurn", Type = typeof(bool), DefaultValue = default(bool))]
public bool StepTurn { get; set; } = default(bool);
/// <summary>
/// Start velocity where parameters begin to be ramped down to zero linearly
/// </summary>
[EuphoriaParameter(Name = "velMultiplierStart", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float VelMultiplierStart { get; set; } = 1.0f;
/// <summary>
/// End velocity of ramp where parameters are scaled to zero
/// </summary>
[EuphoriaParameter(Name = "velMultiplierEnd", Type = typeof(float), DefaultValue = 5.0f, MinimumValue = 1.00f, MaximumValue = 40.00f)]
public float VelMultiplierEnd { get; set; } = 5.0f;
/// <summary>
/// Velocity above which a step is not forced
/// </summary>
[EuphoriaParameter(Name = "velForceStep", Type = typeof(float), DefaultValue = 0.80f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float VelForceStep { get; set; } = 0.80f;
/// <summary>
/// Velocity above which a stepTurn is not asked for
/// </summary>
[EuphoriaParameter(Name = "velStepTurn", Type = typeof(float), DefaultValue = 0.80f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float VelStepTurn { get; set; } = 0.80f;
/// <summary>
/// Use the velocity scaling parameters. Tune for standing still then use velocity scaling to make sure a running character stays balanced (the turning tends to make the character fall over more at speed)
/// </summary>
[EuphoriaParameter(Name = "velScales", Type = typeof(bool), DefaultValue = default(bool))]
public bool VelScales { get; set; } = default(bool);
public EuphoriaMessageConfigureShotInjuredArm(bool startNow) : base("configureShotInjuredArm", startNow)
{ }
}
/// <summary>
/// configureShotInjuredLeg: This single message allows you to configure the injured leg reaction during shot
/// </summary>
internal class EuphoriaMessageConfigureShotInjuredLeg : EuphoriaMessage
{
/// <summary>
/// time before a wounded leg is set to be weak and cause the character to collapse
/// </summary>
[EuphoriaParameter(Name = "timeBeforeCollapseWoundLeg", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TimeBeforeCollapseWoundLeg { get; set; } = 0.30f;
/// <summary>
/// Leg inury duration (reaction to being shot in leg)
/// </summary>
[EuphoriaParameter(Name = "legInjuryTime", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float LegInjuryTime { get; set; } = 0.40f;
/// <summary>
/// force a step to be taken whether pushed out of balance or not
/// </summary>
[EuphoriaParameter(Name = "legForceStep", Type = typeof(bool), DefaultValue = default(bool))]
public bool LegForceStep { get; set; } = default(bool);
/// <summary>
/// Bend the legs via the balancer by this amount if stepping on the injured leg. 0.2 seems a good default
/// </summary>
[EuphoriaParameter(Name = "legLimpBend", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LegLimpBend { get; set; } = 0.00f;
/// <summary>
/// Leg lift duration (reaction to being shot in leg) (lifting happens when not stepping with other leg)
/// </summary>
[EuphoriaParameter(Name = "legLiftTime", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float LegLiftTime { get; set; } = 0.00f;
/// <summary>
/// Leg injury - leg strength is reduced
/// </summary>
[EuphoriaParameter(Name = "legInjury", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LegInjury { get; set; } = 0.30f;
/// <summary>
/// Leg injury bend forwards amount when not lifting leg
/// </summary>
[EuphoriaParameter(Name = "legInjuryHipPitch", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float LegInjuryHipPitch { get; set; } = 0.00f;
/// <summary>
/// Leg injury bend forwards amount when lifting leg (lifting happens when not stepping with other leg)
/// </summary>
[EuphoriaParameter(Name = "legInjuryLiftHipPitch", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float LegInjuryLiftHipPitch { get; set; } = 0.00f;
/// <summary>
/// Leg injury bend forwards amount when not lifting leg
/// </summary>
[EuphoriaParameter(Name = "legInjurySpineBend", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float LegInjurySpineBend { get; set; } = 0.10f;
/// <summary>
/// Leg injury bend forwards amount when lifting leg (lifting happens when not stepping with other leg)
/// </summary>
[EuphoriaParameter(Name = "legInjuryLiftSpineBend", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float LegInjuryLiftSpineBend { get; set; } = 0.20f;
public EuphoriaMessageConfigureShotInjuredLeg(bool startNow) : base("configureShotInjuredLeg", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageDefineAttachedObject : EuphoriaMessage
{
/// <summary>
/// index of part to attach to
/// </summary>
[EuphoriaParameter(Name = "partIndex", Type = typeof(int), DefaultValue = -1, MinimumValue = -1, MaximumValue = 21)]
public int PartIndex { get; set; } = -1;
/// <summary>
/// mass of the attached object
/// </summary>
[EuphoriaParameter(Name = "objectMass", Type = typeof(float), DefaultValue = 0.000f)]
public float ObjectMass { get; set; } = 0.000f;
/// <summary>
/// world position of attached object's centre of mass. must be updated each frame.
/// </summary>
[EuphoriaParameter(Name = "worldPos", Type = typeof(Vector3))]
public Vector3 WorldPos { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageDefineAttachedObject(bool startNow) : base("defineAttachedObject", startNow)
{ }
}
/// <summary>
/// forceToBodyPart: Apply an impulse to a named body part
/// </summary>
internal class EuphoriaMessageForceToBodyPart : EuphoriaMessage
{
/// <summary>
/// part or link or bound index
/// </summary>
[EuphoriaParameter(Name = "partIndex", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 28)]
public int PartIndex { get; set; } = 0;
/// <summary>
/// force to apply
/// </summary>
[EuphoriaParameter(Name = "force", Type = typeof(Vector3))]
public Vector3 Force { get; set; } = new Vector3(0.00f, -50.00f, 0.00f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "forceDefinedInPartSpace", Type = typeof(bool), DefaultValue = default(bool))]
public bool ForceDefinedInPartSpace { get; set; } = default(bool);
public EuphoriaMessageForceToBodyPart(bool startNow) : base("forceToBodyPart", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageLeanInDirection : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// direction to lean in
/// </summary>
[EuphoriaParameter(Name = "dir", Type = typeof(Vector3))]
public Vector3 Dir { get; set; } = new Vector3(0.00f, 0.00f, 1.00f);
public EuphoriaMessageLeanInDirection(bool startNow) : base("leanInDirection", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageLeanRandom : EuphoriaMessage
{
/// <summary>
/// minimum amount of lean
/// </summary>
[EuphoriaParameter(Name = "leanAmountMin", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanAmountMin { get; set; } = 0.200f;
/// <summary>
/// maximum amount of lean
/// </summary>
[EuphoriaParameter(Name = "leanAmountMax", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanAmountMax { get; set; } = 0.200f;
/// <summary>
/// min time until changing direction
/// </summary>
[EuphoriaParameter(Name = "changeTimeMin", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ChangeTimeMin { get; set; } = 0.50f;
/// <summary>
/// maximum time until changing direction
/// </summary>
[EuphoriaParameter(Name = "changeTimeMax", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ChangeTimeMax { get; set; } = 1.00f;
public EuphoriaMessageLeanRandom(bool startNow) : base("leanRandom", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageLeanToPosition : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// position to head towards
/// </summary>
[EuphoriaParameter(Name = "pos", Type = typeof(Vector3))]
public Vector3 Pos { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageLeanToPosition(bool startNow) : base("leanToPosition", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageLeanTowardsObject : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// offset from instance position added when calculating position to lean to
/// </summary>
[EuphoriaParameter(Name = "offset", Type = typeof(Vector3))]
public Vector3 Offset { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// levelIndex of object to lean towards
/// </summary>
[EuphoriaParameter(Name = "instanceIndex", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndex { get; set; } = -1;
/// <summary>
/// boundIndex of object to lean towards (0 = just use instance coordinates)
/// </summary>
[EuphoriaParameter(Name = "boundIndex", Type = typeof(int), DefaultValue = 0)]
public int BoundIndex { get; set; } = 0;
public EuphoriaMessageLeanTowardsObject(bool startNow) : base("leanTowardsObject", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageHipsLeanInDirection : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// direction to lean in
/// </summary>
[EuphoriaParameter(Name = "dir", Type = typeof(Vector3))]
public Vector3 Dir { get; set; } = new Vector3(0.00f, 0.00f, 1.00f);
public EuphoriaMessageHipsLeanInDirection(bool startNow) : base("hipsLeanInDirection", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageHipsLeanRandom : EuphoriaMessage
{
/// <summary>
/// minimum amount of lean
/// </summary>
[EuphoriaParameter(Name = "leanAmountMin", Type = typeof(float), DefaultValue = 0.300f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanAmountMin { get; set; } = 0.300f;
/// <summary>
/// maximum amount of lean
/// </summary>
[EuphoriaParameter(Name = "leanAmountMax", Type = typeof(float), DefaultValue = 0.400f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanAmountMax { get; set; } = 0.400f;
/// <summary>
/// min time until changing direction
/// </summary>
[EuphoriaParameter(Name = "changeTimeMin", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ChangeTimeMin { get; set; } = 2.00f;
/// <summary>
/// maximum time until changing direction
/// </summary>
[EuphoriaParameter(Name = "changeTimeMax", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ChangeTimeMax { get; set; } = 4.00f;
public EuphoriaMessageHipsLeanRandom(bool startNow) : base("hipsLeanRandom", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageHipsLeanToPosition : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// position to head towards
/// </summary>
[EuphoriaParameter(Name = "pos", Type = typeof(Vector3))]
public Vector3 Pos { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageHipsLeanToPosition(bool startNow) : base("hipsLeanToPosition", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageHipsLeanTowardsObject : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// offset from instance position added when calculating position to lean to
/// </summary>
[EuphoriaParameter(Name = "offset", Type = typeof(Vector3))]
public Vector3 Offset { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// levelIndex of object to lean hips towards
/// </summary>
[EuphoriaParameter(Name = "instanceIndex", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndex { get; set; } = -1;
/// <summary>
/// boundIndex of object to lean hips towards (0 = just use instance coordinates)
/// </summary>
[EuphoriaParameter(Name = "boundIndex", Type = typeof(int), DefaultValue = 0)]
public int BoundIndex { get; set; } = 0;
public EuphoriaMessageHipsLeanTowardsObject(bool startNow) : base("hipsLeanTowardsObject", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageForceLeanInDirection : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// direction to lean in
/// </summary>
[EuphoriaParameter(Name = "dir", Type = typeof(Vector3))]
public Vector3 Dir { get; set; } = new Vector3(0.00f, 0.00f, 1.00f);
/// <summary>
/// body part that the force is applied to
/// </summary>
[EuphoriaParameter(Name = "bodyPart", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 21)]
public int BodyPart { get; set; } = 0;
public EuphoriaMessageForceLeanInDirection(bool startNow) : base("forceLeanInDirection", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageForceLeanRandom : EuphoriaMessage
{
/// <summary>
/// minimum amount of lean
/// </summary>
[EuphoriaParameter(Name = "leanAmountMin", Type = typeof(float), DefaultValue = 0.300f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanAmountMin { get; set; } = 0.300f;
/// <summary>
/// maximum amount of lean
/// </summary>
[EuphoriaParameter(Name = "leanAmountMax", Type = typeof(float), DefaultValue = 0.400f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanAmountMax { get; set; } = 0.400f;
/// <summary>
/// min time until changing direction
/// </summary>
[EuphoriaParameter(Name = "changeTimeMin", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ChangeTimeMin { get; set; } = 2.00f;
/// <summary>
/// maximum time until changing direction
/// </summary>
[EuphoriaParameter(Name = "changeTimeMax", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ChangeTimeMax { get; set; } = 4.00f;
/// <summary>
/// body part that the force is applied to
/// </summary>
[EuphoriaParameter(Name = "bodyPart", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 21)]
public int BodyPart { get; set; } = 0;
public EuphoriaMessageForceLeanRandom(bool startNow) : base("forceLeanRandom", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageForceLeanToPosition : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// position to head towards
/// </summary>
[EuphoriaParameter(Name = "pos", Type = typeof(Vector3))]
public Vector3 Pos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// body part that the force is applied to
/// </summary>
[EuphoriaParameter(Name = "bodyPart", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 21)]
public int BodyPart { get; set; } = 0;
public EuphoriaMessageForceLeanToPosition(bool startNow) : base("forceLeanToPosition", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageForceLeanTowardsObject : EuphoriaMessage
{
/// <summary>
/// amount of lean, 0 to about 0.5. -ve will move away from the target.
/// </summary>
[EuphoriaParameter(Name = "leanAmount", Type = typeof(float), DefaultValue = 0.200f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float LeanAmount { get; set; } = 0.200f;
/// <summary>
/// offset from instance position added when calculating position to lean to
/// </summary>
[EuphoriaParameter(Name = "offset", Type = typeof(Vector3))]
public Vector3 Offset { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// levelIndex of object to move towards
/// </summary>
[EuphoriaParameter(Name = "instanceIndex", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndex { get; set; } = -1;
/// <summary>
/// boundIndex of object to move towards (0 = just use instance coordinates)
/// </summary>
[EuphoriaParameter(Name = "boundIndex", Type = typeof(int), DefaultValue = 0)]
public int BoundIndex { get; set; } = 0;
/// <summary>
/// body part that the force is applied to
/// </summary>
[EuphoriaParameter(Name = "bodyPart", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 21)]
public int BodyPart { get; set; } = 0;
public EuphoriaMessageForceLeanTowardsObject(bool startNow) : base("forceLeanTowardsObject", startNow)
{ }
}
/// <summary>
/// setStiffness: Use this message to manually set the body stiffness values -before using Active Pose to drive to an animated pose, for example.
/// </summary>
internal class EuphoriaMessageSetStiffness : EuphoriaMessage
{
/// <summary>
/// stiffness of whole character
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 12.000f, MinimumValue = 2.0f, MaximumValue = 20.0f)]
public float BodyStiffness { get; set; } = 12.000f;
/// <summary>
/// damping amount, less is underdamped
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float Damping { get; set; } = 1.000f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
public EuphoriaMessageSetStiffness(bool startNow) : base("setStiffness", startNow)
{ }
}
/// <summary>
/// setMuscleStiffness: Use this message to manually set the muscle stiffness values -before using Active Pose to drive to an animated pose, for example.
/// </summary>
internal class EuphoriaMessageSetMuscleStiffness : EuphoriaMessage
{
/// <summary>
/// muscle stiffness of joint/s
/// </summary>
[EuphoriaParameter(Name = "muscleStiffness", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float MuscleStiffness { get; set; } = 1.000f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
public EuphoriaMessageSetMuscleStiffness(bool startNow) : base("setMuscleStiffness", startNow)
{ }
}
/// <summary>
/// setWeaponMode: Use this message to set the character's weapon mode. This is an alternativeto the setWeaponMode public function.
/// </summary>
internal class EuphoriaMessageSetWeaponMode : EuphoriaMessage
{
/// <summary>
/// Weapon mode. kNone = -1, kPistol = 0, kDual = 1, kRifle = 2, kSidearm = 3, kPistolLeft = 4, kPistolRight = 5. See WeaponMode enum in NmRsUtils.h and -1 from that.
/// </summary>
[EuphoriaParameter(Name = "weaponMode", Type = typeof(int), DefaultValue = 5, MinimumValue = -1, MaximumValue = 6)]
public int WeaponMode { get; set; } = 5;
public EuphoriaMessageSetWeaponMode(bool startNow) : base("setWeaponMode", startNow)
{ }
}
/// <summary>
/// registerWeapon: Use this message to register weapon. This is an alternativeto the registerWeapon public function.
/// </summary>
internal class EuphoriaMessageRegisterWeapon : EuphoriaMessage
{
/// <summary>
/// What hand the weapon is in. LeftHand = 0, RightHand = 1
/// </summary>
[EuphoriaParameter(Name = "hand", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 1)]
public int Hand { get; set; } = 1;
/// <summary>
/// Level index of the weapon
/// </summary>
[EuphoriaParameter(Name = "levelIndex", Type = typeof(int), DefaultValue = -1)]
public int LevelIndex { get; set; } = -1;
/// <summary>
/// pointer to the hand-gun constraint handle
/// </summary>
[EuphoriaParameter(Name = "constraintHandle", Type = typeof(int), DefaultValue = -1)]
public int ConstraintHandle { get; set; } = -1;
/// <summary>
/// A vector of the gunToHand matrix. The gunToHandMatrix is the desired gunToHandMatrix in the aimingPose. (The gunToHandMatrix when pointGun starts can be different so will be blended to this desired one)
/// </summary>
[EuphoriaParameter(Name = "gunToHandA", Type = typeof(Vector3))]
public Vector3 GunToHandA { get; set; } = new Vector3(1.00f, 0.00f, 0.00f);
/// <summary>
/// B vector of the gunToHand matrix
/// </summary>
[EuphoriaParameter(Name = "gunToHandB", Type = typeof(Vector3))]
public Vector3 GunToHandB { get; set; } = new Vector3(0.00f, 1.00f, 0.00f);
/// <summary>
/// C vector of the gunToHand matrix
/// </summary>
[EuphoriaParameter(Name = "gunToHandC", Type = typeof(Vector3))]
public Vector3 GunToHandC { get; set; } = new Vector3(0.00f, 0.00f, 1.00f);
/// <summary>
/// D vector of the gunToHand matrix
/// </summary>
[EuphoriaParameter(Name = "gunToHandD", Type = typeof(Vector3))]
public Vector3 GunToHandD { get; set; } = new Vector3(0.00f, 0.00f, 0.00f);
/// <summary>
/// Gun centre to muzzle expressed in gun co-ordinates. To get the line of sight/barrel of the gun. Assumption: the muzzle direction is always along the same primary axis of the gun.
/// </summary>
[EuphoriaParameter(Name = "gunToMuzzleInGun", Type = typeof(Vector3))]
public Vector3 GunToMuzzleInGun { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Gun centre to butt expressed in gun co-ordinates. The gun pivots around this point when aiming
/// </summary>
[EuphoriaParameter(Name = "gunToButtInGun", Type = typeof(Vector3))]
public Vector3 GunToButtInGun { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageRegisterWeapon(bool startNow) : base("registerWeapon", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageShotRelax : EuphoriaMessage
{
/// <summary>
/// time over which to relax to full relaxation for upper body
/// </summary>
[EuphoriaParameter(Name = "relaxPeriodUpper", Type = typeof(float), DefaultValue = 2.000f, MinimumValue = 0.0f, MaximumValue = 40.0f)]
public float RelaxPeriodUpper { get; set; } = 2.000f;
/// <summary>
/// time over which to relax to full relaxation for lower body
/// </summary>
[EuphoriaParameter(Name = "relaxPeriodLower", Type = typeof(float), DefaultValue = 0.400f, MinimumValue = 0.0f, MaximumValue = 40.0f)]
public float RelaxPeriodLower { get; set; } = 0.400f;
public EuphoriaMessageShotRelax(bool startNow) : base("shotRelax", startNow)
{ }
}
/// <summary>
/// fireWeapon: One shot message apply a force to the hand as we fire the gun that should be in this hand
/// </summary>
internal class EuphoriaMessageFireWeapon : EuphoriaMessage
{
/// <summary>
/// The force of the gun.
/// </summary>
[EuphoriaParameter(Name = "firedWeaponStrength", Type = typeof(float), DefaultValue = 1000.0f, MinimumValue = 0.0f, MaximumValue = 10000.0f)]
public float FiredWeaponStrength { get; set; } = 1000.0f;
/// <summary>
/// Which hand in the gun in, 0 = left, 1 = right.
/// </summary>
[EuphoriaParameter(Name = "gunHandEnum", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 1)]
public int GunHandEnum { get; set; } = 0;
/// <summary>
/// Should we apply some of the force at the shoulder. Force double handed weapons (Ak47 etc).
/// </summary>
[EuphoriaParameter(Name = "applyFireGunForceAtClavicle", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyFireGunForceAtClavicle { get; set; } = default(bool);
/// <summary>
/// Minimum time before next fire impulse
/// </summary>
[EuphoriaParameter(Name = "inhibitTime", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float InhibitTime { get; set; } = 0.40f;
/// <summary>
/// direction of impulse in gun frame
/// </summary>
[EuphoriaParameter(Name = "direction", Type = typeof(Vector3))]
public Vector3 Direction { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Split force between hand and clavicle when applyFireGunForceAtClavicle is true. 1 = all hand, 0 = all clavicle.
/// </summary>
[EuphoriaParameter(Name = "split", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Split { get; set; } = 0.50f;
public EuphoriaMessageFireWeapon(bool startNow) : base("fireWeapon", startNow)
{ }
}
/// <summary>
/// configureConstraints: One shot to give state of constraints on character and response to constraints
/// </summary>
internal class EuphoriaMessageConfigureConstraints : EuphoriaMessage
{
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "handCuffs", Type = typeof(bool), DefaultValue = default(bool))]
public bool HandCuffs { get; set; } = default(bool);
/// <summary>
/// not implemented
/// </summary>
[EuphoriaParameter(Name = "handCuffsBehindBack", Type = typeof(bool), DefaultValue = default(bool))]
public bool HandCuffsBehindBack { get; set; } = default(bool);
/// <summary>
/// not implemented
/// </summary>
[EuphoriaParameter(Name = "legCuffs", Type = typeof(bool), DefaultValue = default(bool))]
public bool LegCuffs { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "rightDominant", Type = typeof(bool), DefaultValue = default(bool))]
public bool RightDominant { get; set; } = default(bool);
/// <summary>
/// 0 setCurrent, 1= IK to dominant, (2=pointGunLikeIK //not implemented)
/// </summary>
[EuphoriaParameter(Name = "passiveMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 5)]
public int PassiveMode { get; set; } = 0;
/// <summary>
/// not implemented
/// </summary>
[EuphoriaParameter(Name = "bespokeBehaviour", Type = typeof(bool), DefaultValue = default(bool))]
public bool BespokeBehaviour { get; set; } = default(bool);
/// <summary>
/// Blend Arms to zero pose
/// </summary>
[EuphoriaParameter(Name = "blend2ZeroPose", Type = typeof(float), DefaultValue = 0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Blend2ZeroPose { get; set; } = 0f;
public EuphoriaMessageConfigureConstraints(bool startNow) : base("configureConstraints", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageStayUpright : EuphoriaMessage
{
/// <summary>
/// enable force based constraint
/// </summary>
[EuphoriaParameter(Name = "useForces", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseForces { get; set; } = default(bool);
/// <summary>
/// enable torque based constraint
/// </summary>
[EuphoriaParameter(Name = "useTorques", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseTorques { get; set; } = default(bool);
/// <summary>
/// Uses position/orientation control on the spine and drifts in the direction of bullets. This ignores all other stayUpright settings.
/// </summary>
[EuphoriaParameter(Name = "lastStandMode", Type = typeof(bool), DefaultValue = default(bool))]
public bool LastStandMode { get; set; } = default(bool);
/// <summary>
/// The sink rate (higher for a faster drop).
/// </summary>
[EuphoriaParameter(Name = "lastStandSinkRate", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LastStandSinkRate { get; set; } = 0.30f;
/// <summary>
/// Higher values for more damping
/// </summary>
[EuphoriaParameter(Name = "lastStandHorizDamping", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LastStandHorizDamping { get; set; } = 0.40f;
/// <summary>
/// Max time allowed in last stand mode
/// </summary>
[EuphoriaParameter(Name = "lastStandMaxTime", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.0f, MaximumValue = 5.0f)]
public float LastStandMaxTime { get; set; } = 0.40f;
/// <summary>
/// Use cheat torques to face the direction of bullets if not facing too far away
/// </summary>
[EuphoriaParameter(Name = "turnTowardsBullets", Type = typeof(bool), DefaultValue = default(bool))]
public bool TurnTowardsBullets { get; set; } = default(bool);
/// <summary>
/// make strength of constraint function of COM velocity. Uses -1 for forceDamping if the damping is positive.
/// </summary>
[EuphoriaParameter(Name = "velocityBased", Type = typeof(bool), DefaultValue = default(bool))]
public bool VelocityBased { get; set; } = default(bool);
/// <summary>
/// only apply torque based constraint when airBorne
/// </summary>
[EuphoriaParameter(Name = "torqueOnlyInAir", Type = typeof(bool), DefaultValue = default(bool))]
public bool TorqueOnlyInAir { get; set; } = default(bool);
/// <summary>
/// strength of constraint
/// </summary>
[EuphoriaParameter(Name = "forceStrength", Type = typeof(float), DefaultValue = 3.00f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float ForceStrength { get; set; } = 3.00f;
/// <summary>
/// damping in constraint: -1 makes it scale automagically with forceStrength. Other negative values will scale this automagic damping.
/// </summary>
[EuphoriaParameter(Name = "forceDamping", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 50.0f)]
public float ForceDamping { get; set; } = -1.00f;
/// <summary>
/// multiplier to the force applied to the feet
/// </summary>
[EuphoriaParameter(Name = "forceFeetMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ForceFeetMult { get; set; } = 1.00f;
/// <summary>
/// share of pelvis force applied to spine3
/// </summary>
[EuphoriaParameter(Name = "forceSpine3Share", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ForceSpine3Share { get; set; } = 0.30f;
/// <summary>
/// how much the character lean is taken into account when reducing the force.
/// </summary>
[EuphoriaParameter(Name = "forceLeanReduction", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ForceLeanReduction { get; set; } = 1.00f;
/// <summary>
/// share of the feet force to the airborne foot
/// </summary>
[EuphoriaParameter(Name = "forceInAirShare", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ForceInAirShare { get; set; } = 0.50f;
/// <summary>
/// when min and max are greater than 0 the constraint strength is determined from character strength, scaled into the range given by min and max
/// </summary>
[EuphoriaParameter(Name = "forceMin", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 16.0f)]
public float ForceMin { get; set; } = -1.00f;
/// <summary>
/// see above
/// </summary>
[EuphoriaParameter(Name = "forceMax", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 16.0f)]
public float ForceMax { get; set; } = -1.00f;
/// <summary>
/// when in velocityBased mode, the COM velocity at which constraint reaches maximum strength (forceStrength)
/// </summary>
[EuphoriaParameter(Name = "forceSaturationVel", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.10f, MaximumValue = 10.0f)]
public float ForceSaturationVel { get; set; } = 4.00f;
/// <summary>
/// when in velocityBased mode, the COM velocity above which constraint starts applying forces
/// </summary>
[EuphoriaParameter(Name = "forceThresholdVel", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float ForceThresholdVel { get; set; } = 0.50f;
/// <summary>
/// strength of torque based constraint
/// </summary>
[EuphoriaParameter(Name = "torqueStrength", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 16.0f)]
public float TorqueStrength { get; set; } = 0.00f;
/// <summary>
/// damping of torque based constraint
/// </summary>
[EuphoriaParameter(Name = "torqueDamping", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 16.0f)]
public float TorqueDamping { get; set; } = 0.50f;
/// <summary>
/// when in velocityBased mode, the COM velocity at which constraint reaches maximum strength (torqueStrength)
/// </summary>
[EuphoriaParameter(Name = "torqueSaturationVel", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.10f, MaximumValue = 10.0f)]
public float TorqueSaturationVel { get; set; } = 4.00f;
/// <summary>
/// when in velocityBased mode, the COM velocity above which constraint starts applying torques
/// </summary>
[EuphoriaParameter(Name = "torqueThresholdVel", Type = typeof(float), DefaultValue = 2.50f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float TorqueThresholdVel { get; set; } = 2.50f;
/// <summary>
/// distance the foot is behind Com projection that is still considered able to generate the support for the upright constraint
/// </summary>
[EuphoriaParameter(Name = "supportPosition", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = -2.00f, MaximumValue = 2.00f)]
public float SupportPosition { get; set; } = 2.00f;
/// <summary>
/// still apply this fraction of the upright constaint force if the foot is not in a position (defined by supportPosition) to generate the support for the upright constraint
/// </summary>
[EuphoriaParameter(Name = "noSupportForceMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float NoSupportForceMult { get; set; } = 1.00f;
/// <summary>
/// strength of cheat force applied upwards to spine3 to help the character up steps/slopes
/// </summary>
[EuphoriaParameter(Name = "stepUpHelp", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 16.0f)]
public float StepUpHelp { get; set; } = 0.00f;
/// <summary>
/// How much the cheat force takes into account the acceleration of moving platforms
/// </summary>
[EuphoriaParameter(Name = "stayUpAcc", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float StayUpAcc { get; set; } = 0.70f;
/// <summary>
/// The maximum floorAcceleration (of a moving platform) that the cheat force takes into account
/// </summary>
[EuphoriaParameter(Name = "stayUpAccMax", Type = typeof(float), DefaultValue = 5.00f, MinimumValue = 0.00f, MaximumValue = 15.0f)]
public float StayUpAccMax { get; set; } = 5.00f;
public EuphoriaMessageStayUpright(bool startNow) : base("stayUpright", startNow)
{ }
}
/// <summary>
/// stopAllBehaviours: Send this message to immediately stop all behaviours from executing.
/// </summary>
internal class EuphoriaMessageStopAllBehaviours : EuphoriaMessage
{
public EuphoriaMessageStopAllBehaviours(bool startNow) : base("stopAllBehaviours", startNow)
{ }
}
/// <summary>
/// setCharacterStrength: Sets character's strength on the dead-granny-to-healthy-terminator scale: [0..1]
/// </summary>
internal class EuphoriaMessageSetCharacterStrength : EuphoriaMessage
{
/// <summary>
/// strength of character
/// </summary>
[EuphoriaParameter(Name = "characterStrength", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CharacterStrength { get; set; } = 1.00f;
public EuphoriaMessageSetCharacterStrength(bool startNow) : base("setCharacterStrength", startNow)
{ }
}
/// <summary>
/// setCharacterHealth: Sets character's health on the dead-to-alive scale: [0..1]
/// </summary>
internal class EuphoriaMessageSetCharacterHealth : EuphoriaMessage
{
/// <summary>
/// health of character
/// </summary>
[EuphoriaParameter(Name = "characterHealth", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CharacterHealth { get; set; } = 1.00f;
public EuphoriaMessageSetCharacterHealth(bool startNow) : base("setCharacterHealth", startNow)
{ }
}
/// <summary>
/// setFallingReaction: Sets the type of reaction if catchFall is called
/// </summary>
internal class EuphoriaMessageSetFallingReaction : EuphoriaMessage
{
/// <summary>
/// set to true to get handsAndKnees catchFall if catchFall called. If true allows the dynBalancer to stay on during the catchfall and modifies the catch fall to give a more alive looking performance (hands and knees for front landing or sitting up for back landing)
/// </summary>
[EuphoriaParameter(Name = "handsAndKnees", Type = typeof(bool), DefaultValue = default(bool))]
public bool HandsAndKnees { get; set; } = default(bool);
/// <summary>
/// If true catchFall will call rollDownstairs if comVel GT comVelRDSThresh - prevents excessive sliding in catchFall. Was previously only true for handsAndKnees
/// </summary>
[EuphoriaParameter(Name = "callRDS", Type = typeof(bool), DefaultValue = default(bool))]
public bool CallRDS { get; set; } = default(bool);
/// <summary>
/// comVel above which rollDownstairs will start - prevents excessive sliding in catchFall
/// </summary>
[EuphoriaParameter(Name = "comVelRDSThresh", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float ComVelRDSThresh { get; set; } = 2.00f;
/// <summary>
/// For rds catchFall only: True to resist rolling motion (rolling motion is set off by ub contact and a sliding velocity), false to allow more of a continuous rolling (rolling motion is set off at a sliding velocity)
/// </summary>
[EuphoriaParameter(Name = "resistRolling", Type = typeof(bool), DefaultValue = default(bool))]
public bool ResistRolling { get; set; } = default(bool);
/// <summary>
/// Strength is reduced in the catchFall when the arms contact the ground. 0.2 is good for handsAndKnees. 2.5 is good for normal catchFall, anything lower than 1.0 for normal catchFall may lead to bad catchFall poses.
/// </summary>
[EuphoriaParameter(Name = "armReduceSpeed", Type = typeof(float), DefaultValue = 2.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ArmReduceSpeed { get; set; } = 2.50f;
/// <summary>
/// Reach length multiplier that scales characters arm topological length, value in range from (0, 1 GT where 1.0 means reach length is maximum.
/// </summary>
[EuphoriaParameter(Name = "reachLengthMultiplier", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.30f, MaximumValue = 1.00f)]
public float ReachLengthMultiplier { get; set; } = 1.00f;
/// <summary>
/// Time after hitting ground that the catchFall can call rds
/// </summary>
[EuphoriaParameter(Name = "inhibitRollingTime", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float InhibitRollingTime { get; set; } = 0.20f;
/// <summary>
/// Time after hitting ground that the catchFall can change the friction of parts to inhibit sliding
/// </summary>
[EuphoriaParameter(Name = "changeFrictionTime", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float ChangeFrictionTime { get; set; } = 0.20f;
/// <summary>
/// 8.0 was used on yanked) Friction multiplier on bodyParts when on ground. Character can look too slidy with groundFriction = 1. Higher values give a more jerky reation but this seems timestep dependent especially for dragged by the feet.
/// </summary>
[EuphoriaParameter(Name = "groundFriction", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GroundFriction { get; set; } = 1.00f;
/// <summary>
/// Min Friction of an impact with a body part (not head, hands or feet) - to increase friction of slippy environment to get character to roll better. Applied in catchFall and rollUp(rollDownStairs)
/// </summary>
[EuphoriaParameter(Name = "frictionMin", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float FrictionMin { get; set; } = 0.00f;
/// <summary>
/// Max Friction of an impact with a body part (not head, hands or feet) - to increase friction of slippy environment to get character to roll better. Applied in catchFall and rollUp(rollDownStairs)
/// </summary>
[EuphoriaParameter(Name = "frictionMax", Type = typeof(float), DefaultValue = 9999.00f)]
public float FrictionMax { get; set; } = 9999.00f;
/// <summary>
/// Apply tactics to help stop on slopes.
/// </summary>
[EuphoriaParameter(Name = "stopOnSlopes", Type = typeof(bool), DefaultValue = default(bool))]
public bool StopOnSlopes { get; set; } = default(bool);
/// <summary>
/// Override slope value to manually force stopping on flat ground. Encourages character to come to rest face down or face up.
/// </summary>
[EuphoriaParameter(Name = "stopManual", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float StopManual { get; set; } = 0.00f;
/// <summary>
/// Speed at which strength reduces when stopped.
/// </summary>
[EuphoriaParameter(Name = "stoppedStrengthDecay", Type = typeof(float), DefaultValue = 5.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float StoppedStrengthDecay { get; set; } = 5.00f;
/// <summary>
/// Bias spine post towards hunched (away from arched).
/// </summary>
[EuphoriaParameter(Name = "spineLean1Offset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float SpineLean1Offset { get; set; } = 0.00f;
/// <summary>
/// Hold rifle in a safe position to reduce complications with collision. Only applied if holding a rifle
/// </summary>
[EuphoriaParameter(Name = "riflePose", Type = typeof(bool), DefaultValue = default(bool))]
public bool RiflePose { get; set; } = default(bool);
/// <summary>
/// Enable head ground avoidance when handsAndKnees is true.
/// </summary>
[EuphoriaParameter(Name = "hkHeadAvoid", Type = typeof(bool), DefaultValue = default(bool))]
public bool HkHeadAvoid { get; set; } = default(bool);
/// <summary>
/// Discourage the character getting stuck propped up by elbows when falling backwards - by inhibiting backwards moving clavicles (keeps the arms slightly wider)
/// </summary>
[EuphoriaParameter(Name = "antiPropClav", Type = typeof(bool), DefaultValue = default(bool))]
public bool AntiPropClav { get; set; } = default(bool);
/// <summary>
/// Discourage the character getting stuck propped up by elbows when falling backwards - by weakening the arms as soon they hit the floor. (Also stops the hands lifting up when flat on back)
/// </summary>
[EuphoriaParameter(Name = "antiPropWeak", Type = typeof(bool), DefaultValue = default(bool))]
public bool AntiPropWeak { get; set; } = default(bool);
/// <summary>
/// Head weakens as arms weaken. If false and antiPropWeak when falls onto back doesn't loosen neck so early (matches bodyStrength instead)
/// </summary>
[EuphoriaParameter(Name = "headAsWeakAsArms", Type = typeof(bool), DefaultValue = default(bool))]
public bool HeadAsWeakAsArms { get; set; } = default(bool);
/// <summary>
/// When bodyStrength is less than successStrength send a success feedback - DO NOT GO OUTSIDE MIN/MAX PARAMETER VALUES OTHERWISE NO SUCCESS FEEDBACK WILL BE SENT
/// </summary>
[EuphoriaParameter(Name = "successStrength", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.30f, MaximumValue = 1.00f)]
public float SuccessStrength { get; set; } = 1.00f;
public EuphoriaMessageSetFallingReaction(bool startNow) : base("setFallingReaction", startNow)
{ }
}
/// <summary>
/// setCharacterUnderwater: Sets viscosity applied to damping limbs
/// </summary>
internal class EuphoriaMessageSetCharacterUnderwater : EuphoriaMessage
{
/// <summary>
/// is character underwater?
/// </summary>
[EuphoriaParameter(Name = "underwater", Type = typeof(bool), DefaultValue = default(bool))]
public bool Underwater { get; set; } = default(bool);
/// <summary>
/// viscosity applied to character's parts
/// </summary>
[EuphoriaParameter(Name = "viscosity", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 100.00f)]
public float Viscosity { get; set; } = -1.00f;
/// <summary>
/// gravity factor applied to character
/// </summary>
[EuphoriaParameter(Name = "gravityFactor", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = -10.00f, MaximumValue = 10.00f)]
public float GravityFactor { get; set; } = 1.00f;
/// <summary>
/// swimming force applied to character as a function of handVelocity and footVelocity
/// </summary>
[EuphoriaParameter(Name = "stroke", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1000.00f, MaximumValue = 1000.00f)]
public float Stroke { get; set; } = 0.00f;
/// <summary>
/// swimming force (linearStroke=true,False) = (f(v),f(v*v))
/// </summary>
[EuphoriaParameter(Name = "linearStroke", Type = typeof(bool), DefaultValue = default(bool))]
public bool LinearStroke { get; set; } = default(bool);
public EuphoriaMessageSetCharacterUnderwater(bool startNow) : base("setCharacterUnderwater", startNow)
{ }
}
/// <summary>
/// setCharacterCollisions:
/// </summary>
internal class EuphoriaMessageSetCharacterCollisions : EuphoriaMessage
{
/// <summary>
/// sliding friction turned into spin 80.0 (used in demo videos) good for rest of default params below. If 0.0 then no collision enhancement
/// </summary>
[EuphoriaParameter(Name = "spin", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float Spin { get; set; } = 0.00f;
/// <summary>
/// torque = spin*(relative velocity) up to this maximum for relative velocity
/// </summary>
[EuphoriaParameter(Name = "maxVelocity", Type = typeof(float), DefaultValue = 8.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float MaxVelocity { get; set; } = 8.00f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "applyToAll", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyToAll { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "applyToSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyToSpine { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "applyToThighs", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyToThighs { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "applyToClavicles", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyToClavicles { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "applyToUpperArms", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyToUpperArms { get; set; } = default(bool);
/// <summary>
/// allow foot slipping if collided
/// </summary>
[EuphoriaParameter(Name = "footSlip", Type = typeof(bool), DefaultValue = default(bool))]
public bool FootSlip { get; set; } = default(bool);
/// <summary>
/// ClassType of the object against which to enhance the collision. All character vehicle interaction (e.g. braceForImpact glancing spins) relies on this value so EDIT WISELY. If it is used for things other than vehicles then NM should be informed.
/// </summary>
[EuphoriaParameter(Name = "vehicleClass", Type = typeof(int), DefaultValue = 15, MinimumValue = 0, MaximumValue = 100)]
public int VehicleClass { get; set; } = 15;
public EuphoriaMessageSetCharacterCollisions(bool startNow) : base("setCharacterCollisions", startNow)
{ }
}
/// <summary>
/// setCharacterDamping: Damp out cartwheeling and somersaulting above a certain threshold
/// </summary>
internal class EuphoriaMessageSetCharacterDamping : EuphoriaMessage
{
/// <summary>
/// Somersault AngularMomentum measure above which we start damping - try 34.0. Falling over straight backwards gives 54 on hitting ground.
/// </summary>
[EuphoriaParameter(Name = "somersaultThresh", Type = typeof(float), DefaultValue = 34.00f, MinimumValue = 0.00f, MaximumValue = 200.00f)]
public float SomersaultThresh { get; set; } = 34.00f;
/// <summary>
/// Amount to damp somersaulting by (spinning around left/right axis) - try 0.45
/// </summary>
[EuphoriaParameter(Name = "somersaultDamp", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float SomersaultDamp { get; set; } = 0.00f;
/// <summary>
/// Cartwheel AngularMomentum measure above which we start damping - try 27.0
/// </summary>
[EuphoriaParameter(Name = "cartwheelThresh", Type = typeof(float), DefaultValue = 27.00f, MinimumValue = 0.00f, MaximumValue = 200.00f)]
public float CartwheelThresh { get; set; } = 27.00f;
/// <summary>
/// Amount to damp somersaulting by (spinning around front/back axis) - try 0.8
/// </summary>
[EuphoriaParameter(Name = "cartwheelDamp", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float CartwheelDamp { get; set; } = 0.00f;
/// <summary>
/// Time after impact with a vehicle to apply characterDamping. -ve values mean always apply whether collided with vehicle or not. =0.0 never apply. =timestep apply for only that frame. A typical roll from being hit by a car lasts about 4secs.
/// </summary>
[EuphoriaParameter(Name = "vehicleCollisionTime", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1000.00f)]
public float VehicleCollisionTime { get; set; } = 0.00f;
/// <summary>
/// If true damping is proportional to Angular momentum squared. If false proportional to Angular momentum
/// </summary>
[EuphoriaParameter(Name = "v2", Type = typeof(bool), DefaultValue = default(bool))]
public bool V2 { get; set; } = default(bool);
public EuphoriaMessageSetCharacterDamping(bool startNow) : base("setCharacterDamping", startNow)
{ }
}
/// <summary>
/// setFrictionScale:
/// </summary>
internal class EuphoriaMessageSetFrictionScale : EuphoriaMessage
{
/// <summary>
/// Friction scale to be applied to parts in mask.
/// </summary>
[EuphoriaParameter(Name = "scale", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float Scale { get; set; } = 1.00f;
/// <summary>
/// Character-wide minimum impact friction. Affects all parts (not just those in mask).
/// </summary>
[EuphoriaParameter(Name = "globalMin", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1000000.00f)]
public float GlobalMin { get; set; } = 0.00f;
/// <summary>
/// Character-wide maximum impact friction. Affects all parts (not just those in mask).
/// </summary>
[EuphoriaParameter(Name = "globalMax", Type = typeof(float), DefaultValue = 999999.00f, MinimumValue = 0.00f, MaximumValue = 1000000.00f)]
public float GlobalMax { get; set; } = 999999.00f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
public EuphoriaMessageSetFrictionScale(bool startNow) : base("setFrictionScale", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageAnimPose : EuphoriaMessage
{
/// <summary>
/// muscleStiffness of masked joints. -values mean don't apply (just use defaults or ones applied by behaviours - safer if you are going to return to a behaviour)
/// </summary>
[EuphoriaParameter(Name = "muscleStiffness", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.10f, MaximumValue = 10.00f)]
public float MuscleStiffness { get; set; } = -1.0f;
/// <summary>
/// stiffness of masked joints. -ve values mean don't apply stiffness or damping (just use defaults or ones applied by behaviours). If you are using animpose fullbody on its own then this gives the opprtunity to use setStffness and setMuscleStiffness messages to set up the character's muscles. mmmmtodo get rid of this -ve
/// </summary>
[EuphoriaParameter(Name = "stiffness", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.10f, MaximumValue = 16.00f)]
public float Stiffness { get; set; } = -1.0f;
/// <summary>
/// damping of masked joints
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float Damping { get; set; } = 1.0f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see notes for explanation)
/// </summary>
[EuphoriaParameter(Name = "effectorMask", Type = typeof(string), DefaultValue = "ub")]
public string EffectorMask { get; set; } = "ub";
/// <summary>
/// overide Headlook behaviour (if animPose includes the head)
/// </summary>
[EuphoriaParameter(Name = "overideHeadlook", Type = typeof(bool), DefaultValue = default(bool))]
public bool OverideHeadlook { get; set; } = default(bool);
/// <summary>
/// overide PointArm behaviour (if animPose includes the arm/arms)
/// </summary>
[EuphoriaParameter(Name = "overidePointArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool OveridePointArm { get; set; } = default(bool);
/// <summary>
/// overide PointGun behaviour (if animPose includes the arm/arms)//mmmmtodo not used at moment
/// </summary>
[EuphoriaParameter(Name = "overidePointGun", Type = typeof(bool), DefaultValue = default(bool))]
public bool OveridePointGun { get; set; } = default(bool);
/// <summary>
/// If true then modify gravity compensation based on stance (can reduce gravity compensation to zero if cofm is outside of balance area)
/// </summary>
[EuphoriaParameter(Name = "useZMPGravityCompensation", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseZMPGravityCompensation { get; set; } = default(bool);
/// <summary>
/// gravity compensation applied to joints in the effectorMask. If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "gravityCompensation", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 14.00f)]
public float GravityCompensation { get; set; } = -1.0f;
/// <summary>
/// muscle stiffness applied to left arm (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "muscleStiffnessLeftArm", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10.00f)]
public float MuscleStiffnessLeftArm { get; set; } = -1.0f;
/// <summary>
/// muscle stiffness applied to right arm (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "muscleStiffnessRightArm", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10.00f)]
public float MuscleStiffnessRightArm { get; set; } = -1.0f;
/// <summary>
/// muscle stiffness applied to spine (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "muscleStiffnessSpine", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10.00f)]
public float MuscleStiffnessSpine { get; set; } = -1.0f;
/// <summary>
/// muscle stiffness applied to left leg (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "muscleStiffnessLeftLeg", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10.00f)]
public float MuscleStiffnessLeftLeg { get; set; } = -1.0f;
/// <summary>
/// muscle stiffness applied to right leg (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "muscleStiffnessRightLeg", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10.00f)]
public float MuscleStiffnessRightLeg { get; set; } = -1.0f;
/// <summary>
/// stiffness applied to left arm (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "stiffnessLeftArm", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 16.00f)]
public float StiffnessLeftArm { get; set; } = -1.0f;
/// <summary>
/// stiffness applied to right arm (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "stiffnessRightArm", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 16.00f)]
public float StiffnessRightArm { get; set; } = -1.0f;
/// <summary>
/// stiffness applied to spine (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "stiffnessSpine", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 16.00f)]
public float StiffnessSpine { get; set; } = -1.0f;
/// <summary>
/// stiffness applied to left leg (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "stiffnessLeftLeg", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 16.00f)]
public float StiffnessLeftLeg { get; set; } = -1.0f;
/// <summary>
/// stiffness applied to right leg (applied after stiffness). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "stiffnessRightLeg", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 16.00f)]
public float StiffnessRightLeg { get; set; } = -1.0f;
/// <summary>
/// damping applied to left arm (applied after stiffness). If stiffness -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "dampingLeftArm", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float DampingLeftArm { get; set; } = 1.0f;
/// <summary>
/// damping applied to right arm (applied after stiffness). If stiffness -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "dampingRightArm", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float DampingRightArm { get; set; } = 1.0f;
/// <summary>
/// damping applied to spine (applied after stiffness). If stiffness-ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "dampingSpine", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float DampingSpine { get; set; } = 1.0f;
/// <summary>
/// damping applied to left leg (applied after stiffness). If stiffness-ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "dampingLeftLeg", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float DampingLeftLeg { get; set; } = 1.0f;
/// <summary>
/// damping applied to right leg (applied after stiffness). If stiffness -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "dampingRightLeg", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float DampingRightLeg { get; set; } = 1.0f;
/// <summary>
/// gravity compensation applied to left arm (applied after gravityCompensation). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "gravCompLeftArm", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 14.00f)]
public float GravCompLeftArm { get; set; } = -1.0f;
/// <summary>
/// gravity compensation applied to right arm (applied after gravityCompensation). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "gravCompRightArm", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 14.00f)]
public float GravCompRightArm { get; set; } = -1.0f;
/// <summary>
/// gravity compensation applied to spine (applied after gravityCompensation). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "gravCompSpine", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 14.00f)]
public float GravCompSpine { get; set; } = -1.0f;
/// <summary>
/// gravity compensation applied to left leg (applied after gravityCompensation). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "gravCompLeftLeg", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 14.00f)]
public float GravCompLeftLeg { get; set; } = -1.0f;
/// <summary>
/// gravity compensation applied to right leg (applied after gravityCompensation). If -ve then not applied (use current setting)
/// </summary>
[EuphoriaParameter(Name = "gravCompRightLeg", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 14.00f)]
public float GravCompRightLeg { get; set; } = -1.0f;
/// <summary>
/// Is the left hand constrained to the world/ an object: -1=auto decide by impact info, 0=no, 1=part fully constrained (not implemented:, 2=part point constraint, 3=line constraint)
/// </summary>
[EuphoriaParameter(Name = "connectedLeftHand", Type = typeof(int), DefaultValue = 0, MinimumValue = -1, MaximumValue = 2)]
public int ConnectedLeftHand { get; set; } = 0;
/// <summary>
/// Is the right hand constrained to the world/ an object: -1=auto decide by impact info, 0=no, 1=part fully constrained (not implemented:, 2=part point constraint, 3=line constraint)
/// </summary>
[EuphoriaParameter(Name = "connectedRightHand", Type = typeof(int), DefaultValue = 0, MinimumValue = -1, MaximumValue = 2)]
public int ConnectedRightHand { get; set; } = 0;
/// <summary>
/// Is the left foot constrained to the world/ an object: -2=do not set in animpose (e.g. let the balancer decide), -1=auto decide by impact info, 0=no, 1=part fully constrained (not implemented:, 2=part point constraint, 3=line constraint)
/// </summary>
[EuphoriaParameter(Name = "connectedLeftFoot", Type = typeof(int), DefaultValue = -2, MinimumValue = -2, MaximumValue = 2)]
public int ConnectedLeftFoot { get; set; } = -2;
/// <summary>
/// Is the right foot constrained to the world/ an object: -2=do not set in animpose (e.g. let the balancer decide),-1=auto decide by impact info, 0=no, 1=part fully constrained (not implemented:, 2=part point constraint, 3=line constraint)
/// </summary>
[EuphoriaParameter(Name = "connectedRightFoot", Type = typeof(int), DefaultValue = -2, MinimumValue = -2, MaximumValue = 2)]
public int ConnectedRightFoot { get; set; } = -2;
/// <summary>
/// AnimSource 0 = CurrentItms, 1 = PreviousItms, 2 = AnimItms
/// </summary>
[EuphoriaParameter(Name = "animSource", Type = typeof(int), DefaultValue = default(int))]
public int AnimSource { get; set; } = default(int);
/// <summary>
/// LevelIndex of object to dampen side motion relative to. -1 means not used.
/// </summary>
[EuphoriaParameter(Name = "dampenSideMotionInstanceIndex", Type = typeof(int), DefaultValue = -1)]
public int DampenSideMotionInstanceIndex { get; set; } = -1;
public EuphoriaMessageAnimPose(bool startNow) : base("animPose", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageArmsWindmill : EuphoriaMessage
{
/// <summary>
/// ID of part that the circle uses as local space for positioning
/// </summary>
[EuphoriaParameter(Name = "leftPartID", Type = typeof(int), DefaultValue = 10, MinimumValue = 0, MaximumValue = 21)]
public int LeftPartID { get; set; } = 10;
/// <summary>
/// radius for first axis of ellipse
/// </summary>
[EuphoriaParameter(Name = "leftRadius1", Type = typeof(float), DefaultValue = 0.750f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LeftRadius1 { get; set; } = 0.750f;
/// <summary>
/// radius for second axis of ellipse
/// </summary>
[EuphoriaParameter(Name = "leftRadius2", Type = typeof(float), DefaultValue = 0.750f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LeftRadius2 { get; set; } = 0.750f;
/// <summary>
/// speed of target around the circle
/// </summary>
[EuphoriaParameter(Name = "leftSpeed", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = -2.00f, MaximumValue = 2.00f)]
public float LeftSpeed { get; set; } = 1.00f;
/// <summary>
/// Euler Angles orientation of circle in space of part with part ID
/// </summary>
[EuphoriaParameter(Name = "leftNormal", Type = typeof(Vector3))]
public Vector3 LeftNormal { get; set; } = new Vector3(0.00f, 0.20f, 0.20f);
/// <summary>
/// centre of circle in the space of partID
/// </summary>
[EuphoriaParameter(Name = "leftCentre", Type = typeof(Vector3))]
public Vector3 LeftCentre { get; set; } = new Vector3(0.00f, 0.50f, -0.10f);
/// <summary>
/// ID of part that the circle uses as local space for positioning
/// </summary>
[EuphoriaParameter(Name = "rightPartID", Type = typeof(int), DefaultValue = 10, MinimumValue = 0, MaximumValue = 21)]
public int RightPartID { get; set; } = 10;
/// <summary>
/// radius for first axis of ellipse
/// </summary>
[EuphoriaParameter(Name = "rightRadius1", Type = typeof(float), DefaultValue = 0.750f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float RightRadius1 { get; set; } = 0.750f;
/// <summary>
/// radius for second axis of ellipse
/// </summary>
[EuphoriaParameter(Name = "rightRadius2", Type = typeof(float), DefaultValue = 0.750f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float RightRadius2 { get; set; } = 0.750f;
/// <summary>
/// speed of target around the circle
/// </summary>
[EuphoriaParameter(Name = "rightSpeed", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = -2.00f, MaximumValue = 2.00f)]
public float RightSpeed { get; set; } = 1.00f;
/// <summary>
/// Euler Angles orientation of circle in space of part with part ID
/// </summary>
[EuphoriaParameter(Name = "rightNormal", Type = typeof(Vector3))]
public Vector3 RightNormal { get; set; } = new Vector3(0.00f, -0.20f, -0.20f);
/// <summary>
/// centre of circle in the space of partID
/// </summary>
[EuphoriaParameter(Name = "rightCentre", Type = typeof(Vector3))]
public Vector3 RightCentre { get; set; } = new Vector3(0.00f, -0.50f, -0.10f);
/// <summary>
/// Stiffness applied to the shoulders
/// </summary>
[EuphoriaParameter(Name = "shoulderStiffness", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 1.00f, MaximumValue = 16.00f)]
public float ShoulderStiffness { get; set; } = 12.00f;
/// <summary>
/// Damping applied to the shoulders
/// </summary>
[EuphoriaParameter(Name = "shoulderDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float ShoulderDamping { get; set; } = 1.00f;
/// <summary>
/// Stiffness applied to the elbows
/// </summary>
[EuphoriaParameter(Name = "elbowStiffness", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 1.00f, MaximumValue = 16.00f)]
public float ElbowStiffness { get; set; } = 12.00f;
/// <summary>
/// Damping applied to the elbows
/// </summary>
[EuphoriaParameter(Name = "elbowDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float ElbowDamping { get; set; } = 1.00f;
/// <summary>
/// Minimum left elbow bend
/// </summary>
[EuphoriaParameter(Name = "leftElbowMin", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.70f)]
public float LeftElbowMin { get; set; } = 0.50f;
/// <summary>
/// Minimum right elbow bend
/// </summary>
[EuphoriaParameter(Name = "rightElbowMin", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.70f)]
public float RightElbowMin { get; set; } = 0.50f;
/// <summary>
/// phase offset(degrees) when phase synchronization is turned on.
/// </summary>
[EuphoriaParameter(Name = "phaseOffset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -360.00f, MaximumValue = 360.00f)]
public float PhaseOffset { get; set; } = 0.00f;
/// <summary>
/// how much to compensate for movement of character/target
/// </summary>
[EuphoriaParameter(Name = "dragReduction", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float DragReduction { get; set; } = 0.20f;
/// <summary>
/// angle of elbow around twist axis ?
/// </summary>
[EuphoriaParameter(Name = "IKtwist", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -3.141593f, MaximumValue = 3.141593f)]
public float IKtwist { get; set; } = 0.00f;
/// <summary>
/// value of character angular speed above which adaptive arm motion starts
/// </summary>
[EuphoriaParameter(Name = "angVelThreshold", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float AngVelThreshold { get; set; } = 0.10f;
/// <summary>
/// multiplies angular speed of character to get speed of arms
/// </summary>
[EuphoriaParameter(Name = "angVelGain", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float AngVelGain { get; set; } = 1.00f;
/// <summary>
/// 0: circle orientations are independent, 1: they mirror each other, 2: they're parallel (leftArm parmeters are used)
/// </summary>
[EuphoriaParameter(Name = "mirrorMode", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 2)]
public int MirrorMode { get; set; } = 1;
/// <summary>
/// 0:not adaptive, 1:only direction, 2: dir and speed, 3: dir, speed and strength
/// </summary>
[EuphoriaParameter(Name = "adaptiveMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 3)]
public int AdaptiveMode { get; set; } = 0;
/// <summary>
/// toggles phase synchronization
/// </summary>
[EuphoriaParameter(Name = "forceSync", Type = typeof(bool), DefaultValue = default(bool))]
public bool ForceSync { get; set; } = default(bool);
/// <summary>
/// Use the left arm
/// </summary>
[EuphoriaParameter(Name = "useLeft", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseLeft { get; set; } = default(bool);
/// <summary>
/// Use the right arm
/// </summary>
[EuphoriaParameter(Name = "useRight", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseRight { get; set; } = default(bool);
/// <summary>
/// If true, each arm will stop windmilling if it hits the ground
/// </summary>
[EuphoriaParameter(Name = "disableOnImpact", Type = typeof(bool), DefaultValue = default(bool))]
public bool DisableOnImpact { get; set; } = default(bool);
public EuphoriaMessageArmsWindmill(bool startNow) : base("armsWindmill", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageArmsWindmillAdaptive : EuphoriaMessage
{
/// <summary>
/// Controls the speed of the windmilling
/// </summary>
[EuphoriaParameter(Name = "angSpeed", Type = typeof(float), DefaultValue = 6.280f, MinimumValue = 0.10f, MaximumValue = 10.0f)]
public float AngSpeed { get; set; } = 6.280f;
/// <summary>
/// Controls how stiff the rest of the body is
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 11.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float BodyStiffness { get; set; } = 11.000f;
/// <summary>
/// Controls how large the motion is, higher values means the character waves his arms in a massive arc
/// </summary>
[EuphoriaParameter(Name = "amplitude", Type = typeof(float), DefaultValue = 0.600f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float Amplitude { get; set; } = 0.600f;
/// <summary>
/// Set to a non-zero value to desynchronise the left and right arms motion.
/// </summary>
[EuphoriaParameter(Name = "phase", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = -4.0f, MaximumValue = 8.0f)]
public float Phase { get; set; } = 0.000f;
/// <summary>
/// How stiff the arms are controls how pronounced the windmilling motion appears
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 14.140f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffness { get; set; } = 14.140f;
/// <summary>
/// If not negative then left arm will blend to this angle
/// </summary>
[EuphoriaParameter(Name = "leftElbowAngle", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 6.0f)]
public float LeftElbowAngle { get; set; } = -1.0f;
/// <summary>
/// If not negative then right arm will blend to this angle
/// </summary>
[EuphoriaParameter(Name = "rightElbowAngle", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 6.0f)]
public float RightElbowAngle { get; set; } = -1.0f;
/// <summary>
/// 0 arms go up and down at the side. 1 circles. 0..1 elipse
/// </summary>
[EuphoriaParameter(Name = "lean1mult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float Lean1mult { get; set; } = 1.0f;
/// <summary>
/// 0.f centre of circle at side.
/// </summary>
[EuphoriaParameter(Name = "lean1offset", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = -6.0f, MaximumValue = 6.0f)]
public float Lean1offset { get; set; } = 0.0f;
/// <summary>
/// rate at which elbow tries to match *ElbowAngle
/// </summary>
[EuphoriaParameter(Name = "elbowRate", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 6.0f)]
public float ElbowRate { get; set; } = 1.0f;
/// <summary>
/// Arm circling direction. -1 = Backwards, 0 = Adaptive, 1 = Forwards
/// </summary>
[EuphoriaParameter(Name = "armDirection", Type = typeof(int), DefaultValue = 0, MinimumValue = -1, MaximumValue = 1)]
public int ArmDirection { get; set; } = 0;
/// <summary>
/// If true, each arm will stop windmilling if it hits the ground
/// </summary>
[EuphoriaParameter(Name = "disableOnImpact", Type = typeof(bool), DefaultValue = default(bool))]
public bool DisableOnImpact { get; set; } = default(bool);
/// <summary>
/// If true, back angles will be set to compliment arms windmill
/// </summary>
[EuphoriaParameter(Name = "setBackAngles", Type = typeof(bool), DefaultValue = default(bool))]
public bool SetBackAngles { get; set; } = default(bool);
/// <summary>
/// If true, use angular momentum about com to choose arm circling direction. Otherwise use com angular velocity
/// </summary>
[EuphoriaParameter(Name = "useAngMom", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseAngMom { get; set; } = default(bool);
/// <summary>
/// If true, bend the left elbow to give a stuntman type scramble look
/// </summary>
[EuphoriaParameter(Name = "bendLeftElbow", Type = typeof(bool), DefaultValue = default(bool))]
public bool BendLeftElbow { get; set; } = default(bool);
/// <summary>
/// If true, bend the right elbow to give a stuntman type scramble look
/// </summary>
[EuphoriaParameter(Name = "bendRightElbow", Type = typeof(bool), DefaultValue = default(bool))]
public bool BendRightElbow { get; set; } = default(bool);
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "ub")]
public string Mask { get; set; } = "ub";
public EuphoriaMessageArmsWindmillAdaptive(bool startNow) : base("armsWindmillAdaptive", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageBalancerCollisionsReaction : EuphoriaMessage
{
/// <summary>
/// Begin slump and stop stepping after this many steps
/// </summary>
[EuphoriaParameter(Name = "numStepsTillSlump", Type = typeof(int), DefaultValue = 4)]
public int NumStepsTillSlump { get; set; } = 4;
/// <summary>
/// Time after becoming stable leaning against a wall that slump starts
/// </summary>
[EuphoriaParameter(Name = "stable2SlumpTime", Type = typeof(float), DefaultValue = 0.0f)]
public float Stable2SlumpTime { get; set; } = 0.0f;
/// <summary>
/// Steps are ihibited to not go closer to the wall than this (after impact).
/// </summary>
[EuphoriaParameter(Name = "exclusionZone", Type = typeof(float), DefaultValue = 0.2f)]
public float ExclusionZone { get; set; } = 0.2f;
/// <summary>
/// Friction multiplier applied to feet when slump starts
/// </summary>
[EuphoriaParameter(Name = "footFrictionMultStart", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float FootFrictionMultStart { get; set; } = 1.0f;
/// <summary>
/// Friction multiplier reduced by this amount every second after slump starts (only if character is not slumping)
/// </summary>
[EuphoriaParameter(Name = "footFrictionMultRate", Type = typeof(float), DefaultValue = 2.0f, MinimumValue = 0.0f, MaximumValue = 50.0f)]
public float FootFrictionMultRate { get; set; } = 2.0f;
/// <summary>
/// Friction multiplier applied to back when slump starts
/// </summary>
[EuphoriaParameter(Name = "backFrictionMultStart", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float BackFrictionMultStart { get; set; } = 1.0f;
/// <summary>
/// Friction multiplier reduced by this amount every second after slump starts (only if character is not slumping)
/// </summary>
[EuphoriaParameter(Name = "backFrictionMultRate", Type = typeof(float), DefaultValue = 2.0f, MinimumValue = 0.0f, MaximumValue = 50.0f)]
public float BackFrictionMultRate { get; set; } = 2.0f;
/// <summary>
/// Reduce the stiffness of the legs by this much as soon as an impact is detected
/// </summary>
[EuphoriaParameter(Name = "impactLegStiffReduction", Type = typeof(float), DefaultValue = 3.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float ImpactLegStiffReduction { get; set; } = 3.0f;
/// <summary>
/// Reduce the stiffness of the legs by this much as soon as slump starts
/// </summary>
[EuphoriaParameter(Name = "slumpLegStiffReduction", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float SlumpLegStiffReduction { get; set; } = 1.0f;
/// <summary>
/// Rate at which the stiffness of the legs is reduced during slump
/// </summary>
[EuphoriaParameter(Name = "slumpLegStiffRate", Type = typeof(float), DefaultValue = 8.0f, MinimumValue = 0.0f, MaximumValue = 50.0f)]
public float SlumpLegStiffRate { get; set; } = 8.0f;
/// <summary>
/// Time that the character reacts to the impact with ub flinch and writhe
/// </summary>
[EuphoriaParameter(Name = "reactTime", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ReactTime { get; set; } = 0.3f;
/// <summary>
/// Time that the character exaggerates impact with spine
/// </summary>
[EuphoriaParameter(Name = "impactExagTime", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ImpactExagTime { get; set; } = 0.3f;
/// <summary>
/// Duration that the glance torque is applied for
/// </summary>
[EuphoriaParameter(Name = "glanceSpinTime", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float GlanceSpinTime { get; set; } = 0.5f;
/// <summary>
/// Magnitude of the glance torque
/// </summary>
[EuphoriaParameter(Name = "glanceSpinMag", Type = typeof(float), DefaultValue = 50.0f, MinimumValue = 0.0f, MaximumValue = 1000.0f)]
public float GlanceSpinMag { get; set; } = 50.0f;
/// <summary>
/// multiplier used when decaying torque spin over time
/// </summary>
[EuphoriaParameter(Name = "glanceSpinDecayMult", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float GlanceSpinDecayMult { get; set; } = 0.3f;
/// <summary>
/// used so impact with the character that is pushing you over doesn't set off the behaviour
/// </summary>
[EuphoriaParameter(Name = "ignoreColWithIndex", Type = typeof(int), DefaultValue = -2)]
public int IgnoreColWithIndex { get; set; } = -2;
/// <summary>
/// 0=Normal slump(less movement then slump and movement LT small), 1=fast slump, 2=less movement then slump
/// </summary>
[EuphoriaParameter(Name = "slumpMode", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 2)]
public int SlumpMode { get; set; } = 1;
/// <summary>
/// 0=fall2knees/slump if shot not running, 1=stumble, 2=slump, 3=restart
/// </summary>
[EuphoriaParameter(Name = "reboundMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 3)]
public int ReboundMode { get; set; } = 0;
/// <summary>
/// collisions with non-fixed objects with mass below this will not set this behaviour off (e.g. ignore guns)
/// </summary>
[EuphoriaParameter(Name = "ignoreColMassBelow", Type = typeof(float), DefaultValue = 20.0f, MinimumValue = -1.0f, MaximumValue = 1000.0f)]
public float IgnoreColMassBelow { get; set; } = 20.0f;
/// <summary>
/// 0=slump, 1=fallToKnees if shot is running, otherwise slump
/// </summary>
[EuphoriaParameter(Name = "forwardMode", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 1)]
public int ForwardMode { get; set; } = 0;
/// <summary>
/// time after a forwards impact before forwardMode is called (leave sometime for a rebound or brace - the min of 0.1 is to ensure fallOverWall can start although it probably needs only 1or2 frames for the probes to return)
/// </summary>
[EuphoriaParameter(Name = "timeToForward", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.10f, MaximumValue = 2.00f)]
public float TimeToForward { get; set; } = 0.50f;
/// <summary>
/// if forwards impact only: cheat force to try to get the character away from the wall. 3 is a good value.
/// </summary>
[EuphoriaParameter(Name = "reboundForce", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ReboundForce { get; set; } = 0.00f;
/// <summary>
/// Brace against wall if forwards impact(at the moment only if bodyBalance is running/in charge of arms)
/// </summary>
[EuphoriaParameter(Name = "braceWall", Type = typeof(bool), DefaultValue = default(bool))]
public bool BraceWall { get; set; } = default(bool);
/// <summary>
/// collisions with non-fixed objects with volume below this will not set this behaviour off
/// </summary>
[EuphoriaParameter(Name = "ignoreColVolumeBelow", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = -1.0f, MaximumValue = 1000.0f)]
public float IgnoreColVolumeBelow { get; set; } = 0.1f;
/// <summary>
/// use fallOverWall as the main drape reaction
/// </summary>
[EuphoriaParameter(Name = "fallOverWallDrape", Type = typeof(bool), DefaultValue = default(bool))]
public bool FallOverWallDrape { get; set; } = default(bool);
/// <summary>
/// trigger fall over wall if hit up to spine2 else only if hit up to spine1
/// </summary>
[EuphoriaParameter(Name = "fallOverHighWalls", Type = typeof(bool), DefaultValue = default(bool))]
public bool FallOverHighWalls { get; set; } = default(bool);
/// <summary>
/// Add a Snap to when you hit a wall to emphasize the hit.
/// </summary>
[EuphoriaParameter(Name = "snap", Type = typeof(bool), DefaultValue = default(bool))]
public bool Snap { get; set; } = default(bool);
/// <summary>
/// The magnitude of the snap reaction
/// </summary>
[EuphoriaParameter(Name = "snapMag", Type = typeof(float), DefaultValue = -0.60f, MinimumValue = -10.00f, MaximumValue = 10.0f)]
public float SnapMag { get; set; } = -0.60f;
/// <summary>
/// The character snaps in a prescribed way (decided by bullet direction) - Higher the value the more random this direction is.
/// </summary>
[EuphoriaParameter(Name = "snapDirectionRandomness", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float SnapDirectionRandomness { get; set; } = 0.30f;
/// <summary>
/// snap the leftArm.
/// </summary>
[EuphoriaParameter(Name = "snapLeftArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapLeftArm { get; set; } = default(bool);
/// <summary>
/// snap the rightArm.
/// </summary>
[EuphoriaParameter(Name = "snapRightArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapRightArm { get; set; } = default(bool);
/// <summary>
/// snap the leftLeg.
/// </summary>
[EuphoriaParameter(Name = "snapLeftLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapLeftLeg { get; set; } = default(bool);
/// <summary>
/// snap the rightLeg.
/// </summary>
[EuphoriaParameter(Name = "snapRightLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapRightLeg { get; set; } = default(bool);
/// <summary>
/// snap the spine.
/// </summary>
[EuphoriaParameter(Name = "snapSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapSpine { get; set; } = default(bool);
/// <summary>
/// snap the neck.
/// </summary>
[EuphoriaParameter(Name = "snapNeck", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapNeck { get; set; } = default(bool);
/// <summary>
/// Legs are either in phase with each other or not
/// </summary>
[EuphoriaParameter(Name = "snapPhasedLegs", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapPhasedLegs { get; set; } = default(bool);
/// <summary>
/// type of hip reaction 0=none, 1=side2side 2=steplike
/// </summary>
[EuphoriaParameter(Name = "snapHipType", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int SnapHipType { get; set; } = 0;
/// <summary>
/// Interval before applying reverse snap
/// </summary>
[EuphoriaParameter(Name = "unSnapInterval", Type = typeof(float), DefaultValue = 0.010f, MinimumValue = 0.00f, MaximumValue = 100.0f)]
public float UnSnapInterval { get; set; } = 0.010f;
/// <summary>
/// The magnitude of the reverse snap
/// </summary>
[EuphoriaParameter(Name = "unSnapRatio", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 100.0f)]
public float UnSnapRatio { get; set; } = 0.70f;
/// <summary>
/// use torques to make the snap otherwise use a change in the parts angular velocity
/// </summary>
[EuphoriaParameter(Name = "snapUseTorques", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapUseTorques { get; set; } = default(bool);
/// <summary>
/// duration for which the character's upper body stays at minimum stiffness (not quite zero)
/// </summary>
[EuphoriaParameter(Name = "impactWeaknessZeroDuration", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ImpactWeaknessZeroDuration { get; set; } = 0.20f;
/// <summary>
/// duration of the ramp to bring the character's upper body stiffness back to normal levels
/// </summary>
[EuphoriaParameter(Name = "impactWeaknessRampDuration", Type = typeof(float), DefaultValue = 0.010f, MinimumValue = 0.010f, MaximumValue = 10.00f)]
public float ImpactWeaknessRampDuration { get; set; } = 0.010f;
/// <summary>
/// how loose the character is on impact. between 0 and 1
/// </summary>
[EuphoriaParameter(Name = "impactLoosenessAmount", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ImpactLoosenessAmount { get; set; } = 1.00f;
/// <summary>
/// detected an object behind a shot victim in the direction of a bullet?
/// </summary>
[EuphoriaParameter(Name = "objectBehindVictim", Type = typeof(bool), DefaultValue = default(bool))]
public bool ObjectBehindVictim { get; set; } = default(bool);
/// <summary>
/// the intersection pos of a detected object behind a shot victim in the direction of a bullet
/// </summary>
[EuphoriaParameter(Name = "objectBehindVictimPos", Type = typeof(Vector3))]
public Vector3 ObjectBehindVictimPos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// the normal of a detected object behind a shot victim in the direction of a bullet
/// </summary>
[EuphoriaParameter(Name = "objectBehindVictimNormal", Type = typeof(Vector3))]
public Vector3 ObjectBehindVictimNormal { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageBalancerCollisionsReaction(bool startNow) : base("balancerCollisionsReaction", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageBodyBalance : EuphoriaMessage
{
/// <summary>
/// NB. WAS m_bodyStiffness ClaviclesStiffness=9.0f
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 9.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffness { get; set; } = 9.0f;
/// <summary>
/// How much the elbow swings based on the leg movement
/// </summary>
[EuphoriaParameter(Name = "elbow", Type = typeof(float), DefaultValue = 0.9f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float Elbow { get; set; } = 0.9f;
/// <summary>
/// How much the shoulder(lean1) swings based on the leg movement
/// </summary>
[EuphoriaParameter(Name = "shoulder", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float Shoulder { get; set; } = 1.00f;
/// <summary>
/// NB. WAS m_damping NeckDamping=1 ClaviclesDamping=1
/// </summary>
[EuphoriaParameter(Name = "armDamping", Type = typeof(float), DefaultValue = 0.7f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDamping { get; set; } = 0.7f;
/// <summary>
/// enable and provide a look-at target to make the character's head turn to face it while balancing
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// position of thing to look at
/// </summary>
[EuphoriaParameter(Name = "headLookPos", Type = typeof(Vector3))]
public Vector3 HeadLookPos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// level index of thing to look at
/// </summary>
[EuphoriaParameter(Name = "headLookInstanceIndex", Type = typeof(int), DefaultValue = -1)]
public int HeadLookInstanceIndex { get; set; } = -1;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "spineStiffness", Type = typeof(float), DefaultValue = 10.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float SpineStiffness { get; set; } = 10.0f;
/// <summary>
/// multiplier of the somersault 'angle' (lean forward/back) for arms out (lean2)
/// </summary>
[EuphoriaParameter(Name = "somersaultAngle", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float SomersaultAngle { get; set; } = 1.0f;
/// <summary>
/// Amount of somersault 'angle' before m_somersaultAngle is used for ArmsOut. Unless drunk - DO NOT EXCEED 0.8
/// </summary>
[EuphoriaParameter(Name = "somersaultAngleThreshold", Type = typeof(float), DefaultValue = 0.25f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float SomersaultAngleThreshold { get; set; } = 0.25f;
/// <summary>
/// Amount of side somersault 'angle' before sideSomersault is used for ArmsOut. Unless drunk - DO NOT EXCEED 0.8
/// </summary>
[EuphoriaParameter(Name = "sideSomersaultAngle", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float SideSomersaultAngle { get; set; } = 1.0f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "sideSomersaultAngleThreshold", Type = typeof(float), DefaultValue = 0.25f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float SideSomersaultAngleThreshold { get; set; } = 0.25f;
/// <summary>
/// Automatically turn around if moving backwards
/// </summary>
[EuphoriaParameter(Name = "backwardsAutoTurn", Type = typeof(bool), DefaultValue = default(bool))]
public bool BackwardsAutoTurn { get; set; } = default(bool);
/// <summary>
/// 0.9 is a sensible value. If pusher within this distance then turn to get out of the way of the pusher
/// </summary>
[EuphoriaParameter(Name = "turnWithBumpRadius", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 10.00f)]
public float TurnWithBumpRadius { get; set; } = -1.00f;
/// <summary>
/// Bend elbows, relax shoulders and inhibit spine twist when moving backwards
/// </summary>
[EuphoriaParameter(Name = "backwardsArms", Type = typeof(bool), DefaultValue = default(bool))]
public bool BackwardsArms { get; set; } = default(bool);
/// <summary>
/// Blend upper body to zero pose as the character comes to rest. If false blend to a stored pose
/// </summary>
[EuphoriaParameter(Name = "blendToZeroPose", Type = typeof(bool), DefaultValue = default(bool))]
public bool BlendToZeroPose { get; set; } = default(bool);
/// <summary>
/// Put arms out based on lean2 of legs, or angular velocity (lean or twist), or lean (front/back or side/side)
/// </summary>
[EuphoriaParameter(Name = "armsOutOnPush", Type = typeof(bool), DefaultValue = default(bool))]
public bool ArmsOutOnPush { get; set; } = default(bool);
/// <summary>
/// Arms out based on lean2 of the legs to simulate being pushed
/// </summary>
[EuphoriaParameter(Name = "armsOutOnPushMultiplier", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmsOutOnPushMultiplier { get; set; } = 1.0f;
/// <summary>
/// number of seconds before turning off the armsOutOnPush response only for Arms out based on lean2 of the legs (NOT for the angle or angular velocity)
/// </summary>
[EuphoriaParameter(Name = "armsOutOnPushTimeout", Type = typeof(float), DefaultValue = 1.1f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmsOutOnPushTimeout { get; set; } = 1.1f;
/// <summary>
/// range 0:1 0 = don't raise arms if returning to upright position, 0.x = 0.x*raise arms based on angvel and 'angle' settings, 1 = raise arms based on angvel and 'angle' settings
/// </summary>
[EuphoriaParameter(Name = "returningToBalanceArmsOut", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ReturningToBalanceArmsOut { get; set; } = 0.0f;
/// <summary>
/// multiplier for straightening the elbows based on the amount of arms out(lean2) 0 = dont straighten elbows. Otherwise straighten elbows proportionately to armsOut
/// </summary>
[EuphoriaParameter(Name = "armsOutStraightenElbows", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ArmsOutStraightenElbows { get; set; } = 0.0f;
/// <summary>
/// Minimum desiredLean2 applied to shoulder (to stop arms going above shoulder height or not)
/// </summary>
[EuphoriaParameter(Name = "armsOutMinLean2", Type = typeof(float), DefaultValue = -9.9f, MinimumValue = -10.0f, MaximumValue = 0.0f)]
public float ArmsOutMinLean2 { get; set; } = -9.9f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "spineDamping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float SpineDamping { get; set; } = 1.0f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "useBodyTurn", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseBodyTurn { get; set; } = default(bool);
/// <summary>
/// on contact with upperbody the desired elbow angle is set to at least this value
/// </summary>
[EuphoriaParameter(Name = "elbowAngleOnContact", Type = typeof(float), DefaultValue = 1.9f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float ElbowAngleOnContact { get; set; } = 1.9f;
/// <summary>
/// Time after contact (with Upper body) that the min m_elbowAngleOnContact is applied
/// </summary>
[EuphoriaParameter(Name = "bendElbowsTime", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float BendElbowsTime { get; set; } = 0.3f;
/// <summary>
/// Minimum desired angle of elbow during non contact arm swing
/// </summary>
[EuphoriaParameter(Name = "bendElbowsGait", Type = typeof(float), DefaultValue = 0.7f, MinimumValue = -3.0f, MaximumValue = 3.0f)]
public float BendElbowsGait { get; set; } = 0.7f;
/// <summary>
/// mmmmdrunk = 0.2 multiplier of hip lean2 (star jump) to give shoulder lean2 (flapping)
/// </summary>
[EuphoriaParameter(Name = "hipL2ArmL2", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float HipL2ArmL2 { get; set; } = 0.3f;
/// <summary>
/// mmmmdrunk = 0.7 shoulder lean2 offset
/// </summary>
[EuphoriaParameter(Name = "shoulderL2", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = -3.0f, MaximumValue = 3.0f)]
public float ShoulderL2 { get; set; } = 0.5f;
/// <summary>
/// mmmmdrunk 1.1 shoulder lean1 offset (+ve frankenstein)
/// </summary>
[EuphoriaParameter(Name = "shoulderL1", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = -1.0f, MaximumValue = 2.0f)]
public float ShoulderL1 { get; set; } = 0.0f;
/// <summary>
/// mmmmdrunk = 0.0 shoulder twist
/// </summary>
[EuphoriaParameter(Name = "shoulderTwist", Type = typeof(float), DefaultValue = -0.35f, MinimumValue = -3.0f, MaximumValue = 3.0f)]
public float ShoulderTwist { get; set; } = -0.35f;
/// <summary>
/// Probability [0-1] that headLook will be looking in the direction of velocity when stepping
/// </summary>
[EuphoriaParameter(Name = "headLookAtVelProb", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float HeadLookAtVelProb { get; set; } = -1.0f;
/// <summary>
/// Weighted Probability that turn will be off. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnOffProb", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnOffProb { get; set; } = 0.1f;
/// <summary>
/// Weighted Probability of turning towards velocity. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turn2VelProb", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Turn2VelProb { get; set; } = 0.3f;
/// <summary>
/// Weighted Probability of turning away from headLook target. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnAwayProb", Type = typeof(float), DefaultValue = 0.15f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnAwayProb { get; set; } = 0.15f;
/// <summary>
/// Weighted Probability of turning left. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnLeftProb", Type = typeof(float), DefaultValue = 0.125f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnLeftProb { get; set; } = 0.125f;
/// <summary>
/// Weighted Probability of turning right. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnRightProb", Type = typeof(float), DefaultValue = 0.125f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnRightProb { get; set; } = 0.125f;
/// <summary>
/// Weighted Probability of turning towards headLook target. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turn2TargetProb", Type = typeof(float), DefaultValue = 0.2f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Turn2TargetProb { get; set; } = 0.2f;
/// <summary>
/// somersault, twist, sideSomersault) multiplier of the angular velocity for arms out (lean2) (somersault, twist, sideSomersault)
/// </summary>
[EuphoriaParameter(Name = "angVelMultiplier", Type = typeof(Vector3))]
public Vector3 AngVelMultiplier { get; set; } = new Vector3(4.00f, 1.00f, 4.00f);
/// <summary>
/// somersault, twist, sideSomersault) threshold above which angVel is used for arms out (lean2) Unless drunk - DO NOT EXCEED 7.0 for each component
/// </summary>
[EuphoriaParameter(Name = "angVelThreshold", Type = typeof(Vector3))]
public Vector3 AngVelThreshold { get; set; } = new Vector3(1.20f, 3.00f, 1.20f);
/// <summary>
/// if -ve then do not brace. distance from object at which to raise hands to brace 0.5 good if newBrace=true - otherwise 0.65
/// </summary>
[EuphoriaParameter(Name = "braceDistance", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float BraceDistance { get; set; } = -1.00f;
/// <summary>
/// time expected to get arms up from idle
/// </summary>
[EuphoriaParameter(Name = "targetPredictionTime", Type = typeof(float), DefaultValue = 0.450f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TargetPredictionTime { get; set; } = 0.450f;
/// <summary>
/// larger values and he absorbs the impact more
/// </summary>
[EuphoriaParameter(Name = "reachAbsorbtionTime", Type = typeof(float), DefaultValue = 0.150f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ReachAbsorbtionTime { get; set; } = 0.150f;
/// <summary>
/// stiffness of character. catch_fall stiffness scales with this too, with its defaults at this values default
/// </summary>
[EuphoriaParameter(Name = "braceStiffness", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float BraceStiffness { get; set; } = 12.00f;
/// <summary>
/// minimum bracing time so the character doesn't look twitchy
/// </summary>
[EuphoriaParameter(Name = "minBraceTime", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float MinBraceTime { get; set; } = 0.30f;
/// <summary>
/// time before arm brace kicks in when hit from behind
/// </summary>
[EuphoriaParameter(Name = "timeToBackwardsBrace", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TimeToBackwardsBrace { get; set; } = 0.50f;
/// <summary>
/// If bracing with 2 hands delay one hand by at least this amount of time to introduce some asymmetry.
/// </summary>
[EuphoriaParameter(Name = "handsDelayMin", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float HandsDelayMin { get; set; } = 0.30f;
/// <summary>
/// If bracing with 2 hands delay one hand by at most this amount of time to introduce some asymmetry.
/// </summary>
[EuphoriaParameter(Name = "handsDelayMax", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float HandsDelayMax { get; set; } = 0.70f;
/// <summary>
/// braceTarget is global headLookPos plus braceOffset m in the up direction
/// </summary>
[EuphoriaParameter(Name = "braceOffset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -2.00f, MaximumValue = 2.00f)]
public float BraceOffset { get; set; } = 0.00f;
/// <summary>
/// if -ve don't move away from pusher unless moveWhenBracing is true and braceDistance GT 0.0f. if the pusher is closer than moveRadius then move away from it.
/// </summary>
[EuphoriaParameter(Name = "moveRadius", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 2.00f)]
public float MoveRadius { get; set; } = -1.00f;
/// <summary>
/// amount of leanForce applied away from pusher
/// </summary>
[EuphoriaParameter(Name = "moveAmount", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float MoveAmount { get; set; } = 0.30f;
/// <summary>
/// Only move away from pusher when bracing against pusher
/// </summary>
[EuphoriaParameter(Name = "moveWhenBracing", Type = typeof(bool), DefaultValue = default(bool))]
public bool MoveWhenBracing { get; set; } = default(bool);
public EuphoriaMessageBodyBalance(bool startNow) : base("bodyBalance", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageBodyFoetal : EuphoriaMessage
{
/// <summary>
/// The stiffness of the body determines how fast the character moves into the position, and how well that they hold it.
/// </summary>
[EuphoriaParameter(Name = "stiffness", Type = typeof(float), DefaultValue = 9.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float Stiffness { get; set; } = 9.000f;
/// <summary>
/// Sets damping value for the character joints
/// </summary>
[EuphoriaParameter(Name = "dampingFactor", Type = typeof(float), DefaultValue = 1.400f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float DampingFactor { get; set; } = 1.400f;
/// <summary>
/// A value between 0-1 that controls how asymmetric the results are by varying stiffness across the body
/// </summary>
[EuphoriaParameter(Name = "asymmetry", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Asymmetry { get; set; } = 0.000f;
/// <summary>
/// Random seed used to generate asymmetry values
/// </summary>
[EuphoriaParameter(Name = "randomSeed", Type = typeof(int), DefaultValue = 100)]
public int RandomSeed { get; set; } = 100;
/// <summary>
/// Amount of random back twist to add
/// </summary>
[EuphoriaParameter(Name = "backTwist", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float BackTwist { get; set; } = 0.000f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
public EuphoriaMessageBodyFoetal(bool startNow) : base("bodyFoetal", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageBodyRollUp : EuphoriaMessage
{
/// <summary>
/// stiffness of whole body
/// </summary>
[EuphoriaParameter(Name = "stiffness", Type = typeof(float), DefaultValue = 10.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float Stiffness { get; set; } = 10.000f;
/// <summary>
/// the degree to which the character will try to stop a barrel roll with his arms
/// </summary>
[EuphoriaParameter(Name = "useArmToSlowDown", Type = typeof(float), DefaultValue = 1.300f, MinimumValue = -2.0f, MaximumValue = 3.0f)]
public float UseArmToSlowDown { get; set; } = 1.300f;
/// <summary>
/// the likeliness of the character reaching for the ground with its arms
/// </summary>
[EuphoriaParameter(Name = "armReachAmount", Type = typeof(float), DefaultValue = 1.400f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float ArmReachAmount { get; set; } = 1.400f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
/// <summary>
/// used to keep rolling down slope, 1 is full (kicks legs out when pointing upwards)
/// </summary>
[EuphoriaParameter(Name = "legPush", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = -1.0f, MaximumValue = 2.0f)]
public float LegPush { get; set; } = 0.000f;
/// <summary>
/// 0 is no leg asymmetry in 'foetal' position. greater than 0 a asymmetricalLegs-rand(30%), added/minus each joint of the legs in radians. Random number changes about once every roll. 0.4 gives a lot of asymmetry
/// </summary>
[EuphoriaParameter(Name = "asymmetricalLegs", Type = typeof(float), DefaultValue = 0.000f, MinimumValue = -2.0f, MaximumValue = 2.0f)]
public float AsymmetricalLegs { get; set; } = 0.000f;
/// <summary>
/// time that roll velocity has to be lower than rollVelForSuccess, before success message is sent
/// </summary>
[EuphoriaParameter(Name = "noRollTimeBeforeSuccess", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float NoRollTimeBeforeSuccess { get; set; } = 0.50f;
/// <summary>
/// lower threshold for roll velocity at which success message can be sent
/// </summary>
[EuphoriaParameter(Name = "rollVelForSuccess", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float RollVelForSuccess { get; set; } = 0.20f;
/// <summary>
/// contribution of linear COM velocity to roll Velocity (if 0, roll velocity equal to COM angular velocity)
/// </summary>
[EuphoriaParameter(Name = "rollVelLinearContribution", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float RollVelLinearContribution { get; set; } = 1.00f;
/// <summary>
/// Scales perceived body velocity. The higher this value gets, the more quickly the velocity measure saturates, resulting in a tighter roll at slower speeds. (NB: Set to 1 to match earlier behaviour)
/// </summary>
[EuphoriaParameter(Name = "velocityScale", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float VelocityScale { get; set; } = 0.20f;
/// <summary>
/// Offsets perceived body velocity. Increase to create larger "dead zone" around zero velocity where character will be less rolled. (NB: Reset to 0 to match earlier behaviour)
/// </summary>
[EuphoriaParameter(Name = "velocityOffset", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float VelocityOffset { get; set; } = 2.00f;
/// <summary>
/// Controls whether or not behaviour enforces min/max friction
/// </summary>
[EuphoriaParameter(Name = "applyMinMaxFriction", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyMinMaxFriction { get; set; } = default(bool);
public EuphoriaMessageBodyRollUp(bool startNow) : base("bodyRollUp", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageBodyWrithe : EuphoriaMessage
{
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 13.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffness { get; set; } = 13.000f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "backStiffness", Type = typeof(float), DefaultValue = 13.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float BackStiffness { get; set; } = 13.000f;
/// <summary>
/// The stiffness of the character will determine how 'determined' a writhe this is - high values will make him thrash about wildly
/// </summary>
[EuphoriaParameter(Name = "legStiffness", Type = typeof(float), DefaultValue = 13.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float LegStiffness { get; set; } = 13.000f;
/// <summary>
/// damping amount, less is underdamped
/// </summary>
[EuphoriaParameter(Name = "armDamping", Type = typeof(float), DefaultValue = 0.500f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float ArmDamping { get; set; } = 0.500f;
/// <summary>
/// damping amount, less is underdamped
/// </summary>
[EuphoriaParameter(Name = "backDamping", Type = typeof(float), DefaultValue = 0.500f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float BackDamping { get; set; } = 0.500f;
/// <summary>
/// damping amount, less is underdamped
/// </summary>
[EuphoriaParameter(Name = "legDamping", Type = typeof(float), DefaultValue = 0.500f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float LegDamping { get; set; } = 0.500f;
/// <summary>
/// Controls how fast the writhe is executed, smaller values make faster motions
/// </summary>
[EuphoriaParameter(Name = "armPeriod", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.010f, MaximumValue = 4.0f)]
public float ArmPeriod { get; set; } = 1.000f;
/// <summary>
/// Controls how fast the writhe is executed, smaller values make faster motions
/// </summary>
[EuphoriaParameter(Name = "backPeriod", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.010f, MaximumValue = 4.0f)]
public float BackPeriod { get; set; } = 1.000f;
/// <summary>
/// Controls how fast the writhe is executed, smaller values make faster motions
/// </summary>
[EuphoriaParameter(Name = "legPeriod", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.010f, MaximumValue = 4.0f)]
public float LegPeriod { get; set; } = 1.000f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "armAmplitude", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float ArmAmplitude { get; set; } = 1.000f;
/// <summary>
/// scales the amount of writhe. 0 = no writhe
/// </summary>
[EuphoriaParameter(Name = "backAmplitude", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float BackAmplitude { get; set; } = 1.000f;
/// <summary>
/// scales the amount of writhe. 0 = no writhe
/// </summary>
[EuphoriaParameter(Name = "legAmplitude", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float LegAmplitude { get; set; } = 1.000f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "elbowAmplitude", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float ElbowAmplitude { get; set; } = 1.000f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "kneeAmplitude", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float KneeAmplitude { get; set; } = 1.000f;
/// <summary>
/// Flag to set trying to rollOver
/// </summary>
[EuphoriaParameter(Name = "rollOverFlag", Type = typeof(bool), DefaultValue = default(bool))]
public bool RollOverFlag { get; set; } = default(bool);
/// <summary>
/// Blend the writhe arms with the current desired arms (0=don't apply any writhe, 1=only writhe)
/// </summary>
[EuphoriaParameter(Name = "blendArms", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float BlendArms { get; set; } = 1.0f;
/// <summary>
/// Blend the writhe spine and neck with the current desired (0=don't apply any writhe, 1=only writhe)
/// </summary>
[EuphoriaParameter(Name = "blendBack", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float BlendBack { get; set; } = 1.0f;
/// <summary>
/// Blend the writhe legs with the current desired legs (0=don't apply any writhe, 1=only writhe)
/// </summary>
[EuphoriaParameter(Name = "blendLegs", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float BlendLegs { get; set; } = 1.0f;
/// <summary>
/// Use writhe stiffnesses if true. If false don't set any stiffnesses
/// </summary>
[EuphoriaParameter(Name = "applyStiffness", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyStiffness { get; set; } = default(bool);
/// <summary>
/// Extra shoulderBlend. Rolling:one way only, maxRollOverTime, rollOverRadius, doesn't reduce arm stiffness to help rolling. No shoulder twist
/// </summary>
[EuphoriaParameter(Name = "onFire", Type = typeof(bool), DefaultValue = default(bool))]
public bool OnFire { get; set; } = default(bool);
/// <summary>
/// Blend writhe shoulder desired lean1 with this angle in RAD. Note that onFire has to be set to true for this parameter to take any effect.
/// </summary>
[EuphoriaParameter(Name = "shoulderLean1", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 6.283185f)]
public float ShoulderLean1 { get; set; } = 0.70f;
/// <summary>
/// Blend writhe shoulder desired lean2 with this angle in RAD. Note that onFire has to be set to true for this parameter to take any effect.
/// </summary>
[EuphoriaParameter(Name = "shoulderLean2", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 6.283185f)]
public float ShoulderLean2 { get; set; } = 0.40f;
/// <summary>
/// Shoulder desired lean1 with shoulderLean1 angle blend factor. Set it to 0 to use original shoulder withe desired lean1 angle for shoulders. Note that onFire has to be set to true for this parameter to take any effect.
/// </summary>
[EuphoriaParameter(Name = "lean1BlendFactor", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Lean1BlendFactor { get; set; } = 0.00f;
/// <summary>
/// Shoulder desired lean2 with shoulderLean2 angle blend factor. Set it to 0 to use original shoulder withe desired lean2 angle for shoulders. Note that onFire has to be set to true for this parameter to take any effect.
/// </summary>
[EuphoriaParameter(Name = "lean2BlendFactor", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Lean2BlendFactor { get; set; } = 0.00f;
/// <summary>
/// Scale rolling torque that is applied to character spine.
/// </summary>
[EuphoriaParameter(Name = "rollTorqueScale", Type = typeof(float), DefaultValue = 150.00f, MinimumValue = 0.00f, MaximumValue = 300.00f)]
public float RollTorqueScale { get; set; } = 150.00f;
/// <summary>
/// Rolling torque is ramped down over time. At this time in seconds torque value converges to zero. Use this parameter to restrict time the character is rolling. Note that onFire has to be set to true for this parameter to take any effect.
/// </summary>
[EuphoriaParameter(Name = "maxRollOverTime", Type = typeof(float), DefaultValue = 8.00f, MinimumValue = 0.00f, MaximumValue = 60.00f)]
public float MaxRollOverTime { get; set; } = 8.00f;
/// <summary>
/// Rolling torque is ramped down with distance measured from position where character hit the ground and started rolling. At this distance in meters torque value converges to zero. Use this parameter to restrict distance the character travels due to rolling. Note that onFire has to be set to true for this parameter to take any effect.
/// </summary>
[EuphoriaParameter(Name = "rollOverRadius", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float RollOverRadius { get; set; } = 2.00f;
public EuphoriaMessageBodyWrithe(bool startNow) : base("bodyWrithe", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageBraceForImpact : EuphoriaMessage
{
/// <summary>
/// distance from object at which to raise hands to brace 0.5 good if newBrace=true - otherwise 0.65
/// </summary>
[EuphoriaParameter(Name = "braceDistance", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float BraceDistance { get; set; } = 0.50f;
/// <summary>
/// time epected to get arms up from idle
/// </summary>
[EuphoriaParameter(Name = "targetPredictionTime", Type = typeof(float), DefaultValue = 0.450f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TargetPredictionTime { get; set; } = 0.450f;
/// <summary>
/// larger values and he absorbs the impact more
/// </summary>
[EuphoriaParameter(Name = "reachAbsorbtionTime", Type = typeof(float), DefaultValue = 0.150f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ReachAbsorbtionTime { get; set; } = 0.150f;
/// <summary>
/// levelIndex of object to brace
/// </summary>
[EuphoriaParameter(Name = "instanceIndex", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndex { get; set; } = -1;
/// <summary>
/// stiffness of character. catch_fall stiffness scales with this too, with its defaults at this values default
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float BodyStiffness { get; set; } = 12.00f;
/// <summary>
/// Once a constraint is made, keep reaching with whatever hand is allowed
/// </summary>
[EuphoriaParameter(Name = "grabDontLetGo", Type = typeof(bool), DefaultValue = default(bool))]
public bool GrabDontLetGo { get; set; } = default(bool);
/// <summary>
/// strength in hands for grabbing (kg m/s), -1 to ignore/disable
/// </summary>
[EuphoriaParameter(Name = "grabStrength", Type = typeof(float), DefaultValue = 40.00f, MinimumValue = -1.00f, MaximumValue = 1000.00f)]
public float GrabStrength { get; set; } = 40.00f;
/// <summary>
/// Relative distance at which the grab starts.
/// </summary>
[EuphoriaParameter(Name = "grabDistance", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 4.00f)]
public float GrabDistance { get; set; } = 2.00f;
/// <summary>
/// Angle from front at which the grab activates. If the point is outside this angle from front will not try to grab.
/// </summary>
[EuphoriaParameter(Name = "grabReachAngle", Type = typeof(float), DefaultValue = 1.50f, MinimumValue = 0.00f, MaximumValue = 3.160f)]
public float GrabReachAngle { get; set; } = 1.50f;
/// <summary>
/// amount of time, in seconds, before grab automatically bails
/// </summary>
[EuphoriaParameter(Name = "grabHoldTimer", Type = typeof(float), DefaultValue = 2.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GrabHoldTimer { get; set; } = 2.50f;
/// <summary>
/// Don't try to grab a car moving above this speed mmmmtodo make this the relative velocity of car to character?
/// </summary>
[EuphoriaParameter(Name = "maxGrabCarVelocity", Type = typeof(float), DefaultValue = 95.00f, MinimumValue = 0.00f, MaximumValue = 1000.00f)]
public float MaxGrabCarVelocity { get; set; } = 95.00f;
/// <summary>
/// Balancer leg stiffness mmmmtodo remove this parameter and use configureBalance?
/// </summary>
[EuphoriaParameter(Name = "legStiffness", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float LegStiffness { get; set; } = 12.00f;
/// <summary>
/// time before arm brace kicks in when hit from behind
/// </summary>
[EuphoriaParameter(Name = "timeToBackwardsBrace", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TimeToBackwardsBrace { get; set; } = 1.00f;
/// <summary>
/// position to look at, e.g. the driver
/// </summary>
[EuphoriaParameter(Name = "look", Type = typeof(Vector3))]
public Vector3 Look { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// location of the front part of the object to brace against. This should be the centre of where his hands should meet the object
/// </summary>
[EuphoriaParameter(Name = "pos", Type = typeof(Vector3))]
public Vector3 Pos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// minimum bracing time so the character doesn't look twitchy
/// </summary>
[EuphoriaParameter(Name = "minBraceTime", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float MinBraceTime { get; set; } = 0.30f;
/// <summary>
/// If bracing with 2 hands delay one hand by at least this amount of time to introduce some asymmetry.
/// </summary>
[EuphoriaParameter(Name = "handsDelayMin", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float HandsDelayMin { get; set; } = 0.10f;
/// <summary>
/// If bracing with 2 hands delay one hand by at most this amount of time to introduce some asymmetry.
/// </summary>
[EuphoriaParameter(Name = "handsDelayMax", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float HandsDelayMax { get; set; } = 0.30f;
/// <summary>
/// move away from the car (if in reaching zone)
/// </summary>
[EuphoriaParameter(Name = "moveAway", Type = typeof(bool), DefaultValue = default(bool))]
public bool MoveAway { get; set; } = default(bool);
/// <summary>
/// forceLean away amount (-ve is lean towards)
/// </summary>
[EuphoriaParameter(Name = "moveAwayAmount", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float MoveAwayAmount { get; set; } = 0.10f;
/// <summary>
/// Lean away amount (-ve is lean towards)
/// </summary>
[EuphoriaParameter(Name = "moveAwayLean", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = -0.5f, MaximumValue = 0.5f)]
public float MoveAwayLean { get; set; } = 0.050f;
/// <summary>
/// Amount of sideways movement if at the front or back of the car to add to the move away from car
/// </summary>
[EuphoriaParameter(Name = "moveSideways", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float MoveSideways { get; set; } = 0.30f;
/// <summary>
/// Use bodyBalance arms for the default (non bracing) behaviour if bodyBalance is active
/// </summary>
[EuphoriaParameter(Name = "bbArms", Type = typeof(bool), DefaultValue = default(bool))]
public bool BbArms { get; set; } = default(bool);
/// <summary>
/// Use the new brace prediction code
/// </summary>
[EuphoriaParameter(Name = "newBrace", Type = typeof(bool), DefaultValue = default(bool))]
public bool NewBrace { get; set; } = default(bool);
/// <summary>
/// If true then if a shin or thigh is in contact with the car then brace. NB: newBrace must be true. For those situations where the car has pushed the ped backwards (at the same speed as the car) before the behaviour has been started and so doesn't predict an impact.
/// </summary>
[EuphoriaParameter(Name = "braceOnImpact", Type = typeof(bool), DefaultValue = default(bool))]
public bool BraceOnImpact { get; set; } = default(bool);
/// <summary>
/// When rollDownStairs is running use roll2Velocity to control the helper torques (this only attempts to roll to the chaarcter's velocity not some default linear velocity mag
/// </summary>
[EuphoriaParameter(Name = "roll2Velocity", Type = typeof(bool), DefaultValue = default(bool))]
public bool Roll2Velocity { get; set; } = default(bool);
/// <summary>
/// 0 = original/roll off/stay on car: Roll with character velocity, 1 = //Gentle: roll off/stay on car = use relative velocity of character to car to roll against, 2 = //roll over car: Roll against character velocity. i.e. roll against any velocity picked up by hitting car, 3 = //Gentle: roll over car: use relative velocity of character to car to roll with
/// </summary>
[EuphoriaParameter(Name = "rollType", Type = typeof(int), DefaultValue = 3, MinimumValue = 0, MaximumValue = 3)]
public int RollType { get; set; } = 3;
/// <summary>
/// Exaggerate impacts using snap
/// </summary>
[EuphoriaParameter(Name = "snapImpacts", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapImpacts { get; set; } = default(bool);
/// <summary>
/// Exaggeration amount of the initial impact (legs). +ve fold with car impact (as if pushed at hips in the car velocity direction). -ve fold away from car impact
/// </summary>
[EuphoriaParameter(Name = "snapImpact", Type = typeof(float), DefaultValue = 7.00f, MinimumValue = -20.00f, MaximumValue = 20.00f)]
public float SnapImpact { get; set; } = 7.00f;
/// <summary>
/// Exaggeration amount of the secondary (torso) impact with bonnet. +ve fold with car impact (as if pushed at hips by the impact normal). -ve fold away from car impact
/// </summary>
[EuphoriaParameter(Name = "snapBonnet", Type = typeof(float), DefaultValue = -7.00f, MinimumValue = -20.00f, MaximumValue = 20.00f)]
public float SnapBonnet { get; set; } = -7.00f;
/// <summary>
/// Exaggeration amount of the impact with the floor after falling off of car +ve fold with floor impact (as if pushed at hips in the impact normal direction). -ve fold away from car impact
/// </summary>
[EuphoriaParameter(Name = "snapFloor", Type = typeof(float), DefaultValue = 7.00f, MinimumValue = -20.00f, MaximumValue = 20.00f)]
public float SnapFloor { get; set; } = 7.00f;
/// <summary>
/// Damp out excessive spin and upward velocity when on car
/// </summary>
[EuphoriaParameter(Name = "dampVel", Type = typeof(bool), DefaultValue = default(bool))]
public bool DampVel { get; set; } = default(bool);
/// <summary>
/// Amount to damp spinning by (cartwheeling and somersaulting)
/// </summary>
[EuphoriaParameter(Name = "dampSpin", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 40.00f)]
public float DampSpin { get; set; } = 0.00f;
/// <summary>
/// Amount to damp upward velocity by to limit the amount of air above the car the character can get.
/// </summary>
[EuphoriaParameter(Name = "dampUpVel", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 0.00f, MaximumValue = 40.00f)]
public float DampUpVel { get; set; } = 10.00f;
/// <summary>
/// Angular velocity above which we start damping
/// </summary>
[EuphoriaParameter(Name = "dampSpinThresh", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float DampSpinThresh { get; set; } = 4.00f;
/// <summary>
/// Upward velocity above which we start damping
/// </summary>
[EuphoriaParameter(Name = "dampUpVelThresh", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float DampUpVelThresh { get; set; } = 2.00f;
/// <summary>
/// Enhance a glancing spin with the side of the car by modulating body friction.
/// </summary>
[EuphoriaParameter(Name = "gsHelp", Type = typeof(bool), DefaultValue = default(bool))]
public bool GsHelp { get; set; } = default(bool);
/// <summary>
/// ID for glancing spin. min depth to be considered from either end (front/rear) of a car (-ve is inside the car area)
/// </summary>
[EuphoriaParameter(Name = "gsEndMin", Type = typeof(float), DefaultValue = -0.10f, MinimumValue = -10.00f, MaximumValue = 1.00f)]
public float GsEndMin { get; set; } = -0.10f;
/// <summary>
/// ID for glancing spin. min depth to be considered on the side of a car (-ve is inside the car area)
/// </summary>
[EuphoriaParameter(Name = "gsSideMin", Type = typeof(float), DefaultValue = -0.20f, MinimumValue = -10.00f, MaximumValue = 1.00f)]
public float GsSideMin { get; set; } = -0.20f;
/// <summary>
/// ID for glancing spin. max depth to be considered on the side of a car (+ve is outside the car area)
/// </summary>
[EuphoriaParameter(Name = "gsSideMax", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = -10.00f, MaximumValue = 1.00f)]
public float GsSideMax { get; set; } = 0.50f;
/// <summary>
/// ID for glancing spin. Character has to be more upright than this value for it to be considered on the side of a car. Fully upright = 1, upsideDown = -1. Max Angle from upright is acos(gsUpness)
/// </summary>
[EuphoriaParameter(Name = "gsUpness", Type = typeof(float), DefaultValue = 0.90f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GsUpness { get; set; } = 0.90f;
/// <summary>
/// ID for glancing spin. Minimum car velocity.
/// </summary>
[EuphoriaParameter(Name = "gsCarVelMin", Type = typeof(float), DefaultValue = 3.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GsCarVelMin { get; set; } = 3.00f;
/// <summary>
/// Apply gsFricScale1 to the foot if colliding with car. (Otherwise foot friction - with the ground - is determined by gsFricScale2 if it is in gsFricMask2)
/// </summary>
[EuphoriaParameter(Name = "gsScale1Foot", Type = typeof(bool), DefaultValue = default(bool))]
public bool GsScale1Foot { get; set; } = default(bool);
/// <summary>
/// Glancing spin help. Friction scale applied when to the side of the car. e.g. make the character spin more by upping the friction against the car
/// </summary>
[EuphoriaParameter(Name = "gsFricScale1", Type = typeof(float), DefaultValue = 8.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GsFricScale1 { get; set; } = 8.00f;
/// <summary>
/// Glancing spin help. Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see notes for explanation). Note gsFricMask1 and gsFricMask2 are made independent by the code so you can have fb for gsFricMask1 but gsFricScale1 will not be applied to any bodyParts in gsFricMask2
/// </summary>
[EuphoriaParameter(Name = "gsFricMask1", Type = typeof(string), DefaultValue = "fb")]
public string GsFricMask1 { get; set; } = "fb";
/// <summary>
/// Glancing spin help. Friction scale applied when to the side of the car. e.g. make the character spin more by lowering the feet friction. You could also lower the wrist friction here to stop the car pulling along the hands i.e. gsFricMask2 = la|uw
/// </summary>
[EuphoriaParameter(Name = "gsFricScale2", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GsFricScale2 { get; set; } = 0.20f;
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see notes for explanation). Note gsFricMask1 and gsFricMask2 are made independent by the code so you can have fb for gsFricMask1 but gsFricScale1 will not be applied to any bodyParts in gsFricMask2
/// </summary>
[EuphoriaParameter(Name = "gsFricMask2", Type = typeof(string), DefaultValue = "la")]
public string GsFricMask2 { get; set; } = "la";
public EuphoriaMessageBraceForImpact(bool startNow) : base("braceForImpact", startNow)
{ }
}
/// <summary>
/// buoyancy: Simple buoyancy model. No character movement just fluid forces/torques added to parts.
/// </summary>
internal class EuphoriaMessageBuoyancy : EuphoriaMessage
{
/// <summary>
/// Arbitrary point on surface of water.
/// </summary>
[EuphoriaParameter(Name = "surfacePoint", Type = typeof(Vector3))]
public Vector3 SurfacePoint { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Normal to surface of water.
/// </summary>
[EuphoriaParameter(Name = "surfaceNormal", Type = typeof(Vector3))]
public Vector3 SurfaceNormal { get; set; } = new Vector3(0f, 0f, 1f);
/// <summary>
/// Buoyancy multiplier.
/// </summary>
[EuphoriaParameter(Name = "buoyancy", Type = typeof(float), DefaultValue = 1.0f)]
public float Buoyancy { get; set; } = 1.0f;
/// <summary>
/// Buoyancy mulplier for spine2/3. Helps character float upright.
/// </summary>
[EuphoriaParameter(Name = "chestBuoyancy", Type = typeof(float), DefaultValue = 8.0f)]
public float ChestBuoyancy { get; set; } = 8.0f;
/// <summary>
/// Damping for submerged parts.
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 40.0f)]
public float Damping { get; set; } = 40.0f;
/// <summary>
/// Use righting torque to being character face-up in water?
/// </summary>
[EuphoriaParameter(Name = "righting", Type = typeof(bool), DefaultValue = default(bool))]
public bool Righting { get; set; } = default(bool);
/// <summary>
/// Strength of righting torque.
/// </summary>
[EuphoriaParameter(Name = "rightingStrength", Type = typeof(float), DefaultValue = 25.0f)]
public float RightingStrength { get; set; } = 25.0f;
/// <summary>
/// How long to wait after chest hits water to begin righting torque.
/// </summary>
[EuphoriaParameter(Name = "rightingTime", Type = typeof(float), DefaultValue = 1.0f)]
public float RightingTime { get; set; } = 1.0f;
public EuphoriaMessageBuoyancy(bool startNow) : base("buoyancy", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageCatchFall : EuphoriaMessage
{
/// <summary>
/// stiffness of torso
/// </summary>
[EuphoriaParameter(Name = "torsoStiffness", Type = typeof(float), DefaultValue = 9.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float TorsoStiffness { get; set; } = 9.0f;
/// <summary>
/// stiffness of legs
/// </summary>
[EuphoriaParameter(Name = "legsStiffness", Type = typeof(float), DefaultValue = 6.0f, MinimumValue = 4.0f, MaximumValue = 16.0f)]
public float LegsStiffness { get; set; } = 6.0f;
/// <summary>
/// stiffness of arms
/// </summary>
[EuphoriaParameter(Name = "armsStiffness", Type = typeof(float), DefaultValue = 15.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmsStiffness { get; set; } = 15.0f;
/// <summary>
/// 0 will prop arms up near his shoulders. -0.3 will place hands nearer his behind
/// </summary>
[EuphoriaParameter(Name = "backwardsMinArmOffset", Type = typeof(float), DefaultValue = -0.25f, MinimumValue = -1.0f, MaximumValue = 0.0f)]
public float BackwardsMinArmOffset { get; set; } = -0.25f;
/// <summary>
/// 0 will point arms down with angled body, 0.45 will point arms forward a bit to catch nearer the head
/// </summary>
[EuphoriaParameter(Name = "forwardMaxArmOffset", Type = typeof(float), DefaultValue = 0.35f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ForwardMaxArmOffset { get; set; } = 0.35f;
/// <summary>
/// Tries to reduce the spin around the Z axis. Scale 0 - 1.
/// </summary>
[EuphoriaParameter(Name = "zAxisSpinReduction", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ZAxisSpinReduction { get; set; } = 0.0f;
/// <summary>
/// Scale extra-sit value 0..1. Setting to 0 helps with arched-back issues. Set to 1 for a more alive-looking finish.
/// </summary>
[EuphoriaParameter(Name = "extraSit", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ExtraSit { get; set; } = 1.0f;
/// <summary>
/// Toggle to use the head look in this behaviour.
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// Two character body-masking value, bitwise joint mask or bitwise logic string of two character body-masking value (see Active Pose notes for possible values)
/// </summary>
[EuphoriaParameter(Name = "mask", Type = typeof(string), DefaultValue = "fb")]
public string Mask { get; set; } = "fb";
public EuphoriaMessageCatchFall(bool startNow) : base("catchFall", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageElectrocute : EuphoriaMessage
{
/// <summary>
/// The magnitude of the reaction
/// </summary>
[EuphoriaParameter(Name = "stunMag", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float StunMag { get; set; } = 0.250f;
/// <summary>
/// initialMult*stunMag = The magnitude of the 1st snap reaction (other mults are applied after this)
/// </summary>
[EuphoriaParameter(Name = "initialMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float InitialMult { get; set; } = 1.00f;
/// <summary>
/// largeMult*stunMag = The magnitude of a random large snap reaction (other mults are applied after this)
/// </summary>
[EuphoriaParameter(Name = "largeMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 20.0f)]
public float LargeMult { get; set; } = 1.00f;
/// <summary>
/// min time to next large random snap (about 14 snaps with stunInterval = 0.07s)
/// </summary>
[EuphoriaParameter(Name = "largeMinTime", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 200.00f)]
public float LargeMinTime { get; set; } = 1.00f;
/// <summary>
/// max time to next large random snap (about 28 snaps with stunInterval = 0.07s)
/// </summary>
[EuphoriaParameter(Name = "largeMaxTime", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 200.00f)]
public float LargeMaxTime { get; set; } = 2.00f;
/// <summary>
/// movingMult*stunMag = The magnitude of the reaction if moving(comVelMag) faster than movingThresh
/// </summary>
[EuphoriaParameter(Name = "movingMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float MovingMult { get; set; } = 1.00f;
/// <summary>
/// balancingMult*stunMag = The magnitude of the reaction if balancing = (not lying on the floor/ not upper body not collided) and not airborne
/// </summary>
[EuphoriaParameter(Name = "balancingMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float BalancingMult { get; set; } = 1.00f;
/// <summary>
/// airborneMult*stunMag = The magnitude of the reaction if airborne
/// </summary>
[EuphoriaParameter(Name = "airborneMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float AirborneMult { get; set; } = 1.00f;
/// <summary>
/// If moving(comVelMag) faster than movingThresh then mvingMult applied to stunMag
/// </summary>
[EuphoriaParameter(Name = "movingThresh", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 20.00f)]
public float MovingThresh { get; set; } = 1.00f;
/// <summary>
/// Direction flips every stunInterval
/// </summary>
[EuphoriaParameter(Name = "stunInterval", Type = typeof(float), DefaultValue = 0.070f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float StunInterval { get; set; } = 0.070f;
/// <summary>
/// The character vibrates in a prescribed way - Higher the value the more random this direction is.
/// </summary>
[EuphoriaParameter(Name = "directionRandomness", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float DirectionRandomness { get; set; } = 0.30f;
/// <summary>
/// vibrate the leftArm.
/// </summary>
[EuphoriaParameter(Name = "leftArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool LeftArm { get; set; } = default(bool);
/// <summary>
/// vibrate the rightArm.
/// </summary>
[EuphoriaParameter(Name = "rightArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool RightArm { get; set; } = default(bool);
/// <summary>
/// vibrate the leftLeg.
/// </summary>
[EuphoriaParameter(Name = "leftLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool LeftLeg { get; set; } = default(bool);
/// <summary>
/// vibrate the rightLeg.
/// </summary>
[EuphoriaParameter(Name = "rightLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool RightLeg { get; set; } = default(bool);
/// <summary>
/// vibrate the spine.
/// </summary>
[EuphoriaParameter(Name = "spine", Type = typeof(bool), DefaultValue = default(bool))]
public bool Spine { get; set; } = default(bool);
/// <summary>
/// vibrate the neck.
/// </summary>
[EuphoriaParameter(Name = "neck", Type = typeof(bool), DefaultValue = default(bool))]
public bool Neck { get; set; } = default(bool);
/// <summary>
/// Legs are either in phase with each other or not
/// </summary>
[EuphoriaParameter(Name = "phasedLegs", Type = typeof(bool), DefaultValue = default(bool))]
public bool PhasedLegs { get; set; } = default(bool);
/// <summary>
/// let electrocute apply a (higher generally) stiffness to the character whilst being vibrated
/// </summary>
[EuphoriaParameter(Name = "applyStiffness", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyStiffness { get; set; } = default(bool);
/// <summary>
/// use torques to make vibration otherwise use a change in the parts angular velocity
/// </summary>
[EuphoriaParameter(Name = "useTorques", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseTorques { get; set; } = default(bool);
/// <summary>
/// type of hip reaction 0=none, 1=side2side 2=steplike
/// </summary>
[EuphoriaParameter(Name = "hipType", Type = typeof(int), DefaultValue = 2, MinimumValue = 0, MaximumValue = 2)]
public int HipType { get; set; } = 2;
public EuphoriaMessageElectrocute(bool startNow) : base("electrocute", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageFallOverWall : EuphoriaMessage
{
/// <summary>
/// stiffness of the body, roll up stiffness scales with this and defaults at this default value
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 9.000f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float BodyStiffness { get; set; } = 9.000f;
/// <summary>
/// Damping in the effectors
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 0.500f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float Damping { get; set; } = 0.500f;
/// <summary>
/// Magnitude of the falloverWall helper force
/// </summary>
[EuphoriaParameter(Name = "magOfForce", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float MagOfForce { get; set; } = 0.50f;
/// <summary>
/// The maximum distance away from the pelvis that hit points will be registered.
/// </summary>
[EuphoriaParameter(Name = "maxDistanceFromPelToHitPoint", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.010f, MaximumValue = 1.00f)]
public float MaxDistanceFromPelToHitPoint { get; set; } = 0.250f;
/// <summary>
/// maximum distance between hitPoint and body part at which forces are applied to part
/// </summary>
[EuphoriaParameter(Name = "maxForceDist", Type = typeof(float), DefaultValue = 0.80f, MinimumValue = 0.010f, MaximumValue = 2.00f)]
public float MaxForceDist { get; set; } = 0.80f;
/// <summary>
/// Specifies extent of area in front of the wall in which balancer won't try to take another step
/// </summary>
[EuphoriaParameter(Name = "stepExclusionZone", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.010f, MaximumValue = 2.00f)]
public float StepExclusionZone { get; set; } = 0.50f;
/// <summary>
/// minimum height of pelvis above feet at which fallOverWall is attempted
/// </summary>
[EuphoriaParameter(Name = "minLegHeight", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.10f, MaximumValue = 2.00f)]
public float MinLegHeight { get; set; } = 0.40f;
/// <summary>
/// amount of twist to apply to the spine as the character tries to fling himself over the wall, provides more of a believable roll but increases the amount of lateral space the character needs to successfully flip.
/// </summary>
[EuphoriaParameter(Name = "bodyTwist", Type = typeof(float), DefaultValue = 0.540f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float BodyTwist { get; set; } = 0.540f;
/// <summary>
/// max angle the character can twist before twsit helper torques are turned off
/// </summary>
[EuphoriaParameter(Name = "maxTwist", Type = typeof(float), DefaultValue = 3.141593f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float MaxTwist { get; set; } = 3.141593f;
/// <summary>
/// One end of the wall to try to fall over.
/// </summary>
[EuphoriaParameter(Name = "fallOverWallEndA", Type = typeof(Vector3))]
public Vector3 FallOverWallEndA { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// One end of the wall over which we are trying to fall over.
/// </summary>
[EuphoriaParameter(Name = "fallOverWallEndB", Type = typeof(Vector3))]
public Vector3 FallOverWallEndB { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// The angle abort threshold.
/// </summary>
[EuphoriaParameter(Name = "forceAngleAbort", Type = typeof(float), DefaultValue = -0.20f)]
public float ForceAngleAbort { get; set; } = -0.20f;
/// <summary>
/// The force time out.
/// </summary>
[EuphoriaParameter(Name = "forceTimeOut", Type = typeof(float), DefaultValue = 2.00f)]
public float ForceTimeOut { get; set; } = 2.00f;
/// <summary>
/// Lift the arms up if true. Do nothing with the arms if false (eg when using catchfall arms or brace etc)
/// </summary>
[EuphoriaParameter(Name = "moveArms", Type = typeof(bool), DefaultValue = default(bool))]
public bool MoveArms { get; set; } = default(bool);
/// <summary>
/// Move the legs if true. Do nothing with the legs if false (eg when using dynamicBalancer etc)
/// </summary>
[EuphoriaParameter(Name = "moveLegs", Type = typeof(bool), DefaultValue = default(bool))]
public bool MoveLegs { get; set; } = default(bool);
/// <summary>
/// Bend spine to help falloverwall if true. Do nothing with the spine if false.
/// </summary>
[EuphoriaParameter(Name = "bendSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool BendSpine { get; set; } = default(bool);
/// <summary>
/// Maximum angle in degrees (between the direction of the velocity of the COM and the wall normal) to start to apply forces and torques to fall over the wall.
/// </summary>
[EuphoriaParameter(Name = "angleDirWithWallNormal", Type = typeof(float), DefaultValue = 180.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float AngleDirWithWallNormal { get; set; } = 180.00f;
/// <summary>
/// Maximum angle in degrees (between the vertical vector and a vector from pelvis to lower neck) to start to apply forces and torques to fall over the wall.
/// </summary>
[EuphoriaParameter(Name = "leaningAngleThreshold", Type = typeof(float), DefaultValue = 180.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float LeaningAngleThreshold { get; set; } = 180.00f;
/// <summary>
/// if the angular velocity is higher than maxAngVel, the torques and forces are not applied.
/// </summary>
[EuphoriaParameter(Name = "maxAngVel", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = -1.00f, MaximumValue = 30.00f)]
public float MaxAngVel { get; set; } = 2.00f;
/// <summary>
/// Will reduce the magnitude of the forces applied to the character to help him to fall over wall
/// </summary>
[EuphoriaParameter(Name = "adaptForcesToLowWall", Type = typeof(bool), DefaultValue = default(bool))]
public bool AdaptForcesToLowWall { get; set; } = default(bool);
/// <summary>
/// Maximum height (from the lowest foot) to start to apply forces and torques to fall over the wall.
/// </summary>
[EuphoriaParameter(Name = "maxWallHeight", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 3.00f)]
public float MaxWallHeight { get; set; } = -1.00f;
/// <summary>
/// Minimum distance between the pelvis and the wall to send the success message. If negative doesn't take this parameter into account when sending feedback.
/// </summary>
[EuphoriaParameter(Name = "distanceToSendSuccessMessage", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 3.00f)]
public float DistanceToSendSuccessMessage { get; set; } = -1.00f;
/// <summary>
/// Value of the angular velocity about the wallEgde above which the character is considered as rolling backwards i.e. goes in to fow_RollingBack state
/// </summary>
[EuphoriaParameter(Name = "rollingBackThr", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float RollingBackThr { get; set; } = 0.50f;
/// <summary>
/// On impact with the wall if the rollingPotential(calculated from the characters linear velocity w.r.t the wall) is greater than this value the character will try to go over the wall otherwise it won't try (fow_Aborted).
/// </summary>
[EuphoriaParameter(Name = "rollingPotential", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = -1.00f, MaximumValue = 10.00f)]
public float RollingPotential { get; set; } = 0.30f;
/// <summary>
/// Try to reach the wallEdge. To configure the IK : use limitAngleBack, limitAngleFront and limitAngleTotallyBack.
/// </summary>
[EuphoriaParameter(Name = "useArmIK", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseArmIK { get; set; } = default(bool);
/// <summary>
/// distance from predicted hitpoint where each hands will try to reach the wall.
/// </summary>
[EuphoriaParameter(Name = "reachDistanceFromHitPoint", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ReachDistanceFromHitPoint { get; set; } = 0.30f;
/// <summary>
/// minimal distance from predicted hitpoint where each hands will try to reach the wall. Used if the hand target is outside the wall Edge.
/// </summary>
[EuphoriaParameter(Name = "minReachDistanceFromHitPoint", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float MinReachDistanceFromHitPoint { get; set; } = 0.10f;
/// <summary>
/// max angle in degrees (between 1.the vector between two hips and 2. wallEdge) to try to reach the wall just behind his pelvis with his arms when the character is back to the wall.
/// </summary>
[EuphoriaParameter(Name = "angleTotallyBack", Type = typeof(float), DefaultValue = 15.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float AngleTotallyBack { get; set; } = 15.00f;
public EuphoriaMessageFallOverWall(bool startNow) : base("fallOverWall", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageGrab : EuphoriaMessage
{
/// <summary>
/// Flag to toggle use of left hand
/// </summary>
[EuphoriaParameter(Name = "useLeft", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseLeft { get; set; } = default(bool);
/// <summary>
/// Flag to toggle the use of the Right hand
/// </summary>
[EuphoriaParameter(Name = "useRight", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseRight { get; set; } = default(bool);
/// <summary>
/// if hasn't grabbed when weapon carrying hand is close to target, grab anyway
/// </summary>
[EuphoriaParameter(Name = "dropWeaponIfNecessary", Type = typeof(bool), DefaultValue = default(bool))]
public bool DropWeaponIfNecessary { get; set; } = default(bool);
/// <summary>
/// distance below which a weapon carrying hand will request weapon to be dropped
/// </summary>
[EuphoriaParameter(Name = "dropWeaponDistance", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float DropWeaponDistance { get; set; } = 0.30f;
/// <summary>
/// strength in hands for grabbing (kg m/s), -1 to ignore/disable
/// </summary>
[EuphoriaParameter(Name = "grabStrength", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10000.0f)]
public float GrabStrength { get; set; } = -1.0f;
/// <summary>
/// strength of cheat force on hands to pull towards target and stick to target ("cleverHandIK" strength)
/// </summary>
[EuphoriaParameter(Name = "stickyHands", Type = typeof(float), DefaultValue = 4.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float StickyHands { get; set; } = 4.0f;
/// <summary>
/// 0=don't turn, 1=turnToTarget, 2=turnAwayFromTarget
/// </summary>
[EuphoriaParameter(Name = "turnToTarget", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 2)]
public int TurnToTarget { get; set; } = 1;
/// <summary>
/// amount of time, in seconds, before grab automatically bails
/// </summary>
[EuphoriaParameter(Name = "grabHoldMaxTimer", Type = typeof(float), DefaultValue = 100.0f, MinimumValue = 0.0f, MaximumValue = 1000.0f)]
public float GrabHoldMaxTimer { get; set; } = 100.0f;
/// <summary>
/// Time to reach the full pullup strength
/// </summary>
[EuphoriaParameter(Name = "pullUpTime", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float PullUpTime { get; set; } = 1.0f;
/// <summary>
/// Strength to pull up with the right arm. 0 = no pull up.
/// </summary>
[EuphoriaParameter(Name = "pullUpStrengthRight", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float PullUpStrengthRight { get; set; } = 0.0f;
/// <summary>
/// Strength to pull up with the left arm. 0 = no pull up.
/// </summary>
[EuphoriaParameter(Name = "pullUpStrengthLeft", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float PullUpStrengthLeft { get; set; } = 0.0f;
/// <summary>
/// Grab pos1, right hand if not using line or surface grab.
/// </summary>
[EuphoriaParameter(Name = "pos1", Type = typeof(Vector3))]
public Vector3 Pos1 { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Grab pos2, left hand if not using line or surface grab.
/// </summary>
[EuphoriaParameter(Name = "pos2", Type = typeof(Vector3))]
public Vector3 Pos2 { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "pos3", Type = typeof(Vector3))]
public Vector3 Pos3 { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "pos4", Type = typeof(Vector3))]
public Vector3 Pos4 { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Normal for the right grab point.
/// </summary>
[EuphoriaParameter(Name = "normalR", Type = typeof(Vector3))]
public Vector3 NormalR { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Normal for the left grab point.
/// </summary>
[EuphoriaParameter(Name = "normalL", Type = typeof(Vector3))]
public Vector3 NormalL { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Normal for the 2nd right grab point (if pointsX4grab=true).
/// </summary>
[EuphoriaParameter(Name = "normalR2", Type = typeof(Vector3))]
public Vector3 NormalR2 { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Normal for the 3rd left grab point (if pointsX4grab=true).
/// </summary>
[EuphoriaParameter(Name = "normalL2", Type = typeof(Vector3))]
public Vector3 NormalL2 { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Hand collisions on when grabbing (false turns off hand collisions making grab more stable esp. to grab points slightly inside geometry)
/// </summary>
[EuphoriaParameter(Name = "handsCollide", Type = typeof(bool), DefaultValue = default(bool))]
public bool HandsCollide { get; set; } = default(bool);
/// <summary>
/// Flag to toggle between grabbing and bracing
/// </summary>
[EuphoriaParameter(Name = "justBrace", Type = typeof(bool), DefaultValue = default(bool))]
public bool JustBrace { get; set; } = default(bool);
/// <summary>
/// use the line grab, Grab along the line (x-x2)
/// </summary>
[EuphoriaParameter(Name = "useLineGrab", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseLineGrab { get; set; } = default(bool);
/// <summary>
/// use 2 point
/// </summary>
[EuphoriaParameter(Name = "pointsX4grab", Type = typeof(bool), DefaultValue = default(bool))]
public bool PointsX4grab { get; set; } = default(bool);
/// <summary>
/// use 2 point
/// </summary>
[EuphoriaParameter(Name = "fromEA", Type = typeof(bool), DefaultValue = default(bool))]
public bool FromEA { get; set; } = default(bool);
/// <summary>
/// Toggle surface grab on. Requires pos1,pos2,pos3 and pos4 to be specified.
/// </summary>
[EuphoriaParameter(Name = "surfaceGrab", Type = typeof(bool), DefaultValue = default(bool))]
public bool SurfaceGrab { get; set; } = default(bool);
/// <summary>
/// levelIndex of instance to grab (-1 = world coordinates)
/// </summary>
[EuphoriaParameter(Name = "instanceIndex", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndex { get; set; } = -1;
/// <summary>
/// boundIndex of part on instance to grab (0 = just use instance coordinates)
/// </summary>
[EuphoriaParameter(Name = "instancePartIndex", Type = typeof(int), DefaultValue = 0)]
public int InstancePartIndex { get; set; } = 0;
/// <summary>
/// Once a constraint is made, keep reaching with whatever hand is allowed - no matter what the angle/distance and whether or not the constraint has broken due to constraintForce GT grabStrength. mmmtodo this is a badly named parameter
/// </summary>
[EuphoriaParameter(Name = "dontLetGo", Type = typeof(bool), DefaultValue = default(bool))]
public bool DontLetGo { get; set; } = default(bool);
/// <summary>
/// stiffness of upper body. Scales the arm grab such that the armStiffness is default when this is at default value
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 11.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float BodyStiffness { get; set; } = 11.0f;
/// <summary>
/// Angle from front at which the grab activates. If the point is outside this angle from front will not try to grab.
/// </summary>
[EuphoriaParameter(Name = "reachAngle", Type = typeof(float), DefaultValue = 2.80f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float ReachAngle { get; set; } = 2.80f;
/// <summary>
/// Angle at which we will only reach with one hand.
/// </summary>
[EuphoriaParameter(Name = "oneSideReachAngle", Type = typeof(float), DefaultValue = 1.4f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float OneSideReachAngle { get; set; } = 1.4f;
/// <summary>
/// Relative distance at which the grab starts.
/// </summary>
[EuphoriaParameter(Name = "grabDistance", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float GrabDistance { get; set; } = 1.0f;
/// <summary>
/// Relative distance (additional to grabDistance - doesn't try to move inside grabDistance)at which the grab tries to use the balancer to move to the grab point.
/// </summary>
[EuphoriaParameter(Name = "move2Radius", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 14.0f)]
public float Move2Radius { get; set; } = 0.0f;
/// <summary>
/// Stiffness of the arm.
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 14.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffness { get; set; } = 14.0f;
/// <summary>
/// distance to reach out towards the grab point.
/// </summary>
[EuphoriaParameter(Name = "maxReachDistance", Type = typeof(float), DefaultValue = 0.7f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float MaxReachDistance { get; set; } = 0.7f;
/// <summary>
/// scale torque used to rotate hands to face normals
/// </summary>
[EuphoriaParameter(Name = "orientationConstraintScale", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float OrientationConstraintScale { get; set; } = 1.0f;
/// <summary>
/// When we are grabbing the max angle the wrist ccan be at before we break the grab.
/// </summary>
[EuphoriaParameter(Name = "maxWristAngle", Type = typeof(float), DefaultValue = 3.141593f, MinimumValue = 0.0f, MaximumValue = 3.151593f)]
public float MaxWristAngle { get; set; } = 3.141593f;
/// <summary>
/// if true, the character will look at targetForHeadLook after a hand grabs until the end of the behavior. (Before grabbing it looks at the grab target)
/// </summary>
[EuphoriaParameter(Name = "useHeadLookToTarget", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLookToTarget { get; set; } = default(bool);
/// <summary>
/// if true, the character will look at the grab
/// </summary>
[EuphoriaParameter(Name = "lookAtGrab", Type = typeof(bool), DefaultValue = default(bool))]
public bool LookAtGrab { get; set; } = default(bool);
/// <summary>
/// Only used if useHeadLookToTarget is true, the target in world space to look at.
/// </summary>
[EuphoriaParameter(Name = "targetForHeadLook", Type = typeof(Vector3))]
public Vector3 TargetForHeadLook { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageGrab(bool startNow) : base("grab", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageHeadLook : EuphoriaMessage
{
/// <summary>
/// Damping of the muscles
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 1.000f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float Damping { get; set; } = 1.000f;
/// <summary>
/// Stiffness of the muscles
/// </summary>
[EuphoriaParameter(Name = "stiffness", Type = typeof(float), DefaultValue = 10.000f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float Stiffness { get; set; } = 10.000f;
/// <summary>
/// levelIndex of object to be looked at. vel parameters are ignored if this is non -1
/// </summary>
[EuphoriaParameter(Name = "instanceIndex", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndex { get; set; } = -1;
/// <summary>
/// The velocity of the point being looked at
/// </summary>
[EuphoriaParameter(Name = "vel", Type = typeof(Vector3))]
public Vector3 Vel { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// The point being looked at
/// </summary>
[EuphoriaParameter(Name = "pos", Type = typeof(Vector3))]
public Vector3 Pos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Flag to force always to look
/// </summary>
[EuphoriaParameter(Name = "alwaysLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysLook { get; set; } = default(bool);
/// <summary>
/// Keep the eyes horizontal. Use true for impact with cars. Use false if you want better look at target accuracy when the character is on the floor or leaned over alot.
/// </summary>
[EuphoriaParameter(Name = "eyesHorizontal", Type = typeof(bool), DefaultValue = default(bool))]
public bool EyesHorizontal { get; set; } = default(bool);
/// <summary>
/// Keep the eyes horizontal. Use true for impact with cars. Use false if you want better look at target accuracy when the character is on the floor or leaned over (when not leaned over the eyes are still kept horizontal if eyesHorizontal=true ) alot.
/// </summary>
[EuphoriaParameter(Name = "alwaysEyesHorizontal", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysEyesHorizontal { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "keepHeadAwayFromGround", Type = typeof(bool), DefaultValue = default(bool))]
public bool KeepHeadAwayFromGround { get; set; } = default(bool);
/// <summary>
/// Allow headlook to twist spine.
/// </summary>
[EuphoriaParameter(Name = "twistSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool TwistSpine { get; set; } = default(bool);
public EuphoriaMessageHeadLook(bool startNow) : base("headLook", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageHighFall : EuphoriaMessage
{
/// <summary>
/// stiffness of body. Value feeds through to bodyBalance (synched with defaults), to armsWindmill (14 for this value at default ), legs pedal, head look and roll down stairs directly
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 11.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float BodyStiffness { get; set; } = 11.00f;
/// <summary>
/// The damping of the joints.
/// </summary>
[EuphoriaParameter(Name = "bodydamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float Bodydamping { get; set; } = 1.00f;
/// <summary>
/// The length of time before the impact that the character transitions to the landing.
/// </summary>
[EuphoriaParameter(Name = "catchfalltime", Type = typeof(float), DefaultValue = 0.300f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Catchfalltime { get; set; } = 0.300f;
/// <summary>
/// 0.52angle is 0.868 dot//A threshold for deciding how far away from upright the character needs to be before bailing out (going into a foetal) instead of trying to land (keeping stretched out). NB: never does bailout if ignorWorldCollisions true
/// </summary>
[EuphoriaParameter(Name = "crashOrLandCutOff", Type = typeof(float), DefaultValue = 0.8680f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CrashOrLandCutOff { get; set; } = 0.8680f;
/// <summary>
/// Strength of the controller to keep the character at angle aimAngleBase from vertical.
/// </summary>
[EuphoriaParameter(Name = "pdStrength", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float PdStrength { get; set; } = 0.00f;
/// <summary>
/// Damping multiplier of the controller to keep the character at angle aimAngleBase from vertical. The actual damping is pdDamping*pdStrength*constant*angVel.
/// </summary>
[EuphoriaParameter(Name = "pdDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float PdDamping { get; set; } = 1.00f;
/// <summary>
/// arm circling speed in armWindMillAdaptive
/// </summary>
[EuphoriaParameter(Name = "armAngSpeed", Type = typeof(float), DefaultValue = 7.850f, MinimumValue = 0.00f, MaximumValue = 20.0f)]
public float ArmAngSpeed { get; set; } = 7.850f;
/// <summary>
/// in armWindMillAdaptive
/// </summary>
[EuphoriaParameter(Name = "armAmplitude", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ArmAmplitude { get; set; } = 2.00f;
/// <summary>
/// in armWindMillAdaptive 3.1 opposite for stuntman. 1.0 old default. 0.0 in phase.
/// </summary>
[EuphoriaParameter(Name = "armPhase", Type = typeof(float), DefaultValue = 3.10f, MinimumValue = 0.00f, MaximumValue = 6.283185f)]
public float ArmPhase { get; set; } = 3.10f;
/// <summary>
/// in armWindMillAdaptive bend the elbows as a function of armAngle. For stuntman true otherwise false.
/// </summary>
[EuphoriaParameter(Name = "armBendElbows", Type = typeof(bool), DefaultValue = default(bool))]
public bool ArmBendElbows { get; set; } = default(bool);
/// <summary>
/// radius of legs on pedal
/// </summary>
[EuphoriaParameter(Name = "legRadius", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.010f, MaximumValue = 0.50f)]
public float LegRadius { get; set; } = 0.40f;
/// <summary>
/// in pedal
/// </summary>
[EuphoriaParameter(Name = "legAngSpeed", Type = typeof(float), DefaultValue = 7.850f, MinimumValue = 0.00f, MaximumValue = 15.0f)]
public float LegAngSpeed { get; set; } = 7.850f;
/// <summary>
/// 0.0 for stuntman. Random offset applied per leg to the angular speed to desynchronise the pedaling - set to 0 to disable, otherwise should be set to less than the angularSpeed value.
/// </summary>
[EuphoriaParameter(Name = "legAsymmetry", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = -10.00f, MaximumValue = 10.00f)]
public float LegAsymmetry { get; set; } = 4.00f;
/// <summary>
/// phase angle between the arms and legs circling angle
/// </summary>
[EuphoriaParameter(Name = "arms2LegsPhase", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 6.50f)]
public float Arms2LegsPhase { get; set; } = 0.00f;
/// <summary>
/// 0=not synched, 1=always synched, 2= synch at start only. Synchs the arms angle to what the leg angle is. All speed/direction parameters of armswindmill are overwritten if = 1. If 2 and you want synced arms/legs then armAngSpeed=legAngSpeed, legAsymmetry = 0.0 (to stop randomizations of the leg cicle speed)
/// </summary>
[EuphoriaParameter(Name = "arms2LegsSync", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 2)]
public int Arms2LegsSync { get; set; } = 1;
/// <summary>
/// Where to put the arms when preparing to land. Approx 1 = above head, 0 = head height, -1 = down. LT -2.0 use catchFall arms, LT -3.0 use prepare for landing pose if Agent is due to land vertically, feet first.
/// </summary>
[EuphoriaParameter(Name = "armsUp", Type = typeof(float), DefaultValue = -3.10f, MinimumValue = -4.00f, MaximumValue = 2.00f)]
public float ArmsUp { get; set; } = -3.10f;
/// <summary>
/// toggle to orientate to fall direction. i.e. orientate so that the character faces the horizontal velocity direction
/// </summary>
[EuphoriaParameter(Name = "orientateBodyToFallDirection", Type = typeof(bool), DefaultValue = default(bool))]
public bool OrientateBodyToFallDirection { get; set; } = default(bool);
/// <summary>
/// If false don't worry about the twist angle of the character when orientating the character. If false this allows the twist axis of the character to be free (You can get a nice twisting highFall like the one in dieHard 4 when the car goes into the helicopter)
/// </summary>
[EuphoriaParameter(Name = "orientateTwist", Type = typeof(bool), DefaultValue = default(bool))]
public bool OrientateTwist { get; set; } = default(bool);
/// <summary>
/// DEVEL parameter - suggest you don't edit it. Maximum torque the orientation controller can apply. If 0 then no helper torques will be used. 300 will orientate the character soflty for all but extreme angles away from aimAngleBase. If abs (current -aimAngleBase) is getting near 3.0 then this can be reduced to give a softer feel.
/// </summary>
[EuphoriaParameter(Name = "orientateMax", Type = typeof(float), DefaultValue = 300.00f, MinimumValue = 0.00f, MaximumValue = 2000.00f)]
public float OrientateMax { get; set; } = 300.00f;
/// <summary>
/// If true then orientate the character to face the point from where it started falling. HighFall like the one in dieHard with Alan Rickman
/// </summary>
[EuphoriaParameter(Name = "alanRickman", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlanRickman { get; set; } = default(bool);
/// <summary>
/// Try to execute a forward Roll on landing
/// </summary>
[EuphoriaParameter(Name = "fowardRoll", Type = typeof(bool), DefaultValue = default(bool))]
public bool FowardRoll { get; set; } = default(bool);
/// <summary>
/// Blend to a zero pose when forward roll is attempted.
/// </summary>
[EuphoriaParameter(Name = "useZeroPose_withFowardRoll", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseZeroPose_withFowardRoll { get; set; } = default(bool);
/// <summary>
/// Angle from vertical the pdController is driving to ( positive = forwards)
/// </summary>
[EuphoriaParameter(Name = "aimAngleBase", Type = typeof(float), DefaultValue = 0.180f, MinimumValue = -3.141593f, MaximumValue = 3.141593f)]
public float AimAngleBase { get; set; } = 0.180f;
/// <summary>
/// scale to add/subtract from aimAngle based on forward speed (Internal)
/// </summary>
[EuphoriaParameter(Name = "fowardVelRotation", Type = typeof(float), DefaultValue = -0.020f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float FowardVelRotation { get; set; } = -0.020f;
/// <summary>
/// Scale to change to amount of vel that is added to the foot ik from the velocity (Internal)
/// </summary>
[EuphoriaParameter(Name = "footVelCompScale", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FootVelCompScale { get; set; } = 0.050f;
/// <summary>
/// sideoffset for the feet during prepareForLanding. +ve = right.
/// </summary>
[EuphoriaParameter(Name = "sideD", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float SideD { get; set; } = 0.20f;
/// <summary>
/// Forward offset for the feet during prepareForLanding
/// </summary>
[EuphoriaParameter(Name = "fowardOffsetOfLegIK", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FowardOffsetOfLegIK { get; set; } = 0.00f;
/// <summary>
/// Leg Length for ik (Internal)//unused
/// </summary>
[EuphoriaParameter(Name = "legL", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float LegL { get; set; } = 1.00f;
/// <summary>
/// 0.5angle is 0.878 dot. Cutoff to go to the catchFall ( internal) //mmmtodo do like crashOrLandCutOff
/// </summary>
[EuphoriaParameter(Name = "catchFallCutOff", Type = typeof(float), DefaultValue = 0.8780f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CatchFallCutOff { get; set; } = 0.8780f;
/// <summary>
/// Strength of the legs at landing
/// </summary>
[EuphoriaParameter(Name = "legStrength", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 6.00f, MaximumValue = 16.0f)]
public float LegStrength { get; set; } = 12.00f;
/// <summary>
/// If true have enough strength to balance. If false not enough strength in legs to balance (even though bodyBlance called)
/// </summary>
[EuphoriaParameter(Name = "balance", Type = typeof(bool), DefaultValue = default(bool))]
public bool Balance { get; set; } = default(bool);
/// <summary>
/// Never go into bailout (foetal)
/// </summary>
[EuphoriaParameter(Name = "ignorWorldCollisions", Type = typeof(bool), DefaultValue = default(bool))]
public bool IgnorWorldCollisions { get; set; } = default(bool);
/// <summary>
/// stuntman type fall. Arm and legs circling direction controlled by angmom and orientation
/// </summary>
[EuphoriaParameter(Name = "adaptiveCircling", Type = typeof(bool), DefaultValue = default(bool))]
public bool AdaptiveCircling { get; set; } = default(bool);
/// <summary>
/// With stuntman type fall. Hula reaction if can't see floor and not rotating fast
/// </summary>
[EuphoriaParameter(Name = "hula", Type = typeof(bool), DefaultValue = default(bool))]
public bool Hula { get; set; } = default(bool);
/// <summary>
/// Character needs to be moving less than this speed to consider fall as a recoverable one.
/// </summary>
[EuphoriaParameter(Name = "maxSpeedForRecoverableFall", Type = typeof(float), DefaultValue = 15.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float MaxSpeedForRecoverableFall { get; set; } = 15.00f;
/// <summary>
/// Character needs to be moving at least this fast horizontally to start bracing for impact if there is an object along its trajectory.
/// </summary>
[EuphoriaParameter(Name = "minSpeedForBrace", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float MinSpeedForBrace { get; set; } = 10.00f;
/// <summary>
/// Ray-cast normal doted with up direction has to be greater than this number to consider object flat enough to land on it.
/// </summary>
[EuphoriaParameter(Name = "landingNormal", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LandingNormal { get; set; } = 0.60f;
public EuphoriaMessageHighFall(bool startNow) : base("highFall", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageIncomingTransforms : EuphoriaMessage
{
public EuphoriaMessageIncomingTransforms(bool startNow) : base("incomingTransforms", startNow)
{ }
}
/// <summary>
/// InjuredOnGround
/// </summary>
internal class EuphoriaMessageInjuredOnGround : EuphoriaMessage
{
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "numInjuries", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int NumInjuries { get; set; } = 0;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "injury1Component", Type = typeof(int), DefaultValue = 0)]
public int Injury1Component { get; set; } = 0;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "injury2Component", Type = typeof(int), DefaultValue = 0)]
public int Injury2Component { get; set; } = 0;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "injury1LocalPosition", Type = typeof(Vector3))]
public Vector3 Injury1LocalPosition { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "injury2LocalPosition", Type = typeof(Vector3))]
public Vector3 Injury2LocalPosition { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "injury1LocalNormal", Type = typeof(Vector3))]
public Vector3 Injury1LocalNormal { get; set; } = new Vector3(1f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "injury2LocalNormal", Type = typeof(Vector3))]
public Vector3 Injury2LocalNormal { get; set; } = new Vector3(1f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "attackerPos", Type = typeof(Vector3))]
public Vector3 AttackerPos { get; set; } = new Vector3(1f, 0f, 0f);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "dontReachWithLeft", Type = typeof(bool), DefaultValue = default(bool))]
public bool DontReachWithLeft { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "dontReachWithRight", Type = typeof(bool), DefaultValue = default(bool))]
public bool DontReachWithRight { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "strongRollForce", Type = typeof(bool), DefaultValue = default(bool))]
public bool StrongRollForce { get; set; } = default(bool);
public EuphoriaMessageInjuredOnGround(bool startNow) : base("injuredOnGround", startNow)
{ }
}
/// <summary>
/// Carried
/// </summary>
internal class EuphoriaMessageCarried : EuphoriaMessage
{
public EuphoriaMessageCarried(bool startNow) : base("carried", startNow)
{ }
}
/// <summary>
/// Dangle
/// </summary>
internal class EuphoriaMessageDangle : EuphoriaMessage
{
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "doGrab", Type = typeof(bool), DefaultValue = default(bool))]
public bool DoGrab { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "grabFrequency", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float GrabFrequency { get; set; } = 1.00f;
public EuphoriaMessageDangle(bool startNow) : base("dangle", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageOnFire : EuphoriaMessage
{
/// <summary>
/// Max time for stumbling around before falling to ground.
/// </summary>
[EuphoriaParameter(Name = "staggerTime", Type = typeof(float), DefaultValue = 2.50f, MinimumValue = 0.00f, MaximumValue = 30.00f)]
public float StaggerTime { get; set; } = 2.50f;
/// <summary>
/// How quickly the character leans hips when staggering.
/// </summary>
[EuphoriaParameter(Name = "staggerLeanRate", Type = typeof(float), DefaultValue = 0.90f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float StaggerLeanRate { get; set; } = 0.90f;
/// <summary>
/// max the character leans hips back when staggering
/// </summary>
[EuphoriaParameter(Name = "stumbleMaxLeanBack", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 1.50f)]
public float StumbleMaxLeanBack { get; set; } = 0.40f;
/// <summary>
/// max the character leans hips forwards when staggering
/// </summary>
[EuphoriaParameter(Name = "stumbleMaxLeanForward", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.50f)]
public float StumbleMaxLeanForward { get; set; } = 0.50f;
/// <summary>
/// Blend armsWindmill with the bodyWrithe arms when character is upright.
/// </summary>
[EuphoriaParameter(Name = "armsWindmillWritheBlend", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ArmsWindmillWritheBlend { get; set; } = 0.40f;
/// <summary>
/// Blend spine stumble with the bodyWrithe spine when character is upright.
/// </summary>
[EuphoriaParameter(Name = "spineStumbleWritheBlend", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float SpineStumbleWritheBlend { get; set; } = 0.70f;
/// <summary>
/// Blend legs stumble with the bodyWrithe legs when character is upright.
/// </summary>
[EuphoriaParameter(Name = "legsStumbleWritheBlend", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LegsStumbleWritheBlend { get; set; } = 0.20f;
/// <summary>
/// Blend the bodyWrithe arms with the current desired pose from on fire behaviour when character is on the floor.
/// </summary>
[EuphoriaParameter(Name = "armsPoseWritheBlend", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ArmsPoseWritheBlend { get; set; } = 0.70f;
/// <summary>
/// Blend the bodyWrithe back with the current desired pose from on fire behaviour when character is on the floor.
/// </summary>
[EuphoriaParameter(Name = "spinePoseWritheBlend", Type = typeof(float), DefaultValue = 0.550f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float SpinePoseWritheBlend { get; set; } = 0.550f;
/// <summary>
/// Blend the bodyWrithe legs with the current desired pose from on fire behaviour when character is on the floor.
/// </summary>
[EuphoriaParameter(Name = "legsPoseWritheBlend", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LegsPoseWritheBlend { get; set; } = 0.50f;
/// <summary>
/// Flag to set bodyWrithe trying to rollOver.
/// </summary>
[EuphoriaParameter(Name = "rollOverFlag", Type = typeof(bool), DefaultValue = default(bool))]
public bool RollOverFlag { get; set; } = default(bool);
/// <summary>
/// Scale rolling torque that is applied to character spine by bodyWrithe. Torque magnitude is calculated with the following formula: m_rollOverDirection*rollOverPhase*rollTorqueScale.
/// </summary>
[EuphoriaParameter(Name = "rollTorqueScale", Type = typeof(float), DefaultValue = 25.00f, MinimumValue = 0.00f, MaximumValue = 300.00f)]
public float RollTorqueScale { get; set; } = 25.00f;
/// <summary>
/// Character pose depends on character facing direction that is evaluated from its COMTM orientation. Set this value to 0 to use no orientation prediction i.e. current character COMTM orientation will be used to determine character facing direction and finally the pose bodyWrithe is blending to. Set this value to GT 0 to predict character COMTM orientation this amout of time in seconds to the future.
/// </summary>
[EuphoriaParameter(Name = "predictTime", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float PredictTime { get; set; } = 0.10f;
/// <summary>
/// Rolling torque is ramped down over time. At this time in seconds torque value converges to zero. Use this parameter to restrict time the character is rolling.
/// </summary>
[EuphoriaParameter(Name = "maxRollOverTime", Type = typeof(float), DefaultValue = 8.00f, MinimumValue = 0.00f, MaximumValue = 60.00f)]
public float MaxRollOverTime { get; set; } = 8.00f;
/// <summary>
/// Rolling torque is ramped down with distance measured from position where character hit the ground and started rolling. At this distance in meters torque value converges to zero. Use this parameter to restrict distance the character travels due to rolling.
/// </summary>
[EuphoriaParameter(Name = "rollOverRadius", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float RollOverRadius { get; set; } = 2.00f;
public EuphoriaMessageOnFire(bool startNow) : base("onFire", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessagePedalLegs : EuphoriaMessage
{
/// <summary>
/// pedal with this leg or not
/// </summary>
[EuphoriaParameter(Name = "pedalLeftLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool PedalLeftLeg { get; set; } = default(bool);
/// <summary>
/// pedal with this leg or not
/// </summary>
[EuphoriaParameter(Name = "pedalRightLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool PedalRightLeg { get; set; } = default(bool);
/// <summary>
/// pedal forwards or backwards
/// </summary>
[EuphoriaParameter(Name = "backPedal", Type = typeof(bool), DefaultValue = default(bool))]
public bool BackPedal { get; set; } = default(bool);
/// <summary>
/// base radius of pedal action
/// </summary>
[EuphoriaParameter(Name = "radius", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.010f, MaximumValue = 2.00f)]
public float Radius { get; set; } = 0.250f;
/// <summary>
/// rate of pedaling. If adaptivePedal4Dragging is true then the legsAngularSpeed calculated to match the linear speed of the character can have a maximum value of angularSpeed (this max used to be hard coded to 13.0)
/// </summary>
[EuphoriaParameter(Name = "angularSpeed", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float AngularSpeed { get; set; } = 10.00f;
/// <summary>
/// stiffness of legs
/// </summary>
[EuphoriaParameter(Name = "legStiffness", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float LegStiffness { get; set; } = 10.00f;
/// <summary>
/// Move the centre of the pedal for the left leg up by this amount, the right leg down by this amount
/// </summary>
[EuphoriaParameter(Name = "pedalOffset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float PedalOffset { get; set; } = 0.00f;
/// <summary>
/// Random seed used to generate speed changes
/// </summary>
[EuphoriaParameter(Name = "randomSeed", Type = typeof(int), DefaultValue = 100)]
public int RandomSeed { get; set; } = 100;
/// <summary>
/// Random offset applied per leg to the angular speed to desynchronise the pedaling - set to 0 to disable, otherwise should be set to less than the angularSpeed value.
/// </summary>
[EuphoriaParameter(Name = "speedAsymmetry", Type = typeof(float), DefaultValue = 8.00f, MinimumValue = -10.00f, MaximumValue = 10.00f)]
public float SpeedAsymmetry { get; set; } = 8.00f;
/// <summary>
/// Will pedal in the direction of travel (if backPedal = false, against travel if backPedal = true) and with an angular velocity relative to speed upto a maximum of 13(rads/sec). Use when being dragged by a car. Overrides angularSpeed.
/// </summary>
[EuphoriaParameter(Name = "adaptivePedal4Dragging", Type = typeof(bool), DefaultValue = default(bool))]
public bool AdaptivePedal4Dragging { get; set; } = default(bool);
/// <summary>
/// newAngularSpeed = Clamp(angSpeedMultiplier4Dragging * linear_speed/pedalRadius, 0.0, angularSpeed)
/// </summary>
[EuphoriaParameter(Name = "angSpeedMultiplier4Dragging", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float AngSpeedMultiplier4Dragging { get; set; } = 0.30f;
/// <summary>
/// 0-1 value used to add variance to the radius value while pedalling, to desynchonize the legs' movement and provide some variety
/// </summary>
[EuphoriaParameter(Name = "radiusVariance", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float RadiusVariance { get; set; } = 0.40f;
/// <summary>
/// 0-1 value used to vary the angle of the legs from the hips during the pedal
/// </summary>
[EuphoriaParameter(Name = "legAngleVariance", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LegAngleVariance { get; set; } = 0.50f;
/// <summary>
/// Move the centre of the pedal for both legs sideways (+ve = right). NB: not applied to hula.
/// </summary>
[EuphoriaParameter(Name = "centreSideways", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CentreSideways { get; set; } = 0.00f;
/// <summary>
/// Move the centre of the pedal for both legs forward (or backward -ve)
/// </summary>
[EuphoriaParameter(Name = "centreForwards", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CentreForwards { get; set; } = 0.00f;
/// <summary>
/// Move the centre of the pedal for both legs up (or down -ve)
/// </summary>
[EuphoriaParameter(Name = "centreUp", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CentreUp { get; set; } = 0.00f;
/// <summary>
/// Turn the circle into an ellipse. Ellipse has horizontal radius a and vertical radius b. If ellipse is +ve then a=radius*ellipse and b=radius. If ellipse is -ve then a=radius and b = radius*ellipse. 0.0 = vertical line of length 2*radius, 0.0:1.0 circle squashed horizontally (vertical radius = radius), 1.0=circle. -0.001 = horizontal line of length 2*radius, -0.0:-1.0 circle squashed vertically (horizontal radius = radius), -1.0 = circle
/// </summary>
[EuphoriaParameter(Name = "ellipse", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float Ellipse { get; set; } = 1.00f;
/// <summary>
/// how much to account for the target moving through space rather than being static
/// </summary>
[EuphoriaParameter(Name = "dragReduction", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float DragReduction { get; set; } = 0.250f;
/// <summary>
/// Spread legs.
/// </summary>
[EuphoriaParameter(Name = "spread", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float Spread { get; set; } = 0.00f;
/// <summary>
/// If true circle the legs in a hula motion.
/// </summary>
[EuphoriaParameter(Name = "hula", Type = typeof(bool), DefaultValue = default(bool))]
public bool Hula { get; set; } = default(bool);
public EuphoriaMessagePedalLegs(bool startNow) : base("pedalLegs", startNow)
{ }
}
/// <summary>
/// pointArm:BEHAVIOURS REFERENCED: AnimPose - allows animPose to overridebodyParts: Arms (useLeftArm, useRightArm)
/// </summary>
internal class EuphoriaMessagePointArm : EuphoriaMessage
{
/// <summary>
/// point to point to (in world space)
/// </summary>
[EuphoriaParameter(Name = "targetLeft", Type = typeof(Vector3))]
public Vector3 TargetLeft { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// twist of the arm around point direction
/// </summary>
[EuphoriaParameter(Name = "twistLeft", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float TwistLeft { get; set; } = 0.3f;
/// <summary>
/// values less than 1 can give the arm a more bent look
/// </summary>
[EuphoriaParameter(Name = "armStraightnessLeft", Type = typeof(float), DefaultValue = 0.8f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmStraightnessLeft { get; set; } = 0.8f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "useLeftArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseLeftArm { get; set; } = default(bool);
/// <summary>
/// stiffness of arm
/// </summary>
[EuphoriaParameter(Name = "armStiffnessLeft", Type = typeof(float), DefaultValue = 15.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffnessLeft { get; set; } = 15.0f;
/// <summary>
/// damping value for arm used to point
/// </summary>
[EuphoriaParameter(Name = "armDampingLeft", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDampingLeft { get; set; } = 1.0f;
/// <summary>
/// level index of thing to point at, or -1 for none. if -1, target is specified in world space, otherwise it is an offset from the object specified by this index.
/// </summary>
[EuphoriaParameter(Name = "instanceIndexLeft", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndexLeft { get; set; } = -1;
/// <summary>
/// Swing limit
/// </summary>
[EuphoriaParameter(Name = "pointSwingLimitLeft", Type = typeof(float), DefaultValue = 1.5f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float PointSwingLimitLeft { get; set; } = 1.5f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "useZeroPoseWhenNotPointingLeft", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseZeroPoseWhenNotPointingLeft { get; set; } = default(bool);
/// <summary>
/// point to point to (in world space)
/// </summary>
[EuphoriaParameter(Name = "targetRight", Type = typeof(Vector3))]
public Vector3 TargetRight { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// twist of the arm around point direction
/// </summary>
[EuphoriaParameter(Name = "twistRight", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float TwistRight { get; set; } = 0.3f;
/// <summary>
/// values less than 1 can give the arm a more bent look
/// </summary>
[EuphoriaParameter(Name = "armStraightnessRight", Type = typeof(float), DefaultValue = 0.8f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmStraightnessRight { get; set; } = 0.8f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "useRightArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseRightArm { get; set; } = default(bool);
/// <summary>
/// stiffness of arm
/// </summary>
[EuphoriaParameter(Name = "armStiffnessRight", Type = typeof(float), DefaultValue = 15.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffnessRight { get; set; } = 15.0f;
/// <summary>
/// damping value for arm used to point
/// </summary>
[EuphoriaParameter(Name = "armDampingRight", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDampingRight { get; set; } = 1.0f;
/// <summary>
/// level index of thing to point at, or -1 for none. if -1, target is specified in world space, otherwise it is an offset from the object specified by this index.
/// </summary>
[EuphoriaParameter(Name = "instanceIndexRight", Type = typeof(int), DefaultValue = -1)]
public int InstanceIndexRight { get; set; } = -1;
/// <summary>
/// Swing limit
/// </summary>
[EuphoriaParameter(Name = "pointSwingLimitRight", Type = typeof(float), DefaultValue = 1.5f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float PointSwingLimitRight { get; set; } = 1.5f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "useZeroPoseWhenNotPointingRight", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseZeroPoseWhenNotPointingRight { get; set; } = default(bool);
public EuphoriaMessagePointArm(bool startNow) : base("pointArm", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessagePointGun : EuphoriaMessage
{
/// <summary>
/// Allow right hand to point/support?
/// </summary>
[EuphoriaParameter(Name = "enableRight", Type = typeof(bool), DefaultValue = default(bool))]
public bool EnableRight { get; set; } = default(bool);
/// <summary>
/// Allow right hand to point/support?
/// </summary>
[EuphoriaParameter(Name = "enableLeft", Type = typeof(bool), DefaultValue = default(bool))]
public bool EnableLeft { get; set; } = default(bool);
/// <summary>
/// Target for the left Hand
/// </summary>
[EuphoriaParameter(Name = "leftHandTarget", Type = typeof(Vector3))]
public Vector3 LeftHandTarget { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Index of the object that the left hand target is specified in, -1 is world space.
/// </summary>
[EuphoriaParameter(Name = "leftHandTargetIndex", Type = typeof(int), DefaultValue = -1)]
public int LeftHandTargetIndex { get; set; } = -1;
/// <summary>
/// Target for the right Hand
/// </summary>
[EuphoriaParameter(Name = "rightHandTarget", Type = typeof(Vector3))]
public Vector3 RightHandTarget { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Index of the object that the right hand target is specified in, -1 is world space.
/// </summary>
[EuphoriaParameter(Name = "rightHandTargetIndex", Type = typeof(int), DefaultValue = -1)]
public int RightHandTargetIndex { get; set; } = -1;
/// <summary>
/// NB: Only Applied to single handed weapons (some more work is required to have this tech on two handed weapons). Amount to lead target based on target velocity relative to the chest.
/// </summary>
[EuphoriaParameter(Name = "leadTarget", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float LeadTarget { get; set; } = 0.00f;
/// <summary>
/// Stiffness of the arm.
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 14.00f, MinimumValue = 2.00f, MaximumValue = 15.00f)]
public float ArmStiffness { get; set; } = 14.00f;
/// <summary>
/// Stiffness of the arm on pointing arm when a support arm is detached from a two-handed weapon.
/// </summary>
[EuphoriaParameter(Name = "armStiffnessDetSupport", Type = typeof(float), DefaultValue = 8.00f, MinimumValue = 2.00f, MaximumValue = 15.00f)]
public float ArmStiffnessDetSupport { get; set; } = 8.00f;
/// <summary>
/// Damping.
/// </summary>
[EuphoriaParameter(Name = "armDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 5.00f)]
public float ArmDamping { get; set; } = 1.00f;
/// <summary>
/// Amount of gravity opposition on pointing arm.
/// </summary>
[EuphoriaParameter(Name = "gravityOpposition", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float GravityOpposition { get; set; } = 1.00f;
/// <summary>
/// Amount of gravity opposition on pointing arm when a support arm is detached from a two-handed weapon.
/// </summary>
[EuphoriaParameter(Name = "gravOppDetachedSupport", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float GravOppDetachedSupport { get; set; } = 0.50f;
/// <summary>
/// Amount of mass of weapon taken into account by gravity opposition on pointing arm when a support arm is detached from a two-handed weapon. The lower the value the more the character doesn't know about the weapon mass and therefore is more affected by it.
/// </summary>
[EuphoriaParameter(Name = "massMultDetachedSupport", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float MassMultDetachedSupport { get; set; } = 0.10f;
/// <summary>
/// Allow shot to set a lower arm muscleStiffness than pointGun normally would.
/// </summary>
[EuphoriaParameter(Name = "allowShotLooseness", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowShotLooseness { get; set; } = default(bool);
/// <summary>
/// How much of blend should come from incoming transforms 0(all IK) .. 1(all ITMs) For pointing arms only. (Support arm uses the IK solution as is for clavicles)
/// </summary>
[EuphoriaParameter(Name = "clavicleBlend", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ClavicleBlend { get; set; } = 0.00f;
/// <summary>
/// Controls arm twist. (except in pistolIK)
/// </summary>
[EuphoriaParameter(Name = "elbowAttitude", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float ElbowAttitude { get; set; } = 0.30f;
/// <summary>
/// Type of constraint between the support hand and gun. 0=no constraint, 1=hard distance constraint, 2=Force based constraint, 3=hard spherical constraint
/// </summary>
[EuphoriaParameter(Name = "supportConstraint", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 3)]
public int SupportConstraint { get; set; } = 1;
/// <summary>
/// For supportConstraint = 1: Support hand constraint distance will be slowly reduced until it hits this value. This is for stability and also allows the pointing arm to lead a little. Don't set lower than NM_MIN_STABLE_DISTANCECONSTRAINT_DISTANCE 0.001f
/// </summary>
[EuphoriaParameter(Name = "constraintMinDistance", Type = typeof(float), DefaultValue = 0.0150f, MinimumValue = 0.0010f, MaximumValue = 0.10f)]
public float ConstraintMinDistance { get; set; } = 0.0150f;
/// <summary>
/// For supportConstraint = 1: Minimum distance within which support hand constraint will be made.
/// </summary>
[EuphoriaParameter(Name = "makeConstraintDistance", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float MakeConstraintDistance { get; set; } = 0.10f;
/// <summary>
/// For supportConstraint = 1: Velocity at which to reduce the support hand constraint length
/// </summary>
[EuphoriaParameter(Name = "reduceConstraintLengthVel", Type = typeof(float), DefaultValue = 1.50f, MinimumValue = 0.10f, MaximumValue = 10.00f)]
public float ReduceConstraintLengthVel { get; set; } = 1.50f;
/// <summary>
/// For supportConstraint = 1: strength of the supporting hands constraint (kg m/s), -1 to ignore/disable
/// </summary>
[EuphoriaParameter(Name = "breakingStrength", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 1000.00f)]
public float BreakingStrength { get; set; } = -1.00f;
/// <summary>
/// Once constraint is broken then do not try to reconnect/support for this amount of time
/// </summary>
[EuphoriaParameter(Name = "brokenSupportTime", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float BrokenSupportTime { get; set; } = 1.00f;
/// <summary>
/// Probability that the when a constraint is broken that during brokenSupportTime a side pose will be selected.
/// </summary>
[EuphoriaParameter(Name = "brokenToSideProb", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float BrokenToSideProb { get; set; } = 0.50f;
/// <summary>
/// If gunArm has been controlled by other behaviours for this time when it could have been pointing but couldn't due to pointing only allowed if connected, change gunArm pose to something that could connect for connectFor seconds
/// </summary>
[EuphoriaParameter(Name = "connectAfter", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float ConnectAfter { get; set; } = 0.70f;
/// <summary>
/// Time to try to reconnect for
/// </summary>
[EuphoriaParameter(Name = "connectFor", Type = typeof(float), DefaultValue = 0.550f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float ConnectFor { get; set; } = 0.550f;
/// <summary>
/// 0 = don't allow, 1= allow for kPistol(two handed pistol) only, 2 = allow for kRifle only, 3 = allow for kPistol and kRifle. Allow one handed pointing - no constraint if cant be supported . If not allowed then gunHand does not try to point at target if it cannot be supported - the constraint will be controlled by always support.
/// </summary>
[EuphoriaParameter(Name = "oneHandedPointing", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 3)]
public int OneHandedPointing { get; set; } = 1;
/// <summary>
/// Support a non pointing gunHand i.e. if in zero pose (constrain as well if constraint possible)
/// </summary>
[EuphoriaParameter(Name = "alwaysSupport", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysSupport { get; set; } = default(bool);
/// <summary>
/// Apply neutral pose when a gun arm isn't in use. NB: at the moment Rifle hand is always controlled by pointGun.
/// </summary>
[EuphoriaParameter(Name = "poseUnusedGunArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool PoseUnusedGunArm { get; set; } = default(bool);
/// <summary>
/// Apply neutral pose when a support arm isn't in use.
/// </summary>
[EuphoriaParameter(Name = "poseUnusedSupportArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool PoseUnusedSupportArm { get; set; } = default(bool);
/// <summary>
/// Apply neutral pose to the non-gun arm (otherwise it is always under the control of other behaviours or not set). If the non-gun hand is a supporting hand it is not controlled by this parameter but by poseUnusedSupportArm
/// </summary>
[EuphoriaParameter(Name = "poseUnusedOtherArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool PoseUnusedOtherArm { get; set; } = default(bool);
/// <summary>
/// max aiming angle(deg) sideways across body midline measured from chest forward that the character will try to point
/// </summary>
[EuphoriaParameter(Name = "maxAngleAcross", Type = typeof(float), DefaultValue = 90.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float MaxAngleAcross { get; set; } = 90.00f;
/// <summary>
/// max aiming angle(deg) sideways away from body midline measured from chest forward that the character will try to point
/// </summary>
[EuphoriaParameter(Name = "maxAngleAway", Type = typeof(float), DefaultValue = 90.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float MaxAngleAway { get; set; } = 90.00f;
/// <summary>
/// 0= don't apply limits. 1=apply the limits below only when the character is falling. 2 = always apply these limits (instead of applying maxAngleAcross and maxAngleAway which only limits the horizontal angle but implicity limits the updown (the limit shape is a vertical hinge)
/// </summary>
[EuphoriaParameter(Name = "fallingLimits", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int FallingLimits { get; set; } = 0;
/// <summary>
/// max aiming angle(deg) sideways across body midline measured from chest forward that the character will try to point. i.e. for rightHanded gun this is the angle left of the midline
/// </summary>
[EuphoriaParameter(Name = "acrossLimit", Type = typeof(float), DefaultValue = 90.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float AcrossLimit { get; set; } = 90.00f;
/// <summary>
/// max aiming angle(deg) sideways away from body midline measured from chest forward that the character will try to point. i.e. for rightHanded gun this is the angle right of the midline
/// </summary>
[EuphoriaParameter(Name = "awayLimit", Type = typeof(float), DefaultValue = 90.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float AwayLimit { get; set; } = 90.00f;
/// <summary>
/// max aiming angle(deg) upwards from body midline measured from chest forward that the character will try to point.
/// </summary>
[EuphoriaParameter(Name = "upLimit", Type = typeof(float), DefaultValue = 90.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float UpLimit { get; set; } = 90.00f;
/// <summary>
/// max aiming angle(deg) downwards from body midline measured from chest forward that the character will try to point
/// </summary>
[EuphoriaParameter(Name = "downLimit", Type = typeof(float), DefaultValue = 45.00f, MinimumValue = 0.00f, MaximumValue = 180.00f)]
public float DownLimit { get; set; } = 45.00f;
/// <summary>
/// Pose the rifle hand to reduce complications with collisions. 0 = false, 1 = always when falling, 2 = when falling except if falling backwards
/// </summary>
[EuphoriaParameter(Name = "rifleFall", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int RifleFall { get; set; } = 0;
/// <summary>
/// Allow supporting of a rifle(or two handed pistol) when falling. 0 = false, 1 = support if allowed, 2 = support until constraint not active (don't allow support to restart), 3 = support until constraint not effective (support hand to support distance must be less than 0.15 - don't allow support to restart).
/// </summary>
[EuphoriaParameter(Name = "fallingSupport", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 3)]
public int FallingSupport { get; set; } = 1;
/// <summary>
/// What is considered a fall by fallingSupport). Apply fallingSupport 0=never(will support if allowed), 1 = falling, 2 = falling except if falling backwards, 3 = falling and collided, 4 = falling and collided except if falling backwards, 5 = falling except if falling backwards until collided
/// </summary>
[EuphoriaParameter(Name = "fallingTypeSupport", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 5)]
public int FallingTypeSupport { get; set; } = 0;
/// <summary>
/// 0 = byFace, 1=acrossFront, 2=bySide. NB: bySide is not connectible so be careful if combined with kPistol and oneHandedPointing = 0 or 2
/// </summary>
[EuphoriaParameter(Name = "pistolNeutralType", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int PistolNeutralType { get; set; } = 0;
/// <summary>
/// NOT IMPLEMENTED YET KEEP=false - use pointing for neutral targets in pistol modes
/// </summary>
[EuphoriaParameter(Name = "neutralPoint4Pistols", Type = typeof(bool), DefaultValue = default(bool))]
public bool NeutralPoint4Pistols { get; set; } = default(bool);
/// <summary>
/// use pointing for neutral targets in rifle mode
/// </summary>
[EuphoriaParameter(Name = "neutralPoint4Rifle", Type = typeof(bool), DefaultValue = default(bool))]
public bool NeutralPoint4Rifle { get; set; } = default(bool);
/// <summary>
/// Check the neutral pointing is pointable, if it isn't then choose a neutral pose instead
/// </summary>
[EuphoriaParameter(Name = "checkNeutralPoint", Type = typeof(bool), DefaultValue = default(bool))]
public bool CheckNeutralPoint { get; set; } = default(bool);
/// <summary>
/// side, up, back) side is left for left arm, right for right arm mmmmtodo
/// </summary>
[EuphoriaParameter(Name = "point2Side", Type = typeof(Vector3))]
public Vector3 Point2Side { get; set; } = new Vector3(5.00f, -5.00f, -2.00f);
/// <summary>
/// add to weaponDistance for point2Side neutral pointing (to straighten the arm)
/// </summary>
[EuphoriaParameter(Name = "add2WeaponDistSide", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = -1.00f, MaximumValue = 1000.00f)]
public float Add2WeaponDistSide { get; set; } = 0.30f;
/// <summary>
/// side, up, back) side is left for left arm, right for rght arm mmmmtodo
/// </summary>
[EuphoriaParameter(Name = "point2Connect", Type = typeof(Vector3))]
public Vector3 Point2Connect { get; set; } = new Vector3(-1.00f, -0.90f, -0.20f);
/// <summary>
/// add to weaponDistance for point2Connect neutral pointing (to straighten the arm)
/// </summary>
[EuphoriaParameter(Name = "add2WeaponDistConnect", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -1.00f, MaximumValue = 1000.00f)]
public float Add2WeaponDistConnect { get; set; } = 0.00f;
/// <summary>
/// enable new ik for pistol pointing.
/// </summary>
[EuphoriaParameter(Name = "usePistolIK", Type = typeof(bool), DefaultValue = default(bool))]
public bool UsePistolIK { get; set; } = default(bool);
/// <summary>
/// Use spine twist to orient chest?
/// </summary>
[EuphoriaParameter(Name = "useSpineTwist", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseSpineTwist { get; set; } = default(bool);
/// <summary>
/// Turn balancer to help gun point at target
/// </summary>
[EuphoriaParameter(Name = "useTurnToTarget", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseTurnToTarget { get; set; } = default(bool);
/// <summary>
/// Use head look to drive head?
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// angular difference between pointing direction and target direction above which feedback will be generated.
/// </summary>
[EuphoriaParameter(Name = "errorThreshold", Type = typeof(float), DefaultValue = 0.39260f, MinimumValue = 0.00f, MaximumValue = 3.141590f)]
public float ErrorThreshold { get; set; } = 0.39260f;
/// <summary>
/// Duration of arms relax following firing weapon. NB:This is clamped (0,5) in pointGun
/// </summary>
[EuphoriaParameter(Name = "fireWeaponRelaxTime", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float FireWeaponRelaxTime { get; set; } = 0.40f;
/// <summary>
/// Relax multiplier following firing weapon. Recovers over relaxTime.
/// </summary>
[EuphoriaParameter(Name = "fireWeaponRelaxAmount", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.10f, MaximumValue = 1.00f)]
public float FireWeaponRelaxAmount { get; set; } = 0.50f;
/// <summary>
/// Range of motion for ik-based recoil.
/// </summary>
[EuphoriaParameter(Name = "fireWeaponRelaxDistance", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = 0.00f, MaximumValue = 0.250f)]
public float FireWeaponRelaxDistance { get; set; } = 0.050f;
/// <summary>
/// Use the incoming transforms to inform the pointGun of the primaryWeaponDistance, poleVector for the arm
/// </summary>
[EuphoriaParameter(Name = "useIncomingTransforms", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseIncomingTransforms { get; set; } = default(bool);
/// <summary>
/// If useIncomingTransforms = true and measureParentOffset=true then measure the Pointing-from offset from parent effector, using itms - this should point the barrel of the gun to the target. This is added to the rightHandParentOffset. NB NOT used if rightHandParentEffector LT 0
/// </summary>
[EuphoriaParameter(Name = "measureParentOffset", Type = typeof(bool), DefaultValue = default(bool))]
public bool MeasureParentOffset { get; set; } = default(bool);
/// <summary>
/// Pointing-from offset from parent effector, expressed in spine3's frame, x = back/forward, y = right/left, z = up/down.
/// </summary>
[EuphoriaParameter(Name = "leftHandParentOffset", Type = typeof(Vector3))]
public Vector3 LeftHandParentOffset { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// 1 = Use leftShoulder. Effector from which the left hand pointing originates. ie, point from this part to the target. -1 causes default offset for active weapon mode to be applied.
/// </summary>
[EuphoriaParameter(Name = "leftHandParentEffector", Type = typeof(int), DefaultValue = -1, MinimumValue = -1, MaximumValue = 21)]
public int LeftHandParentEffector { get; set; } = -1;
/// <summary>
/// Pointing-from offset from parent effector, expressed in spine3's frame, x = back/forward, y = right/left, z = up/down. This is added to the measured one if useIncomingTransforms=true and measureParentOffset=true. NB NOT used if rightHandParentEffector LT 0. Pistol(0,0,0) Rifle(0.0032, 0.0, -0.0)
/// </summary>
[EuphoriaParameter(Name = "rightHandParentOffset", Type = typeof(Vector3))]
public Vector3 RightHandParentOffset { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// 1 = Use rightShoulder.. Effector from which the right hand pointing originates. ie, point from this part to the target. -1 causes default offset for active weapon mode to be applied.
/// </summary>
[EuphoriaParameter(Name = "rightHandParentEffector", Type = typeof(int), DefaultValue = -1, MinimumValue = -1, MaximumValue = 21)]
public int RightHandParentEffector { get; set; } = -1;
/// <summary>
/// Distance from the shoulder to hold the weapon. If -1 and useIncomingTransforms then weaponDistance is read from ITMs. weaponDistance=primaryHandWeaponDistance clamped [0.2f:m_maxArmReach=0.65] if useIncomingTransforms = false. pistol 0.60383, rifle 0.336
/// </summary>
[EuphoriaParameter(Name = "primaryHandWeaponDistance", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float PrimaryHandWeaponDistance { get; set; } = -1.00f;
/// <summary>
/// Use hard constraint to keep rifle stock against shoulder?
/// </summary>
[EuphoriaParameter(Name = "constrainRifle", Type = typeof(bool), DefaultValue = default(bool))]
public bool ConstrainRifle { get; set; } = default(bool);
/// <summary>
/// Rifle constraint distance. Deliberately kept large to create a flat constraint surface where rifle meets the shoulder.
/// </summary>
[EuphoriaParameter(Name = "rifleConstraintMinDistance", Type = typeof(float), DefaultValue = 0.20f)]
public float RifleConstraintMinDistance { get; set; } = 0.20f;
/// <summary>
/// Disable collisions between right hand/forearm and the torso/legs.
/// </summary>
[EuphoriaParameter(Name = "disableArmCollisions", Type = typeof(bool), DefaultValue = default(bool))]
public bool DisableArmCollisions { get; set; } = default(bool);
/// <summary>
/// Disable collisions between right hand/forearm and spine3/spine2 if in rifle mode.
/// </summary>
[EuphoriaParameter(Name = "disableRifleCollisions", Type = typeof(bool), DefaultValue = default(bool))]
public bool DisableRifleCollisions { get; set; } = default(bool);
public EuphoriaMessagePointGun(bool startNow) : base("pointGun", startNow)
{ }
}
/// <summary>
/// pointGunExtra: Seldom set parameters for pointGun - just to keep number of parameters in any message less than or equal to 64
/// </summary>
internal class EuphoriaMessagePointGunExtra : EuphoriaMessage
{
/// <summary>
/// For supportConstraint = 2: force constraint strength of the supporting hands - it gets shaky at about 4.0
/// </summary>
[EuphoriaParameter(Name = "constraintStrength", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float ConstraintStrength { get; set; } = 2.00f;
/// <summary>
/// For supportConstraint = 2: Like makeConstraintDistance. Force starts acting when the hands are LT 3.0*thresh apart but is maximum strength LT thresh. For comparison: 0.1 is used for reachForWound in shot, 0.25 is used in grab.
/// </summary>
[EuphoriaParameter(Name = "constraintThresh", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float ConstraintThresh { get; set; } = 0.10f;
/// <summary>
/// Currently unused - no intoWorldTest. RAGE bit mask to exclude weapons from ray probe - currently defaults to MP3 weapon flag
/// </summary>
[EuphoriaParameter(Name = "weaponMask", Type = typeof(int), DefaultValue = 1024)]
public int WeaponMask { get; set; } = 1024;
/// <summary>
/// Is timeWarpActive enabled?
/// </summary>
[EuphoriaParameter(Name = "timeWarpActive", Type = typeof(bool), DefaultValue = default(bool))]
public bool TimeWarpActive { get; set; } = default(bool);
/// <summary>
/// Scale for arm and helper strength when timewarp is enabled. 1 = normal compensation.
/// </summary>
[EuphoriaParameter(Name = "timeWarpStrengthScale", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 2.00f)]
public float TimeWarpStrengthScale { get; set; } = 1.00f;
/// <summary>
/// Hand stabilization controller stiffness.
/// </summary>
[EuphoriaParameter(Name = "oriStiff", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float OriStiff { get; set; } = 0.00f;
/// <summary>
/// Hand stabilization controller damping.
/// </summary>
[EuphoriaParameter(Name = "oriDamp", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float OriDamp { get; set; } = 0.00f;
/// <summary>
/// Hand stabilization controller stiffness.
/// </summary>
[EuphoriaParameter(Name = "posStiff", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float PosStiff { get; set; } = 0.00f;
/// <summary>
/// Hand stabilization controller damping.
/// </summary>
[EuphoriaParameter(Name = "posDamp", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float PosDamp { get; set; } = 0.00f;
public EuphoriaMessagePointGunExtra(bool startNow) : base("pointGunExtra", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageRollDownStairs : EuphoriaMessage
{
/// <summary>
/// Effector Stiffness. value feeds through to rollUp directly
/// </summary>
[EuphoriaParameter(Name = "stiffness", Type = typeof(float), DefaultValue = 11.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float Stiffness { get; set; } = 11.0f;
/// <summary>
/// Effector Damping.
/// </summary>
[EuphoriaParameter(Name = "damping", Type = typeof(float), DefaultValue = 1.4f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float Damping { get; set; } = 1.4f;
/// <summary>
/// Helper force strength. Do not go above 1 for a rollDownStairs/roll along ground reaction.
/// </summary>
[EuphoriaParameter(Name = "forcemag", Type = typeof(float), DefaultValue = 0.55f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float Forcemag { get; set; } = 0.55f;
/// <summary>
/// the degree to which the character will try to stop a barrel roll with his arms
/// </summary>
[EuphoriaParameter(Name = "m_useArmToSlowDown", Type = typeof(float), DefaultValue = -1.9f, MinimumValue = -3.0f, MaximumValue = 3.0f)]
public float M_useArmToSlowDown { get; set; } = -1.9f;
/// <summary>
/// Blends between a zeroPose and the Rollup, Faster the character is rotating the less the zeroPose
/// </summary>
[EuphoriaParameter(Name = "useZeroPose", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseZeroPose { get; set; } = default(bool);
/// <summary>
/// Applied cheat forces to spin the character when in the air, the forces are 40% of the forces applied when touching the ground. Be careful little bunny rabbits, the character could spin unnaturally in the air.
/// </summary>
[EuphoriaParameter(Name = "spinWhenInAir", Type = typeof(bool), DefaultValue = default(bool))]
public bool SpinWhenInAir { get; set; } = default(bool);
/// <summary>
/// how much the character reaches with his arms to brace against the ground
/// </summary>
[EuphoriaParameter(Name = "m_armReachAmount", Type = typeof(float), DefaultValue = 1.4f, MinimumValue = 0.0f, MaximumValue = 3.0f)]
public float M_armReachAmount { get; set; } = 1.4f;
/// <summary>
/// amount that the legs push outwards when tumbling
/// </summary>
[EuphoriaParameter(Name = "m_legPush", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float M_legPush { get; set; } = 1.0f;
/// <summary>
/// Blends between a zeroPose and the Rollup, Faster the character is rotating the less the zeroPose
/// </summary>
[EuphoriaParameter(Name = "tryToAvoidHeadButtingGround", Type = typeof(bool), DefaultValue = default(bool))]
public bool TryToAvoidHeadButtingGround { get; set; } = default(bool);
/// <summary>
/// the length that the arm reaches and so how much it straightens
/// </summary>
[EuphoriaParameter(Name = "armReachLength", Type = typeof(float), DefaultValue = 0.4f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ArmReachLength { get; set; } = 0.4f;
/// <summary>
/// pass in a custom direction in to have the character try and roll in that direction
/// </summary>
[EuphoriaParameter(Name = "customRollDir", Type = typeof(Vector3))]
public Vector3 CustomRollDir { get; set; } = new Vector3(0f, 0f, 1f);
/// <summary>
/// pass in true to use the customRollDir parameter
/// </summary>
[EuphoriaParameter(Name = "useCustomRollDir", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseCustomRollDir { get; set; } = default(bool);
/// <summary>
/// The target linear velocity used to start the rolling.
/// </summary>
[EuphoriaParameter(Name = "stiffnessDecayTarget", Type = typeof(float), DefaultValue = 9.0f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float StiffnessDecayTarget { get; set; } = 9.0f;
/// <summary>
/// time, in seconds, to decay stiffness down to the stiffnessDecayTarget value (or -1 to disable)
/// </summary>
[EuphoriaParameter(Name = "stiffnessDecayTime", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 10.0f)]
public float StiffnessDecayTime { get; set; } = -1.0f;
/// <summary>
/// 0 is no leg asymmetry in 'foetal' position. greater than 0 a asymmetricalLegs-rand(30%), added/minus each joint of the legs in radians. Random number changes about once every roll. 0.4 gives a lot of asymmetry
/// </summary>
[EuphoriaParameter(Name = "asymmetricalLegs", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float AsymmetricalLegs { get; set; } = 0.0f;
/// <summary>
/// Tries to reduce the spin around the z axis. Scale 0 - 1
/// </summary>
[EuphoriaParameter(Name = "zAxisSpinReduction", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ZAxisSpinReduction { get; set; } = 0.0f;
/// <summary>
/// Time for the targetlinearVelocity to decay to zero.
/// </summary>
[EuphoriaParameter(Name = "targetLinearVelocityDecayTime", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float TargetLinearVelocityDecayTime { get; set; } = 0.5f;
/// <summary>
/// Helper torques are applied to match the spin of the character to the max of targetLinearVelocity and COMVelMag
/// </summary>
[EuphoriaParameter(Name = "targetLinearVelocity", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float TargetLinearVelocity { get; set; } = 1.0f;
/// <summary>
/// Don't use rollup if true
/// </summary>
[EuphoriaParameter(Name = "onlyApplyHelperForces", Type = typeof(bool), DefaultValue = default(bool))]
public bool OnlyApplyHelperForces { get; set; } = default(bool);
/// <summary>
/// scale applied cheat forces/torques to (zero) if object underneath character has velocity greater than 1.f
/// </summary>
[EuphoriaParameter(Name = "useVelocityOfObjectBelow", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseVelocityOfObjectBelow { get; set; } = default(bool);
/// <summary>
/// useVelocityOfObjectBelow uses a relative velocity of the character to the object underneath
/// </summary>
[EuphoriaParameter(Name = "useRelativeVelocity", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseRelativeVelocity { get; set; } = default(bool);
/// <summary>
/// if true, use rollup for upper body and a kind of foetal behavior for legs
/// </summary>
[EuphoriaParameter(Name = "applyFoetalToLegs", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyFoetalToLegs { get; set; } = default(bool);
/// <summary>
/// Only used if applyFoetalToLegs = true : define the variation of angles for the joints of the legs
/// </summary>
[EuphoriaParameter(Name = "movementLegsInFoetalPosition", Type = typeof(float), DefaultValue = 1.30f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float MovementLegsInFoetalPosition { get; set; } = 1.30f;
/// <summary>
/// Only used if applyNewRollingCheatingTorques or applyHelPerTorqueToAlign defined to true : maximal angular velocity around frontward axis of the pelvis to apply cheating torques.
/// </summary>
[EuphoriaParameter(Name = "maxAngVelAroundFrontwardAxis", Type = typeof(float), DefaultValue = 2.0f, MinimumValue = -1.0f, MaximumValue = 10.0f)]
public float MaxAngVelAroundFrontwardAxis { get; set; } = 2.0f;
/// <summary>
/// Only used if applyNewRollingCheatingTorques or applyHelPerTorqueToAlign defined to true : minimal angular velocity of the roll to apply cheating torques
/// </summary>
[EuphoriaParameter(Name = "minAngVel", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float MinAngVel { get; set; } = 0.5f;
/// <summary>
/// if true will use the new way to apply cheating torques (like in fallOverWall), otherwise will use the old way
/// </summary>
[EuphoriaParameter(Name = "applyNewRollingCheatingTorques", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyNewRollingCheatingTorques { get; set; } = default(bool);
/// <summary>
/// Only used if applyNewRollingCheatingTorques defined to true : maximal angular velocity of the roll to apply cheating torque
/// </summary>
[EuphoriaParameter(Name = "maxAngVel", Type = typeof(float), DefaultValue = 5.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float MaxAngVel { get; set; } = 5.0f;
/// <summary>
/// Only used if applyNewRollingCheatingTorques defined to true : magnitude of the torque to roll down the stairs
/// </summary>
[EuphoriaParameter(Name = "magOfTorqueToRoll", Type = typeof(float), DefaultValue = 50.0f, MinimumValue = 0.0f, MaximumValue = 500.0f)]
public float MagOfTorqueToRoll { get; set; } = 50.0f;
/// <summary>
/// apply torque to align the body orthogonally to the direction of the roll
/// </summary>
[EuphoriaParameter(Name = "applyHelPerTorqueToAlign", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyHelPerTorqueToAlign { get; set; } = default(bool);
/// <summary>
/// Only used if applyHelPerTorqueToAlign defined to true : delay to start to apply torques
/// </summary>
[EuphoriaParameter(Name = "delayToAlignBody", Type = typeof(float), DefaultValue = 0.2f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float DelayToAlignBody { get; set; } = 0.2f;
/// <summary>
/// Only used if applyHelPerTorqueToAlign defined to true : magnitude of the torque to align orthogonally the body
/// </summary>
[EuphoriaParameter(Name = "magOfTorqueToAlign", Type = typeof(float), DefaultValue = 50.0f, MinimumValue = 0.0f, MaximumValue = 500.0f)]
public float MagOfTorqueToAlign { get; set; } = 50.0f;
/// <summary>
/// Ordinarily keep at 0.85. Make this lower if you want spinning in the air.
/// </summary>
[EuphoriaParameter(Name = "airborneReduction", Type = typeof(float), DefaultValue = 0.85f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float AirborneReduction { get; set; } = 0.85f;
/// <summary>
/// Pass-through to Roll Up. Controls whether or not behaviour enforces min/max friction.
/// </summary>
[EuphoriaParameter(Name = "applyMinMaxFriction", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyMinMaxFriction { get; set; } = default(bool);
/// <summary>
/// Scale zAxisSpinReduction back when rotating end-over-end (somersault) to give the body a chance to align with the axis of rotation.
/// </summary>
[EuphoriaParameter(Name = "limitSpinReduction", Type = typeof(bool), DefaultValue = default(bool))]
public bool LimitSpinReduction { get; set; } = default(bool);
public EuphoriaMessageRollDownStairs(bool startNow) : base("rollDownStairs", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageShot : EuphoriaMessage
{
/// <summary>
/// stiffness of body. Feeds through to roll_up
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 11.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float BodyStiffness { get; set; } = 11.00f;
/// <summary>
/// stiffness of body. Feeds through to roll_up
/// </summary>
[EuphoriaParameter(Name = "spineDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 2.00f)]
public float SpineDamping { get; set; } = 1.00f;
/// <summary>
/// arm stiffness
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float ArmStiffness { get; set; } = 10.00f;
/// <summary>
/// initial stiffness of neck after being shot.
/// </summary>
[EuphoriaParameter(Name = "initialNeckStiffness", Type = typeof(float), DefaultValue = 14.00f, MinimumValue = 3.00f, MaximumValue = 16.00f)]
public float InitialNeckStiffness { get; set; } = 14.00f;
/// <summary>
/// intial damping of neck after being shot.
/// </summary>
[EuphoriaParameter(Name = "initialNeckDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 10.00f)]
public float InitialNeckDamping { get; set; } = 1.00f;
/// <summary>
/// stiffness of neck.
/// </summary>
[EuphoriaParameter(Name = "neckStiffness", Type = typeof(float), DefaultValue = 14.00f, MinimumValue = 3.00f, MaximumValue = 16.00f)]
public float NeckStiffness { get; set; } = 14.00f;
/// <summary>
/// damping of neck.
/// </summary>
[EuphoriaParameter(Name = "neckDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 2.00f)]
public float NeckDamping { get; set; } = 1.00f;
/// <summary>
/// how much to add to upperbody stiffness dependent on looseness
/// </summary>
[EuphoriaParameter(Name = "kMultOnLoose", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float KMultOnLoose { get; set; } = 0.00f;
/// <summary>
/// how much to add to leg stiffnesses dependent on looseness
/// </summary>
[EuphoriaParameter(Name = "kMult4Legs", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float KMult4Legs { get; set; } = 0.30f;
/// <summary>
/// how loose the character is made by a newBullet. between 0 and 1
/// </summary>
[EuphoriaParameter(Name = "loosenessAmount", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LoosenessAmount { get; set; } = 1.00f;
/// <summary>
/// how loose the character is made by a newBullet if falling
/// </summary>
[EuphoriaParameter(Name = "looseness4Fall", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Looseness4Fall { get; set; } = 0.00f;
/// <summary>
/// how loose the upperBody of the character is made by a newBullet if staggerFall is running (and not falling). Note atm the neck ramp values are ignored in staggerFall
/// </summary>
[EuphoriaParameter(Name = "looseness4Stagger", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Looseness4Stagger { get; set; } = 0.00f;
/// <summary>
/// minimum looseness to apply to the arms
/// </summary>
[EuphoriaParameter(Name = "minArmsLooseness", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float MinArmsLooseness { get; set; } = 0.10f;
/// <summary>
/// minimum looseness to apply to the Legs
/// </summary>
[EuphoriaParameter(Name = "minLegsLooseness", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float MinLegsLooseness { get; set; } = 0.10f;
/// <summary>
/// how long to hold for before returning to relaxed arm position
/// </summary>
[EuphoriaParameter(Name = "grabHoldTime", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float GrabHoldTime { get; set; } = 2.00f;
/// <summary>
/// true: spine is blended with zero pose, false: spine is blended with zero pose if not setting exag or cpain
/// </summary>
[EuphoriaParameter(Name = "spineBlendExagCPain", Type = typeof(bool), DefaultValue = default(bool))]
public bool SpineBlendExagCPain { get; set; } = default(bool);
/// <summary>
/// spine is always blended with zero pose this much and up to 1 as the character become stationary. If negative no blend is ever applied.
/// </summary>
[EuphoriaParameter(Name = "spineBlendZero", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = -0.10f, MaximumValue = 1.0f)]
public float SpineBlendZero { get; set; } = 0.60f;
/// <summary>
/// looseness applied to spine is different if bulletProofVest is true
/// </summary>
[EuphoriaParameter(Name = "bulletProofVest", Type = typeof(bool), DefaultValue = default(bool))]
public bool BulletProofVest { get; set; } = default(bool);
/// <summary>
/// looseness always reset on shotNewBullet even if previous looseness ramp still running. Except for the neck which has it's own ramp.
/// </summary>
[EuphoriaParameter(Name = "alwaysResetLooseness", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysResetLooseness { get; set; } = default(bool);
/// <summary>
/// Neck looseness always reset on shotNewBullet even if previous looseness ramp still running
/// </summary>
[EuphoriaParameter(Name = "alwaysResetNeckLooseness", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysResetNeckLooseness { get; set; } = default(bool);
/// <summary>
/// How much to scale the angular velocity coming in from animation of a part if it is in angVelScaleMask (otherwise scale by 1.0)
/// </summary>
[EuphoriaParameter(Name = "angVelScale", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float AngVelScale { get; set; } = 1.00f;
/// <summary>
/// Parts to scale the initial angular velocity by angVelScale (otherwize scale by 1.0)
/// </summary>
[EuphoriaParameter(Name = "angVelScaleMask", Type = typeof(string), DefaultValue = "fb")]
public string AngVelScaleMask { get; set; } = "fb";
/// <summary>
/// Width of the fling behaviour.
/// </summary>
[EuphoriaParameter(Name = "flingWidth", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FlingWidth { get; set; } = 0.50f;
/// <summary>
/// Duration of the fling behaviour.
/// </summary>
[EuphoriaParameter(Name = "flingTime", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FlingTime { get; set; } = 0.60f;
/// <summary>
/// time, in seconds, before the character begins to grab for the wound on the first hit
/// </summary>
[EuphoriaParameter(Name = "timeBeforeReachForWound", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TimeBeforeReachForWound { get; set; } = 0.20f;
/// <summary>
/// exaggerate bullet duration (at exagMag/exagTwistMag)
/// </summary>
[EuphoriaParameter(Name = "exagDuration", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ExagDuration { get; set; } = 0.00f;
/// <summary>
/// exaggerate bullet spine Lean magnitude
/// </summary>
[EuphoriaParameter(Name = "exagMag", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ExagMag { get; set; } = 1.00f;
/// <summary>
/// exaggerate bullet spine Twist magnitude
/// </summary>
[EuphoriaParameter(Name = "exagTwistMag", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ExagTwistMag { get; set; } = 0.50f;
/// <summary>
/// exaggerate bullet duration ramping to zero after exagDuration
/// </summary>
[EuphoriaParameter(Name = "exagSmooth2Zero", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ExagSmooth2Zero { get; set; } = 0.00f;
/// <summary>
/// exaggerate bullet time spent at 0 spine lean/twist after exagDuration + exagSmooth2Zero
/// </summary>
[EuphoriaParameter(Name = "exagZeroTime", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ExagZeroTime { get; set; } = 0.00f;
/// <summary>
/// conscious pain duration ramping from zero to cpainMag/cpainTwistMag
/// </summary>
[EuphoriaParameter(Name = "cpainSmooth2Time", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float CpainSmooth2Time { get; set; } = 0.20f;
/// <summary>
/// conscious pain duration at cpainMag/cpainTwistMag after cpainSmooth2Time
/// </summary>
[EuphoriaParameter(Name = "cpainDuration", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float CpainDuration { get; set; } = 0.00f;
/// <summary>
/// conscious pain spine Lean(back/Forward) magnitude (Replaces spinePainMultiplier)
/// </summary>
[EuphoriaParameter(Name = "cpainMag", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 10.00f)]
public float CpainMag { get; set; } = 1.00f;
/// <summary>
/// conscious pain spine Twist/Lean2Side magnitude Replaces spinePainTwistMultiplier)
/// </summary>
[EuphoriaParameter(Name = "cpainTwistMag", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float CpainTwistMag { get; set; } = 0.50f;
/// <summary>
/// conscious pain ramping to zero after cpainSmooth2Time + cpainDuration (Replaces spinePainTime)
/// </summary>
[EuphoriaParameter(Name = "cpainSmooth2Zero", Type = typeof(float), DefaultValue = 1.50f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float CpainSmooth2Zero { get; set; } = 1.50f;
/// <summary>
/// is the guy crouching or not
/// </summary>
[EuphoriaParameter(Name = "crouching", Type = typeof(bool), DefaultValue = default(bool))]
public bool Crouching { get; set; } = default(bool);
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "chickenArms", Type = typeof(bool), DefaultValue = default(bool))]
public bool ChickenArms { get; set; } = default(bool);
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "reachForWound", Type = typeof(bool), DefaultValue = default(bool))]
public bool ReachForWound { get; set; } = default(bool);
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "fling", Type = typeof(bool), DefaultValue = default(bool))]
public bool Fling { get; set; } = default(bool);
/// <summary>
/// injured arm code runs if arm hit (turns and steps and bends injured arm)
/// </summary>
[EuphoriaParameter(Name = "allowInjuredArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowInjuredArm { get; set; } = default(bool);
/// <summary>
/// when false injured leg is not bent and character does not bend to reach it
/// </summary>
[EuphoriaParameter(Name = "allowInjuredLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowInjuredLeg { get; set; } = default(bool);
/// <summary>
/// when false don't try to reach for injured Lower Legs (shins/feet)
/// </summary>
[EuphoriaParameter(Name = "allowInjuredLowerLegReach", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowInjuredLowerLegReach { get; set; } = default(bool);
/// <summary>
/// when false don't try to reach for injured Thighs
/// </summary>
[EuphoriaParameter(Name = "allowInjuredThighReach", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowInjuredThighReach { get; set; } = default(bool);
/// <summary>
/// additional stability for hands and neck (less loose)
/// </summary>
[EuphoriaParameter(Name = "stableHandsAndNeck", Type = typeof(bool), DefaultValue = default(bool))]
public bool StableHandsAndNeck { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "melee", Type = typeof(bool), DefaultValue = default(bool))]
public bool Melee { get; set; } = default(bool);
/// <summary>
/// 0=Rollup, 1=Catchfall, 2=rollDownStairs, 3=smartFall
/// </summary>
[EuphoriaParameter(Name = "fallingReaction", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 3)]
public int FallingReaction { get; set; } = 0;
/// <summary>
/// keep the character active instead of relaxing at the end of the catch fall
/// </summary>
[EuphoriaParameter(Name = "useExtendedCatchFall", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseExtendedCatchFall { get; set; } = default(bool);
/// <summary>
/// duration for which the character's upper body stays at minimum stiffness (not quite zero)
/// </summary>
[EuphoriaParameter(Name = "initialWeaknessZeroDuration", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float InitialWeaknessZeroDuration { get; set; } = 0.00f;
/// <summary>
/// duration of the ramp to bring the character's upper body stiffness back to normal levels
/// </summary>
[EuphoriaParameter(Name = "initialWeaknessRampDuration", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float InitialWeaknessRampDuration { get; set; } = 0.40f;
/// <summary>
/// duration for which the neck stays at intial stiffness/damping
/// </summary>
[EuphoriaParameter(Name = "initialNeckDuration", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float InitialNeckDuration { get; set; } = 0.00f;
/// <summary>
/// duration of the ramp to bring the neck stiffness/damping back to normal levels
/// </summary>
[EuphoriaParameter(Name = "initialNeckRampDuration", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float InitialNeckRampDuration { get; set; } = 0.40f;
/// <summary>
/// if enabled upper and lower body strength scales with character strength, using the range given by parameters below
/// </summary>
[EuphoriaParameter(Name = "useCStrModulation", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseCStrModulation { get; set; } = default(bool);
/// <summary>
/// proportions to what the strength would be normally
/// </summary>
[EuphoriaParameter(Name = "cStrUpperMin", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.10f, MaximumValue = 1.00f)]
public float CStrUpperMin { get; set; } = 0.10f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "cStrUpperMax", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 1.00f)]
public float CStrUpperMax { get; set; } = 1.00f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "cStrLowerMin", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.10f, MaximumValue = 1.00f)]
public float CStrLowerMin { get; set; } = 0.10f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "cStrLowerMax", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.10f, MaximumValue = 1.00f)]
public float CStrLowerMax { get; set; } = 1.00f;
/// <summary>
/// time to death (HACK for underwater). If -ve don't ever die
/// </summary>
[EuphoriaParameter(Name = "deathTime", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.0f, MaximumValue = 1000.0f)]
public float DeathTime { get; set; } = -1.00f;
public EuphoriaMessageShot(bool startNow) : base("shot", startNow)
{ }
}
/// <summary>
/// shotNewBullet: Send new wound information to the shot. Can cause shot to restart it's performance in part or in whole.
/// </summary>
internal class EuphoriaMessageShotNewBullet : EuphoriaMessage
{
/// <summary>
/// part ID on the body where the bullet hit
/// </summary>
[EuphoriaParameter(Name = "bodyPart", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 21)]
public int BodyPart { get; set; } = 0;
/// <summary>
/// if true then normal and hitPoint should be supplied in local coordinates of bodyPart. If false then normal and hitPoint should be supplied in World coordinates
/// </summary>
[EuphoriaParameter(Name = "localHitPointInfo", Type = typeof(bool), DefaultValue = default(bool))]
public bool LocalHitPointInfo { get; set; } = default(bool);
/// <summary>
/// Normal coming out of impact point on character. Can be local or global depending on localHitPointInfo
/// </summary>
[EuphoriaParameter(Name = "normal", Type = typeof(Vector3))]
public Vector3 Normal { get; set; } = new Vector3(0f, 0f, -1f);
/// <summary>
/// position of impact on character. Can be local or global depending on localHitPointInfo
/// </summary>
[EuphoriaParameter(Name = "hitPoint", Type = typeof(Vector3))]
public Vector3 HitPoint { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// bullet velocity in world coordinates
/// </summary>
[EuphoriaParameter(Name = "bulletVel", Type = typeof(Vector3))]
public Vector3 BulletVel { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageShotNewBullet(bool startNow) : base("shotNewBullet", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageShotSnap : EuphoriaMessage
{
/// <summary>
/// Add a Snap to shot.
/// </summary>
[EuphoriaParameter(Name = "snap", Type = typeof(bool), DefaultValue = default(bool))]
public bool Snap { get; set; } = default(bool);
/// <summary>
/// The magnitude of the reaction
/// </summary>
[EuphoriaParameter(Name = "snapMag", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = -10.00f, MaximumValue = 10.0f)]
public float SnapMag { get; set; } = 0.40f;
/// <summary>
/// movingMult*snapMag = The magnitude of the reaction if moving(comVelMag) faster than movingThresh
/// </summary>
[EuphoriaParameter(Name = "snapMovingMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float SnapMovingMult { get; set; } = 1.0f;
/// <summary>
/// balancingMult*snapMag = The magnitude of the reaction if balancing = (not lying on the floor/ not upper body not collided) and not airborne
/// </summary>
[EuphoriaParameter(Name = "snapBalancingMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float SnapBalancingMult { get; set; } = 1.0f;
/// <summary>
/// airborneMult*snapMag = The magnitude of the reaction if airborne
/// </summary>
[EuphoriaParameter(Name = "snapAirborneMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float SnapAirborneMult { get; set; } = 1.0f;
/// <summary>
/// If moving(comVelMag) faster than movingThresh then mvingMult applied to stunMag
/// </summary>
[EuphoriaParameter(Name = "snapMovingThresh", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float SnapMovingThresh { get; set; } = 1.0f;
/// <summary>
/// The character snaps in a prescribed way (decided by bullet direction) - Higher the value the more random this direction is.
/// </summary>
[EuphoriaParameter(Name = "snapDirectionRandomness", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float SnapDirectionRandomness { get; set; } = 0.30f;
/// <summary>
/// snap the leftArm.
/// </summary>
[EuphoriaParameter(Name = "snapLeftArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapLeftArm { get; set; } = default(bool);
/// <summary>
/// snap the rightArm.
/// </summary>
[EuphoriaParameter(Name = "snapRightArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapRightArm { get; set; } = default(bool);
/// <summary>
/// snap the leftLeg.
/// </summary>
[EuphoriaParameter(Name = "snapLeftLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapLeftLeg { get; set; } = default(bool);
/// <summary>
/// snap the rightLeg.
/// </summary>
[EuphoriaParameter(Name = "snapRightLeg", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapRightLeg { get; set; } = default(bool);
/// <summary>
/// snap the spine.
/// </summary>
[EuphoriaParameter(Name = "snapSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapSpine { get; set; } = default(bool);
/// <summary>
/// snap the neck.
/// </summary>
[EuphoriaParameter(Name = "snapNeck", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapNeck { get; set; } = default(bool);
/// <summary>
/// Legs are either in phase with each other or not
/// </summary>
[EuphoriaParameter(Name = "snapPhasedLegs", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapPhasedLegs { get; set; } = default(bool);
/// <summary>
/// type of hip reaction 0=none, 1=side2side 2=steplike
/// </summary>
[EuphoriaParameter(Name = "snapHipType", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int SnapHipType { get; set; } = 0;
/// <summary>
/// Legs are either in phase with each other or not
/// </summary>
[EuphoriaParameter(Name = "snapUseBulletDir", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapUseBulletDir { get; set; } = default(bool);
/// <summary>
/// Snap only around the wounded part//mmmmtodo check whether bodyPart doesn't have to be remembered for unSnap
/// </summary>
[EuphoriaParameter(Name = "snapHitPart", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapHitPart { get; set; } = default(bool);
/// <summary>
/// Interval before applying reverse snap
/// </summary>
[EuphoriaParameter(Name = "unSnapInterval", Type = typeof(float), DefaultValue = 0.010f, MinimumValue = 0.00f, MaximumValue = 100.0f)]
public float UnSnapInterval { get; set; } = 0.010f;
/// <summary>
/// The magnitude of the reverse snap
/// </summary>
[EuphoriaParameter(Name = "unSnapRatio", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 100.0f)]
public float UnSnapRatio { get; set; } = 0.70f;
/// <summary>
/// use torques to make the snap otherwise use a change in the parts angular velocity
/// </summary>
[EuphoriaParameter(Name = "snapUseTorques", Type = typeof(bool), DefaultValue = default(bool))]
public bool SnapUseTorques { get; set; } = default(bool);
public EuphoriaMessageShotSnap(bool startNow) : base("shotSnap", startNow)
{ }
}
/// <summary>
/// shotShockSpin: configure the shockSpin effect in shot. Spin/Lift the character using cheat torques/forces
/// </summary>
internal class EuphoriaMessageShotShockSpin : EuphoriaMessage
{
/// <summary>
/// if enabled, add a short 'shock' of torque to the character's spine to exaggerate bullet impact
/// </summary>
[EuphoriaParameter(Name = "addShockSpin", Type = typeof(bool), DefaultValue = default(bool))]
public bool AddShockSpin { get; set; } = default(bool);
/// <summary>
/// for use with close-range shotgun blasts, or similar
/// </summary>
[EuphoriaParameter(Name = "randomizeShockSpinDirection", Type = typeof(bool), DefaultValue = default(bool))]
public bool RandomizeShockSpinDirection { get; set; } = default(bool);
/// <summary>
/// if true, apply the shock spin no matter which body component was hit. otherwise only apply if the spine or clavicles get hit
/// </summary>
[EuphoriaParameter(Name = "alwaysAddShockSpin", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysAddShockSpin { get; set; } = default(bool);
/// <summary>
/// minimum amount of torque to add if using shock-spin feature
/// </summary>
[EuphoriaParameter(Name = "shockSpinMin", Type = typeof(float), DefaultValue = 50.0f, MinimumValue = 0.0f, MaximumValue = 1000.0f)]
public float ShockSpinMin { get; set; } = 50.0f;
/// <summary>
/// maxiumum amount of torque to add if using shock-spin feature
/// </summary>
[EuphoriaParameter(Name = "shockSpinMax", Type = typeof(float), DefaultValue = 90.0f, MinimumValue = 0.0f, MaximumValue = 1000.0f)]
public float ShockSpinMax { get; set; } = 90.0f;
/// <summary>
/// if greater than 0, apply a force to lift the character up while the torque is applied, trying to produce a dramatic spun/twist shotgun-to-the-chest effect. this is a scale of the torque applied, so 8.0 or so would give a reasonable amount of lift
/// </summary>
[EuphoriaParameter(Name = "shockSpinLiftForceMult", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ShockSpinLiftForceMult { get; set; } = 0.0f;
/// <summary>
/// multiplier used when decaying torque spin over time
/// </summary>
[EuphoriaParameter(Name = "shockSpinDecayMult", Type = typeof(float), DefaultValue = 4.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float ShockSpinDecayMult { get; set; } = 4.0f;
/// <summary>
/// torque applied is scaled by this amount across the spine components - spine2 recieving the full amount, then 3 and 1 and finally 0. each time, this value is used to scale it down. 0.5 means half the torque each time.
/// </summary>
[EuphoriaParameter(Name = "shockSpinScalePerComponent", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ShockSpinScalePerComponent { get; set; } = 0.5f;
/// <summary>
/// shock spin ends when twist velocity is greater than this value (try 6.0). If set to -1 does not stop
/// </summary>
[EuphoriaParameter(Name = "shockSpinMaxTwistVel", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 200.0f)]
public float ShockSpinMaxTwistVel { get; set; } = -1.0f;
/// <summary>
/// shock spin scales by lever arm of bullet i.e. bullet impact point to centre line
/// </summary>
[EuphoriaParameter(Name = "shockSpinScaleByLeverArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool ShockSpinScaleByLeverArm { get; set; } = default(bool);
/// <summary>
/// shockSpin's torque is multipied by this value when both the character's feet are not in contact
/// </summary>
[EuphoriaParameter(Name = "shockSpinAirMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ShockSpinAirMult { get; set; } = 1.0f;
/// <summary>
/// shockSpin's torque is multipied by this value when the one of the character's feet are not in contact
/// </summary>
[EuphoriaParameter(Name = "shockSpin1FootMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ShockSpin1FootMult { get; set; } = 1.0f;
/// <summary>
/// shockSpin scales the torques applied to the feet by footSlipCompensation
/// </summary>
[EuphoriaParameter(Name = "shockSpinFootGripMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float ShockSpinFootGripMult { get; set; } = 1.0f;
/// <summary>
/// If shot on a side with a forward foot and both feet are on the ground and balanced, increase the shockspin to compensate for the balancer naturally resisting spin to that side
/// </summary>
[EuphoriaParameter(Name = "bracedSideSpinMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 1.0f, MaximumValue = 5.0f)]
public float BracedSideSpinMult { get; set; } = 1.0f;
public EuphoriaMessageShotShockSpin(bool startNow) : base("shotShockSpin", startNow)
{ }
}
/// <summary>
/// shotFallToKnees: configure the fall to knees shot.
/// </summary>
internal class EuphoriaMessageShotFallToKnees : EuphoriaMessage
{
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "fallToKnees", Type = typeof(bool), DefaultValue = default(bool))]
public bool FallToKnees { get; set; } = default(bool);
/// <summary>
/// Always change fall behaviour. If false only change when falling forward
/// </summary>
[EuphoriaParameter(Name = "ftkAlwaysChangeFall", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkAlwaysChangeFall { get; set; } = default(bool);
/// <summary>
/// How long the balancer runs for before fallToKnees starts
/// </summary>
[EuphoriaParameter(Name = "ftkBalanceTime", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float FtkBalanceTime { get; set; } = 0.70f;
/// <summary>
/// Hip helper force magnitude - to help character lean over balance point of line between toes
/// </summary>
[EuphoriaParameter(Name = "ftkHelperForce", Type = typeof(float), DefaultValue = 200.0f, MinimumValue = 0.00f, MaximumValue = 2000.00f)]
public float FtkHelperForce { get; set; } = 200.0f;
/// <summary>
/// Helper force applied to spine3 aswell
/// </summary>
[EuphoriaParameter(Name = "ftkHelperForceOnSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkHelperForceOnSpine { get; set; } = default(bool);
/// <summary>
/// Help balancer lean amount - to help character lean over balance point of line between toes. Half of this is also applied as hipLean
/// </summary>
[EuphoriaParameter(Name = "ftkLeanHelp", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = 0.00f, MaximumValue = 0.30f)]
public float FtkLeanHelp { get; set; } = 0.050f;
/// <summary>
/// Bend applied to spine when falling from knees. (+ve forward - try -0.1) (only if rds called)
/// </summary>
[EuphoriaParameter(Name = "ftkSpineBend", Type = typeof(float), DefaultValue = -0.00f, MinimumValue = -0.20f, MaximumValue = 0.30f)]
public float FtkSpineBend { get; set; } = -0.00f;
/// <summary>
/// Stiffen spine when falling from knees (only if rds called)
/// </summary>
[EuphoriaParameter(Name = "ftkStiffSpine", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkStiffSpine { get; set; } = default(bool);
/// <summary>
/// Looseness (muscleStiffness = 1.01f - m_parameters.ftkImpactLooseness) applied to upperBody on knee impacts
/// </summary>
[EuphoriaParameter(Name = "ftkImpactLooseness", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.0f)]
public float FtkImpactLooseness { get; set; } = 0.50f;
/// <summary>
/// Time that looseness is applied after knee impacts
/// </summary>
[EuphoriaParameter(Name = "ftkImpactLoosenessTime", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -0.10f, MaximumValue = 1.00f)]
public float FtkImpactLoosenessTime { get; set; } = 0.20f;
/// <summary>
/// Rate at which the legs are bent to go from standing to on knees
/// </summary>
[EuphoriaParameter(Name = "ftkBendRate", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 4.00f)]
public float FtkBendRate { get; set; } = 0.70f;
/// <summary>
/// Blend from current hip to balancing on knees hip angle
/// </summary>
[EuphoriaParameter(Name = "ftkHipBlend", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FtkHipBlend { get; set; } = 0.30f;
/// <summary>
/// Probability that a lunge reaction will be allowed
/// </summary>
[EuphoriaParameter(Name = "ftkLungeProb", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FtkLungeProb { get; set; } = 0.00f;
/// <summary>
/// When on knees allow some spinning of the character. If false then the balancers' footSlipCompensation remains on and tends to keep the character facing the same way as when it was balancing.
/// </summary>
[EuphoriaParameter(Name = "ftkKneeSpin", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkKneeSpin { get; set; } = default(bool);
/// <summary>
/// Multiplier on the reduction of friction for the feet based on angle away from horizontal - helps the character fall to knees quicker
/// </summary>
[EuphoriaParameter(Name = "ftkFricMult", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float FtkFricMult { get; set; } = 1.00f;
/// <summary>
/// Apply this hip angle when the character starts to fall backwards when on knees
/// </summary>
[EuphoriaParameter(Name = "ftkHipAngleFall", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float FtkHipAngleFall { get; set; } = 0.50f;
/// <summary>
/// Hip pitch applied (+ve forward, -ve backwards) if character is falling forwards on way down to it's knees
/// </summary>
[EuphoriaParameter(Name = "ftkPitchForwards", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float FtkPitchForwards { get; set; } = 0.10f;
/// <summary>
/// Hip pitch applied (+ve forward, -ve backwards) if character is falling backwards on way down to it's knees
/// </summary>
[EuphoriaParameter(Name = "ftkPitchBackwards", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = -0.50f, MaximumValue = 0.50f)]
public float FtkPitchBackwards { get; set; } = 0.10f;
/// <summary>
/// Balancer instability below which the character starts to bend legs even if it isn't going to fall on to it's knees (i.e. if going backwards). 0.3 almost ensures a fall to knees but means the character will keep stepping backward until it slows down enough.
/// </summary>
[EuphoriaParameter(Name = "ftkFallBelowStab", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 15.00f)]
public float FtkFallBelowStab { get; set; } = 0.50f;
/// <summary>
/// when the character gives up and goes into a fall
/// </summary>
[EuphoriaParameter(Name = "ftkBalanceAbortThreshold", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 4.00f)]
public float FtkBalanceAbortThreshold { get; set; } = 2.00f;
/// <summary>
/// Type of arm response when on knees falling forward 0=useFallArms (from RollDownstairs or catchFall), 1= armsIn, 2=armsOut
/// </summary>
[EuphoriaParameter(Name = "ftkOnKneesArmType", Type = typeof(int), DefaultValue = 2, MinimumValue = 0, MaximumValue = 2)]
public int FtkOnKneesArmType { get; set; } = 2;
/// <summary>
/// Release the reachForWound this amount of time after the knees have hit. If LT 0.0 then keep reaching for wound regardless of fall/onground state.
/// </summary>
[EuphoriaParameter(Name = "ftkReleaseReachForWound", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 5.00f)]
public float FtkReleaseReachForWound { get; set; } = -1.00f;
/// <summary>
/// true = Keep reaching for wound regardless of fall/onground state. false = respect the shotConfigureArms params: reachFalling, reachFallingWithOneHand, reachOnFloor
/// </summary>
[EuphoriaParameter(Name = "ftkReachForWound", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkReachForWound { get; set; } = default(bool);
/// <summary>
/// Override the pointGun when knees hit
/// </summary>
[EuphoriaParameter(Name = "ftkReleasePointGun", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkReleasePointGun { get; set; } = default(bool);
/// <summary>
/// The upper body of the character must be colliding and other failure conditions met to fail
/// </summary>
[EuphoriaParameter(Name = "ftkFailMustCollide", Type = typeof(bool), DefaultValue = default(bool))]
public bool FtkFailMustCollide { get; set; } = default(bool);
public EuphoriaMessageShotFallToKnees(bool startNow) : base("shotFallToKnees", startNow)
{ }
}
/// <summary>
/// shotFromBehind: configure the shot from behind reaction
/// </summary>
internal class EuphoriaMessageShotFromBehind : EuphoriaMessage
{
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "shotFromBehind", Type = typeof(bool), DefaultValue = default(bool))]
public bool ShotFromBehind { get; set; } = default(bool);
/// <summary>
/// SpineBend.
/// </summary>
[EuphoriaParameter(Name = "sfbSpineAmount", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SfbSpineAmount { get; set; } = 4.00f;
/// <summary>
/// Neck Bend.
/// </summary>
[EuphoriaParameter(Name = "sfbNeckAmount", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SfbNeckAmount { get; set; } = 1.00f;
/// <summary>
/// hip Pitch
/// </summary>
[EuphoriaParameter(Name = "sfbHipAmount", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SfbHipAmount { get; set; } = 1.00f;
/// <summary>
/// knee bend
/// </summary>
[EuphoriaParameter(Name = "sfbKneeAmount", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float SfbKneeAmount { get; set; } = 0.050f;
/// <summary>
/// shotFromBehind reaction period after being shot
/// </summary>
[EuphoriaParameter(Name = "sfbPeriod", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.010f, MaximumValue = 10.00f)]
public float SfbPeriod { get; set; } = 0.70f;
/// <summary>
/// amount of time not taking a step
/// </summary>
[EuphoriaParameter(Name = "sfbForceBalancePeriod", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SfbForceBalancePeriod { get; set; } = 0.30f;
/// <summary>
/// amount of time before applying spread out arms pose
/// </summary>
[EuphoriaParameter(Name = "sfbArmsOnset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SfbArmsOnset { get; set; } = 0.00f;
/// <summary>
/// amount of time before bending knees a bit
/// </summary>
[EuphoriaParameter(Name = "sfbKneesOnset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SfbKneesOnset { get; set; } = 0.00f;
/// <summary>
/// Controls additional independent randomized bending of left/right elbows
/// </summary>
[EuphoriaParameter(Name = "sfbNoiseGain", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float SfbNoiseGain { get; set; } = 0.00f;
/// <summary>
/// 0=balancer fails as normal, 1= ignore backArchedBack and leanedTooFarBack balancer failures, 2= ignore backArchedBack balancer failure only, 3= ignore leanedTooFarBack balancer failure only
/// </summary>
[EuphoriaParameter(Name = "sfbIgnoreFail", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 3)]
public int SfbIgnoreFail { get; set; } = 0;
public EuphoriaMessageShotFromBehind(bool startNow) : base("shotFromBehind", startNow)
{ }
}
/// <summary>
/// shotInGuts: configure the shot in guts reaction
/// </summary>
internal class EuphoriaMessageShotInGuts : EuphoriaMessage
{
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "shotInGuts", Type = typeof(bool), DefaultValue = default(bool))]
public bool ShotInGuts { get; set; } = default(bool);
/// <summary>
/// SpineBend.
/// </summary>
[EuphoriaParameter(Name = "sigSpineAmount", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SigSpineAmount { get; set; } = 2.00f;
/// <summary>
/// Neck Bend.
/// </summary>
[EuphoriaParameter(Name = "sigNeckAmount", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SigNeckAmount { get; set; } = 1.00f;
/// <summary>
/// hip Pitch
/// </summary>
[EuphoriaParameter(Name = "sigHipAmount", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SigHipAmount { get; set; } = 1.00f;
/// <summary>
/// knee bend
/// </summary>
[EuphoriaParameter(Name = "sigKneeAmount", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float SigKneeAmount { get; set; } = 0.050f;
/// <summary>
/// active time after being shot
/// </summary>
[EuphoriaParameter(Name = "sigPeriod", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.010f, MaximumValue = 10.00f)]
public float SigPeriod { get; set; } = 2.00f;
/// <summary>
/// amount of time not taking a step
/// </summary>
[EuphoriaParameter(Name = "sigForceBalancePeriod", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SigForceBalancePeriod { get; set; } = 0.00f;
/// <summary>
/// amount of time not taking a step
/// </summary>
[EuphoriaParameter(Name = "sigKneesOnset", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float SigKneesOnset { get; set; } = 0.00f;
public EuphoriaMessageShotInGuts(bool startNow) : base("shotInGuts", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageShotHeadLook : EuphoriaMessage
{
/// <summary>
/// Use headLook. Default: looks at provided target or if this is zero - looks forward or in velocity direction. If reachForWound is enabled, switches between looking at the wound and at the default target.
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// position to look at with headlook flag
/// </summary>
[EuphoriaParameter(Name = "headLook", Type = typeof(Vector3))]
public Vector3 HeadLook { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// Min time to look at wound
/// </summary>
[EuphoriaParameter(Name = "headLookAtWoundMinTimer", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float HeadLookAtWoundMinTimer { get; set; } = 0.250f;
/// <summary>
/// Max time to look at wound
/// </summary>
[EuphoriaParameter(Name = "headLookAtWoundMaxTimer", Type = typeof(float), DefaultValue = 0.80f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float HeadLookAtWoundMaxTimer { get; set; } = 0.80f;
/// <summary>
/// Min time to look headLook or if zero - forward or in velocity direction
/// </summary>
[EuphoriaParameter(Name = "headLookAtHeadPosMaxTimer", Type = typeof(float), DefaultValue = 1.70f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float HeadLookAtHeadPosMaxTimer { get; set; } = 1.70f;
/// <summary>
/// Max time to look headLook or if zero - forward or in velocity direction
/// </summary>
[EuphoriaParameter(Name = "headLookAtHeadPosMinTimer", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float HeadLookAtHeadPosMinTimer { get; set; } = 0.60f;
public EuphoriaMessageShotHeadLook(bool startNow) : base("shotHeadLook", startNow)
{ }
}
/// <summary>
/// shotConfigureArms: configure the arm reactions in shot
/// </summary>
internal class EuphoriaMessageShotConfigureArms : EuphoriaMessage
{
/// <summary>
/// blind brace with arms if appropriate
/// </summary>
[EuphoriaParameter(Name = "brace", Type = typeof(bool), DefaultValue = default(bool))]
public bool Brace { get; set; } = default(bool);
/// <summary>
/// Point gun if appropriate.
/// </summary>
[EuphoriaParameter(Name = "pointGun", Type = typeof(bool), DefaultValue = default(bool))]
public bool PointGun { get; set; } = default(bool);
/// <summary>
/// armsWindmill if going backwards fast enough
/// </summary>
[EuphoriaParameter(Name = "useArmsWindmill", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseArmsWindmill { get; set; } = default(bool);
/// <summary>
/// release wound if going sideways/forward fast enough. 0 = don't. 1 = only if bracing. 2 = any default arm reaction
/// </summary>
[EuphoriaParameter(Name = "releaseWound", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 2)]
public int ReleaseWound { get; set; } = 1;
/// <summary>
/// reachForWound when falling 0 = false, 1 = true, 2 = once per shot performance
/// </summary>
[EuphoriaParameter(Name = "reachFalling", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int ReachFalling { get; set; } = 0;
/// <summary>
/// Force character to reach for wound with only one hand when falling or fallen. 0= allow 2 handed reach, 1= left only if 2 handed possible, 2= right only if 2 handed possible, 3 = one handed but automatic (allows switching of hands)
/// </summary>
[EuphoriaParameter(Name = "reachFallingWithOneHand", Type = typeof(int), DefaultValue = 3, MinimumValue = 0, MaximumValue = 3)]
public int ReachFallingWithOneHand { get; set; } = 3;
/// <summary>
/// reachForWound when on floor - 0 = false, 1 = true, 2 = once per shot performance
/// </summary>
[EuphoriaParameter(Name = "reachOnFloor", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int ReachOnFloor { get; set; } = 0;
/// <summary>
/// Inhibit arms brace for this amount of time after reachForWound has begun
/// </summary>
[EuphoriaParameter(Name = "alwaysReachTime", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float AlwaysReachTime { get; set; } = 0.30f;
/// <summary>
/// For armsWindmill, multiplier on character speed - increase of speed of circling is proportional to character speed (max speed of circliing increase = 1.5). eg. lowering the value increases the range of velocity that the 0-1.5 is applied over
/// </summary>
[EuphoriaParameter(Name = "AWSpeedMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float AWSpeedMult { get; set; } = 1.0f;
/// <summary>
/// For armsWindmill, multiplier on character speed - increase of radii is proportional to character speed (max radius increase = 0.45). eg. lowering the value increases the range of velocity that the 0-0.45 is applied over
/// </summary>
[EuphoriaParameter(Name = "AWRadiusMult", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float AWRadiusMult { get; set; } = 1.0f;
/// <summary>
/// For armsWindmill, added arm stiffness ranges from 0 to AWStiffnessAdd
/// </summary>
[EuphoriaParameter(Name = "AWStiffnessAdd", Type = typeof(float), DefaultValue = 4.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float AWStiffnessAdd { get; set; } = 4.0f;
/// <summary>
/// Force character to reach for wound with only one hand. 0= allow 2 handed reach, 1= left only if 2 handed possible, 2= right only if 2 handed possible
/// </summary>
[EuphoriaParameter(Name = "reachWithOneHand", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 2)]
public int ReachWithOneHand { get; set; } = 0;
/// <summary>
/// Allow character to reach for wound with left hand if holding a pistol. It never will for a rifle. If pointGun is running this will only happen if the hand cannot point and pointGun:poseUnusedGunArm = false
/// </summary>
[EuphoriaParameter(Name = "allowLeftPistolRFW", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowLeftPistolRFW { get; set; } = default(bool);
/// <summary>
/// Allow character to reach for wound with right hand if holding a pistol. It never will for a rifle. If pointGun is running this will only happen if the hand cannot point and pointGun:poseUnusedGunArm = false
/// </summary>
[EuphoriaParameter(Name = "allowRightPistolRFW", Type = typeof(bool), DefaultValue = default(bool))]
public bool AllowRightPistolRFW { get; set; } = default(bool);
/// <summary>
/// Override pointGun and reachForWound if desired if holding a pistol. It never will for a rifle
/// </summary>
[EuphoriaParameter(Name = "rfwWithPistol", Type = typeof(bool), DefaultValue = default(bool))]
public bool RfwWithPistol { get; set; } = default(bool);
/// <summary>
/// Type of reaction
/// </summary>
[EuphoriaParameter(Name = "fling2", Type = typeof(bool), DefaultValue = default(bool))]
public bool Fling2 { get; set; } = default(bool);
/// <summary>
/// Fling the left arm
/// </summary>
[EuphoriaParameter(Name = "fling2Left", Type = typeof(bool), DefaultValue = default(bool))]
public bool Fling2Left { get; set; } = default(bool);
/// <summary>
/// Fling the right arm
/// </summary>
[EuphoriaParameter(Name = "fling2Right", Type = typeof(bool), DefaultValue = default(bool))]
public bool Fling2Right { get; set; } = default(bool);
/// <summary>
/// Override stagger arms even if staggerFall:m_upperBodyReaction = true
/// </summary>
[EuphoriaParameter(Name = "fling2OverrideStagger", Type = typeof(bool), DefaultValue = default(bool))]
public bool Fling2OverrideStagger { get; set; } = default(bool);
/// <summary>
/// Time after hit that the fling will start (allows for a bit of loose arm movement from bullet impact.snap etc)
/// </summary>
[EuphoriaParameter(Name = "fling2TimeBefore", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Fling2TimeBefore { get; set; } = 0.10f;
/// <summary>
/// Duration of the fling behaviour.
/// </summary>
[EuphoriaParameter(Name = "fling2Time", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Fling2Time { get; set; } = 0.50f;
/// <summary>
/// MuscleStiffness of the left arm. If negative then uses the shots underlying muscle stiffness from controlStiffness (i.e. respects looseness)
/// </summary>
[EuphoriaParameter(Name = "fling2MStiffL", Type = typeof(float), DefaultValue = 0.950f, MinimumValue = -1.00f, MaximumValue = 1.50f)]
public float Fling2MStiffL { get; set; } = 0.950f;
/// <summary>
/// MuscleStiffness of the right arm. If negative then uses the shots underlying muscle stiffness from controlStiffness (i.e. respects looseness)
/// </summary>
[EuphoriaParameter(Name = "fling2MStiffR", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -1.00f, MaximumValue = 1.50f)]
public float Fling2MStiffR { get; set; } = -1.00f;
/// <summary>
/// Maximum time before the left arm relaxes in the fling. It will relax automatically when the arm has completed it's bent arm fling. This is what causes the arm to straighten.
/// </summary>
[EuphoriaParameter(Name = "fling2RelaxTimeL", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Fling2RelaxTimeL { get; set; } = 0.50f;
/// <summary>
/// Maximum time before the right arm relaxes in the fling. It will relax automatically when the arm has completed it's bent arm fling. This is what causes the arm to straighten.
/// </summary>
[EuphoriaParameter(Name = "fling2RelaxTimeR", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Fling2RelaxTimeR { get; set; } = 0.50f;
/// <summary>
/// Min fling angle for left arm. Fling angle is random in the range fling2AngleMin:fling2AngleMax. Angle of fling in radians measured from the body horizontal sideways from shoulder. positive is up, 0 shoulder level, negative down
/// </summary>
[EuphoriaParameter(Name = "fling2AngleMinL", Type = typeof(float), DefaultValue = -1.50f, MinimumValue = -1.50f, MaximumValue = 1.00f)]
public float Fling2AngleMinL { get; set; } = -1.50f;
/// <summary>
/// Max fling angle for left arm
/// </summary>
[EuphoriaParameter(Name = "fling2AngleMaxL", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = -1.50f, MaximumValue = 1.00f)]
public float Fling2AngleMaxL { get; set; } = 1.00f;
/// <summary>
/// Min fling angle for right arm.
/// </summary>
[EuphoriaParameter(Name = "fling2AngleMinR", Type = typeof(float), DefaultValue = -1.50f, MinimumValue = -1.50f, MaximumValue = 1.00f)]
public float Fling2AngleMinR { get; set; } = -1.50f;
/// <summary>
/// Max fling angle for right arm
/// </summary>
[EuphoriaParameter(Name = "fling2AngleMaxR", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = -1.50f, MaximumValue = 1.00f)]
public float Fling2AngleMaxR { get; set; } = 1.00f;
/// <summary>
/// Min left arm length. Armlength is random in the range fling2LengthMin:fling2LengthMax. Armlength maps one to one with elbow angle. (These values are scaled internally for the female character)
/// </summary>
[EuphoriaParameter(Name = "fling2LengthMinL", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.250f, MaximumValue = 0.60f)]
public float Fling2LengthMinL { get; set; } = 0.250f;
/// <summary>
/// Max left arm length.
/// </summary>
[EuphoriaParameter(Name = "fling2LengthMaxL", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.250f, MaximumValue = 0.60f)]
public float Fling2LengthMaxL { get; set; } = 0.60f;
/// <summary>
/// Min right arm length.
/// </summary>
[EuphoriaParameter(Name = "fling2LengthMinR", Type = typeof(float), DefaultValue = 0.250f, MinimumValue = 0.250f, MaximumValue = 0.60f)]
public float Fling2LengthMinR { get; set; } = 0.250f;
/// <summary>
/// Max right arm length.
/// </summary>
[EuphoriaParameter(Name = "fling2LengthMaxR", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.250f, MaximumValue = 0.60f)]
public float Fling2LengthMaxR { get; set; } = 0.60f;
/// <summary>
/// Has the character got a bust. If so then cupBust (move bust reach targets below bust) or bustElbowLift and cupSize (stop upperArm penetrating bust and move bust targets to surface of bust) are implemented.
/// </summary>
[EuphoriaParameter(Name = "bust", Type = typeof(bool), DefaultValue = default(bool))]
public bool Bust { get; set; } = default(bool);
/// <summary>
/// Lift the elbows up this much extra to avoid upper arm penetrating the bust (when target hits spine2 or spine3)
/// </summary>
[EuphoriaParameter(Name = "bustElbowLift", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float BustElbowLift { get; set; } = 0.70f;
/// <summary>
/// Amount reach target to bust (spine2) will be offset forward by
/// </summary>
[EuphoriaParameter(Name = "cupSize", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CupSize { get; set; } = 0.10f;
/// <summary>
/// All reach targets above or on the bust will cause a reach below the bust. (specifically moves spine3 and spine2 targets to spine1). bustElbowLift and cupSize are ignored.
/// </summary>
[EuphoriaParameter(Name = "cupBust", Type = typeof(bool), DefaultValue = default(bool))]
public bool CupBust { get; set; } = default(bool);
public EuphoriaMessageShotConfigureArms(bool startNow) : base("shotConfigureArms", startNow)
{ }
}
/// <summary>
/// smartFall: Clone of High Fall with a wider range of operating conditions.
/// </summary>
internal class EuphoriaMessageSmartFall : EuphoriaMessage
{
/// <summary>
/// stiffness of body. Value feeds through to bodyBalance (synched with defaults), to armsWindmill (14 for this value at default ), legs pedal, head look and roll down stairs directly
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 11.00f, MinimumValue = 6.00f, MaximumValue = 16.00f)]
public float BodyStiffness { get; set; } = 11.00f;
/// <summary>
/// The damping of the joints.
/// </summary>
[EuphoriaParameter(Name = "bodydamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 3.00f)]
public float Bodydamping { get; set; } = 1.00f;
/// <summary>
/// The length of time before the impact that the character transitions to the landing.
/// </summary>
[EuphoriaParameter(Name = "catchfalltime", Type = typeof(float), DefaultValue = 0.300f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float Catchfalltime { get; set; } = 0.300f;
/// <summary>
/// 0.52angle is 0.868 dot//A threshold for deciding how far away from upright the character needs to be before bailing out (going into a foetal) instead of trying to land (keeping stretched out). NB: never does bailout if ignorWorldCollisions true
/// </summary>
[EuphoriaParameter(Name = "crashOrLandCutOff", Type = typeof(float), DefaultValue = 0.8680f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CrashOrLandCutOff { get; set; } = 0.8680f;
/// <summary>
/// Strength of the controller to keep the character at angle aimAngleBase from vertical.
/// </summary>
[EuphoriaParameter(Name = "pdStrength", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float PdStrength { get; set; } = 0.00f;
/// <summary>
/// Damping multiplier of the controller to keep the character at angle aimAngleBase from vertical. The actual damping is pdDamping*pdStrength*constant*angVel.
/// </summary>
[EuphoriaParameter(Name = "pdDamping", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 5.00f)]
public float PdDamping { get; set; } = 1.00f;
/// <summary>
/// arm circling speed in armWindMillAdaptive
/// </summary>
[EuphoriaParameter(Name = "armAngSpeed", Type = typeof(float), DefaultValue = 7.850f, MinimumValue = 0.00f, MaximumValue = 20.0f)]
public float ArmAngSpeed { get; set; } = 7.850f;
/// <summary>
/// in armWindMillAdaptive
/// </summary>
[EuphoriaParameter(Name = "armAmplitude", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float ArmAmplitude { get; set; } = 2.00f;
/// <summary>
/// in armWindMillAdaptive 3.1 opposite for stuntman. 1.0 old default. 0.0 in phase.
/// </summary>
[EuphoriaParameter(Name = "armPhase", Type = typeof(float), DefaultValue = 3.10f, MinimumValue = 0.00f, MaximumValue = 6.283185f)]
public float ArmPhase { get; set; } = 3.10f;
/// <summary>
/// in armWindMillAdaptive bend the elbows as a function of armAngle. For stuntman true otherwise false.
/// </summary>
[EuphoriaParameter(Name = "armBendElbows", Type = typeof(bool), DefaultValue = default(bool))]
public bool ArmBendElbows { get; set; } = default(bool);
/// <summary>
/// radius of legs on pedal
/// </summary>
[EuphoriaParameter(Name = "legRadius", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = 0.010f, MaximumValue = 0.50f)]
public float LegRadius { get; set; } = 0.40f;
/// <summary>
/// in pedal
/// </summary>
[EuphoriaParameter(Name = "legAngSpeed", Type = typeof(float), DefaultValue = 7.850f, MinimumValue = 0.00f, MaximumValue = 15.0f)]
public float LegAngSpeed { get; set; } = 7.850f;
/// <summary>
/// 0.0 for stuntman. Random offset applied per leg to the angular speed to desynchronise the pedaling - set to 0 to disable, otherwise should be set to less than the angularSpeed value.
/// </summary>
[EuphoriaParameter(Name = "legAsymmetry", Type = typeof(float), DefaultValue = 4.00f, MinimumValue = -10.00f, MaximumValue = 10.00f)]
public float LegAsymmetry { get; set; } = 4.00f;
/// <summary>
/// phase angle between the arms and legs circling angle
/// </summary>
[EuphoriaParameter(Name = "arms2LegsPhase", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 6.50f)]
public float Arms2LegsPhase { get; set; } = 0.00f;
/// <summary>
/// 0=not synched, 1=always synched, 2= synch at start only. Synchs the arms angle to what the leg angle is. All speed/direction parameters of armswindmill are overwritten if = 1. If 2 and you want synced arms/legs then armAngSpeed=legAngSpeed, legAsymmetry = 0.0 (to stop randomizations of the leg cicle speed)
/// </summary>
[EuphoriaParameter(Name = "arms2LegsSync", Type = typeof(int), DefaultValue = 1, MinimumValue = 0, MaximumValue = 2)]
public int Arms2LegsSync { get; set; } = 1;
/// <summary>
/// Where to put the arms when preparing to land. Approx 1 = above head, 0 = head height, -1 = down. LT -2.0 use catchFall arms, LT -3.0 use prepare for landing pose if Agent is due to land vertically, feet first.
/// </summary>
[EuphoriaParameter(Name = "armsUp", Type = typeof(float), DefaultValue = -3.10f, MinimumValue = -4.00f, MaximumValue = 2.00f)]
public float ArmsUp { get; set; } = -3.10f;
/// <summary>
/// toggle to orientate to fall direction. i.e. orientate so that the character faces the horizontal velocity direction
/// </summary>
[EuphoriaParameter(Name = "orientateBodyToFallDirection", Type = typeof(bool), DefaultValue = default(bool))]
public bool OrientateBodyToFallDirection { get; set; } = default(bool);
/// <summary>
/// If false don't worry about the twist angle of the character when orientating the character. If false this allows the twist axis of the character to be free (You can get a nice twisting highFall like the one in dieHard 4 when the car goes into the helicopter)
/// </summary>
[EuphoriaParameter(Name = "orientateTwist", Type = typeof(bool), DefaultValue = default(bool))]
public bool OrientateTwist { get; set; } = default(bool);
/// <summary>
/// DEVEL parameter - suggest you don't edit it. Maximum torque the orientation controller can apply. If 0 then no helper torques will be used. 300 will orientate the character soflty for all but extreme angles away from aimAngleBase. If abs (current -aimAngleBase) is getting near 3.0 then this can be reduced to give a softer feel.
/// </summary>
[EuphoriaParameter(Name = "orientateMax", Type = typeof(float), DefaultValue = 300.00f, MinimumValue = 0.00f, MaximumValue = 2000.00f)]
public float OrientateMax { get; set; } = 300.00f;
/// <summary>
/// If true then orientate the character to face the point from where it started falling. HighFall like the one in dieHard with Alan Rickman
/// </summary>
[EuphoriaParameter(Name = "alanRickman", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlanRickman { get; set; } = default(bool);
/// <summary>
/// Try to execute a forward Roll on landing
/// </summary>
[EuphoriaParameter(Name = "fowardRoll", Type = typeof(bool), DefaultValue = default(bool))]
public bool FowardRoll { get; set; } = default(bool);
/// <summary>
/// Blend to a zero pose when forward roll is attempted.
/// </summary>
[EuphoriaParameter(Name = "useZeroPose_withFowardRoll", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseZeroPose_withFowardRoll { get; set; } = default(bool);
/// <summary>
/// Angle from vertical the pdController is driving to ( positive = forwards)
/// </summary>
[EuphoriaParameter(Name = "aimAngleBase", Type = typeof(float), DefaultValue = 0.180f, MinimumValue = -3.141593f, MaximumValue = 3.141593f)]
public float AimAngleBase { get; set; } = 0.180f;
/// <summary>
/// scale to add/subtract from aimAngle based on forward speed (Internal)
/// </summary>
[EuphoriaParameter(Name = "fowardVelRotation", Type = typeof(float), DefaultValue = -0.020f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float FowardVelRotation { get; set; } = -0.020f;
/// <summary>
/// Scale to change to amount of vel that is added to the foot ik from the velocity (Internal)
/// </summary>
[EuphoriaParameter(Name = "footVelCompScale", Type = typeof(float), DefaultValue = 0.050f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FootVelCompScale { get; set; } = 0.050f;
/// <summary>
/// sideoffset for the feet during prepareForLanding. +ve = right.
/// </summary>
[EuphoriaParameter(Name = "sideD", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float SideD { get; set; } = 0.20f;
/// <summary>
/// Forward offset for the feet during prepareForLanding
/// </summary>
[EuphoriaParameter(Name = "fowardOffsetOfLegIK", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float FowardOffsetOfLegIK { get; set; } = 0.00f;
/// <summary>
/// Leg Length for ik (Internal)//unused
/// </summary>
[EuphoriaParameter(Name = "legL", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.0f, MaximumValue = 2.00f)]
public float LegL { get; set; } = 1.00f;
/// <summary>
/// 0.5angle is 0.878 dot. Cutoff to go to the catchFall ( internal) //mmmtodo do like crashOrLandCutOff
/// </summary>
[EuphoriaParameter(Name = "catchFallCutOff", Type = typeof(float), DefaultValue = 0.8780f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float CatchFallCutOff { get; set; } = 0.8780f;
/// <summary>
/// Strength of the legs at landing
/// </summary>
[EuphoriaParameter(Name = "legStrength", Type = typeof(float), DefaultValue = 12.00f, MinimumValue = 6.00f, MaximumValue = 16.0f)]
public float LegStrength { get; set; } = 12.00f;
/// <summary>
/// If true have enough strength to balance. If false not enough strength in legs to balance (even though bodyBlance called)
/// </summary>
[EuphoriaParameter(Name = "balance", Type = typeof(bool), DefaultValue = default(bool))]
public bool Balance { get; set; } = default(bool);
/// <summary>
/// Never go into bailout (foetal)
/// </summary>
[EuphoriaParameter(Name = "ignorWorldCollisions", Type = typeof(bool), DefaultValue = default(bool))]
public bool IgnorWorldCollisions { get; set; } = default(bool);
/// <summary>
/// stuntman type fall. Arm and legs circling direction controlled by angmom and orientation
/// </summary>
[EuphoriaParameter(Name = "adaptiveCircling", Type = typeof(bool), DefaultValue = default(bool))]
public bool AdaptiveCircling { get; set; } = default(bool);
/// <summary>
/// With stuntman type fall. Hula reaction if can't see floor and not rotating fast
/// </summary>
[EuphoriaParameter(Name = "hula", Type = typeof(bool), DefaultValue = default(bool))]
public bool Hula { get; set; } = default(bool);
/// <summary>
/// Character needs to be moving less than this speed to consider fall as a recoverable one.
/// </summary>
[EuphoriaParameter(Name = "maxSpeedForRecoverableFall", Type = typeof(float), DefaultValue = 15.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float MaxSpeedForRecoverableFall { get; set; } = 15.00f;
/// <summary>
/// Character needs to be moving at least this fast horizontally to start bracing for impact if there is an object along its trajectory.
/// </summary>
[EuphoriaParameter(Name = "minSpeedForBrace", Type = typeof(float), DefaultValue = 10.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float MinSpeedForBrace { get; set; } = 10.00f;
/// <summary>
/// Ray-cast normal doted with up direction has to be greater than this number to consider object flat enough to land on it.
/// </summary>
[EuphoriaParameter(Name = "landingNormal", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LandingNormal { get; set; } = 0.60f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "rdsForceMag", Type = typeof(float), DefaultValue = 0.80f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float RdsForceMag { get; set; } = 0.80f;
/// <summary>
/// RDS: Time for the targetlinearVelocity to decay to zero.
/// </summary>
[EuphoriaParameter(Name = "rdsTargetLinVeDecayTime", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float RdsTargetLinVeDecayTime { get; set; } = 0.5f;
/// <summary>
/// RDS: Helper torques are applied to match the spin of the character to the max of targetLinearVelocity and COMVelMag. -1 to use initial character velocity.
/// </summary>
[EuphoriaParameter(Name = "rdsTargetLinearVelocity", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 30.0f)]
public float RdsTargetLinearVelocity { get; set; } = 1.0f;
/// <summary>
/// Start Catch Fall/RDS state with specified friction. Catch fall will overwrite based on setFallingReaction.
/// </summary>
[EuphoriaParameter(Name = "rdsUseStartingFriction", Type = typeof(bool), DefaultValue = default(bool))]
public bool RdsUseStartingFriction { get; set; } = default(bool);
/// <summary>
/// Catch Fall/RDS starting friction. Catch fall will overwrite based on setFallingReaction.
/// </summary>
[EuphoriaParameter(Name = "rdsStartingFriction", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.0f)]
public float RdsStartingFriction { get; set; } = 0.00f;
/// <summary>
/// Catch Fall/RDS starting friction minimum. Catch fall will overwrite based on setFallingReaction.
/// </summary>
[EuphoriaParameter(Name = "rdsStartingFrictionMin", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float RdsStartingFrictionMin { get; set; } = 0.00f;
/// <summary>
/// Velocity threshold under which RDS force mag will be applied.
/// </summary>
[EuphoriaParameter(Name = "rdsForceVelThreshold", Type = typeof(float), DefaultValue = 10.0f, MinimumValue = 0.00f, MaximumValue = 100.0f)]
public float RdsForceVelThreshold { get; set; } = 10.0f;
/// <summary>
/// Force initial state (used in vehicle bail out to start SF_CatchFall (6) earlier.
/// </summary>
[EuphoriaParameter(Name = "initialState", Type = typeof(int), DefaultValue = 0, MinimumValue = 0, MaximumValue = 7)]
public int InitialState { get; set; } = 0;
/// <summary>
/// Allow friction changes to be applied to the hands and feet.
/// </summary>
[EuphoriaParameter(Name = "changeExtremityFriction", Type = typeof(bool), DefaultValue = default(bool))]
public bool ChangeExtremityFriction { get; set; } = default(bool);
/// <summary>
/// Set up an immediate teeter in the direction of trave if initial state is SF_Balance.
/// </summary>
[EuphoriaParameter(Name = "teeter", Type = typeof(bool), DefaultValue = default(bool))]
public bool Teeter { get; set; } = default(bool);
/// <summary>
/// Offset the default Teeter edge in the direction of travel. Will need to be tweaked depending on how close to the real edge AI tends to trigger the behaviour.
/// </summary>
[EuphoriaParameter(Name = "teeterOffset", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float TeeterOffset { get; set; } = 0.30f;
/// <summary>
/// Time in seconds before ped should start actively trying to stop rolling.
/// </summary>
[EuphoriaParameter(Name = "stopRollingTime", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float StopRollingTime { get; set; } = 2.00f;
/// <summary>
/// Scale for rebound assistance. 0=off, 1=very bouncy, 2=jbone crazy Try 0.5?
/// </summary>
[EuphoriaParameter(Name = "reboundScale", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 2.00f)]
public float ReboundScale { get; set; } = 0.00f;
/// <summary>
/// Part mask to apply rebound assistance.
/// </summary>
[EuphoriaParameter(Name = "reboundMask", Type = typeof(string), DefaultValue = "uk")]
public string ReboundMask { get; set; } = "uk";
/// <summary>
/// Force head avoid to be active during Catch Fall even when character is not on the ground.
/// </summary>
[EuphoriaParameter(Name = "forceHeadAvoid", Type = typeof(bool), DefaultValue = default(bool))]
public bool ForceHeadAvoid { get; set; } = default(bool);
/// <summary>
/// Pass-through parameter for Catch Fall spin reduction. Increase to stop more spin. 0..1.
/// </summary>
[EuphoriaParameter(Name = "cfZAxisSpinReduction", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float CfZAxisSpinReduction { get; set; } = 0.50f;
/// <summary>
/// Transition to splat state when com vel is below value, regardless of character health or fall velocity. Set to zero to disable.
/// </summary>
[EuphoriaParameter(Name = "splatWhenStopped", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float SplatWhenStopped { get; set; } = 0.00f;
/// <summary>
/// Blend head to neutral pose com vel approaches zero. Linear between zero and value. Set to zero to disable.
/// </summary>
[EuphoriaParameter(Name = "blendHeadWhenStopped", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.00f, MaximumValue = 100.00f)]
public float BlendHeadWhenStopped { get; set; } = 0.00f;
/// <summary>
/// Spread legs amount for Pedal during fall.
/// </summary>
[EuphoriaParameter(Name = "spreadLegs", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = -1.00f, MaximumValue = 1.00f)]
public float SpreadLegs { get; set; } = 0.10f;
public EuphoriaMessageSmartFall(bool startNow) : base("smartFall", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageStaggerFall : EuphoriaMessage
{
/// <summary>
/// stiffness of arms. catch_fall's stiffness scales with this value, but has default values when this is default
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 12.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float ArmStiffness { get; set; } = 12.0f;
/// <summary>
/// Sets damping value for the arms
/// </summary>
[EuphoriaParameter(Name = "armDamping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDamping { get; set; } = 1.0f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "spineDamping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float SpineDamping { get; set; } = 1.0f;
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "spineStiffness", Type = typeof(float), DefaultValue = 10.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float SpineStiffness { get; set; } = 10.0f;
/// <summary>
/// armStiffness during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "armStiffnessStart", Type = typeof(float), DefaultValue = 3.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float ArmStiffnessStart { get; set; } = 3.0f;
/// <summary>
/// armDamping during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "armDampingStart", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDampingStart { get; set; } = 0.1f;
/// <summary>
/// spineDamping during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "spineDampingStart", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float SpineDampingStart { get; set; } = 0.1f;
/// <summary>
/// spineStiffness during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "spineStiffnessStart", Type = typeof(float), DefaultValue = 3.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float SpineStiffnessStart { get; set; } = 3.0f;
/// <summary>
/// time spent with Start values for arms and spine stiffness and damping ie for whiplash efffect
/// </summary>
[EuphoriaParameter(Name = "timeAtStartValues", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float TimeAtStartValues { get; set; } = 0.0f;
/// <summary>
/// time spent ramping from Start to end values for arms and spine stiffness and damping ie for whiplash efffect (occurs after timeAtStartValues)
/// </summary>
[EuphoriaParameter(Name = "rampTimeFromStartValues", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RampTimeFromStartValues { get; set; } = 0.0f;
/// <summary>
/// Probability per step of time spent in a stagger step
/// </summary>
[EuphoriaParameter(Name = "staggerStepProb", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float StaggerStepProb { get; set; } = 0.0f;
/// <summary>
/// steps taken before lowerBodyStiffness starts ramping down by perStepReduction1
/// </summary>
[EuphoriaParameter(Name = "stepsTillStartEnd", Type = typeof(int), DefaultValue = 2, MinimumValue = 0, MaximumValue = 100)]
public int StepsTillStartEnd { get; set; } = 2;
/// <summary>
/// time from start of behaviour before lowerBodyStiffness starts ramping down for rampTimeToEndValues to endValues
/// </summary>
[EuphoriaParameter(Name = "timeStartEnd", Type = typeof(float), DefaultValue = 100.0f, MinimumValue = 0.0f, MaximumValue = 100.0f)]
public float TimeStartEnd { get; set; } = 100.0f;
/// <summary>
/// time spent ramping from lowerBodyStiffness to lowerBodyStiffnessEnd
/// </summary>
[EuphoriaParameter(Name = "rampTimeToEndValues", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float RampTimeToEndValues { get; set; } = 0.0f;
/// <summary>
/// lowerBodyStiffness should be 12
/// </summary>
[EuphoriaParameter(Name = "lowerBodyStiffness", Type = typeof(float), DefaultValue = 13.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float LowerBodyStiffness { get; set; } = 13.0f;
/// <summary>
/// lowerBodyStiffness at end
/// </summary>
[EuphoriaParameter(Name = "lowerBodyStiffnessEnd", Type = typeof(float), DefaultValue = 8.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float LowerBodyStiffnessEnd { get; set; } = 8.0f;
/// <summary>
/// amount of time (seconds) into the future that the character tries to step to. bigger values try to recover with fewer, bigger steps. smaller values recover with smaller steps, and generally recover less.
/// </summary>
[EuphoriaParameter(Name = "predictionTime", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float PredictionTime { get; set; } = 0.10f;
/// <summary>
/// LowerBody stiffness will be reduced every step to make the character fallover
/// </summary>
[EuphoriaParameter(Name = "perStepReduction1", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float PerStepReduction1 { get; set; } = 0.70f;
/// <summary>
/// leanInDirection will be increased from 0 to leanInDirMax linearly at this rate
/// </summary>
[EuphoriaParameter(Name = "leanInDirRate", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float LeanInDirRate { get; set; } = 1.0f;
/// <summary>
/// Max of leanInDirection magnitude when going forwards
/// </summary>
[EuphoriaParameter(Name = "leanInDirMaxF", Type = typeof(float), DefaultValue = 0.10f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanInDirMaxF { get; set; } = 0.10f;
/// <summary>
/// Max of leanInDirection magnitude when going backwards
/// </summary>
[EuphoriaParameter(Name = "leanInDirMaxB", Type = typeof(float), DefaultValue = 0.30f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanInDirMaxB { get; set; } = 0.30f;
/// <summary>
/// Max of leanInDirectionHips magnitude when going forwards
/// </summary>
[EuphoriaParameter(Name = "leanHipsMaxF", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanHipsMaxF { get; set; } = 0.00f;
/// <summary>
/// Max of leanInDirectionHips magnitude when going backwards
/// </summary>
[EuphoriaParameter(Name = "leanHipsMaxB", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float LeanHipsMaxB { get; set; } = 0.00f;
/// <summary>
/// Lean of spine to side in side velocity direction when going forwards
/// </summary>
[EuphoriaParameter(Name = "lean2multF", Type = typeof(float), DefaultValue = -1.00f, MinimumValue = -5.00f, MaximumValue = 5.00f)]
public float Lean2multF { get; set; } = -1.00f;
/// <summary>
/// Lean of spine to side in side velocity direction when going backwards
/// </summary>
[EuphoriaParameter(Name = "lean2multB", Type = typeof(float), DefaultValue = -2.00f, MinimumValue = -5.00f, MaximumValue = 5.00f)]
public float Lean2multB { get; set; } = -2.00f;
/// <summary>
/// amount stance foot is behind com in the direction of velocity before the leg tries to pushOff to increase momentum. Increase to lower the probability of the pushOff making the character bouncy
/// </summary>
[EuphoriaParameter(Name = "pushOffDist", Type = typeof(float), DefaultValue = 0.20f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float PushOffDist { get; set; } = 0.20f;
/// <summary>
/// stance leg will only pushOff to increase momentum if the vertical hip velocity is less than this value. 0.4 seems like a good value. The higher it is the the less this functionality is applied. If it is very low or negative this can stop the pushOff altogether
/// </summary>
[EuphoriaParameter(Name = "maxPushoffVel", Type = typeof(float), DefaultValue = 20.00f, MinimumValue = -20.0f, MaximumValue = 20.0f)]
public float MaxPushoffVel { get; set; } = 20.00f;
/// <summary>
/// hipBend scaled with velocity
/// </summary>
[EuphoriaParameter(Name = "hipBendMult", Type = typeof(float), DefaultValue = 0.00f, MinimumValue = -10.0f, MaximumValue = 10.0f)]
public float HipBendMult { get; set; } = 0.00f;
/// <summary>
/// bend forwards at the hip (hipBendMult) whether moving backwards or forwards
/// </summary>
[EuphoriaParameter(Name = "alwaysBendForwards", Type = typeof(bool), DefaultValue = default(bool))]
public bool AlwaysBendForwards { get; set; } = default(bool);
/// <summary>
/// spine bend scaled with velocity
/// </summary>
[EuphoriaParameter(Name = "spineBendMult", Type = typeof(float), DefaultValue = 0.40f, MinimumValue = -10.0f, MaximumValue = 10.0f)]
public float SpineBendMult { get; set; } = 0.40f;
/// <summary>
/// enable and provide a look-at target to make the character's head turn to face it while balancing, balancer default is 0.2
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// position of thing to look at
/// </summary>
[EuphoriaParameter(Name = "headLookPos", Type = typeof(Vector3))]
public Vector3 HeadLookPos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// level index of thing to look at
/// </summary>
[EuphoriaParameter(Name = "headLookInstanceIndex", Type = typeof(int), DefaultValue = -1)]
public int HeadLookInstanceIndex { get; set; } = -1;
/// <summary>
/// Probability [0-1] that headLook will be looking in the direction of velocity when stepping
/// </summary>
[EuphoriaParameter(Name = "headLookAtVelProb", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float HeadLookAtVelProb { get; set; } = 1.0f;
/// <summary>
/// Weighted Probability that turn will be off. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnOffProb", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnOffProb { get; set; } = 0.0f;
/// <summary>
/// Weighted Probability of turning towards headLook target. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turn2TargetProb", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Turn2TargetProb { get; set; } = 0.0f;
/// <summary>
/// Weighted Probability of turning towards velocity. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turn2VelProb", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float Turn2VelProb { get; set; } = 1.0f;
/// <summary>
/// Weighted Probability of turning away from headLook target. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnAwayProb", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnAwayProb { get; set; } = 0.0f;
/// <summary>
/// Weighted Probability of turning left. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnLeftProb", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnLeftProb { get; set; } = 0.0f;
/// <summary>
/// Weighted Probability of turning right. This is one of six turn type weights.
/// </summary>
[EuphoriaParameter(Name = "turnRightProb", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float TurnRightProb { get; set; } = 0.0f;
/// <summary>
/// enable and provide a positive bodyTurnTimeout and provide a look-at target to make the character turn to face it while balancing
/// </summary>
[EuphoriaParameter(Name = "useBodyTurn", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseBodyTurn { get; set; } = default(bool);
/// <summary>
/// enable upper body reaction ie blindBrace and armswindmill
/// </summary>
[EuphoriaParameter(Name = "upperBodyReaction", Type = typeof(bool), DefaultValue = default(bool))]
public bool UpperBodyReaction { get; set; } = default(bool);
public EuphoriaMessageStaggerFall(bool startNow) : base("staggerFall", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageTeeter : EuphoriaMessage
{
/// <summary>
/// Defines the left edge point (left of character facing edge)
/// </summary>
[EuphoriaParameter(Name = "edgeLeft", Type = typeof(Vector3))]
public Vector3 EdgeLeft { get; set; } = new Vector3(39.470f, 38.890f, 21.120f);
/// <summary>
/// Defines the right edge point (right of character facing edge)
/// </summary>
[EuphoriaParameter(Name = "edgeRight", Type = typeof(Vector3))]
public Vector3 EdgeRight { get; set; } = new Vector3(39.470f, 39.890f, 21.120f);
/// <summary>
/// stop stepping across the line defined by edgeLeft and edgeRight
/// </summary>
[EuphoriaParameter(Name = "useExclusionZone", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseExclusionZone { get; set; } = default(bool);
/// <summary>
///
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// call highFall if fallen over the edge. If false just call blended writhe (to go over the top of the fall behaviour of the underlying behaviour e.g. bodyBalance)
/// </summary>
[EuphoriaParameter(Name = "callHighFall", Type = typeof(bool), DefaultValue = default(bool))]
public bool CallHighFall { get; set; } = default(bool);
/// <summary>
/// lean away from the edge based on velocity towards the edge (if closer than 2m from edge)
/// </summary>
[EuphoriaParameter(Name = "leanAway", Type = typeof(bool), DefaultValue = default(bool))]
public bool LeanAway { get; set; } = default(bool);
/// <summary>
/// Time-to-edge threshold to start pre-teeter (windmilling, etc).
/// </summary>
[EuphoriaParameter(Name = "preTeeterTime", Type = typeof(float), DefaultValue = 2.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float PreTeeterTime { get; set; } = 2.00f;
/// <summary>
/// Time-to-edge threshold to start leaning away from a potential fall.
/// </summary>
[EuphoriaParameter(Name = "leanAwayTime", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float LeanAwayTime { get; set; } = 1.00f;
/// <summary>
/// Scales stay upright lean and hip pitch.
/// </summary>
[EuphoriaParameter(Name = "leanAwayScale", Type = typeof(float), DefaultValue = 0.50f, MinimumValue = 0.00f, MaximumValue = 1.00f)]
public float LeanAwayScale { get; set; } = 0.50f;
/// <summary>
/// Time-to-edge threshold to start full-on teeter (more aggressive lean, drop-and-twist, etc).
/// </summary>
[EuphoriaParameter(Name = "teeterTime", Type = typeof(float), DefaultValue = 1.00f, MinimumValue = 0.00f, MaximumValue = 10.00f)]
public float TeeterTime { get; set; } = 1.00f;
public EuphoriaMessageTeeter(bool startNow) : base("teeter", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageUpperBodyFlinch : EuphoriaMessage
{
/// <summary>
/// Left-Right distance between the hands
/// </summary>
[EuphoriaParameter(Name = "handDistanceLeftRight", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float HandDistanceLeftRight { get; set; } = 0.1f;
/// <summary>
/// Front-Back distance between the hands
/// </summary>
[EuphoriaParameter(Name = "handDistanceFrontBack", Type = typeof(float), DefaultValue = 0.06f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float HandDistanceFrontBack { get; set; } = 0.06f;
/// <summary>
/// Vertical distance between the hands
/// </summary>
[EuphoriaParameter(Name = "handDistanceVertical", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float HandDistanceVertical { get; set; } = 0.1f;
/// <summary>
/// stiffness of body. Value carries over to head look, spine twist
/// </summary>
[EuphoriaParameter(Name = "bodyStiffness", Type = typeof(float), DefaultValue = 11.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float BodyStiffness { get; set; } = 11.0f;
/// <summary>
/// damping value used for upper body
/// </summary>
[EuphoriaParameter(Name = "bodyDamping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float BodyDamping { get; set; } = 1.0f;
/// <summary>
/// Amount to bend the back during the flinch
/// </summary>
[EuphoriaParameter(Name = "backBendAmount", Type = typeof(float), DefaultValue = -0.55f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float BackBendAmount { get; set; } = -0.55f;
/// <summary>
/// Toggle to use the right arm.
/// </summary>
[EuphoriaParameter(Name = "useRightArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseRightArm { get; set; } = default(bool);
/// <summary>
/// Toggle to Use the Left arm
/// </summary>
[EuphoriaParameter(Name = "useLeftArm", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseLeftArm { get; set; } = default(bool);
/// <summary>
/// Amplitude of the perlin noise applied to the arms positions in the flicnh to the front part of the behaviour.
/// </summary>
[EuphoriaParameter(Name = "noiseScale", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float NoiseScale { get; set; } = 0.1f;
/// <summary>
/// Relaxes the character for 1 frame if set.
/// </summary>
[EuphoriaParameter(Name = "newHit", Type = typeof(bool), DefaultValue = default(bool))]
public bool NewHit { get; set; } = default(bool);
/// <summary>
/// Always protect head. Note if false then character flinches if target is in front, protects head if target is behind
/// </summary>
[EuphoriaParameter(Name = "protectHeadToggle", Type = typeof(bool), DefaultValue = default(bool))]
public bool ProtectHeadToggle { get; set; } = default(bool);
/// <summary>
/// don't protect head only brace from front. Turned on by bcr
/// </summary>
[EuphoriaParameter(Name = "dontBraceHead", Type = typeof(bool), DefaultValue = default(bool))]
public bool DontBraceHead { get; set; } = default(bool);
/// <summary>
/// Turned of by bcr
/// </summary>
[EuphoriaParameter(Name = "applyStiffness", Type = typeof(bool), DefaultValue = default(bool))]
public bool ApplyStiffness { get; set; } = default(bool);
/// <summary>
/// Look away from target (unless protecting head then look between feet)
/// </summary>
[EuphoriaParameter(Name = "headLookAwayFromTarget", Type = typeof(bool), DefaultValue = default(bool))]
public bool HeadLookAwayFromTarget { get; set; } = default(bool);
/// <summary>
/// Use headlook
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// ve balancer turn Towards, negative balancer turn Away, 0 balancer won't turn. NB.There is a 50% chance that the character will not turn even if this parameter is set to turn
/// </summary>
[EuphoriaParameter(Name = "turnTowards", Type = typeof(int), DefaultValue = 1, MinimumValue = -2, MaximumValue = 2)]
public int TurnTowards { get; set; } = 1;
/// <summary>
/// position in world-space of object to flinch from
/// </summary>
[EuphoriaParameter(Name = "pos", Type = typeof(Vector3))]
public Vector3 Pos { get; set; } = new Vector3(0f, 0f, 0f);
public EuphoriaMessageUpperBodyFlinch(bool startNow) : base("upperBodyFlinch", startNow)
{ }
}
/// <summary>
///
/// </summary>
internal class EuphoriaMessageYanked : EuphoriaMessage
{
/// <summary>
/// stiffness of arms when upright.
/// </summary>
[EuphoriaParameter(Name = "armStiffness", Type = typeof(float), DefaultValue = 11.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float ArmStiffness { get; set; } = 11.0f;
/// <summary>
/// Sets damping value for the arms when upright.
/// </summary>
[EuphoriaParameter(Name = "armDamping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDamping { get; set; } = 1.0f;
/// <summary>
/// Spine Damping when upright.
/// </summary>
[EuphoriaParameter(Name = "spineDamping", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float SpineDamping { get; set; } = 1.0f;
/// <summary>
/// Spine Stiffness when upright..
/// </summary>
[EuphoriaParameter(Name = "spineStiffness", Type = typeof(float), DefaultValue = 10.0f, MinimumValue = 6.0f, MaximumValue = 16.0f)]
public float SpineStiffness { get; set; } = 10.0f;
/// <summary>
/// armStiffness during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "armStiffnessStart", Type = typeof(float), DefaultValue = 3.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float ArmStiffnessStart { get; set; } = 3.0f;
/// <summary>
/// armDamping during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "armDampingStart", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float ArmDampingStart { get; set; } = 0.1f;
/// <summary>
/// spineDamping during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "spineDampingStart", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float SpineDampingStart { get; set; } = 0.1f;
/// <summary>
/// spineStiffness during the yanked timescale ie timeAtStartValues
/// </summary>
[EuphoriaParameter(Name = "spineStiffnessStart", Type = typeof(float), DefaultValue = 3.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float SpineStiffnessStart { get; set; } = 3.0f;
/// <summary>
/// time spent with Start values for arms and spine stiffness and damping ie for whiplash efffect
/// </summary>
[EuphoriaParameter(Name = "timeAtStartValues", Type = typeof(float), DefaultValue = 0.4f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float TimeAtStartValues { get; set; } = 0.4f;
/// <summary>
/// time spent ramping from Start to end values for arms and spine stiffness and damping ie for whiplash efffect (occurs after timeAtStartValues)
/// </summary>
[EuphoriaParameter(Name = "rampTimeFromStartValues", Type = typeof(float), DefaultValue = 0.1f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RampTimeFromStartValues { get; set; } = 0.1f;
/// <summary>
/// steps taken before lowerBodyStiffness starts ramping down
/// </summary>
[EuphoriaParameter(Name = "stepsTillStartEnd", Type = typeof(int), DefaultValue = 2, MinimumValue = 0, MaximumValue = 100)]
public int StepsTillStartEnd { get; set; } = 2;
/// <summary>
/// time from start of behaviour before lowerBodyStiffness starts ramping down by perStepReduction1
/// </summary>
[EuphoriaParameter(Name = "timeStartEnd", Type = typeof(float), DefaultValue = 100.0f, MinimumValue = 0.0f, MaximumValue = 100.0f)]
public float TimeStartEnd { get; set; } = 100.0f;
/// <summary>
/// time spent ramping from lowerBodyStiffness to lowerBodyStiffnessEnd
/// </summary>
[EuphoriaParameter(Name = "rampTimeToEndValues", Type = typeof(float), DefaultValue = 0.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float RampTimeToEndValues { get; set; } = 0.0f;
/// <summary>
/// lowerBodyStiffness should be 12
/// </summary>
[EuphoriaParameter(Name = "lowerBodyStiffness", Type = typeof(float), DefaultValue = 12.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float LowerBodyStiffness { get; set; } = 12.0f;
/// <summary>
/// lowerBodyStiffness at end
/// </summary>
[EuphoriaParameter(Name = "lowerBodyStiffnessEnd", Type = typeof(float), DefaultValue = 8.0f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float LowerBodyStiffnessEnd { get; set; } = 8.0f;
/// <summary>
/// LowerBody stiffness will be reduced every step to make the character fallover
/// </summary>
[EuphoriaParameter(Name = "perStepReduction", Type = typeof(float), DefaultValue = 1.50f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float PerStepReduction { get; set; } = 1.50f;
/// <summary>
/// Amount to bend forward at the hips (+ve forward, -ve backwards). Behaviour switches between hipPitchForward and hipPitchBack
/// </summary>
[EuphoriaParameter(Name = "hipPitchForward", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = -1.30f, MaximumValue = 1.30f)]
public float HipPitchForward { get; set; } = 0.60f;
/// <summary>
/// Amount to bend backwards at the hips (+ve backwards, -ve forwards). Behaviour switches between hipPitchForward and hipPitchBack
/// </summary>
[EuphoriaParameter(Name = "hipPitchBack", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = -1.30f, MaximumValue = 1.30f)]
public float HipPitchBack { get; set; } = 1.0f;
/// <summary>
/// Bend/Twist the spine amount
/// </summary>
[EuphoriaParameter(Name = "spineBend", Type = typeof(float), DefaultValue = 0.70f, MinimumValue = 0.0f, MaximumValue = 1.0f)]
public float SpineBend { get; set; } = 0.70f;
/// <summary>
/// Foot friction when standing/stepping. 0.5 gives a good slide sometimes
/// </summary>
[EuphoriaParameter(Name = "footFriction", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float FootFriction { get; set; } = 1.0f;
/// <summary>
/// min angle at which the turn with toggle to the other direction (actual toggle angle is chosen randomly in range min to max). If it is 1 then it will never toggle. If negative then no turn is applied.
/// </summary>
[EuphoriaParameter(Name = "turnThresholdMin", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = -0.10f, MaximumValue = 1.00f)]
public float TurnThresholdMin { get; set; } = 0.60f;
/// <summary>
/// max angle at which the turn with toggle to the other direction (actual toggle angle is chosen randomly in range min to max). If it is 1 then it will never toggle. If negative then no turn is applied.
/// </summary>
[EuphoriaParameter(Name = "turnThresholdMax", Type = typeof(float), DefaultValue = 0.60f, MinimumValue = -0.10f, MaximumValue = 1.00f)]
public float TurnThresholdMax { get; set; } = 0.60f;
/// <summary>
/// enable and provide a look-at target to make the character's head turn to face it while balancing
/// </summary>
[EuphoriaParameter(Name = "useHeadLook", Type = typeof(bool), DefaultValue = default(bool))]
public bool UseHeadLook { get; set; } = default(bool);
/// <summary>
/// position of thing to look at
/// </summary>
[EuphoriaParameter(Name = "headLookPos", Type = typeof(Vector3))]
public Vector3 HeadLookPos { get; set; } = new Vector3(0f, 0f, 0f);
/// <summary>
/// level index of thing to look at
/// </summary>
[EuphoriaParameter(Name = "headLookInstanceIndex", Type = typeof(int), DefaultValue = -1)]
public int HeadLookInstanceIndex { get; set; } = -1;
/// <summary>
/// Probability [0-1] that headLook will be looking in the direction of velocity when stepping
/// </summary>
[EuphoriaParameter(Name = "headLookAtVelProb", Type = typeof(float), DefaultValue = -1.0f, MinimumValue = -1.0f, MaximumValue = 1.0f)]
public float HeadLookAtVelProb { get; set; } = -1.0f;
/// <summary>
/// for handsAndKnees catchfall ONLY: comVel above which rollDownstairs will start
/// </summary>
[EuphoriaParameter(Name = "comVelRDSThresh", Type = typeof(float), DefaultValue = 2.0f, MinimumValue = 0.0f, MaximumValue = 20.0f)]
public float ComVelRDSThresh { get; set; } = 2.0f;
/// <summary>
/// 0.25 A complete wiggle will take 4*hulaPeriod
/// </summary>
[EuphoriaParameter(Name = "hulaPeriod", Type = typeof(float), DefaultValue = 0.25f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float HulaPeriod { get; set; } = 0.25f;
/// <summary>
/// Amount of hip movement
/// </summary>
[EuphoriaParameter(Name = "hipAmplitude", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float HipAmplitude { get; set; } = 1.0f;
/// <summary>
/// Amount of spine movement
/// </summary>
[EuphoriaParameter(Name = "spineAmplitude", Type = typeof(float), DefaultValue = 1.0f, MinimumValue = 0.0f, MaximumValue = 4.0f)]
public float SpineAmplitude { get; set; } = 1.0f;
/// <summary>
/// wriggle relaxes for a minimum of minRelaxPeriod (if it is negative it is a multiplier on the time previously spent wriggling)
/// </summary>
[EuphoriaParameter(Name = "minRelaxPeriod", Type = typeof(float), DefaultValue = 0.3f, MinimumValue = -5.0f, MaximumValue = 5.0f)]
public float MinRelaxPeriod { get; set; } = 0.3f;
/// <summary>
/// wriggle relaxes for a maximum of maxRelaxPeriod (if it is negative it is a multiplier on the time previously spent wriggling)
/// </summary>
[EuphoriaParameter(Name = "maxRelaxPeriod", Type = typeof(float), DefaultValue = 1.5f, MinimumValue = -5.0f, MaximumValue = 5.0f)]
public float MaxRelaxPeriod { get; set; } = 1.5f;
/// <summary>
/// Amount of cheat torque applied to turn the character over
/// </summary>
[EuphoriaParameter(Name = "rollHelp", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float RollHelp { get; set; } = 0.5f;
/// <summary>
/// Leg Stiffness when on the ground
/// </summary>
[EuphoriaParameter(Name = "groundLegStiffness", Type = typeof(float), DefaultValue = 11f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float GroundLegStiffness { get; set; } = 11f;
/// <summary>
/// Arm Stiffness when on the ground
/// </summary>
[EuphoriaParameter(Name = "groundArmStiffness", Type = typeof(float), DefaultValue = 11f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float GroundArmStiffness { get; set; } = 11f;
/// <summary>
/// Spine Stiffness when on the ground
/// </summary>
[EuphoriaParameter(Name = "groundSpineStiffness", Type = typeof(float), DefaultValue = 14f, MinimumValue = 0.0f, MaximumValue = 16.0f)]
public float GroundSpineStiffness { get; set; } = 14f;
/// <summary>
/// Leg Damping when on the ground
/// </summary>
[EuphoriaParameter(Name = "groundLegDamping", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float GroundLegDamping { get; set; } = 0.5f;
/// <summary>
/// Arm Damping when on the ground
/// </summary>
[EuphoriaParameter(Name = "groundArmDamping", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float GroundArmDamping { get; set; } = 0.5f;
/// <summary>
/// Spine Damping when on the ground
/// </summary>
[EuphoriaParameter(Name = "groundSpineDamping", Type = typeof(float), DefaultValue = 0.5f, MinimumValue = 0.0f, MaximumValue = 2.0f)]
public float GroundSpineDamping { get; set; } = 0.5f;
/// <summary>
/// Friction multiplier on bodyParts when on ground. Character can look too slidy with groundFriction = 1. Higher values give a more jerky reation but this seems timestep dependent especially for dragged by the feet.
/// </summary>
[EuphoriaParameter(Name = "groundFriction", Type = typeof(float), DefaultValue = 8.0f, MinimumValue = 0.0f, MaximumValue = 10.0f)]
public float GroundFriction { get; set; } = 8.0f;
public EuphoriaMessageYanked(bool startNow) : base("yanked", startNow)
{ }
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment