public override void OnReset()
{
if (force != null) {
force.Value = Vector3.zero;
}
forceMode = ForceMode.Force;
}
public override void Reset()
{
center = null;
upwardsModifier = 0f;
forceMode = ForceMode.Force;
everyFrame = false;
}
public override void OnReset()
{
targetGameObject = null;
force = Vector3.zero;
position = Vector3.zero;
forceMode = ForceMode.Force;
}
/// <summary>
/// Function for applying a specific type of force to a Rigidbody2D (since the default functionality is incomplete)
/// </summary>
/// <param name="rb2d">Rigidbody2D to apply the force to</param>
/// <param name="force">The amount of force to apply</param>
/// <param name="mode">What type of force to apply</param>
/// <param name="relativeTo">Should the force be applied in the rigidbody's local space, or world space?</param>
public static void AddForce2D(this Rigidbody2D rb2d, Vector2 force, ForceMode mode = ForceMode.Force, Space relativeTo = Space.World)
{
ForceMode2D mode2D = ForceMode2D.Force;
Vector2 forceApplied = force;
switch (mode)
{
case ForceMode.Impulse:
mode2D = ForceMode2D.Impulse;
break;
case ForceMode.Acceleration:
forceApplied *= rb2d.mass;
break;
case ForceMode.VelocityChange:
forceApplied = force * rb2d.mass / Time.fixedDeltaTime;
break;
case ForceMode.Force:
//nothing special
break;
}
if (relativeTo == Space.Self)
rb2d.AddRelativeForce(forceApplied, mode2D);
else if (relativeTo == Space.World)
rb2d.AddForce(forceApplied, mode2D);
}
public Vector2 ApplyForceMode(Vector2 force, ForceMode forceMode)
{
switch (forceMode)
{
case ForceMode.Force:
return force;
case ForceMode.Impulse:
return force / Time.fixedDeltaTime;
case ForceMode.Acceleration:
return force * rigidbody2D.mass;
case ForceMode.VelocityChange:
return force * rigidbody2D.mass / Time.fixedDeltaTime;
default:
return force;
}
}
/// <summary>
/// Draws a <seealso cref="Rigidbody" />'s trajectory using <seealso cref="Debug" />.DrawLine.
/// </summary>
/// <param name="rb"> The body whose trajectory is being drawn. </param>
/// <param name="force"> For predicting the effects of a Rigidbody.AddForce() method. Use Vector3.zero if not needed. </param>
/// <param name="mode"> Determines how the force vector changes the velocity. Irrelevant when using Vector3.zero. </param>
/// <param name="color"> The color of the line being drawn. </param>
/// <param name="trajectoryDuration"> Amount of time in seconds to predict. </param>
/// <param name="lineDuration"> Amount of time in seconds the drawn line will persist. </param>
/// <param name="constantForce"> Will the force be applied every FixedUpdate. </param>
/// <param name='depthTest'> Whether or not the line should be faded when behind other objects. </param>
public static void DebugTrajectory(this Rigidbody rb, Vector3 force, ForceMode mode, Color color,
float trajectoryDuration = 1.0f, float lineDuration = 0.0f, bool constantForce = false, bool depthTest = false)
{
var positions = rb.GetTrajectory(force, mode, trajectoryDuration, constantForce);
for (var i = 0; i < positions.Length - 1; i++)
Debug.DrawLine(positions[i], positions[i + 1], color, lineDuration, depthTest);
}
public override void Reset()
{
this.center = null;
this.upwardsModifier = 0f;
this.forceMode = ForceMode.Force;
this.everyFrame = false;
}
public override void Reset()
{
gameObject = null;
center = new FsmVector3 { UseVariable = true };
upwardsModifier = 0f;
forceMode = ForceMode.Force;
everyFrame = false;
}
public override void OnReset()
{
targetGameObject = null;
if (force != null) {
force.Value = Vector3.zero;
}
forceMode = ForceMode.Force;
}
public Damage(MonoBehaviour pAttacker, DamageType pDamageType, int pDamage, Vector3 pMomentum, ForceMode pMomentumType)
{
attacker = pAttacker;
damageType = pDamageType;
damage = pDamage;
momentum = pMomentum;
momentumType = pMomentumType;
}
private void metjolturgent(float varpforcemin, float varpforcemax, float varptorquemin, float varptorquemax, ForceMode varpforcemode, bool varpjoltspine, bool varpjolthead, bool varpjoltarmleft, bool varpjoltarmright, bool varpjoltlegright, bool varpjoltlegleft)
{
clsurgent componentInChildren = base.gameObject.GetComponentInChildren<clsurgent>();
if (componentInChildren == null)
{
return;
}
Vector3 force = new Vector3(UnityEngine.Random.Range(varpforcemin, varpforcemax), UnityEngine.Random.Range(varpforcemin, varpforcemax), UnityEngine.Random.Range(varpforcemin, varpforcemax));
Vector3 torque = new Vector3(UnityEngine.Random.Range(varptorquemin, varptorquemax), UnityEngine.Random.Range(varptorquemin, varptorquemax), UnityEngine.Random.Range(varptorquemin, varptorquemax));
if (varpjoltspine)
{
for (int i = 0; i < componentInChildren.vargamnodes.vargamspine.Length; i++)
{
componentInChildren.vargamnodes.vargamspine[i].GetComponent<Rigidbody>().AddForce(force, varpforcemode);
componentInChildren.vargamnodes.vargamspine[i].GetComponent<Rigidbody>().AddTorque(torque, varpforcemode);
}
}
if (varpjolthead)
{
for (int j = 0; j < componentInChildren.vargamnodes.vargamhead.Length; j++)
{
componentInChildren.vargamnodes.vargamhead[j].GetComponent<Rigidbody>().AddForce(force, varpforcemode);
componentInChildren.vargamnodes.vargamhead[j].GetComponent<Rigidbody>().AddTorque(torque, varpforcemode);
}
}
if (varpjoltarmleft)
{
for (int k = 0; k < componentInChildren.vargamnodes.vargamarmleft.Length; k++)
{
componentInChildren.vargamnodes.vargamarmleft[k].GetComponent<Rigidbody>().AddForce(force, varpforcemode);
componentInChildren.vargamnodes.vargamarmleft[k].GetComponent<Rigidbody>().AddTorque(torque, varpforcemode);
}
}
if (varpjoltarmright)
{
for (int l = 0; l < componentInChildren.vargamnodes.vargamarmright.Length; l++)
{
componentInChildren.vargamnodes.vargamarmright[l].GetComponent<Rigidbody>().AddForce(force, varpforcemode);
componentInChildren.vargamnodes.vargamarmright[l].GetComponent<Rigidbody>().AddTorque(torque, varpforcemode);
}
}
if (varpjoltlegleft)
{
for (int m = 0; m < componentInChildren.vargamnodes.vargamlegleft.Length; m++)
{
componentInChildren.vargamnodes.vargamlegleft[m].GetComponent<Rigidbody>().AddForce(force, varpforcemode);
componentInChildren.vargamnodes.vargamlegleft[m].GetComponent<Rigidbody>().AddTorque(torque, varpforcemode);
}
}
if (varpjoltlegright)
{
for (int n = 0; n < componentInChildren.vargamnodes.vargamlegright.Length; n++)
{
componentInChildren.vargamnodes.vargamlegright[n].GetComponent<Rigidbody>().AddForce(force, varpforcemode);
componentInChildren.vargamnodes.vargamlegright[n].GetComponent<Rigidbody>().AddTorque(torque, varpforcemode);
}
}
}
public override void Reset () {
explosionPoint = new ConcreteVector3Var();
explosionPosition = new ConcreteGameObjectVar(this.self);
explosionForce = new ConcreteFloatVar();
explosionRadius = new ConcreteFloatVar();
upwardsModifier = new ConcreteFloatVar();
mode = ForceMode.Force;
layers = -1;
}
public override void OnReset()
{
targetGameObject = null;
explosionForce = 0;
explosionPosition = Vector3.zero;
explosionRadius = 0;
upwardsModifier = 0;
forceMode = ForceMode.Force;
}
public override void Reset () {
gameObject = new ConcreteGameObjectVar(this.self);
space = Space.World;
torque = new ConcreteVector3Var();
torqueX = new ConcreteFloatVar();
torqueY = new ConcreteFloatVar();
torqueZ = new ConcreteFloatVar();
multiplyTorqueBy = new ConcreteFloatVar();
mode = ForceMode.Force;
perSecond = true;
}
public override void Reset()
{
gameObject = null;
// default axis to variable dropdown with None selected.
x = new FsmFloat { UseVariable = true };
y = new FsmFloat { UseVariable = true };
z = new FsmFloat { UseVariable = true };
space = Space.World;
forceMode = ForceMode.Force;
everyFrame = false;
}
public void ForceToPoint(Vector3 point, float maxForce, float maxDistance, bool inverseDirection, ForceMode mode)
{
Vector3 myPosition = myTransform.position;
float distance = Vector3.Distance(myPosition, point);
if (distance <= maxDistance) {
Vector3 direction = (point - myPosition);
if (inverseDirection) {
direction *= -1;
}
myRigidbody.AddForce(direction.normalized * (1f - distance / maxDistance) * maxForce, mode);
}
}
public override void OnReset()
{
if (explosionForce != null) {
explosionForce.Value = 0;
}
if (explosionPosition != null) {
explosionPosition.Value = Vector3.zero;
}
if (explosionRadius != null) {
explosionRadius.Value = 0;
}
upwardsModifier = 0;
forceMode = ForceMode.Force;
}
public static void AddExplosionForce (
this Rigidbody body
, float explosionForce
, Vector3 explosionRadiusCenter
, float explosionRadius
, Vector3 explosionOriginPoint // this is the oposite from upwardsModifier
, ForceMode mode
)
{
if (Vector3.Distance(body.transform.position, explosionRadiusCenter) <= explosionRadius)
{
Vector3 force = (body.transform.position - (explosionRadiusCenter + explosionOriginPoint));
body.AddForce(force * (explosionForce/5), mode); // 5 came from experimentation
}
}
public static void AddForce (this Rigidbody2D rigidbody2D, Vector2 force, ForceMode mode = ForceMode.Force) {
switch(mode){
case ForceMode.Force:
rigidbody2D.AddForce (force);
break;
case ForceMode.Impulse:
rigidbody2D.AddForce (force / Time.fixedDeltaTime);
break;
case ForceMode.Acceleration:
rigidbody2D.AddForce (force * rigidbody2D.mass);
break;
case ForceMode.VelocityChange:
rigidbody2D.AddForce (force * rigidbody2D.mass / Time.fixedDeltaTime);
break;
}
}
// Recieve damage methods
#region Recieve Damage methods and overloads
public virtual void RecieveDamage(GameObject source, int Amount, float KnockbackForce, ForceMode m)
{
if (CharacterHealth > 0)
{
this.CharacterHealth -= Amount;
Vector3 relativeDirection = this.transform.position - source.transform.position;
relativeDirection = relativeDirection.normalized;
relativeDirection *= KnockbackForce;
this.transform.rigidbody.AddForce(relativeDirection, m);
// Visual effect
if (GetHitEffect)
{
Instantiate(GetHitEffect, gotHitPoint, transform.rotation);
}
// Sound effect
DamageTaken(source);
}
}
public void Launch(float speed, ForceMode mode)
{
Speed = speed;
_mode = mode;
enabled = true;
gameObject.SetActive(true);
var r = rigidbody;
r.velocity = Vector3.zero;
r.angularVelocity = Vector3.zero;
//r.inertiaTensorRotation = Quaternion.identity;
//r.rotation = Quaternion.identity;
r.inertiaTensor = new Vector3(1,1,1);
r.isKinematic = true;
r.isKinematic = false;
renderer.enabled = true;
if (LaunchSound)
{
audio.PlayOneShot(LaunchSound);
}
if (thruster)
{
thruster.Play(true);
}
}
public void AddForceAtPosition(Vector3 force, Vector3 position)
{
ForceMode mode = ForceMode.Force;
Rigidbody.INTERNAL_CALL_AddForceAtPosition(this, ref force, ref position, mode);
}
/// <summary>
/// <para>Applies a force to a rigidbody that simulates explosion effects.</para>
/// </summary>
/// <param name="explosionForce">The force of the explosion (which may be modified by distance).</param>
/// <param name="explosionPosition">The centre of the sphere within which the explosion has its effect.</param>
/// <param name="explosionRadius">The radius of the sphere within which the explosion has its effect.</param>
/// <param name="upwardsModifier">Adjustment to the apparent position of the explosion to make it seem to lift objects.</param>
/// <param name="mode">The method used to apply the force to its targets.</param>
public void AddExplosionForce(float explosionForce, Vector3 explosionPosition, float explosionRadius, [DefaultValue("0.0F")] float upwardsModifier, [DefaultValue("ForceMode.Force")] ForceMode mode)
{
Rigidbody.INTERNAL_CALL_AddExplosionForce(this, explosionForce, ref explosionPosition, explosionRadius, upwardsModifier, mode);
}
private static extern void INTERNAL_CALL_AddRelativeTorque(Rigidbody self, ref Vector3 torque, ForceMode mode);
/// <summary>
/// <para>Adds a torque to the rigidbody relative to its coordinate system.</para>
/// </summary>
/// <param name="x">Size of torque along the local x-axis.</param>
/// <param name="y">Size of torque along the local y-axis.</param>
/// <param name="z">Size of torque along the local z-axis.</param>
/// <param name="mode"></param>
public void AddRelativeTorque(float x, float y, float z, [DefaultValue("ForceMode.Force")] ForceMode mode)
{
this.AddRelativeTorque(new Vector3(x, y, z), mode);
}
private static extern void INTERNAL_CALL_AddForceAtPosition(Rigidbody self, ref Vector3 force, ref Vector3 position, ForceMode mode);
/// <summary>
/// <para>Adds a torque to the rigidbody relative to its coordinate system.</para>
/// </summary>
/// <param name="torque">Torque vector in local coordinates.</param>
/// <param name="mode"></param>
public void AddRelativeTorque(Vector3 torque, [DefaultValue("ForceMode.Force")] ForceMode mode)
{
Rigidbody.INTERNAL_CALL_AddRelativeTorque(this, ref torque, mode);
}
public void AddRelativeTorque(Vector3 torque)
{
ForceMode force = ForceMode.Force;
INTERNAL_CALL_AddRelativeTorque(this, ref torque, force);
}
public virtual void ApplyForce(Vector3 power, ForceMode mode)
{
}
public void AddRelativeForce(Vector3 force, [DefaultValue("ForceMode.Force")] ForceMode mode)
{
INTERNAL_CALL_AddRelativeForce(this, ref force, mode);
}
public void AddRelativeForce(float x, float y, float z)
{
ForceMode force = ForceMode.Force;
this.AddRelativeForce(x, y, z, force);
}
public void AddForce(Vector3 elasticityForce, ForceMode mode)
{
Vector2 ef = VectorConverter.Convert(elasticityForce, body.UserData.to2dMode);
switch (mode)
{
case ForceMode.Force:
body.ApplyForce(ef, VectorConverter.Convert(gameObject.transform.position, body.UserData.to2dMode));
break;
case ForceMode.Acceleration:
throw new NotImplementedException();
case ForceMode.Impulse:
body.ApplyLinearImpulse(ef, VectorConverter.Convert(gameObject.transform.position, body.UserData.to2dMode));
break;
case ForceMode.VelocityChange:
throw new NotImplementedException();
}
}
private static extern void INTERNAL_CALL_AddTorque(Rigidbody self, ref Vector3 torque, ForceMode mode);
private static extern void INTERNAL_CALL_AddRelativeForce(Rigidbody self, ref Vector3 force, ForceMode mode);
private static extern void INTERNAL_CALL_AddExplosionForce(Rigidbody self, float explosionForce, ref Vector3 explosionPosition, float explosionRadius, float upwardsModifier, ForceMode mode);
public void Move(Vector3 moveDirection, float speed, ForceMode forceMode)
{
thisRigidBody.AddForce(moveDirection * speed, forceMode);
}
public void GetStunned(float force, Vector3 Vector, ForceMode forceMode)
{
rb.AddForce(force * Vector, forceMode);
StartCoroutine(StunCo());
}
// Damage targets
/// <summary>
/// Damage targets, returns the Character it hit
/// </summary>
/// <returns>GameObject</returns>
public GameObject MeleeDamage(GameObject source, int Amount, float KnockbackForce, ForceMode m)
{
RaycastHit mRay;
LayerMask layer = (1 << LayerMask.NameToLayer("NPC")) | (1 << LayerMask.NameToLayer("Player")); // Player and NPC layer.
if (Physics.Raycast(transform.position + transform.TransformDirection(DamagePointOffset), transform.TransformDirection(Vector3.forward), out mRay, HitDistance, layer))
{
damageDebugGizmo = mRay.point;
Character _char = (Character)mRay.collider.gameObject.GetComponent(typeof(Character));
if (_char)
{
Debug.Log(_char.gameObject.name);
_char.SetHitPoint = mRay.point;
_char.RecieveDamage(source, Amount, KnockbackForce, m);
return mRay.collider.gameObject;
}
else
return null;
}
return null;
}
public void AddForceAtPosition(Vector3 force, Vector3 position, ForceMode mode)
{
_body.AddForceAtPosition(force, position, mode);
}
public ConfigurableForce(float strength, ForceMode mode, ForceDirection dir)
{
_direction = dir;
_strength = strength;
_forceMode = mode;
}
public void AddRelativeForce(Vector3 force)
{
ForceMode mode = ForceMode.Force;
Rigidbody.INTERNAL_CALL_AddRelativeForce(this, ref force, mode);
}
public void AddRelativeForce(Vector3 velocity, ForceMode forceMode = ForceMode.Force)
{
AddForce(transform.TransformDirection(velocity), forceMode);
}
public void AddRelativeTorque(Vector3 torque)
{
ForceMode mode = ForceMode.Force;
Rigidbody.INTERNAL_CALL_AddRelativeTorque(this, ref torque, mode);
}
public void AddExplosionForce(float force, Vector3 position, float explosionRadius, ForceMode forceMode = ForceMode.Force)
{
float distance = Vector3.Distance(position, transform.position);
if (distance < explosionRadius)
{
AddForce(ExtVector3.Direction(position, transform.position) * (force * (distance / explosionRadius)), forceMode);
}
}
public void AddRelativeTorque(float x, float y, float z)
{
ForceMode mode = ForceMode.Force;
this.AddRelativeTorque(x, y, z, mode);
}
public void TakeShot(Vector3 shootDirection, float shootSpeed, ForceMode forceMode)
{
thisRigidBody.isKinematic = false;
thisRigidBody.AddForce(shootDirection.normalized * shootSpeed, ForceMode.Impulse);
}
/// <summary>
/// <para>Applies force at position. As a result this will apply a torque and force on the object.</para>
/// </summary>
/// <param name="force">Force vector in world coordinates.</param>
/// <param name="position">Position in world coordinates.</param>
/// <param name="mode"></param>
public void AddForceAtPosition(Vector3 force, Vector3 position, [DefaultValue("ForceMode.Force")] ForceMode mode)
{
Rigidbody.INTERNAL_CALL_AddForceAtPosition(this, ref force, ref position, mode);
}
public void AddTorque(Vector3 torque, ForceMode mode)
{
this.body.AddTorque(torque, mode);
}
private static extern void INTERNAL_CALL_AddForceAtPosition(Rigidbody self, ref Vector3 force, ref Vector3 position, ForceMode mode);
public void AddForceAtPosition(Vector3 force, Vector3 pos, ForceMode mode)
{
updateContainer();
parentRigid.AddForceAtPosition(force, pos, mode);
}
public void AddExplosionForce(float explosionForce, Vector3 explosionPosition, float explosionRadius, float upwardsModifier)
{
ForceMode mode = ForceMode.Force;
Rigidbody.INTERNAL_CALL_AddExplosionForce(this, explosionForce, ref explosionPosition, explosionRadius, upwardsModifier, mode);
}
public void SetForce(Vector3 newforce, ForceMode newforceMode)
{
rb = GetComponent <Rigidbody>();
rb.AddForce(newforce, newforceMode);
}
public void ApplyForce(Vector3 force, ForceMode forceMode)
{
rb.AddForce(force, forceMode);
}
/// <summary>
/// <para>Adds a force to the rigidbody.</para>
/// </summary>
/// <param name="force">Force vector in world coordinates.</param>
/// <param name="mode"></param>
public void AddForce(Vector3 force, [DefaultValue("ForceMode.Force")] ForceMode mode)
{
Rigidbody.INTERNAL_CALL_AddForce(this, ref force, mode);
}
//applies the force necessary to reach the desired velocity
private static void ApplyForceToReachVelocity(Rigidbody rigidbody, Vector3 velocity, float force = 1, ForceMode mode = ForceMode.Force)
{
if (force == 0 || velocity.magnitude == 0)
{
return;
}
velocity += velocity.normalized * 0.2f * rigidbody.drag;
force = Mathf.Clamp(force, -rigidbody.mass / Time.fixedDeltaTime, rigidbody.mass / Time.fixedDeltaTime);
if (rigidbody.velocity.magnitude == 0)
{
rigidbody.AddForce(velocity * force, mode);
}
else
{
var velocityProjectedToTarget = (velocity.normalized * Vector3.Dot(velocity, rigidbody.velocity) / velocity.magnitude);
rigidbody.AddForce((velocity - velocityProjectedToTarget) * force, mode);
}
}
private static extern void INTERNAL_CALL_AddForce(Rigidbody self, ref Vector3 force, ForceMode mode);
private void ApplyMovement(Vector3 targetVelocity, float force, ForceMode forceMode)
{
rb.AddForce(targetVelocity * force, forceMode);
}
public void AddForce(float x, float y, float z)
{
ForceMode mode = ForceMode.Force;
this.AddForce(x, y, z, mode);
}
public void Rotate(Vector3 torque, float magnitude, ForceMode forcemode)
{
thisRigidBody.AddTorque(torque, forcemode);
}
private static extern void INTERNAL_CALL_AddExplosionForce(Rigidbody self, float explosionForce, ref Vector3 explosionPosition, float explosionRadius, float upwardsModifier, ForceMode mode);
