PosDir Collision(PosDir pd, float distance)
{
Ray ray = new Ray(pd.pos, pd.dir);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, distance))
{
//print (hit.collider.name);
//CROSS PRODUCT - DIRECTION AJUSTEMENT
pd.normal = 0.25f * hit.normal + 0.75f * pd.normal;
float d = Vector3.Dot(hit.normal.normalized, hit.point - pd.pos);
Vector3 H = pd.pos + d * hit.normal;
pd.dir = (hit.point - H).normalized * distance;
float dist = Vector3.Distance(pd.pos, hit.point);
float dd = Mathf.Sqrt(distance * distance - d * d);
pd.pos = (hit.point - H).normalized * dd + H + 0.05f * hit.normal;
}
else
{
pd.pos += pd.dir;
}
return(pd);
}
public static PosDir BallCollidePole(PosDir posDir, float ballRadius, PolePos polePos)
{
Circle circle1 = null;
Circle circle2 = null;
if (polePos.axis == Vector3.up)
{
circle1 = new Circle(posDir.pos.x, posDir.pos.z, posDir.dir.x, posDir.dir.z, ballRadius);
circle2 = new Circle(polePos.pos.x, polePos.pos.z, 0, 0, polePos.radius);
circle1 = DynamicCircleStaticCircleCollision(circle1, circle2);
posDir.pos.x = circle1.x;
posDir.pos.z = circle1.y;
posDir.didCollide = circle1.didCollide;
}
else
{
circle1 = new Circle(posDir.pos.z, posDir.pos.y, posDir.dir.z, posDir.dir.y, ballRadius);
circle2 = new Circle(polePos.pos.z, polePos.pos.y, 0, 0, polePos.radius);
circle1 = DynamicCircleStaticCircleCollision(circle1, circle2);
posDir.pos.z = circle1.x;
posDir.pos.y = circle1.y;
posDir.didCollide = circle1.didCollide;
}
return(posDir);
}
//USED FOR CALCULATE NEW DIRECTION AFTER COLLISION
PosDir Collision(PosDir pd, float distance)
{
Ray ray = new Ray(pd.pos, pd.dir);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, distance))
{
//NORMAL SMOOTHING
pd.normal = 0.25f * hit.normal + 0.75f * pd.normal;
//DIRECTION PROJECTION OVER COLLIDER - DIRECTION AJUSTEMENT
float d = Vector3.Dot(hit.normal.normalized, hit.point - pd.pos);
Vector3 H = pd.pos + d * hit.normal;
pd.dir = (hit.point - H).normalized * distance;
float dist = Vector3.Distance(pd.pos, hit.point);
float dd = Mathf.Sqrt(distance * distance - d * d);
pd.pos = (hit.point - H).normalized * dd + H + 0.05f * hit.normal;
}
else
{
//IF NO COLISION
pd.pos += pd.dir;
}
return(pd);
}
public PositionsAndNormals GenerateTrajectory(Vector3 initialPosition, Vector3 initialDirection, int arrayLength)
{
float rayDuration = 10f;
//PARAMETERS
initialDirection.Normalize();
PositionsAndNormals positionsNormals = new PositionsAndNormals(arrayLength);
Vector3 currentDirection = initialDirection;
Vector3 currentPosition = initialPosition;
Vector3 currentNormal = Vector3.Cross(initialDirection, new Vector3(0.21f, 0.656f, 0.254f));
Vector3 prevPosition = initialPosition;
positionsNormals.pos [0] = initialPosition;
positionsNormals.nor [0] = currentNormal;
for (int i = 1; i < arrayLength; i++)
{
float lengthRatio = i / (float)arrayLength;
//DIRECTION CALCULATION
Vector3 gravity = Vector3.down * gravityForce * gravityOverLength.Evaluate(lengthRatio);
Vector3 noise = noiseForce * noiseOverLength.Evaluate(lengthRatio) * Noise3D.PerlinNoise3D(currentPosition / noiseSize);
float distance = Mathf.Lerp(initialSegmentLength, finalSegmentLength, segmentLengthOverLength.Evaluate(lengthRatio));
currentDirection = distance * (currentDirection + gravity + noise).normalized;
PosDir pd = Collision(new PosDir(currentPosition, currentDirection, currentNormal), distance);
for (int k = 0; k < 10; k++)
{
pd = Collision(new PosDir(currentPosition, pd.dir, pd.normal), distance);
}
currentPosition = pd.pos;
currentDirection = pd.dir;
positionsNormals.pos [i] = currentPosition;
positionsNormals.nor [i] = pd.normal;
prevPosition = currentPosition;
}
return(positionsNormals);
}
private void OnDrawGizmos()
{
Handles.CircleHandleCap(-1, transform.position, transform.rotation, emissionRadius, EventType.Ignore);
for (int i = 0; i < angularSegments; i++)
{
PosDir posDir = GetSpawnCoordinate(i);
Gizmos.DrawSphere(posDir.pos, emissionRadius * 0.05f);
Gizmos.DrawLine(posDir.pos, posDir.pos + posDir.dir * emissionRadius * 0.5f);
}
/*if( particleRings != null ) {
* foreach( ParticleRing particleRing in particleRings ) {
* foreach( Particle particle in particleRing.particles ) {
* Gizmos.DrawSphere( particle.position, emissionRadius * 0.1f );
* }
* }
* }*/
}
void SetParticleRingSpawnPos(ParticleRing ring)
{
for (int i = 0; i < angularSegments; i++)
{
PosDir posDir = GetSpawnCoordinate(i);
if (ring.particles == null)
{
ring.particles = new Particle[angularSegments];
for (int p = 0; p < angularSegments; p++)
{
ring.particles[p] = new Particle();
}
}
ring.particles[i].position = posDir.pos;
ring.particles[i].velocity = posDir.dir * emissionSpeed;
particleRings[emissionRootRingIndex].spawnTime = Time.time;
particleRings[emissionRootRingIndex].lifeTime = 0;
}
}
public PosDir GenRandomPosDirCornerScrenPoint()
{
int yc = (int)Dimensions.Y - 1;
int xc = (int)Dimensions.X - 1;
PosDir posDir = new PosDir();
int con = random.Next(0, 4);
if (con == 0)
{
//left
posDir.position = new Vector2(1, random.Next(0, yc));
float x = random.NextSingle(0, 1);
float y = random.NextSingle(-1, 1);
posDir.direction = new Vector2(x, y);
}
if (con == 1)
{
//up
posDir.position = new Vector2(random.Next(0, xc), 1);
float x = random.NextSingle(-1, 1);
float y = random.NextSingle(0, 1);
posDir.direction = new Vector2(x, y);
}
if (con == 2)
{
//down
posDir.position = new Vector2(random.Next(0, xc), yc);
float x = random.NextSingle(-1, 1);
float y = random.NextSingle(-1, 0);
posDir.direction = new Vector2(x, y);
}
if (con == 3)
{
//right
posDir.position = new Vector2(xc, random.Next(0, yc));
float x = random.NextSingle(-1, 0);
float y = random.NextSingle(-1, 1);
posDir.direction = new Vector2(x, y);
}
posDir.direction = posDir.direction.Normalized();
return(posDir);
}
//USED TO GENERATE THE TRAJECTORY AT THE CREATION OF THE PLANT
public PositionsAndNormals GenerateTrajectory(Vector3 initialPosition, Vector3 initialDirection, int arrayLength)
{
//PARAMETERS
totalLength = 0f;
initialDirection.Normalize();
PositionsAndNormals positionsNormals = new PositionsAndNormals(arrayLength);
Vector3 currentDirection = initialDirection;
Vector3 currentPosition = initialPosition;
Vector3 currentNormal = initialNormal;
positionsNormals.pos [0] = initialPosition;
positionsNormals.nor [0] = currentNormal;
float computedLength = nbOfSegments * (initialSegmentLength + finalSegmentLength) / 2f;
float actualNoiseSize = noiseSize * computedLength;
Vector3 noiseOffset = Vector3.zero;
float noiseMultiplier = 1f;
for (int i = 1; i < arrayLength; i++)
{
//RATIO
float lengthRatio = i / (float)arrayLength;
//DIRECTION FORCES CALCULATION
Vector3 gravity = Vector3.zero;
if (hasGravity)
{
gravity = Vector3.down * gravityForce * gravityOverLength.Evaluate(lengthRatio);
}
Vector3 noise = Vector3.zero;
if (hasNoise)
{
if (i % 25 == 0)
{
noiseOffset.y += 3 * actualNoiseSize;
noiseMultiplier = 5f;
}
noise = noiseForce * noiseOverLength.Evaluate(lengthRatio) * Noise3D.PerlinNoise3D((currentPosition + noiseOffset + plantSeed * Vector3.left) / actualNoiseSize);
}
Vector3 force = currentDirection;
if (initialForce)
{
force = initialForceCoef * initialDirection;
}
float distance = Mathf.Lerp(initialSegmentLength, finalSegmentLength, segmentLengthOverLength.Evaluate(lengthRatio));
totalLength += distance;
currentDirection = distance * (force + gravity + noiseMultiplier * noise).normalized;
//currentDirection = distance * (force + currentDirection + gravity + noiseMultiplier * noise).normalized;
PosDir pd = new PosDir(currentPosition, currentDirection, currentNormal);
//CALCULATE COLLISIONS
if (hasCollisions)
{
//COLLISION CALCULATION WITH 10 ITERATIONS
for (int k = 0; k < 10; k++)
{
pd = Collision(new PosDir(currentPosition, pd.dir, pd.normal), distance);
}
currentPosition = pd.pos;
currentDirection = pd.dir;
}
else
{
currentPosition += currentDirection;
}
noiseMultiplier = 1f;
positionsNormals.pos [i] = currentPosition;
positionsNormals.nor [i] = pd.normal;
}
return(positionsNormals);
}
public override void tick()
{
if (child == null || child.removed)
{
animation.start();
}
else if (animation == death)
{
animation.stop();
}
if (animation == death && animation.finalFrame())
{
remove();
}
if (!removed)
{
animation.tick();
}
if (health <= 0)
{
die();
}
else
{
if (invincible > 0)
{
invincible--;
}
if (health <= 20)
{
state = 3;
}
else if (health <= 40)
{
state = 2;
}
else if (health <= 60)
{
state = 1;
}
else
{
state = 0;
}
if (animation != death)
{
if (parent.positions.Count > Map.TILESIZE * scale.X)
{
PosDir pd = parent.positions.First.Value;
parent.positions.RemoveFirst();
position = pd.position;
xdir = pd.dirx;
ydir = pd.diry;
if (child != null)
{
positions.AddLast(pd);
}
}
}
// super.tick();
animation.tick();
if (animation != death)
{
if (xdir < 0)
{
animation = left[state];
}
else if (xdir > 0)
{
animation = right[state];
}
else if (ydir < 0)
{
animation = up[state];
}
else
{
animation = down[state];
}
}
animation.start();
}
}
