public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
/*
* -32767 32767
|------------------------0------------------------|
|___________________________|
* Random Range
*
*/
// Hex 0x7fff = 32767
float randX = Random.Range(0, 0x7fff) - (0x7fff / 2);
float randZ = Random.Range(0, 0x7fff) - (0x7fff / 2);
#region Calculate randomDir
// Create the randomDir
randomDir = new Vector3(randX, 0, randZ);
// Normalise randomDir
randomDir.Normalize();
// Apply jitter to it
randomDir *= jitter;
#endregion
#region Calculate targetDir
// Offset targetDir with randomDir
targetDir += randomDir;
// Normalise the targetDir
targetDir.Normalize();
// Apply radius to it
targetDir *= radius;
#endregion
// Seek logic
Vector3 seekPos = transform.position + targetDir;
// Offset the seek position
seekPos += transform.forward * offset;
#region GizmosGL
GizmosGL.color = Color.red;
GizmosGL.AddCircle(seekPos + Vector3.up * .11f, .5f, Quaternion.LookRotation(Vector3.down));
Vector3 offsetPos = transform.position + transform.forward * offset;
GizmosGL.color = Color.blue;
GizmosGL.AddCircle(offsetPos + Vector3.up * .1f, radius, Quaternion.LookRotation(Vector3.down));
GizmosGL.color = Color.cyan;
GizmosGL.AddLine(transform.position, offsetPos, .1f, .1f);
#endregion
// Calculate direction
Vector3 direction = seekPos - transform.position;
Vector3 desiredForce = Vector3.zero;
// Check if direction is valid
if (direction != Vector3.zero) // or direction.magnitude != 0
{
// Apply a weighting to the direction
desiredForce = direction.normalized * weighting;
// Apply to force
force = desiredForce - owner.velocity;
}
return(force);
}
public override Vector3 GetForce()
{
// set force to zero
Vector3 force = Vector3.zero;
// gernerate random numbers between a certain range
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region Calculate RandomDir
// SET randomDir to new Vector3 x = randX & z = randZ
Vector3 randomDir = new Vector3(randX, 0, randZ);
// SET randomDir to normalized
randomDir = randomDir.normalized * weighting;
// SET randomDir to randomDir x jitter (amplify randomDir by jitter)
randomDir = randomDir * jitter;
#endregion
#region Calculate TargetDir
// SET targetDir to targetDir + randomDir
targetDir = targetDir + randomDir;
// SET targetDir to normalized targetDir
targetDir = targetDir.normalized;
// SET targetDir to targetDir x radius
targetDir = targetDir * radius;
#endregion
#region Calculate force
// SET seekPos to owners position + targetDir
Vector3 seekPos = transform.position + targetDir;
// SET seekPos to seekPos + owner's forward x offset
seekPos = seekPos + owner.transform.forward * offset;
#endregion
#region GIZMOS
// SET offsetPos to position + forward x offset
Vector3 offsetPos = transform.position + transform.forward.normalized * offset;
GizmosGL.AddCircle(offsetPos + Vector3.up * 0.1f,
radius,
Quaternion.LookRotation(Vector3.down),
16,
Color.red);
GizmosGL.AddCircle(seekPos + Vector3.up * 0.15f,
radius * 0.6f,
Quaternion.LookRotation(Vector3.down),
16, Color.blue);
// ADD circle with offsetPos + up x amount, rotate circle with LookRotation (down)
#endregion
#region
// SET desiredForce to seekPos - position
Vector3 desiredForce = seekPos - transform.position;
// IF desiredforce is not zero
if (desiredForce != Vector3.zero)
{
// SET desiredForce to desiredForce normalized x weighting
desiredForce = desiredForce.normalized * weighting;
// SET force to desiredForce - owner's velocity
// wtf just set force...
force = desiredForce - owner.velocity;
}
#endregion
// return force
return(force);
}
public override Vector3 GetForce()
{
// SET force to zero
Vector3 force = Vector3.zero;
// Generating a random number between -max value to max value
// - half max value to half max value
// 0x7fff = 32767
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region Calculate RandomDir
// SET randomDir to new Vector3 x = randX & z = randZ
randomDir = new Vector3(randX, 0, randZ);
// SET randomDir to normalized randomDir
randomDir = randomDir.normalized;
// SET randomDir to randomDir x jitter
randomDir = randomDir * jitter;
#endregion
#region Calculate TargetDir
// SET targetDir to targetDir + randomDir
targetDir = targetDir + randomDir;
// SET targetDir to normalized targetDir
targetDir = targetDir.normalized;
// SET targetDir to targetDir x radius
targetDir = targetDir * radius;
#endregion
#region Calculate Force
// SET seekPos to owner's position + targetDir
Vector3 seekPos = owner.transform.position + targetDir;
// SET seekPos to seekPos + owner's forward x offset
seekPos = seekPos + owner.transform.forward * offset;
#region GIZMOS
Vector3 offsetPos = transform.position + transform.forward.normalized * offset;
GizmosGL.AddCircle(offsetPos + Vector3.up * 0.1f,
radius, Quaternion.LookRotation(Vector3.down), 16, Color.red);
GizmosGL.AddCircle(seekPos + Vector3.up * 0.15f, radius * 0.6f,
Quaternion.LookRotation(Vector3.down), 16, Color.blue);
#endregion
// SET desiredForce to seekPos - position
Vector3 desiredForce = seekPos - transform.position;
// If desiredForce is not zero
if (desiredForce != Vector3.zero)
{
// SET desiredForce to desiredForce normalized x weighting
desiredForce = desiredForce.normalized * weighting;
// SET force to desiredForce - owner's velocity
force = desiredForce - owner.velocity;
}
#endregion
// RETURN force
return(force);
}
public override Vector3 GetForce()
{
// Force starts at zero (no velocity)
Vector3 force = Vector3.zero; // to hero
/*
* -32767 0 32767
* |--------------------|--------------------|
* |____________________|
* Random Range
*/
//Randomize range between values
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region Calculate Random Direction
// create random direction vector
randomDir = new Vector3(randX, 0, randZ);
//Normalize the random direction
randomDir = randomDir.normalized;
//randomDir.Normalize();
// Multiply jitter to randomDir
randomDir *= jitter;
#endregion
#region calculate Target Direction
// Append target dir with randomDir
targetDir += randomDir;
// normalize target dir
targetDir = targetDir.normalized;
//targetDir.Normalized();
// Amplify it by the radius
targetDir *= radius;
#endregion
// Calculate seek position using targetDir;
Vector3 seekPos = transform.position + targetDir;
seekPos += transform.forward.normalized * offset;
#region GizmosGl
Vector3 forwardPos = transform.position + transform.forward.normalized * offset;
Circle c = GizmosGL.AddCircle(forwardPos + Vector3.up * 0.1f, radius, Quaternion.LookRotation(Vector3.down));
c.color = new Color(1, 0, 0, 0.5f);
c = GizmosGL.AddCircle(seekPos + Vector3.up * 0.15f, radius * 0.6f, Quaternion.LookRotation(Vector3.down));
c.color = new Color(0, 0, 1, 0.5f);
#endregion
#region Wander
// calculate direction
Vector3 direction = seekPos - transform.position;
//Is direction valid? (not zero)
if (direction.magnitude > 0)
{
// calculate force
Vector3 desiredForce = direction.normalized * weighting;
force = desiredForce - owner.velocity;
}
#endregion
// Return the force .... luke
return(force);
}
public override Vector3 GetForce()
{
// Set force to zero
Vector3 force = Vector3.zero;
// Generating a random number between
// - half max value to half max value
/*
* -32,767 16,363 0 16,383 32,767
|---------------------|-------------------|
|_________________|
* Random Range
*/
// 0x7fff = 32767
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region Calculate RandomDir
// SET randomDir to new vector3 x = randX & z = randZ
randomDir = new Vector3(randX, 0, randZ);
// SET randomDir to normalized randomDir
randomDir = randomDir.normalized;
// SET randomDir to randomDir x jitter
randomDir *= jitter;
/* examples
* // SET maxVelocity to maxVelocity x velocity;
* maxVelocity *= velocity;
*
* // SET maxVelocity to maxVelocity + velocity;
* maxVelocity += velocity;
*
* // SET maxVelocity to maxVelocity - velocity;
* maxVelocity -= velocity;
*
* > greater than 5 > 4 is TRUE
* < less than 4 < 5 is TRUE
* >= greater than or equal 4 >= 4 is TRUE
* <= less than or equal 3 <= 4 is TRUE
* == equal to 5 == 5 is TRUE
* != not equal to 5 != 4 is TRUE
*
*/
#endregion
#region Calculate TargetDir
// SET targetDir to targetDir + randomDir
targetDir += randomDir;
// SET targetDir to normalized targetDir
targetDir = targetDir.normalized;
// SET targetDir to targetDir x raduis
targetDir *= radius;
#endregion
#region Calculate force
// SET seekPos to owner's postition + targetDir
Vector3 seekPos = owner.transform.position + targetDir;// not the answer
// SET seekPos to seekPos + owner's forward x offset
seekPos += owner.transform.forward * offset;
#region Gizmos
Vector3 offsetPos = transform.position + transform.position.normalized * offset;
GizmosGL.AddCircle(offsetPos + Vector3.up * 0.1f, radius, Quaternion.LookRotation(Vector3.down), 16, Color.red);
GizmosGL.AddCircle(seekPos + Vector3.up * 0.15f, radius * 0.6f, Quaternion.LookRotation(Vector3.down), 16, Color.blue);
#endregion
// SET desiredForce to seekPos - position
Vector3 desiredForce = seekPos - transform.position;
// IF desiredForce is not zero
if (desiredForce != Vector3.zero)
{
// SET desiredForce to desiredForce normalized x weighting
desiredForce = desiredForce.normalized * weighting;
// SET force to desiredForce - owner's velocity
force = desiredForce - owner.velocity;
}
#endregion
// Return force
return(base.GetForce());
}
