public void UpdateDebugAIRegions(DrawingSurface ds)
{
ds.DrawingColor = Game.GetColorFromRGB(255, 255, 255);
int i = 0;
for (i = 0; i < MAX_RACING_CARS; i += 1)
{
int veh = RobotsRB[i].vehicleIndex;
if (veh < 0)
{
continue;
}
VectorF pos = Cars[veh].position;
if (pos == null)
{
continue;
}
VectorF dir = VectorF.create(50, 0);
dir.rotate(RobotsRB[i].targetAngle);
dir.add(pos);
int x1 = FloatToInt(pos.x, eRoundNearest) - GetViewportX();
int y1 = FloatToInt(pos.y, eRoundNearest) - GetViewportY();
int x2 = FloatToInt(dir.x, eRoundNearest) - GetViewportX();
int y2 = FloatToInt(dir.y, eRoundNearest) - GetViewportY();
ds.DrawLine(x1, y1, x2, y2);
}
}
public void UpdateBody()
{
int i = 0;
for (i = 0; i < NUM_COLLISION_POINTS; i += 1)
{
VectorF colpt = this.collPoint[i];
colpt.set(this.collPointOff[i]);
colpt.rotate(this.direction.angle());
colpt.add(this.position);
}
}
public void processInteraction(float deltaTime)
{
int i = 0;
float[] friction = new float[NUM_COLLISION_POINTS];
float avg_friction = 0.0f;
bool[] hit_area = new bool[NUM_COLLISION_POINTS];
for (i = 0; i < NUM_COLLISION_POINTS; i += 1)
{
VectorF colpoint = this.collPointOff[i].clone();
colpoint.rotate(this.direction.angle());
colpoint.add(this.position);
this.collPoint[i] = colpoint;
int room_x = FloatToInt(colpoint.x, eRoundNearest);
int room_y = FloatToInt(colpoint.y, eRoundNearest);
int screen_x = room_x - GetViewportX();
int screen_y = room_y - GetViewportY();
int area = GetWalkableAreaAt(screen_x, screen_y);
if (area == 0)
{
hit_area[i] = true;
}
else
{
friction[i] = Track.TerraSlideFriction[area];
avg_friction += friction[i];
this.terrafriction[i] = friction[i];
}
this.colpt[i].x = FloatToInt(colpoint.x, eRoundNearest);
this.colpt[i].y = FloatToInt(colpoint.y, eRoundNearest);
}
avg_friction /= IntToFloat(NUM_COLLISION_POINTS);
this.friction = avg_friction;
for (i = 0; i < NUM_COLLISION_POINTS; i += 1)
{
if (!hit_area[i])
{
continue;
}
VectorF impact = VectorF.subtract(this.position, this.collPoint[i]);
impact.normalize();
impact.scale(Maths.AbsF(this.driveVelocityValue));
this.impactVelocity.add(impact);
float projection = VectorF.projection(impact, this.driveVelocity);
if (this.driveVelocityValue < 0.0f)
{
projection = -projection;
}
this.driveVelocityValue += projection;
}
}
public void RunCollision(VectorF impactVelocity, float deltaTime)
{
if (this.numHits == 0)
{
return;
}
VectorF posImpact = VectorF.zero();
VectorF negImpact = VectorF.zero();
int i = 0;
for (i = 0; i < NUM_COLLISION_POINTS; i += 1)
{
if (this.collPtHit[i] < 0)
{
continue;
}
if (this.oldCollPtHit[i] == this.collPtHit[i])
{
continue;
}
VectorF impact = VectorF.subtract(this.collPoint[i], this.oldCollPt[i]);
if (impact.isZero())
{
continue;
}
impact.normalize();
float velProjection = VectorF.projection(this.velocity, impact);
if (velProjection > 0.0f)
{
impact.scale(-velProjection * (2.0f - this.hardImpactLossFactor));
posImpact.max(impact);
negImpact.min(impact);
}
}
impactVelocity.add(posImpact);
impactVelocity.add(negImpact);
}
public int TryInsertNode(int refNode, int x, int y)
{
if (FreePathSlot < 0)
{
return(0);
}
int nodep = Paths[refNode].prev;
int noden = Paths[refNode].next;
if (nodep < 0 && noden < 0)
{
return(PutNewNode(x, y));
}
int nodeopp = 0;
if (nodep < 0)
{
nodeopp = noden;
}
else if (noden < 0)
{
nodeopp = nodep;
}
else
{
VectorF hit = VectorF.create(x, y);
VectorF hitDir = VectorF.subtract(hit, Paths[refNode].pt);
VectorF nextDir = VectorF.subtract(Paths[noden].pt, Paths[refNode].pt);
VectorF prevDir = VectorF.subtract(Paths[nodep].pt, Paths[refNode].pt);
if (Maths.AbsF(VectorF.angleBetween(hitDir, nextDir)) <= Maths.AbsF(VectorF.angleBetween(hitDir, prevDir)))
{
nodeopp = noden;
}
else
{
nodeopp = nodep;
}
}
VectorF newpt = Paths[refNode].pt.clone();
newpt.add(Paths[nodeopp].pt);
newpt.scale(0.5f);
int insertPrev = 0;
int insertNext = 0;
if (nodeopp == noden)
{
insertPrev = refNode;
insertNext = noden;
}
else
{
insertPrev = nodep;
insertNext = refNode;
}
int newnode = FreePathSlot;
Paths[newnode].Reset();
Paths[newnode].pt = newpt;
OnNewNode(newnode, insertPrev, insertNext);
PathNodeCount += 1;
FindFirstFreeNode();
return(newnode);
}
public int TryInsertNode(int refNode, int x, int y)
{
if (FreeCheckptSlot < 0)
{
return(0);
}
int nodep = Checkpoints[refNode].prev;
int noden = Checkpoints[refNode].next;
if (nodep < 0 && noden < 0)
{
return(PutNewNode(x, y));
}
int nodeopp = 0;
if (nodep < 0)
{
nodeopp = noden;
}
else if (noden < 0)
{
nodeopp = nodep;
}
else
{
VectorF hit = VectorF.create(x, y);
VectorF hitDir = VectorF.subtract(hit, Checkpoints[refNode].pt);
VectorF nextDir = VectorF.subtract(Checkpoints[noden].pt, Checkpoints[refNode].pt);
VectorF prevDir = VectorF.subtract(Checkpoints[nodep].pt, Checkpoints[refNode].pt);
if (Maths.AbsF(VectorF.angleBetween(hitDir, nextDir)) <= Maths.AbsF(VectorF.angleBetween(hitDir, prevDir)))
{
nodeopp = noden;
}
else
{
nodeopp = nodep;
}
}
VectorF newpt = Checkpoints[refNode].pt.clone();
newpt.add(Checkpoints[nodeopp].pt);
newpt.scale(0.5f);
int insertPrev = 0;
int insertNext = 0;
if (nodeopp == noden)
{
insertPrev = refNode;
insertNext = noden;
}
else
{
insertPrev = nodep;
insertNext = refNode;
}
int newnode = FreeCheckptSlot;
Checkpoints[newnode].Reset();
Checkpoints[newnode].pt = newpt;
OnNewNode(newnode, insertPrev, insertNext);
CheckptCount += 1;
int fixnode = insertNext;
while (fixnode != FirstCheckpt)
{
Checkpoints[fixnode].order += 1;
fixnode = Checkpoints[fixnode].next;
}
FindFirstFreeCheckpoint();
return(newnode);
}
public VectorF DetectCollision(VectorF[] rect, VectorF otherVelocity, int otherIndex)
{
this.numCarHits = 0;
VectorF p21 = VectorF.subtract(rect[1], rect[0]);
VectorF p41 = VectorF.subtract(rect[3], rect[0]);
float p21magnitude_squared = p21.x * p21.x + p21.y * p21.y;
float p41magnitude_squared = p41.x * p41.x + p41.y * p41.y;
int i = 0;
for (i = 0; i < NUM_COLLISION_POINTS; i += 1)
{
this.collPtCarHit[i] = -1;
VectorF p = VectorF.subtract(this.collPoint[i], rect[0]);
float pp21 = p.x * p21.x + p.y * p21.y;
if (pp21 >= 0.0 && pp21 <= p21magnitude_squared)
{
float pp41 = p.x * p41.x + p.y * p41.y;
if (pp41 >= 0.0 && pp41 <= p41magnitude_squared)
{
this.collPtCarHit[i] = otherIndex;
this.numCarHits += 1;
}
}
}
if (this.numCarHits == 0)
{
return(null);
}
VectorF impactVelocity = new VectorF();
VectorF posImpact = VectorF.zero();
VectorF negImpact = VectorF.zero();
for (i = 0; i < NUM_COLLISION_POINTS; i += 1)
{
if (this.collPtCarHit[i] < 0)
{
continue;
}
if (this.oldCollPtCarHit[i] == this.collPtCarHit[i])
{
continue;
}
VectorF impact = VectorF.subtract(this.collPoint[i], this.oldCollPt[i]);
if (impact.isZero())
{
continue;
}
impact.normalize();
float velProjection = VectorF.projection(this.velocity, impact);
if (velProjection > 0.0f)
{
impact.scale(-velProjection * (1.0f - this.softImpactLossFactor));
posImpact.max(impact);
negImpact.min(impact);
impact.negate();
impact.normalize();
}
float otherProjection = VectorF.projection(otherVelocity, impact);
if (otherProjection < 0.0f)
{
impact.scale(otherProjection * (1.0f - this.softImpactLossFactor));
posImpact.max(impact);
negImpact.min(impact);
}
}
impactVelocity.add(posImpact);
impactVelocity.add(negImpact);
return(impactVelocity);
}
