public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
player1Velocity = player1Velocity / 2;
position += -player1Velocity * (float)gameTime.ElapsedGameTime.TotalSeconds +
-collisionResult.MinimumTranslationVector;
}
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
foreach (MenuButton menuButton in menuButtons)
{
menuButton.onCollision(gameTime, collisionResult, player1Velocity);
}
}
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
foreach (Font font in spriteFonts)
{
font.onCollision(gameTime, collisionResult, player1Velocity);
}
}
public override void OnWallCollision(List <Tuple <PolygonCollisionResult, Polygon> > ListWallCollidingPolygon)
{
Vector2 MovementCorection = Vector2.Zero;
bool IsAWall = false;
//Check if the wall is not a floor/slope
foreach (Tuple <PolygonCollisionResult, Polygon> FinalCollisionResult in ListWallCollidingPolygon)
{
foreach (Polygon ActivePlayerCollisionPolygon in Owner.Collision.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(ActivePlayerCollisionPolygon, FinalCollisionResult.Item2, Owner.Speed, new Vector2(0, -Owner.Speed.Y - 1));
if (CollisionResult.Distance >= 0)
{
IsAWall = true;
MovementCorection += CollisionResult.Axis * CollisionResult.Distance;
WallAxis = CollisionResult.Axis;
CanWallJump = true;
break;
}
}
}
if (IsAWall)
{
Owner.UpdateSkills(TripleThunderRobotRequirement.OnWallCollisionName);
Vector2 FinalMovement = Owner.Speed + MovementCorection;
Owner.Move(FinalMovement);
}
}
public override void Update(GameTime gameTime, float deltaTime)
{
base.Update(gameTime, deltaTime);
//List<InputType> playerInputs = Input.DefineInputs(ref mainGame.gameState.oldKbState); attention, en double avec le Scene
Player.Instance.currentCharacter.mapRepresentation.Update(playerInputs, deltaTime);
collision = SATCollision.CheckPolygonCollision(Player.Instance.currentCharacter.mapRepresentation.CurrentHitBox, legisteTest.CurrentHitBox, new Vector(0, 0));
snowMap.Update();
}
public void OnCollision(WorldObject Other, PolygonCollisionResult FinalCollisionResult, Polygon FinalPlayerPolygon, Polygon FinalWorldPolygon)
{
Vector2 GroundAxis = new Vector2(-FinalCollisionResult.Axis.Y, FinalCollisionResult.Axis.X);
double FinalCollisionResultAngle = Math.Atan2(GroundAxis.X, GroundAxis.Y);
Vector2 MovementCorection = FinalCollisionResult.Axis * FinalCollisionResult.Distance;
Vector2 FinalMovement = Speed + MovementCorection;
Move(FinalMovement);
}
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
Vector2 position = Properties.getProperty<Vector2>("Position");
player1Velocity = player1Velocity / 2;
position += player1Velocity * (float)gameTime.ElapsedGameTime.TotalSeconds +
collisionResult.MinimumTranslationVector;
Properties.updateProperty<Vector2>("Position", position);
}
void Form1_KeyDown(object sender, KeyEventArgs e)
{
int i = 14;
Vector velocity = new Vector();
switch (e.KeyValue)
{
case 32: //SPACE
break;
case 38: // UP
velocity = new Vector(0, -i);
break;
case 40: // DOWN
velocity = new Vector(0, i);
break;
case 39: // RIGHT
velocity = new Vector(i, 0);
break;
case 37: // LEFT
velocity = new Vector(-i, 0);
break;
}
Vector playerTranslation = velocity;
foreach (Polygon polygon in polygons)
{
if (polygon == player)
{
continue;
}
PolygonCollisionResult r = PolygonCollision(player, polygon, velocity);
if (r.WillIntersect)
{
playerTranslation = velocity + r.MinimumTranslationVector;
break;
}
}
player.Offset(playerTranslation);
}
public void GetCollidingWorldPolygon(RobotAnimation ActiveRobot, out List <Tuple <PolygonCollisionResult, Polygon> > ListAllCollidingPolygon,
out List <Tuple <PolygonCollisionResult, Polygon> > ListFloorCollidingPolygon, out List <Tuple <PolygonCollisionResult, Polygon> > ListCelingCollidingPolygon, out List <Tuple <PolygonCollisionResult, Polygon> > ListWallCollidingPolygon)
{
ListAllCollidingPolygon = new List <Tuple <PolygonCollisionResult, Polygon> >();
ListFloorCollidingPolygon = new List <Tuple <PolygonCollisionResult, Polygon> >();
ListCelingCollidingPolygon = new List <Tuple <PolygonCollisionResult, Polygon> >();
ListWallCollidingPolygon = new List <Tuple <PolygonCollisionResult, Polygon> >();
foreach (WorldPolygon ActiveWorldPolygon in GetCollidingWorldObjects(ActiveRobot))
{
if (ActiveRobot.ListIgnoredGroundPolygon.Contains(ActiveWorldPolygon))
{
continue;
}
foreach (Polygon ActivePlayerCollisionPolygon in ActiveRobot.Collision.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResultB;
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(ActivePlayerCollisionPolygon, ActiveWorldPolygon.Collision.ListCollisionPolygon[0], ActiveRobot.Speed, out CollisionResultB);
if (CollisionResult.Distance >= 0)
{
PolygonCollisionResult CollisionResult2 = Polygon.PolygonCollisionSAT(ActivePlayerCollisionPolygon, ActiveWorldPolygon.Collision.ListCollisionPolygon[0], Vector2.Zero, ActiveRobot.Speed);
ListAllCollidingPolygon.Add(new Tuple <PolygonCollisionResult, Polygon>(CollisionResult, ActiveWorldPolygon.Collision.ListCollisionPolygon[0]));
if (CollisionResult2.Distance != CollisionResult.Distance)
{
continue;
}
Vector2 GroundAxis = new Vector2(-CollisionResult.Axis.Y, CollisionResult.Axis.X);
double FinalCollisionResultAngle = Math.Atan2(GroundAxis.X, GroundAxis.Y);
//Ground detection
if (FinalCollisionResultAngle >= FightingZone.GroundMinAngle && FinalCollisionResultAngle <= FightingZone.GroundMaxAngle)
{
ListFloorCollidingPolygon.Add(new Tuple <PolygonCollisionResult, Polygon>(CollisionResult, ActiveWorldPolygon.Collision.ListCollisionPolygon[0]));
}
//Ceiling
else if (FinalCollisionResultAngle <= -FightingZone.GroundMinAngle && FinalCollisionResultAngle >= -FightingZone.GroundMaxAngle)
{
ListCelingCollidingPolygon.Add(new Tuple <PolygonCollisionResult, Polygon>(CollisionResult, ActiveWorldPolygon.Collision.ListCollisionPolygon[0]));
}
//Wall
else
{
ListWallCollidingPolygon.Add(new Tuple <PolygonCollisionResult, Polygon>(CollisionResult, ActiveWorldPolygon.Collision.ListCollisionPolygon[0]));
}
}
}
}
}
public void OnCollision(GameTime gameTime, Player Other, PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, Polygon FinalOtherPolygon)
{
Other.OnCollision(gameTime, this, FinalCollisionResult, FinalCollisionPolygon, FinalOtherPolygon);
Vector2 CollisionPoint;
OnCollision(FinalCollisionResult, FinalCollisionPolygon, out CollisionPoint);
CreateExplosion(CollisionPoint);
ListAttackedRobots.Add(Other);
Die();
}
public void OnCollision(Player Other, PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, Polygon FinalOtherPolygon)
{
Vector2 FinalMovement;
if (FinalCollisionResult.Distance >= 0)
{
Vector2 MovementCorection = FinalCollisionResult.Axis * FinalCollisionResult.Distance;
FinalMovement = Speed + MovementCorection;
}
else
{
FinalMovement = Speed;
}
Move(FinalMovement);
}
public override void Update(GameTime gameTime)
{
TeleportAnimation.Update(gameTime);
PolygonCollisionResult FinalCollisionResult = new PolygonCollisionResult(Vector2.Zero, -1);
foreach (Player ActivePlayer in Map.ListAllPlayer)
{
foreach (Polygon EnemyCollision in ActivePlayer.InGameRobot.Collision.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(TeleportPolygon, EnemyCollision, ActivePlayer.InGameRobot.Speed);
if (CollisionResult.Distance >= 0 && CollisionResult.Distance > FinalCollisionResult.Distance)
{
ActivePlayer.InGameRobot.Speed += _TeleportSpeed;
ActivePlayer.InGameRobot.Move(_TeleportOffset);
Owner.ChangeRobotLayer(ActivePlayer.InGameRobot, _LayerIndex);
}
}
}
}
public void UpdateAttackCollisionWithWorld(AttackBox ActiveAttackBox)
{
PolygonCollisionResult FinalCollisionResult = new PolygonCollisionResult(Vector2.Zero, -1);
PolygonCollisionResult FinalCollisionGroundResult = new PolygonCollisionResult(Vector2.Zero, -1);
Polygon FinalCollisionPolygon = null;
foreach (Polygon ActivePolygon in ListWorldCollisionPolygon)
{
foreach (Polygon CollisionPolygon in ActiveAttackBox.ListCollisionPolygon)
{
PolygonCollisionResult CollisionGroundResult;
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(CollisionPolygon, ActivePolygon, ActiveAttackBox.Speed, out CollisionGroundResult);
if (FinalCollisionResult.Distance < 0 || (CollisionResult.Distance >= 0 && CollisionResult.Distance > FinalCollisionResult.Distance))
{
FinalCollisionResult = CollisionResult;
FinalCollisionGroundResult = CollisionGroundResult;
FinalCollisionPolygon = ActivePolygon;
}
}
}
if (FinalCollisionResult.Distance >= 0)
{
Vector2 CollisionPoint;
ActiveAttackBox.OnCollision(FinalCollisionResult, FinalCollisionPolygon, out CollisionPoint);
SetAttackContext(ActiveAttackBox, ActiveAttackBox.Owner, (float)Math.Atan2(-FinalCollisionGroundResult.Axis.X, -FinalCollisionGroundResult.Axis.Y), CollisionPoint);
ActiveAttackBox.UpdateSkills(TripleThunderAttackRequirement.OnGroundCollisionAttackName);
if (ActiveAttackBox.ExplosionAttributes.ExplosionRadius > 0)
{
CreateExplosion(CollisionPoint, ActiveAttackBox);
}
else if (!ActiveAttackBox.FollowOwner)
{
Owner.PlayerSFXGenerator.PlayBulletHitObjectSound();
}
}
}
public void OnCollision(GameTime gameTime, Bullet Other, PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, Polygon FinalOtherPolygon)
{
if (PlayerAI != null)
{
PlayerAI.Update(gameTime, "On Hit");
}
if (HasKnockback)
{
Speed.X = Math.Sign(Other.Speed.X) * 3;
Speed.Y = Math.Sign(Other.Speed.Y) * 3;
}
int FinalDamage = (int)Other.Damage;
//FightingZone.ListDamageNumber.Add(new DamageNumber(FinalCollisionPolygon.Center, FinalDamage, 1000));
HP -= FinalDamage;
if (HP < 0)
{
Die();
}
}
public override void Update(GameTime gameTime)
{
JumpPadAnimation.Update(gameTime);
foreach (RobotAnimation ActiveRobot in Owner.DicRobot.Values)
{
PolygonCollisionResult FinalCollisionResult = new PolygonCollisionResult(Vector2.Zero, -1);
foreach (CollisionPolygon EnemyCollision in ActiveRobot.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(JumpPadPolygon, EnemyCollision.ActivePolygon, ActiveRobot.Speed);
if (FinalCollisionResult.Distance < 0 || (CollisionResult.Distance >= 0 && CollisionResult.Distance > FinalCollisionResult.Distance))
{
FinalCollisionResult = CollisionResult;
}
}
if (FinalCollisionResult.Distance >= 0)
{
ActiveRobot.Speed.Y = -_JumpSpeed;
}
}
}
public override void Update(GameTime gameTime)
{
JumpPadAnimation.Update(gameTime);
foreach (Player ActivePlayer in Map.ListAllPlayer)
{
PolygonCollisionResult FinalCollisionResult = new PolygonCollisionResult(Vector2.Zero, -1);
foreach (Polygon EnemyCollision in ActivePlayer.InGameRobot.Collision.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(JumpPadPolygon, EnemyCollision, ActivePlayer.InGameRobot.Speed);
if (FinalCollisionResult.Distance < 0 || (CollisionResult.Distance >= 0 && CollisionResult.Distance > FinalCollisionResult.Distance))
{
FinalCollisionResult = CollisionResult;
}
}
if (FinalCollisionResult.Distance >= 0)
{
ActivePlayer.InGameRobot.Speed.Y = -_JumpSpeed;
}
}
}
protected void UpdateRobotCollisionWithRobot(RobotAnimation ActiveRobot, Dictionary <uint, RobotAnimation> DicRobot)
{
PolygonCollisionResult FinalCollisionResult = new PolygonCollisionResult(Vector2.Zero, -1);
foreach (KeyValuePair <uint, RobotAnimation> EnemyRobot in DicRobot)
{
if (ActiveRobot == EnemyRobot.Value)
{
continue;
}
foreach (Polygon ActiveCollision in ActiveRobot.Collision.ListCollisionPolygon)
{
foreach (Polygon EnemyCollision in EnemyRobot.Value.Collision.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(ActiveCollision, EnemyCollision, ActiveRobot.Speed);
if (FinalCollisionResult.Distance < 0 || (CollisionResult.Distance >= 0 && CollisionResult.Distance < FinalCollisionResult.Distance))
{
FinalCollisionResult = CollisionResult;
}
}
}
}
Vector2 FinalMovement;
if (FinalCollisionResult.Distance >= 0)
{
Vector2 MovementCorection = FinalCollisionResult.Axis * FinalCollisionResult.Distance;
FinalMovement = ActiveRobot.Speed + MovementCorection;
}
else
{
FinalMovement = ActiveRobot.Speed;
}
ActiveRobot.Move(FinalMovement);
}
private void CheckForWeaponDrop()
{
foreach (WeaponDrop ActiveWeaponDrop in CurrentLayer.DicWeaponDrop.Values)
{
if (!ActiveWeaponDrop.IsAlive || ActiveWeaponDrop.TimeAlive <= 1)
{
return;
}
PolygonCollisionResult FinalCollisionResult = new PolygonCollisionResult(Vector2.Zero, -1);
foreach (Polygon ActiveCollision in Collision.ListCollisionPolygon)
{
foreach (Polygon EnemyCollision in ActiveWeaponDrop.Collision.ListCollisionPolygon)
{
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(ActiveCollision, EnemyCollision, Speed);
if (FinalCollisionResult.Distance < 0 || (CollisionResult.Distance >= 0 && CollisionResult.Distance < FinalCollisionResult.Distance))
{
FinalCollisionResult = CollisionResult;
}
}
}
if (FinalCollisionResult.Distance >= 0)
{
if (PrimaryWeapons.HolsteredWeaponsCount == 0)
{
ReplacePrimaryWeapon(ActiveWeaponDrop.WeaponName);
ActiveWeaponDrop.IsAlive = false;
CurrentLayer.RemoveDroppedWeapon(ActiveWeaponDrop);
return;
}
}
}
}
/*public void UpdatePosition(Polygon[] polygons, int numFood)
* {
* double foodDist = 0;
* double leftTrack;
* double rightTrack;
* double curSpeed;
*
*
*
* myFood = myWorld.FindClosestFood(x, y, ref foodDist, ref indMyFood, myFoodCollected);
* double[] input = new double[4];
* input[0] = Math.Cos(dir); //could be sin also; doesn't matter aslong as its between 0 and 1
* input[1] = Math.Cos(dir);
* input[2] = (myFood.X - x) / foodDist; //let the ant know about nearest food
* input[3] = (myFood.Y - y) / foodDist; //same
* double[] output = net.FeedData(input); //feed input into network and get output
* leftTrack = output[0];
* rightTrack = output[1];
* dir += (rightTrack - leftTrack) * (Cosmos.maxForce / 100); //find the direction
* curSpeed = (rightTrack + leftTrack) / 2;
* x += Math.Sin(dir) * antMaxSpeed * curSpeed / 10; //max speed is just a twaking parameter; don't get confused by it
* y -= Math.Cos(dir) * antMaxSpeed * curSpeed / 10; //try varying it in simulation
*
* Vector2 velocity = new Vector2((float)x, (float)y);
*
* int tx, ty, lx, ly, rx, ry;
* tx = (int)(Ants.AntTopX * Math.Cos(dir) - Ants.AntTopY * Math.Sin(dir) + x);
* ty = (int)(Ants.AntTopY * Math.Cos(dir) + Ants.AntTopX * Math.Sin(dir) + y);
* lx = (int)(Ants.AntLeftX * Math.Cos(dir) - Ants.AntLeftY * Math.Sin(dir) + x);
* ly = (int)(Ants.AntLeftY * Math.Cos(dir) + Ants.AntLeftX * Math.Sin(dir) + y);
* rx = (int)(Ants.AntRightX * Math.Cos(dir) - Ants.AntRightY * Math.Sin(dir) + x);
* ry = (int)(Ants.AntRightY * Math.Cos(dir) + Ants.AntRightX * Math.Sin(dir) + y);
* //g.FillPolygon(Cosmos.whiteBrush, new Point[] { new Point(tx, ty), new Point(lx, ly), new Point(rx, ry) });
*
* Polygon agent = new Polygon();
* agent.Points.Add(new Vector2(tx, ty));
* agent.Points.Add(new Vector2(lx, ly));
* agent.Points.Add(new Vector2(rx, ry));
* agent.BuildEdges();
* Vector2 playerTranslation = velocity;
*
* for (int m = 0; m < polygons.Length; m++)
* {
* PolygonCollisionResult r = PolygonCollision(agent, polygons[m], velocity);
*
* if (r.WillIntersect)
* {
* playerTranslation = velocity + r.MinimumTranslationVector;
* x = x + playerTranslation.X/2;
* y = y + playerTranslation.Y/2;
*
* // y = y + playerTranslation.Y;
* break;
* }
* }
*
*
* Vector2 finish = new Vector2();
*
* if (agentType != null && agentType.Equals("calm"))
* {
* finish = new Vector2(finishPosition.X, finishPosition.Y);
* Vector2 target = new Vector2(myFood.X,myFood.Y);
* Vector2 current = new Vector2((float)x,(float)y);
* Vector2 steerForce = SteeringBehaviours.Seek(ref target,ref current , ref velocity, 10);
* steerForce = Vector2.Truncate(steerForce, 10);
* Random random = new Random();
* Vector2 acceleration = steerForce / (random.Next(20, 80));
* velocity = Vector2.Truncate(velocity + acceleration,10);
* finish = Vector2.Add(velocity, finish);
* finishPosition = new PointF((float)finish.X, (float)finish.Y);
* }
* else
* finishPosition = new PointF((float)x + finishPosition.X, (float)y + finishPosition.Y);
*
*
*
* if (x < 0)
* x = clientSize.Width;
* if (x > clientSize.Width)
* x = 0;
* if (y < 0)
* y = clientSize.Height;
* if (y > clientSize.Height)
* y = 0;
*
*
*
* if ((myFood.X >= (x - Cosmos.foodTolerance)) &&
* (myFood.X <= (x + Cosmos.foodTolerance)) &&
* (myFood.Y >= (y - Cosmos.foodTolerance)) &&
* (myFood.Y <= (y + Cosmos.foodTolerance)))
* {
* if (myFoodCollected[indMyFood] != 1)
* {
* foodCollected++;
* myFoodCollected[indMyFood] = 1;
* }
*
* // agent disappears when they have reached the total number of goals
* if(foodCollected == numFood)
* invisible = true;
* myWorld.NewFood(indMyFood);
* }
* } */
public void UpdatePosition(Polygon[] polygons, int numFood)
{
double foodDist = 0;
double leftTrack;
double rightTrack;
double curSpeed;
myFood = myWorld.FindClosestFood(x, y, ref foodDist, ref indMyFood, myFoodCollected);
double[] input = new double[4];
input[0] = Math.Cos(dir); //could be sin also; doesn't matter aslong as its between 0 and 1
input[1] = Math.Cos(dir);
input[2] = (myFood.X - x) / foodDist; //let the ant know about nearest food
input[3] = (myFood.Y - y) / foodDist; //same
double[] output = net.FeedData(input); //feed input into network and get output
leftTrack = output[0];
rightTrack = output[1];
double olddir = dir;
dir += (rightTrack - leftTrack) * (Cosmos.maxForce / 100); //find the direction
curSpeed = (rightTrack + leftTrack) / 2;
x += Math.Sin(dir) * antMaxSpeed * curSpeed / 10; //max speed is just a twaking parameter; don't get confused by it
y -= Math.Cos(dir) * antMaxSpeed * curSpeed / 10; //try varying it in simulation
// finishPosition = new PointF((float)x + finishPosition.X, (float)y + finishPosition.Y);
if (((x - 15) <= 5) || ((x + 15) >= 1090))
{
if ((x - 15) <= 5)
{
x += 15;
}
else
{
x -= 15;
}
}
if (((y - 15) <= 5) || ((y + 15) >= 667))
{
if ((y - 15) <= 5)
{
y += 15;
}
else
{
y -= 15;
}
}
Vector2 targetPosition = new Vector2(myFood);
Vector2 currentPosition = new Vector2((float)x, (float)y);
Vector2 desired_V = Vector2.Normalize(Vector2.Subtract(targetPosition, currentPosition)) * (int)antMaxSpeed;
Vector2 velocity = new Vector2(1, 1);
Vector2 steerForce = Vector2.Subtract(desired_V, velocity);
steerForce = Vector2.Truncate(steerForce, (int)Cosmos.maxForce);
float mass = 21;
Vector2 acceleration = steerForce / mass;
velocity = Vector2.Truncate(velocity + acceleration, (int)antMaxSpeed);
currentPosition = Vector2.Add(velocity, currentPosition);
finishPosition = new PointF((float)currentPosition.X + finishPosition.X, (float)currentPosition.Y + finishPosition.Y);
x = (float)currentPosition.X;
y = (float)currentPosition.Y;
int tx, ty, lx, ly, rx, ry;
tx = (int)(Ants.AntTopX * Math.Cos(dir) - Ants.AntTopY * Math.Sin(dir) + x);
ty = (int)(Ants.AntTopY * Math.Cos(dir) + Ants.AntTopX * Math.Sin(dir) + y);
lx = (int)(Ants.AntLeftX * Math.Cos(dir) - Ants.AntLeftY * Math.Sin(dir) + x);
ly = (int)(Ants.AntLeftY * Math.Cos(dir) + Ants.AntLeftX * Math.Sin(dir) + y);
rx = (int)(Ants.AntRightX * Math.Cos(dir) - Ants.AntRightY * Math.Sin(dir) + x);
ry = (int)(Ants.AntRightY * Math.Cos(dir) + Ants.AntRightX * Math.Sin(dir) + y);
Polygon agent = new Polygon();
agent.Points.Add(new Vector2(tx, ty));
agent.Points.Add(new Vector2(lx, ly));
agent.Points.Add(new Vector2(rx, ry));
agent.BuildEdges();
Vector2 playerTranslation = velocity;
for (int m = 0; m < polygons.Length; m++)
{
if ((rx + 270) >= polygons[m].Points[3].X)
{
PolygonCollisionResult r = PolygonCollision(agent, polygons[m], velocity);
if (r.WillIntersect)
{
playerTranslation = velocity + r.MinimumTranslationVector;
x = x + playerTranslation.X / 2;
y = y + playerTranslation.Y / 2;
dir = olddir;
// y = y + playerTranslation.Y;
break;
}
}
}
/*for (int m = 0; m < polygons.Length; m++)
* {
* RectangleF rf = new RectangleF(polygons[m].Points[0].X,polygons[m].Points[0].Y, Math.Abs(polygons[m].Points[1].X - polygons[m].Points[0].X),Math.Abs(polygons[m].Points[2].Y - polygons[m].Points[1].Y));
*
* if(IsIntersected(new PointF((float)x + finishPosition.X, (float)y + finishPosition.Y),(float)6, rf))
* {
* // playerTranslation = velocity + r.MinimumTranslationVector;
* //x = x + playerTranslation.X / 2;
* //y = y + playerTranslation.Y / 2;
* x = x + 50;
* y = y + 50;
*
* // y = y + playerTranslation.Y;
* break;
* }
* } */
//finishPosition = new PointF((float)x + finishPosition.X, (float)y + finishPosition.Y);
if (x < 0)
{
x = clientSize.Width;
}
if (x > clientSize.Width)
{
x = 0;
}
if (y < 0)
{
y = clientSize.Height;
}
if (y > clientSize.Height)
{
y = 0;
}
if ((myFood.X >= (x - Cosmos.foodTolerance)) &&
(myFood.X <= (x + Cosmos.foodTolerance)) &&
(myFood.Y >= (y - Cosmos.foodTolerance)) &&
(myFood.Y <= (y + Cosmos.foodTolerance)))
{
foodCollected++;
invisible = true;
//myWorld.NewFood(indMyFood);
}
}
// Check if polygon A is going to collide with polygon B for the given velocity
public PolygonCollisionResult PolygonCollision(Polygon polygonA, Polygon polygonB, Vector2 velocity)
{
PolygonCollisionResult result = new PolygonCollisionResult();
result.Intersect = true;
result.WillIntersect = true;
int edgeCountA = polygonA.Edges.Count;
int edgeCountB = polygonB.Edges.Count;
float minIntervalDistance = float.PositiveInfinity;
Vector2 translationAxis = new Vector2();
Vector2 edge;
// Loop through all the edges of both polygons
for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
if (edgeIndex < edgeCountA)
{
edge = polygonA.Edges[edgeIndex];
}
else
{
edge = polygonB.Edges[edgeIndex - edgeCountA];
}
// ===== 1. Find if the polygons are currently intersecting =====
// Find the axis perpendicular to the current edge
Vector2 axis = new Vector2(-edge.Y + -25, edge.X + -10);
axis.Normalize();
// Find the projection of the polygon on the current axis
float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
ProjectPolygon(axis, polygonA, ref minA, ref maxA);
ProjectPolygon(axis, polygonB, ref minB, ref maxB);
// Check if the polygon projections are currentlty intersecting
if (IntervalDistance(minA, maxA, minB, maxB) > 0)
{
result.Intersect = false;
}
// ===== 2. Now find if the polygons *will* intersect =====
// Project the velocity on the current axis
float velocityProjection = axis.DotProduct(velocity);
// Get the projection of polygon A during the movement
if (velocityProjection < 0)
{
minA += velocityProjection;
}
else
{
maxA += velocityProjection;
}
// Do the same test as above for the new projection
float intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
if (intervalDistance > 0)
{
result.WillIntersect = false;
}
// If the polygons are not intersecting and won't intersect, exit the loop
if (!result.Intersect && !result.WillIntersect)
{
break;
}
// Check if the current interval distance is the minimum one. If so store
// the interval distance and the current distance.
// This will be used to calculate the minimum translation vector
intervalDistance = Math.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
translationAxis = axis;
Vector2 d = polygonA.Center - polygonB.Center;
if (d.DotProduct(translationAxis) < 0)
{
translationAxis = -translationAxis;
}
}
}
// The minimum translation vector can be used to push the polygons appart.
// First moves the polygons by their velocity
// then move polygonA by MinimumTranslationVector.
if (result.WillIntersect)
{
result.MinimumTranslationVector = translationAxis * 3 * minIntervalDistance;
}
return(result);
}
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
foreach (Menu gameMenu in gameMenus)
{
gameMenu.onCollision(gameTime, collisionResult, player1Velocity);
}
}
public bool IsIntersecting(Polygon p)
{
PolygonCollisionResult polygonCollisionResult = PolygonCollision(this, p);
return(polygonCollisionResult.Intersect);
}
private static void iterate(SvgElementCollection elementCollection1, SvgElementCollection elementCollection2)
{
foreach (SvgElement outerElement in elementCollection1)
{
if (outerElement.Children.Count != 0) iterate(outerElement.Children, elementCollection2);
foreach (SvgElement innerElement in elementCollection2)
{
if (innerElement.Children.Count != 0) iterate(outerElement.Children, innerElement.Children);
{
if (innerElement is SvgVisualElement && outerElement is SvgVisualElement && outerElement != innerElement && !isParent(innerElement, outerElement))
{
PolygonCollisionResult r = new PolygonCollisionResult();
try
{
if (_minimumArea != 0)
{
if (((SvgVisualElement)outerElement).PathOuterArea.Value < _minimumArea) break;
if (((SvgVisualElement)innerElement).PathOuterArea.Value < _minimumArea) break;
}
if (outerElement is SvgCircle) ((SvgCircle)outerElement).Path.Flatten();
if (outerElement is SvgEllipse) ((SvgEllipse)outerElement).Path.Flatten();
if (innerElement is SvgCircle) ((SvgCircle)innerElement).Path.Flatten();
if (innerElement is SvgEllipse) ((SvgEllipse)innerElement).Path.Flatten();
PointF[] ptsA = ((SvgVisualElement)outerElement).Path.PathPoints;
PointF[] ptsB = ((SvgVisualElement)innerElement).Path.PathPoints;
switch (_colCheckType)
{
case collisionCheckType.LineCollision:
r = LineIntersection.PolygonCollision(ptsA, ptsB);
break;
case collisionCheckType.SeparatingAxisTheorem:
r = SeparatingAxisTheorem.PolygonCollision(ptsA, ptsB, _velocity);
break;
case collisionCheckType.Mixed:
r = SeparatingAxisTheorem.PolygonCollision(ptsA, ptsB, _velocity);
if (r.IsIntersecting)
{
PolygonCollisionResult t = LineIntersection.PolygonCollision( ptsA, ptsB);
r.rayCastingResult = LineIntersection.RayCasting(ptsA, ptsB);
r.OnPath = t.OnPath;
r.LineIntersectingPoints = t.LineIntersectingPoints;
}
break;
}
}
catch { }
if (r.IsIntersecting == true || r.WillIntersect == true)
{
r.collidor = outerElement.ID ?? "-";
r.collidee = innerElement.ID ?? "-";
_collisionResultList.Add(r);
}
}
}
}
}
}
public abstract void OnCollision(PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, out Vector2 CollisionPoint);
/*
public Camera getCameraInGame()
{
Vector2 playerPos = this.Properties.getProperty<Vector2>("Position");
return new Camera(Matrix.Identity, new Vector2(Renderer.getInstance.getScreenCenter().X - playerPos.X,
Renderer.getInstance.getScreenCenter().Y - playerPos.Y));
}
*/
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 velocity)
{
Vector2 position = Properties.getProperty<Vector2>("Position");
bool hasCollided = Properties.getProperty<bool>("HasCollided");
List<AABB> axisAlignedBoxes = Properties.getProperty<List<AABB>>("AABB");
List<Polygon> polygons = Properties.getProperty<List<Polygon>>("Polygon");
List<Animation> animations = Properties.getProperty<List<Animation>>("Animations");
float drawDepth = Properties.getProperty<float>("DrawDepth");
float depthPosition = Properties.getProperty<float>("DepthPosition");
hasCollided = true;
velocity = velocity / 2;
velocity = velocity * (float)gameTime.ElapsedGameTime.TotalSeconds + collisionResult.MinimumTranslationVector;
position += velocity;
Vector2 shadowPos = new Vector2(position.X - 11, position.Y - 8);
SceneManager.getInstance.getPlayer1Shadow().Properties.updateProperty<Vector2>("Position", shadowPos);
foreach (Polygon polygon in polygons)
{
polygon.offset(velocity);
polygon.buildEdges();
}
depthPosition += velocity.Y;
drawDepth = depthPosition / (SceneManager.getInstance.getAxisAlignedBox().getPosition().Y + SceneManager.getInstance.getAxisAlignedBox().getHeight());
Properties.updateProperty<Vector2>("Position", position);
Properties.updateProperty<bool>("HasCollided", hasCollided);
Properties.updateProperty<List<AABB>>("AABB", axisAlignedBoxes);
Properties.updateProperty<List<Polygon>>("Polygon", polygons);
Properties.updateProperty<float>("DrawDepth", drawDepth);
Properties.updateProperty<float>("DepthPosition", depthPosition);
Properties.updateProperty<List<Animation>>("Animations", animations);
}
public override void OnCollision(PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, out Vector2 CollisionPoint)
{
float MinDistance = float.MaxValue;
Vector2 FinalCollisionPoint = Collision.ListCollisionPolygon[0].ArrayVertex[2];
for (int I = 0; I < FinalCollisionPolygon.ArrayIndex.Length; I += 3)
{
Vector2 Vertex1 = FinalCollisionPolygon.ArrayVertex[FinalCollisionPolygon.ArrayIndex[I]];
Vector2 Vertex2 = FinalCollisionPolygon.ArrayVertex[FinalCollisionPolygon.ArrayIndex[I + 1]];
Vector2 Vertex3 = FinalCollisionPolygon.ArrayVertex[FinalCollisionPolygon.ArrayIndex[I + 2]];
CollisionPoint = Vector2.Zero;
if (Polygon.DoLinesIntersect(
Collision.ListCollisionPolygon[0].ArrayVertex[0],
Collision.ListCollisionPolygon[0].ArrayVertex[2] + Speed,
Vertex1,
Vertex2,
ref CollisionPoint))
{
float DistanceToPoint = (Collision.ListCollisionPolygon[0].ArrayVertex[0] - CollisionPoint).Length();
if (DistanceToPoint < MinDistance)
{
MinDistance = DistanceToPoint;
FinalCollisionPoint = CollisionPoint;
}
}
if (Polygon.DoLinesIntersect(
Collision.ListCollisionPolygon[0].ArrayVertex[0],
Collision.ListCollisionPolygon[0].ArrayVertex[2] + Speed,
Vertex2,
Vertex3,
ref CollisionPoint))
{
float DistanceToPoint = (Collision.ListCollisionPolygon[0].ArrayVertex[0] - CollisionPoint).Length();
if (DistanceToPoint < MinDistance)
{
MinDistance = DistanceToPoint;
FinalCollisionPoint = CollisionPoint;
}
}
if (Polygon.DoLinesIntersect(
Collision.ListCollisionPolygon[0].ArrayVertex[0],
Collision.ListCollisionPolygon[0].ArrayVertex[2] + Speed,
Vertex3,
Vertex1,
ref CollisionPoint))
{
float DistanceToPoint = (Collision.ListCollisionPolygon[0].ArrayVertex[0] - CollisionPoint).Length();
if (DistanceToPoint < MinDistance)
{
MinDistance = DistanceToPoint;
FinalCollisionPoint = CollisionPoint;
}
}
}
Vector2 MovementCorection = FinalCollisionResult.Axis * FinalCollisionResult.Distance;
Vector2 FinalMovement = Speed + MovementCorection;
CollisionPoint = Polygon.GetCollisionPointFromLine(Collision.ListCollisionPolygon[0].ArrayVertex[0], Collision.ListCollisionPolygon[0].ArrayVertex[2], Speed, FinalCollisionPolygon, out _);
FinalizeCollision(FinalMovement, FinalCollisionPoint);
}
public override void OnCollision(PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, out Vector2 CollisionPoint)
{
throw new NotImplementedException();
}
private void OnCollision(Player Other, PolygonCollisionResult FinalCollisionResult, Polygon FinalBombPolygon, Polygon FinalPlayerPolygon)
{
}
// Check if polygon A is going to collide with polygon B for the given velocity
public PolygonCollisionResult PolygonCollision(PolygonMath polygonB, Vector velocity)
{
PolygonCollisionResult result = new PolygonCollisionResult();
result.Intersect = true;
result.WillIntersect = true;
PolygonMath polygonA = this;
//build edges
if (polygonA.Edges.Count == 0)
polygonA.BuildEdges();
if (polygonB.Edges.Count == 0)
polygonB.BuildEdges();
int edgeCountA = polygonA.Edges.Count;
int edgeCountB = polygonB.Edges.Count;
double minIntervalDistance = double.PositiveInfinity;
Vector translationAxis = new Vector();
Vector edge;
// Loop through all the edges of both polygons
for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
if (edgeIndex < edgeCountA)
{
edge = polygonA.Edges[edgeIndex];
}
else
{
edge = polygonB.Edges[edgeIndex - edgeCountA];
}
// ===== 1. Find if the polygons are currently intersecting =====
// Find the axis perpendicular to the current edge
Vector axis = new Vector(-edge.Y, edge.X);
axis.Normalize();
// Find the projection of the polygon on the current axis
double minA = 0; double minB = 0; double maxA = 0; double maxB = 0;
ProjectPolygon(axis, polygonA, ref minA, ref maxA);
ProjectPolygon(axis, polygonB, ref minB, ref maxB);
// Check if the polygon projections are currentlty intersecting
if (IntervalDistance(minA, maxA, minB, maxB) > 0) result.Intersect = false;
// ===== 2. Now find if the polygons *will* intersect =====
// Project the velocity on the current axis
double velocityProjection = axis.DotProduct(velocity);
// Get the projection of polygon A during the movement
if (velocityProjection < 0)
{
minA += velocityProjection;
}
else
{
maxA += velocityProjection;
}
// Do the same test as above for the new projection
double intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
if (intervalDistance > 0) result.WillIntersect = false;
// If the polygons are not intersecting and won't intersect, exit the loop
if (!result.Intersect && !result.WillIntersect) break;
// Check if the current interval distance is the minimum one. If so store
// the interval distance and the current distance.
// This will be used to calculate the minimum translation vector
intervalDistance = Math.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
translationAxis = axis;
Vector d = polygonA.Center - polygonB.Center;
if (d.DotProduct(translationAxis) < 0) translationAxis = -translationAxis;
}
}
// The minimum translation vector can be used to push the polygons appart.
// First moves the polygons by their velocity
// then move polygonA by MinimumTranslationVector.
if (result.WillIntersect) result.MinimumTranslationVector = translationAxis * minIntervalDistance;
if (result.Intersect)
{
//asa
}
return result;
}
private void OnCollision(WorldObject Other, PolygonCollisionResult FinalCollisionResult, Polygon FinalBombPolygon, Polygon FinalWorldPolygon)
{
float DirectionAngle = (float)Math.Atan2(Speed.Y, Speed.X);
float WallMinAngle = DirectionAngle - MathHelper.PiOver4;
float WallMaxAngle = DirectionAngle + MathHelper.PiOver4;
Vector2 WallAxis = new Vector2(-FinalCollisionResult.Axis.Y, FinalCollisionResult.Axis.X);
double FinalCollisionResultAngle = Math.Atan2(WallAxis.X, WallAxis.Y);
Vector2 MovementCorection = FinalCollisionResult.Axis * FinalCollisionResult.Distance;
Vector2 FinalMovement = Speed + MovementCorection;
//Ground detection
if (FinalCollisionResultAngle >= WallMinAngle && FinalCollisionResultAngle <= WallMaxAngle)
{
Speed.X = 0;
Speed.Y = 0;
Move(FinalMovement);
}
//Slope
else
{
if (FinalWorldPolygon.PolygonCollisionPerTriangle(ForwardLeftVector.X + FinalMovement.X, ForwardLeftVector.Y + FinalMovement.Y))
{
Vector2 PerpendicularAxis = BackLeftVector - ForwardLeftVector;
PerpendicularAxis = new Vector2(-PerpendicularAxis.Y, PerpendicularAxis.X);
PerpendicularAxis.Normalize();
Vector2 CollisionLineAxis;
Vector2 LeftCollisionPoint = Polygon.GetCollisionPointFromLine(BackLeftVector, ForwardLeftVector, Speed, FinalWorldPolygon, out CollisionLineAxis);
Move(LeftCollisionPoint - ForwardLeftVector);
//Collision on the left, the collision axis should divert to the right
if (Vector2.Dot(PerpendicularAxis, CollisionLineAxis) < 0)
{
double WallAngle = Math.Atan2(CollisionLineAxis.Y, CollisionLineAxis.X);
Vector2 WallPerpendicularAxis = new Vector2(-CollisionLineAxis.Y, CollisionLineAxis.X);
WallPerpendicularAxis.Normalize();
double WallPerpendicularAngle = Math.Atan2(WallPerpendicularAxis.Y, WallPerpendicularAxis.X);
Vector2 NewExplosionForwardLeftVector = ForwardLeftVector;
Vector2 NewExplosionForwardRightVector = NewExplosionForwardLeftVector + new Vector2((float)Math.Cos(WallPerpendicularAngle) * Size, (float)Math.Sin(WallPerpendicularAngle) * Size);
SimpleLinearExplosion FollowingExplosion = new SimpleLinearExplosion(Owner, NewExplosionForwardLeftVector + (NewExplosionForwardRightVector - NewExplosionForwardLeftVector) / 2,
new Vector2((float)Math.Cos(WallAngle) * 3, (float)Math.Sin(WallAngle) * 3));
Owner.Add(FollowingExplosion);
}
}
else if (FinalWorldPolygon.PolygonCollisionPerTriangle(ForwardRightVector.X + FinalMovement.X, ForwardRightVector.Y + FinalMovement.Y))
{
Vector2 PerpendicularAxis = BackRightVector - ForwardRightVector;
PerpendicularAxis = new Vector2(-PerpendicularAxis.Y, PerpendicularAxis.X);
PerpendicularAxis.Normalize();
Vector2 CollisionLineAxis;
Vector2 RightCollisionPoint = Polygon.GetCollisionPointFromLine(BackRightVector, ForwardRightVector, Speed, FinalWorldPolygon, out CollisionLineAxis);
Move(RightCollisionPoint - ForwardRightVector);
//Collision on the right, the collision axis should divert to the left
if (Vector2.Dot(PerpendicularAxis, CollisionLineAxis) < 0)
{
}
}
else
{
//Will happen if the collision is on a corner, consider it as a wall.
}
}
}
public static PolygonCollisionResult PolygonCollision(Polygon a, Polygon b, Vector velocity)
{
PolygonCollisionResult result = new PolygonCollisionResult();
result.WillIntersect = true;
result.Intersect = true;
int edgeCountA = a.Edges.Count;
int edgeCountB = b.Edges.Count;
double minIntervalDistance = double.PositiveInfinity;
Vector traslationAxis = new Vector();
Vector edge;
for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
if (edgeIndex < edgeCountA)
{
edge = a.Edges[edgeIndex];
}
else
{
edge = b.Edges[edgeIndex - edgeCountA];
}
Vector axis = edge.PerpendicularVector2D();
axis = axis.Unit;
double minA = 0;
double maxA = 0;
double minB = 0;
double maxB = 0;
ProjectPolygon(axis, a, ref minA, ref maxA);
ProjectPolygon(axis, b, ref minB, ref maxB);
if (IntervalDisance(minA, maxA, minB, maxB) > 0)
{
result.Intersect = false;
}
double velosityProjection = axis.DotProduct(velocity);
if (velosityProjection < 0)
{
minA += velosityProjection;
}
else
{
maxA += velosityProjection;
}
double intervalDistance = IntervalDisance(minA, maxA, minB, maxB);
if (intervalDistance > 0)
{
result.WillIntersect = false;
}
if (!result.Intersect && !result.WillIntersect)
{
break;
}
intervalDistance = Math.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
traslationAxis = axis;
Point d = a.Centroid - b.Centroid;
if (d.ToVector().DotProduct(traslationAxis) < 0)
{
traslationAxis = traslationAxis * -1;
}
}
}
if (result.WillIntersect)
{
result.MinimumTranslationVector = traslationAxis * minIntervalDistance;
}
return(result);
}
public override void OnFloorCollision(List <Tuple <PolygonCollisionResult, Polygon> > ListFloorCollidingPolygon)
{
//Jumping
if (IsJumping)
{
Vector2 MovementCorection = Vector2.Zero;
foreach (Tuple <PolygonCollisionResult, Polygon> FinalCollisionResult in ListFloorCollidingPolygon)
{
MovementCorection += FinalCollisionResult.Item1.Axis * FinalCollisionResult.Item1.Distance;
}
Vector2 FinalMovement = Owner.Speed + MovementCorection;
Owner.Move(FinalMovement);
return;
}
Owner.Land();
if (Owner.IsInAir)
{
Owner.PlayerSFXGenerator.PlayLandSound();
}
bool NeedToMoveUp = true;
bool HasMovedUp = false;
bool HasCollided = false;
while (NeedToMoveUp)
{
foreach (CollisionPolygon ActivePlayerCollisionPolygon in Owner.ListCollisionPolygon)
{
if (ActivePlayerCollisionPolygon.IsDead || !NeedToMoveUp)
{
continue;
}
foreach (Tuple <PolygonCollisionResult, Polygon> FinalCollisionResult in ListFloorCollidingPolygon)
{
Vector2 GroundAxis = new Vector2(-FinalCollisionResult.Item1.Axis.Y, FinalCollisionResult.Item1.Axis.X);
Owner.NormalizedGroundVector = GroundAxis;
Owner.NormalizedPerpendicularGroundVector = FinalCollisionResult.Item1.Axis;
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(ActivePlayerCollisionPolygon.ActivePolygon, FinalCollisionResult.Item2, Vector2.Zero, Vector2.Zero);
if (CollisionResult.Distance >= 0)
{
Owner.Move(-FightingZone.GravityVector);
HasMovedUp = true;
continue;
}
else
{
NeedToMoveUp = false;
}
}
}
}
if (!HasMovedUp)
{
float MaxRetry = Vector2.Dot(Owner.Speed, Owner.GravityVector);
while (!HasCollided && MaxRetry > 0)
{
--MaxRetry;
bool NeedToMoveDown = true;
foreach (Tuple <PolygonCollisionResult, Polygon> FinalCollisionResult in ListFloorCollidingPolygon)
{
foreach (CollisionPolygon ActivePlayerCollisionPolygon in Owner.ListCollisionPolygon)
{
if (ActivePlayerCollisionPolygon.IsDead)
{
continue;
}
PolygonCollisionResult CollisionResult = Polygon.PolygonCollisionSAT(ActivePlayerCollisionPolygon.ActivePolygon, FinalCollisionResult.Item2, Owner.GravityVector);
if (CollisionResult.Distance >= 0)
{
NeedToMoveDown = false;
break;
}
}
}
if (NeedToMoveDown)
{
Owner.Move(FightingZone.GravityVector);
}
else
{
HasCollided = true;
}
}
}
Vector2 VerticalSpeedCancelVector = Owner.Speed * -Owner.GravityVector;
Owner.Move(Owner.Speed + VerticalSpeedCancelVector);
Owner.Speed = Owner.Speed + VerticalSpeedCancelVector + Owner.GravityVector;
}
// Check if polygon A is going to collide with polygon B for the given velocity
public static PolygonCollisionResult CheckCollision(FixPolygon polygonA, FixPolygon polygonB, FixVec2 velocity)
{
var result = new PolygonCollisionResult {
Intersect = true, WillIntersect = true
};
var edgeCountA = polygonA.Edges.Length;
var edgeCountB = polygonB.Edges.Length;
var minIntervalDistance = Fix.MaxValue;
var translationAxis = new FixVec2();
// Loop through all the edges of both polygons
for (var edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
var edge = edgeIndex < edgeCountA ? polygonA.Edges[edgeIndex] : polygonB.Edges[edgeIndex - edgeCountA];
// ===== 1. Find if the polygons are currently intersecting =====
// Find the axis perpendicular to the current edge
var axis = new FixVec2(-edge.Y, edge.X).Normalize();
// Find the projection of the polygon on the current axis
Fix minA;
Fix maxA;
Fix minB;
Fix maxB;
ProjectPolygon(axis, polygonA, out minA, out maxA);
ProjectPolygon(axis, polygonB, out minB, out maxB);
// Check if the polygon projections are currently intersecting
if (IntervalDistance(minA, maxA, minB, maxB) > 0)
{
result.Intersect = false;
}
// ===== 2. Now find if the polygons *will* intersect =====
// Project the velocity on the current axis
var velocityProjection = axis.Dot(velocity);
// Get the projection of polygon A during the movement
if (velocityProjection < 0)
{
minA += velocityProjection;
}
else
{
maxA += velocityProjection;
}
// Do the same test as above for the new projection
var intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
if (intervalDistance > 0)
{
result.WillIntersect = false;
}
// If the polygons are not intersecting and won't intersect, exit the loop
if (!result.Intersect && !result.WillIntersect)
{
break;
}
// Check if the current interval distance is the minimum one. If so store
// the interval distance and the current distance.
// This will be used to calculate the minimum translation FixVec2
intervalDistance = FixMath.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
translationAxis = axis;
var d = polygonA.Center - polygonB.Center;
if (d.Dot(translationAxis) < 0)
{
translationAxis = -translationAxis;
}
}
}
// The minimum translation FixVec2 can be used to push the polygons apart.
// First moves the polygons by their velocity
// then move polygonA by MinimumTranslationVector.
if (result.WillIntersect)
{
result.MinimumTranslationVector = translationAxis * minIntervalDistance;
}
return(result);
}
// Structure that stores the results of the PolygonCollision function
// Check if polygon A is going to collide with polygon B for the given velocity
public static PolygonCollisionResult PolygonCollision(Polygon polygonA, Polygon polygonB, Vector2 velocity)
{
var result = new PolygonCollisionResult {Intersect = true, WillIntersect = true};
int edgeCountA = polygonA.Edges.Count;
int edgeCountB = polygonB.Edges.Count;
float minIntervalDistance = float.PositiveInfinity;
var translationAxis = new Vector2();
Vector2 edge;
// Loop through all the edges of both polygons
for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
edge = edgeIndex < edgeCountA ? polygonA.Edges[edgeIndex] : polygonB.Edges[edgeIndex - edgeCountA];
// ===== 1. Find if the polygons are currently intersecting =====
// Find the axis perpendicular to the current edge
var axis = new Vector2(-edge.Y, edge.X);
axis.Normalize();
// Find the projection of the polygon on the current axis
float minA = 0;
float minB = 0;
float maxA = 0;
float maxB = 0;
ProjectPolygon(axis, polygonA, ref minA, ref maxA);
ProjectPolygon(axis, polygonB, ref minB, ref maxB);
// Check if the polygon projections are currentlty intersecting
if (IntervalDistance(minA, maxA, minB, maxB) > 0) result.Intersect = false;
// ===== 2. Now find if the polygons *will* intersect =====
// Project the velocity on the current axis
float velocityProjection = Vector2.Dot(axis, velocity);
// Get the projection of polygon A during the movement
if (velocityProjection < 0)
{
minA += velocityProjection;
}
else
{
maxA += velocityProjection;
}
// Do the same test as above for the new projection
float intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
if (intervalDistance > 0) result.WillIntersect = false;
// If the polygons are not intersecting and won't intersect, exit the loop
if (!result.Intersect && !result.WillIntersect) break;
// Check if the current interval distance is the minimum one. If so store
// the interval distance and the current distance.
// This will be used to calculate the minimum translation vector
intervalDistance = System.Math.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
translationAxis = axis;
Vector2 d = polygonA.Center - polygonB.Center;
if (Vector2.Dot(d, translationAxis) < 0) translationAxis = -translationAxis;
}
}
// The minimum translation vector can be used to push the polygons appart.
// First moves the polygons by their velocity
// then move polygonA by MinimumTranslationVector.
if (result.WillIntersect) result.MinimumTranslationVector = translationAxis*minIntervalDistance;
result.IntervalDistance = minIntervalDistance;
return result;
}
public static PolygonCollisionResult PolygonCollision(Polygon a, Polygon b, Vector velocity)
{
PolygonCollisionResult result = new PolygonCollisionResult();
result.WillIntersect = true;
result.Intersect = true;
int edgeCountA = a.Edges.Count;
int edgeCountB = b.Edges.Count;
double minIntervalDistance = double.PositiveInfinity;
Vector traslationAxis = new Vector();
Vector edge;
for(int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
if(edgeIndex < edgeCountA)
{
edge = a.Edges[edgeIndex];
}
else
{
edge = b.Edges[edgeIndex - edgeCountA];
}
Vector axis = edge.PerpendicularVector2D();
axis = axis.Unit;
double minA = 0;
double maxA = 0;
double minB = 0;
double maxB = 0;
ProjectPolygon(axis, a, ref minA, ref maxA);
ProjectPolygon(axis, b, ref minB, ref maxB);
if (IntervalDisance(minA, maxA, minB, maxB) > 0)
{
result.Intersect = false;
}
double velosityProjection = axis.DotProduct(velocity);
if(velosityProjection < 0)
{
minA += velosityProjection;
}
else
{
maxA += velosityProjection;
}
double intervalDistance = IntervalDisance(minA, maxA, minB, maxB);
if(intervalDistance > 0)
{
result.WillIntersect = false;
}
if(!result.Intersect && !result.WillIntersect)
{
break;
}
intervalDistance = Math.Abs(intervalDistance);
if(intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
traslationAxis = axis;
Point d = a.Centroid - b.Centroid;
if(d.ToVector().DotProduct(traslationAxis) < 0)
{
traslationAxis = traslationAxis * -1;
}
}
}
if(result.WillIntersect)
{
result.MinimumTranslationVector = traslationAxis * minIntervalDistance;
}
return result;
}
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
foreach (InventorySlotHud slotHud in slots)
{
slotHud.onCollision(gameTime, collisionResult, player1Velocity);
}
}
// Check if polygon A is going to collide with polygon B.
// The last parameter is the *relative* velocity
// of the polygons (i.e. velocityA - velocityB)
public static PolygonCollisionResult PolygonCollision(Polygon polygonA,
Polygon polygonB, Vector velocity)
{
PolygonCollisionResult result = new PolygonCollisionResult();
// If either polygon has no vertices, they do not intersect
if (polygonA.Points.Count == 0 || polygonB.Points.Count == 0)
{
result.Intersect = false;
result.WillIntersect = false;
return(result);
}
/*
* change here to turn off/on collision detection
* */
result.Intersect = true;
result.WillIntersect = true;
int edgeCountA = polygonA.Points.Count;
int edgeCountB = polygonB.Points.Count;
int totalCount = edgeCountA + edgeCountB;
float minIntervalDistance = float.PositiveInfinity;
Vector translationAxis = new Vector();
Vector edge;
// Loop through all the edges of both polygons
for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB - 1; edgeIndex++)
{
if (edgeIndex < edgeCountA)
{
edge = polygonA.Points[(edgeIndex + 1) % edgeCountA] - polygonA.Points[edgeIndex];
}
else
{
int indexB = edgeIndex - edgeCountA;
edge = polygonB.Points[(indexB + 1) % edgeCountB] - polygonB.Points[indexB];
}
// ===== 1. Find if the polygons are currently intersecting =====
// Find the axis perpendicular to the current edge
Vector axis = new Vector(-edge.Y, edge.X);
axis.Normalize();
// Find the projection of the polygon on the current axis
float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
ProjectPolygon(axis, polygonA, ref minA, ref maxA);
ProjectPolygon(axis, polygonB, ref minB, ref maxB);
// Check if the polygon projections are currentlty intersecting
if (IntervalDistance(minA, maxA, minB, maxB) >= CollisionThreshold)
{
result.Intersect = false;
}
// ===== 2. Now find if the polygons *will* intersect =====
// Project the velocity on the current axis
float velocityProjection = (float)Vector.Multiply(velocity, axis);
// Get the projection of polygon A during the movement
if (velocityProjection < 0)
{
minA += velocityProjection;
}
else
{
maxA += velocityProjection;
}
// Do the same test as above for the new projection
float intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
if (intervalDistance >= CollisionThreshold)
{
result.WillIntersect = false;
}
// If the polygons are not intersecting and won't intersect, exit the loop
if (!result.Intersect && !result.WillIntersect)
{
break;
}
// Check if the current interval distance is the minimum one. If so store
// the interval distance and the current distance.
// This will be used to calculate the minimum translation vector
intervalDistance = Math.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
translationAxis = axis;
Vector d = getCenter(polygonA) - getCenter(polygonB);
//Vector d = polygonA.Center - polygonB.Center;
if (Vector.Multiply(d, translationAxis) < 0)
{
translationAxis = -translationAxis;
}
}
}
// The minimum translation vector
// can be used to push the polygons appart.
if (result.WillIntersect)
{
result.MinimumTranslationVector =
translationAxis * minIntervalDistance;
}
return(result);
}
public virtual void OnCollision(PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, out Vector2 CollisionPoint)
{
CollisionPoint = Vector2.Zero;
}
/// <summary>
/// Check if polygon A is going to collide with polygon B for the given velocity
/// </summary>
/// <param name="polygonA">The first polygon to check</param>
/// <param name="polygonB">The second polygon to check</param>
/// <param name="resolve">Whether to resolve the collisions using the static polygon references</param>
/// <returns>A PolygonCollisionResult specifying the result of this test</returns>
public static PolygonCollisionResult PolygonCollision(Vector2[] polygonA, Vector2[] polygonB, bool resolve = false)
{
PolygonCollisionResult result = new PolygonCollisionResult();
result.Intersect = true;
result.WillIntersect = false;
int edgeCountA = polygonA.Length;
int edgeCountB = polygonB.Length;
float minIntervalDistance = float.PositiveInfinity;
Vector2 translationAxis = Vector2.Zero;
Vector2 edge;
Vector2 center1 = Vector2.Zero;
Vector2 center2 = Vector2.Zero;
if (resolve)
{
// Calculate the center of the polygons
for (var i = 0; i < polygonA.Length; i += 1)
{
center1 += polygonA[i];
}
center1 = center1 / polygonA.Length;
for (var i = 0; i < polygonB.Length; i += 1)
{
center2 += polygonB[i];
}
center2 = center2 / polygonB.Length;
}
// Loop through all the edges of both polygons
for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++)
{
if (edgeIndex < edgeCountA)
{
edge = (polygonA[edgeIndex] - polygonA[(edgeIndex + 1) % polygonA.Length]);
}
else
{
edge = (polygonB[(edgeIndex - edgeCountA)] - polygonB[((edgeIndex + 1) - edgeCountA) % polygonB.Length]);
}
// ===== 1. Find if the polygons are currently intersecting =====
// Find the axis perpendicular to the current edge
Vector2 axis = new Vector2(-edge.Y, edge.X);
axis.Normalize();
// Find the projection of the polygon on the current axis
float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
ProjectPolygon(axis, polygonA, ref minA, ref maxA);
ProjectPolygon(axis, polygonB, ref minB, ref maxB);
// Check if the polygon projections are currentlty intersecting
if (IntervalDistance(minA, maxA, minB, maxB) > 0)
{
result.Intersect = false;
}
// ===== 2. Now find if the polygons *will* intersect =====
// Project the velocity on the current axis
float velocityProjection = Vector2.Dot(axis, Vector2.Zero);
// Get the projection of polygon A during the movement
if (velocityProjection < 0)
{
minA += velocityProjection;
}
else
{
maxA += velocityProjection;
}
// Do the same test as above for the new projection
float intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
if (intervalDistance > 0)
{
result.WillIntersect = false;
}
// If the polygons are not intersecting and won't intersect, exit the loop
if (!result.Intersect && !result.WillIntersect)
{
break;
}
// Check if the current interval distance is the minimum one. If so store
// the interval distance and the current distance.
// This will be used to calculate the minimum translation vector
if (resolve)
{
intervalDistance = Math.Abs(intervalDistance);
if (intervalDistance < minIntervalDistance)
{
minIntervalDistance = intervalDistance;
translationAxis = axis;
Vector2 d = center1 - center2;
if (Vector2.Dot(d, translationAxis) < 0)
{
translationAxis = -translationAxis;
}
}
}
}
if (resolve)
{
result.MinimumTranslationVector = translationAxis * minIntervalDistance;
}
return(result);
}
public override void OnCollision(PolygonCollisionResult FinalCollisionResult, Polygon FinalCollisionPolygon, out Vector2 CollisionPoint)
{
IsAlive = false;
CollisionPoint = Collision.ListCollisionPolygon[0].Center;
}
public void onCollision(GameTime gameTime, PolygonCollisionResult collisionResult, Vector2 player1Velocity)
{
inventoryHud.onCollision(gameTime, collisionResult, player1Velocity);
questHud.onCollision(gameTime, collisionResult, player1Velocity);
}
