public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region Calculate RandomDirection
randDir = new Vector3(randX, 0, randZ);
randDir = randDir.normalized;
randDir *= jitter;
#endregion
#region Calculate Target Direction
targetDir += randDir;
targetDir = targetDir.normalized;
targetDir *= radius;
#endregion
Vector3 seekPos = transform.position + targetDir;
seekPos += transform.forward * offset;
#region GizmosGL
Vector3 forwardPos = transform.position + transform.forward * offset;
GizmosGL.color = Color.white;
GizmosGL.AddCircle(forwardPos, radius, Quaternion.LookRotation(Vector3.down));
GizmosGL.color = Color.red;
GizmosGL.AddCircle(seekPos + (Vector3.up * 0.1f), radius * 0.6f, Quaternion.LookRotation(Vector3.down));
#endregion
#region Wander
Vector3 dir = seekPos - transform.position;
if (dir.magnitude > 0)
{
Vector3 desForce = dir.normalized * weighting;
force = desForce - owner.velocity;
}
#endregion
return(force);
}
public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region calculate Random Direction
randomDirection = new Vector3(randX, 0, randZ);
randomDirection = randomDirection.normalized;
randomDirection = randomDirection * jitter;
#endregion
#region Calculate target Direction
targetDirection += randomDirection;
targetDirection = targetDirection.normalized;
targetDirection = targetDirection * radius;
#endregion
#region Calculate force
Vector3 SeekPosition = owner.transform.position + targetDirection;
SeekPosition += owner.transform.forward * offset;
#region GIZMO
Vector3 offsetPosition = transform.position + transform.forward.normalized * offset;
GizmosGL.AddCircle(offsetPosition + Vector3.up * 0.02f, radius, Quaternion.LookRotation(Vector3.down), 16, Color.red);
GizmosGL.AddCircle(SeekPosition + Vector3.up * 0.03f, radius * 0.6f, Quaternion.LookRotation(Vector3.down), 16, Color.blue);
#endregion
desForce = SeekPosition - transform.position;
if (desForce != Vector3.zero)
{
desForce = desForce.normalized * waighting;
force = desForce - owner.velocity;
}
#endregion
return(force);
}
public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
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(Vector3.left = randX, z = 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
Vector3 targetDir = new Vector3();
// 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 = Vector3.zero;
// SET seekPos to seekPos + owner's forward x offset
seekPos = seekPos + Vector3.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 != 0)
{
// 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);
}
public override Vector3 GetForce()
{
// SET force to zero
Vector3 force = Vector3.zero;
// Generate random numbers between a certain 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 * jitter (amplify randomDir by jitter)
randomDir *= jitter;
#endregion
#region Calculate TargetDir
// SET targetDir to targetDir + randomDir
targetDir += randomDir;
// SET targetDir to normalized targetDir
targetDir = targetDir.normalized;
// SET targetDir to targetDir * radius
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 * offset
seekPos += owner.transform.forward * offset;
#region GIZMOS
// SET offsetPos to position + forward * offset
Vector3 offsetPos = transform.position + transform.forward.normalized * offset;
// ADD circle with offsetPos + up * amount, rotate circle with lookRotation (down)
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
Vector3 desiredForce = seekPos - transform.position;
// IF desiredForce is not zero
if (desiredForce != Vector3.zero)
{
// SET desiredForce to desiredForce normalized * 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()
{
Vector3 force = Vector3.zero;
/*
* -32767 0 32767
|---------------------|---------------------|
|_______________________|
* 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
// Create the random directon vector
randomDir = new Vector3(randX, 0, randZ);
// Normalize the random direction
randomDir = randomDir.normalized;
// Multiply jitter to randomDir
randomDir *= jitter;
#endregion
#region Calculate TargetDir
// Append target dir with random dir
targetDir += randomDir;
// Normalize the target dir
targetDir.Normalize();
// 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 circle = GizmosGL.AddCircle(forwardPos + Vector3.up * 0.1f, radius, Quaternion.LookRotation(Vector3.down));
circle.color = new Color(1, 0, 0, 0.5f);
circle = GizmosGL.AddCircle(seekPos + Vector3.up * 0.15f, radius * 0.6f, Quaternion.LookRotation(Vector3.down));
circle.color = new Color(0, 0, 1, 0.5f);
#endregion
// Calculate direction
Vector3 desiredForce;
Vector3 direction = seekPos - transform.position;
// Check if direction is valid
if (direction != Vector3.zero)
{
desiredForce = direction.normalized * weighting;
force = desiredForce - owner.velocity;
}
return(force);
}
public override Vector3 GetForce()
{
// Set orce to zero
Vector3 force = Vector3.zero;
// Generating a random number between - half max value to half max value
// 0x7fff = 32,787 || half = 16,383
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
seekPos = owner.transform.position + targetDir;
// SET seekPos to seekPos + owner's forward x offset
seekPos = seekPos + owner.transform.forward * offset;
// SET desiredForce to seekpos - position
desiredForce = seekPos - owner.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
#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
// Return force
return(force);
}
public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
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);
// Normalize randomDir
randomDir.Normalize();
//Apply jitter to it
randomDir *= jitter;
#endregion
#region Calculate TargetDir
// Offset targetDir with randomDir;
targetDir += randomDir;
// Normalize the targetDir;
targetDir.Normalize();
// Apply radius to it
targetDir *= radius;
#endregion
// Get position of point
Vector3 seekPos = transform.position + targetDir;
// Offset the seek position
seekPos += transform.forward * offset;
#region GizmosGL
GizmosGL.color = Color.red;
GizmosGL.AddCircle(seekPos + Vector3.up * 0.2f, 0.5f, Quaternion.LookRotation(Vector3.down));
Vector3 offsetPos = transform.position + transform.forward * offset;
GizmosGL.color = Color.blue;
GizmosGL.AddCircle(offsetPos + Vector3.up * 0.1f, radius, Quaternion.LookRotation(Vector3.down));
GizmosGL.color = Color.cyan;
GizmosGL.AddLine(transform.position, offsetPos, 0.1f, 0.1f);
#endregion
// Calculate direction
Vector3 direction = seekPos - transform.position;
Vector3 desiredPos = Vector3.zero;
// Check if direction is valid
if (direction != Vector3.zero) // or direction.magnitude != 0
{
// Apply a weighting to the direction
desiredPos = direction.normalized * weighting;
// Apply the force
force = desiredPos - owner.velocity;
}
return(force);
}
// Update is called once per frame
void FixedUpdate()
{
GizmosGL.AddRing(ring.position, ring.innerRadius, ring.outerRadius, Quaternion.Euler(ring.rotation), ring.scale, ring.segments, ring.color);
GizmosGL.AddArc(arc.position, arc.radius, arc.halfAngle, arc.rotation, arc.segments, arc.color);
GizmosGL.AddSphere(sphere.position, sphere.radius, sphere.rotation, sphere.color);
GizmosGL.AddSquare(square.position, square.scale, square.rotation);
GizmosGL.AddCircle(circle.position, circle.radius, Quaternion.identity, circle.segments, circle.color);
GizmosGL.AddCube(cube.position, cube.scale, cube.rotation);
GizmosGL.AddCube(cube.position, cube.scale, cube.rotation);
GizmosGL.AddCylinder(cylinder.position, cylinder.radius, cylinder.scale, cylinder.rotation, cylinder.halfLength, cylinder.segments, cylinder.color);
GizmosGL.AddLine(line.start, line.end, line.startWidth, line.endWidth, line.startColor, line.endColor);
}
public override Vector3 GetForce()
{
// The force starts at 0
Vector3 force = Vector3.zero;
// This part randomizes the values of randX and randZ
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region Calculate Random Direction
// Creates the random direction
randomDir = new Vector3(randX, 0, randZ);
randomDir = randomDir.normalized;
// Applifies the randomness by the jitter
randomDir *= jitter;
#endregion
#region Calculate the direction of the target
// The random Direction is either added or equal to the target direction
targetDir += randomDir;
// Normalize the target dir
targetDir = targetDir.normalized;
targetDir *= radius;
#endregion
// Calulates the seek position using the target direction
Vector3 seekPos = transform.position + targetDir;
seekPos += transform.forward.normalized * offset;
Vector3 forwardPos = transform.position + transform.forward.normalized * offset;
#region Circle Gizmos
Circle c = GizmosGL.AddCircle(forwardPos, radius, Quaternion.LookRotation(Vector3.down));
c.color = new Color(1, 0, 0, 0.5f);
c = GizmosGL.AddCircle(seekPos, radius * 0.6f, Quaternion.LookRotation(Vector3.down));
c.color = new Color(0, 0, 1, 0.5f);
#endregion
#region Wander
// Calculates the direction
Vector3 direction = seekPos - transform.position;
// Checks if the direction is not zero
if (direction.magnitude > 0)
{
// Calculaters the force
Vector3 desiredForce = direction.normalized * weighting;
force = desiredForce - owner.velocity;
}
#endregion
// Remember to return the force at the end
return(force);
}
public override Vector3 GetForce()
{
//Set force to zero
Vector3 force = Vector3.zero;
// Create a random Range between -half max value to half max value
float randX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region RandomDir
// Set randomDir to new Vector 3 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 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
// Set OffsetPos to position + forward x offset
Vector3 offsetPos = transform.position + transform.forward.normalized * offset;
// Add circle with offsetPos + up x amount
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 - owner.transform.position;
// If desiredForce != zero
if (desiredForce != Vector3.zero)
{
// Set desiredForce to desiredForce normalized * weighting
desiredForce = desiredForce.normalized * weighting;
// Set force to desiredForce - owner's velocity
force = desiredForce - owner.velocity;
}
#endregion
return(force);
}
public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
float roundX = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
float roundZ = Random.Range(0, 0x7fff) - (0x7fff * 0.5f);
#region caculate randomDir
// set randomDir to new vector3 x = randx and z = randz
randomDir = new Vector3(roundX, 0, roundZ);
// set randomDir to normalised randomDir
randomDir = randomDir.normalized;
// set randomDir to randomDir x jitter
randomDir = randomDir * jitter;
#endregion
#region caculate target dir
//set targetDir to targetDir + randomDir
targetDir = targetDir + randomDir;
//set targetDir to nomalise targetDir
targetDir = targetDir.normalized;
//set targetDit to targetDir x radius
targetDir = targetDir * rad;
#endregion
#region cauculate force
// set seekpos to owner's pos + targetDir
Vector3 seekPos = owner.transform.position + targetDir;
// set seekPos to seekpos + owners fowerd x offset
seekPos = seekPos + owner.transform.forward * offset;
#region GISMO
Vector3 offsetPos = transform.position + transform.forward.normalized * offset;
GizmosGL.AddCircle(offsetPos + Vector3.up * 0.1f, rad, Quaternion.LookRotation(Vector3.down), 16, Color.red);
GizmosGL.AddCircle(seekPos + Vector3.up * 0.15f, rad * 0.6f, Quaternion.LookRotation(Vector3.down), 16, Color.blue);
#endregion
// set desForce to seekpos - pos
desForce = seekPos - transform.position;
// if decForce not zero
if (desForce != Vector3.zero)
{
// set desForce to desforce nomalised x weiting
desForce = desForce.normalized * waighting;
// set force to desForce - owners velo
force = desForce - owner.velocity;
}
#endregion
return(force);
}
private void Update()
{
//if (Input.GetKey(KeyCode.R))
//{
// Line spawn = GizmosGL.AddLine(Vector3.zero, Vector3.one * 10f, 0.1f, 0.1f);
//}
for (int i = 0; i < 500; i++)
{
Vector3 pos = new Vector3(Mathf.Sin(i) * 9f, i * 0.1f, Mathf.Cos(i) * 9f);
Cube spawn = GizmosGL.AddCube(pos);
spawn.isRigidbodyEnabled = true;
spawn.isCollisionEnabled = true;
//spawn.rigidbody.useGravity = false;
//spawn.isCollisionEnabled = true;
spawn.color = Color.Lerp(Color.red, Color.blue, (float)i / 800f);
}
Vector3 prevPos = transform.position;
for (int i = 0; i < 200; i++)
{
Vector3 pos = prevPos + new Vector3(Mathf.Tan(i) * 2f, i * 0.1f);
Line line = GizmosGL.AddLine(prevPos, pos, 1f, 1f);
line.color = Color.Lerp(Color.red, Color.blue, (float)i / 200f);
line.startColor = Color.red;
line.endColor = Color.blue;
line.startWidth = 0.1f;
line.endWidth = 0.1f;
prevPos = pos;
}
for (int i = 0; i < 200; i++)
{
Circle spawn = GizmosGL.AddCircle(new Vector3(Mathf.Sin(i) * 2f, i * 0.1f), circle.radius, Quaternion.identity, circle.segments, circle.color);
spawn.isRigidbodyEnabled = true;
spawn.name = "FixedUpdate - Circle";
}
for (int i = 0; i < 200; i++)
{
Square spawn = GizmosGL.AddSquare(new Vector3(Mathf.Sin(i) * 2f, i * 1f), new Vector2(1, 1));
spawn.color = Color.blue;
//spawn.isRigidbodyEnabled = true;
spawn.name = "FixedUpdate - Circle";
}
}
public override Vector3 GetForce()
{
// SET force to zero
Vector3 force = Vector3.zero;
// Generate a random number between
// - half max value to half max value
// 0xfff = 32767
float randX = Random.Range(0, 0x7fff) - (0xfff * 0.5f);
float randZ = Random.Range(0, 0x7fff) - (0xfff * 0.5f);
#region Calculate RandomDir
// SET randomDir to new Vector 3 x = randX & z = randZ
//SET randomDir to normalized randomDir
//SET randomDir to randomDir x Jitter
#endregion
#region Calculate TargetDir
// SET targetDir to targetDir + randomDir
// SET targetDir to normalized targetDir
// SET targetDir to targetDir x radius
#endregion
#region Calculate Force
// SET seekPos to owner's position + targetDir
Vector3 seekPos = Vector3.zero;
// SET seekPos to seekPos + owner's forward x 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
// IF desiredForce is not zero
// SET desiredForce to desiredForce normalized x weighting
// SET force to desiredForce - owner's velocity
#endregion
//RETURN force
return(force);
}
// Update is called once per frame
void Update()
{
GizmosGL.AddCircle(circle.position, circle.up, circle.radius, circle.segments, circle.color);
GizmosGL.AddSquare(square.position, square.up, square.scale, square.color);
GizmosGL.AddCube(cube.position, cube.scale, cube.color);
GizmosGL.AddSphere(sphere.position, sphere.radius, sphere.rows, sphere.columns, sphere.color, sphere.longMin, sphere.longMax, sphere.latMin, sphere.latMax);
GizmosGL.AddCylinder(cylinder.position, cylinder.up, cylinder.radius, cylinder.halfLength, cylinder.segments, cylinder.color);
GizmosGL.AddRing(ring.position, ring.up, ring.innerRadius, ring.outerRadius, ring.segments, ring.color);
GizmosGL.AddArc(arc.position, arc.up, arc.radius, arc.rotation, arc.halfAngle, arc.segments, arc.color);
GizmosGL.AddLine(line.start, line.end, line.startWidth, line.endWidth, line.startColor, line.endColor);
for (int i = 0; i < 50; i++)
{
GizmosGL.AddSphere(new Vector3(Mathf.Sin(i) * 10, i * 10, Mathf.Cos(i) * 10), 1, 16, 16, Color.red);
}
}
public override Vector3 GetForce()
{
Vector3 force = Vector3.zero; // Set force to zero
float randX = Random.Range(0, 0x7FFF) - (0x7FFF * 0.5f);
float randZ = Random.Range(0, 0x7FFF) - (0x7FFF * 0.5f);
#region Calculate Random Direction
randomDir = new Vector3(randX, 0, randZ); // Create the random direction vector
randomDir = randomDir.normalized; // Normalize the random direction
randomDir *= jitter; // Multiply randomDir by jitter
#endregion
#region Calculate Target Direction
targetDir += randomDir; // Append target direction with random directon
targetDir = targetDir.normalized; // Normalize the target direction
targetDir *= radius; // Multiply target direction by the radius
#endregion
// Calculate seek position using targetDir
Vector3 seekPos = transform.position + targetDir;
seekPos += transform.forward * offset;
#region GizmosGL
Vector3 forwardPos = transform.position + transform.forward * offset;
GizmosGL.color = Color.red;
GizmosGL.AddCircle(forwardPos, radius, Quaternion.LookRotation(Vector3.down));
GizmosGL.color = Color.blue;
GizmosGL.AddCircle(seekPos + Vector3.up * 0.01f, radius * 0.6f, Quaternion.LookRotation(Vector3.down));
#endregion
#region Wander
Vector3 direction = seekPos - transform.position; // Calculate direction
// Is direction valid? (not zero)
if (direction.magnitude > 0)
{
// Calculate force
Vector3 desiredForce = direction.normalized * weighting;
force = desiredForce - owner.velocity;
}
#endregion
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.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);
}
// Use this for initialization
public override Vector3 GetForce()
{
Vector3 force = Vector3.zero;
// we need the max negative and positive float to get most random
//HEX 0x7fff = 32767
//this needs to have half of itself taken from itself
float randX = Random.RandomRange(0, 0x7fff) - (0x7fff / 2);
float randZ = Random.RandomRange(0, 0x7fff) - (0x7fff / 2);
/*
* -32767 32767
|-----------------------0-----------------------|
|_________________________|
* random range
*/
#region Calculate RandomDir
//Create a random Direction
randomDir = new Vector3(randX, 0f, randZ);
//Normalise for the direction
randomDir.Normalize();
//aApply jitter to apply magnitude to randomDir
randomDir *= jitter;
#endregion
#region Calculate targetDir
//offset the target dir with the random dir
targetDir += randomDir;
//Normalise the target dir for direction
targetDir.Normalize();
//apply the radius as magnitude
targetDir *= rad;
#endregion
//Seek logic
Vector3 seekPos = transform.position + targetDir;
seekPos += transform.forward * offset;
#region GizmosGL
GizmosGL.color = Color.red;
GizmosGL.AddCircle(seekPos + Vector3.up * .1f, .5f, Quaternion.LookRotation(Vector3.down));
GizmosGL.color = Color.blue;
Vector3 offsetPos = transform.position + transform.forward * offset;
GizmosGL.AddCircle(offsetPos + Vector3.up * .1f, rad, Quaternion.LookRotation(Vector3.down));
GizmosGL.color = Color.cyan;
GizmosGL.AddLine(transform.position, offsetPos, .1f, .1f);
#endregion
//calculate final force
Vector3 direction = seekPos - transform.position;
Vector3 desiredForce = Vector3.zero;
if (direction != Vector3.zero)
{
//apply weighting to direction
desiredForce = direction.normalized * weight;
force = desiredForce - agent.velocity;
}
return(force);
}