public NoteSprite(FootballGame game)
{
this.game = game;
this.Spawn();
bounds = new BoundingCircle(this.Position, 32);
r = new Random();
}
public bool Collides(RigidBody other, ref Collision collisionInfo)
{
//circle vs circle collision
if (BoundingCircle.Collides(other.BoundingCircle))
{
if (BoundingBox != null && other.BoundingBox != null)
{
//rect vs rect
return(BoundingBox.Collides(other.BoundingBox, ref collisionInfo));
}
else
{
if (BoundingBox != null)
{
//rect vs circle
return(BoundingBox.Collides(other.BoundingCircle));
}
else if (other.BoundingBox != null)
{
//other rect vs my circle
return(other.BoundingBox.Collides(BoundingCircle));
}
else
{
//none has rect
return(true);
}
}
}
return(false);
}
/// <summary>
/// Updates the egg sprite to continue to fall
/// </summary>
/// <param name="gameTime">The game time</param>
public void Update(GameTime gameTime)
{
waitTimer += gameTime.ElapsedGameTime.TotalSeconds;
if (this.Position.X <= -64 && BalloonReset)
{
this.Position = Start;
}
else if (this.Position.X > -64 && BalloonReset)
{
float t = (float)gameTime.ElapsedGameTime.TotalSeconds;
Position.X -= velocity.X * t;
}
if (Hit)
{
this.bounds = new BoundingCircle(new Vector2(32, 32), 32);
}
/// Update the bounds
else
{
bounds.Center = new Vector2(Position.X, Position.Y);
}
}
/// <summary>
/// Creates a new coin sprite
/// </summary>
/// <param name="position">The position of the sprite in the game</param>
public CoinSprite(Vector2 position)
{
this.position = position;
this.bounds = new BoundingCircle(position + new Vector2(8, 8), 8);
this.Velocity = new Vector2(50, 50);
this.Acceleration = new Vector2(20, 20);
}
public bool Collides(RigidBody other, ref Collision collInfo)
{
if (BoundingCircle.Collides(other.BoundingCircle))
{
if (BoundingBox != null && other.BoundingBox != null)
{
return(BoundingBox.Collides(other.BoundingBox, ref collInfo));
}
else
{
if (BoundingBox != null)
{
return(BoundingBox.Collides(other.BoundingCircle));
}
else if (other.BoundingBox != null)
{
return(other.BoundingBox.Collides(BoundingCircle));
}
else
{
return(true);
}
}
}
return(false);
}
public Asteroid(Vector2 position, Vector2 velocity, GraphicsDevice graphics)
{
this.position = position;
this.velocity = velocity;
this.graphics = graphics;
this.bounds = new BoundingCircle(position - new Vector2(-60, -50), 50);
}
public static bool Collide(AABB Box1, BoundingCircle circle) //Collision detection between box and circle
{
float Radius = circle.Radius; //Set temp radius to be circle radius
Radius *= 0.5f; //Half it as this is the distance from centre to edge
MyVector3 Extent = new MyVector3(Radius, Radius, Radius); //Create vector 3 extent this is used as extents for a new box
AABB Box2; //Create Box 2 which is the circle
Box2 = new AABB(circle.CentrePoint - Extent, circle.CentrePoint + Extent); //Set box 2 extents, minum extent is circles postion - extent and maxium is circles postion + extent
Box2.Half = (Box2.MaxExtent - Box2.MinExtent) * 0.5f; //Set half extent by subtracting max extent by min extent and halfing the value
Box2.Centre = Box2.Half + Box2.MinExtent; //Set the centre by Adding Half to the min extent
if (Mathf.Abs(Box1.Centre.x - Box2.Centre.x) > (Box1.Half.x + Box2.Half.x)) //Gets the abs of Box 1 Centre x - Box 2 Centre x and checks if it is more then Box 1 Half x + Box 2 Half x
{
return(false);
}
if (Mathf.Abs(Box1.Centre.y - Box2.Centre.y) > (Box1.Half.y + Box2.Half.y)) //Gets the abs of Box 1 Centre y - Box 2 Centre y and checks if it is more then Box 1 Half y + Box 2 Half y
{
return(false);
}
if (Mathf.Abs(Box1.Centre.z - Box2.Centre.z) > (Box1.Half.z + Box2.Half.z))//Gets the abs of Box 1 Centre z - Box 2 Centre z and checks if it is more then Box 1 Half z + Box 2 Half z
{
return(false);
}
return(true);
}
public static bool Contains(this BoundingBox a, BoundingCircle b)
{
var deltaX = b.Position.X - Math.Max(a.Position.X, Math.Min(b.Position.X, a.Position.X + a.Width));
var deltaY = b.Position.Y - Math.Max(a.Position.Y, Math.Min(b.Position.Y, a.Position.Y + a.Height));
return((deltaX * deltaX + deltaY * deltaY) < (b.Radius * b.Radius));
}
public bool Collides(RigidBody other)
{
//circle vs circle collision
//return BoundingCircle.Collides(other.BoundingCircle);
if (BoundingCircle.Collides(other.BoundingCircle))
{
if (BoundingBox != null && other.BoundingBox != null)
{
//rect vs rect collision
return(BoundingBox.Collides(other.BoundingBox));
}
else
{
if (BoundingBox != null)
{
//rect vs circle
return(BoundingBox.Collides(other.BoundingCircle));
}
else if (other.BoundingBox != null)
{
return(other.BoundingBox.Collides(other.BoundingCircle));
}
else
{
//none has rect
return(true);
}
}
}
return(false);
}
void ParticleUpdate()
{
switch (collisionObject.Shape)
{
case CollisionShapes.Rectangle:
{
Rectangle rect = (Rectangle)collisionObject.Bounds;
rect.X = (int)particlePhysics.Position.X - rect.Width / 2;
rect.Y = (int)particlePhysics.Position.Y - rect.Height / 2;
collisionObject.SetBounds(rect);
}
break;
case CollisionShapes.Circle:
{
BoundingCircle circle = (BoundingCircle)collisionObject.Bounds;
Vector2 center = new Vector2(particlePhysics.Position.X,
particlePhysics.Position.Y);
circle.Center = center;
collisionObject.SetBounds(circle);
}
break;
}
}
public static bool Collide(BoundingCapsule capsule, BoundingCircle otherCircle)
{
float CombinedRadius = capsule.Radius + otherCircle.Radius;
float DistanceFromFloat = Mathf.Sqrt(VectorMaths.SqDistanceFromFloat(capsule.A, capsule.B, otherCircle.CentrePoint));
return(DistanceFromFloat <= CombinedRadius);
}
protected override float?OnCollides(Vector2 from, Vector2 to, float elapsedTime, Steerable movingEntity)
{
float detectorLength = movingEntity.BoundingRadius + movingEntity.Skin;
var boundingSphere = new BoundingSphere(new Vector3(movingEntity.Position, 0), detectorLength);
Neighbors.FindAll(ref boundingSphere, Partners);
foreach (var partner in Partners)
{
if (partner == null || partner == movingEntity)
{
continue;
}
BoundingCircle obstacle = new BoundingCircle(partner.Position, partner.BoundingRadius);
if (obstacle.Contains(new BoundingCircle(from, movingEntity.BoundingRadius)) != ContainmentType.Disjoint)
{
continue;
}
if (obstacle.Contains(new BoundingCircle(to, movingEntity.BoundingRadius)) == ContainmentType.Disjoint)
{
continue;
}
Partners.Clear();
return(0);
}
Partners.Clear();
return(null);
}
public static bool Collide(BoundingCircle circle, AABB Box1)
{
float Radius = circle.Radius;
Radius *= 0.5f;
MyVector3 Extent = new MyVector3(Radius, Radius, Radius);
AABB Box2;
Box2 = new AABB(circle.CentrePoint - Extent, circle.CentrePoint + Extent);
Box2.Half = (Box2.MaxExtent - Box2.MinExtent) * 0.5f;
Box2.Centre = Box2.Half + Box2.MinExtent;
if (Mathf.Abs(Box1.Centre.x - Box2.Centre.x) > (Box1.Half.x + Box2.Half.x))
{
return(false);
}
if (Mathf.Abs(Box1.Centre.y - Box2.Centre.y) > (Box1.Half.y + Box2.Half.y))
{
return(false);
}
if (Mathf.Abs(Box1.Centre.z - Box2.Centre.z) > (Box1.Half.z + Box2.Half.z))
{
return(false);
}
return(true);
}
// Update is called once per frame
void Update()
{
myTransformation Transformation = GetComponent <myTransformation>();
float CurRadius = float.MinValue;
float MinCurRadius = float.MaxValue;
if (Transformation.ModelMaxExtent.x > CurRadius)
{
CurRadius = Transformation.ModelMaxExtent.x;
}
if (Transformation.ModelMaxExtent.y > CurRadius)
{
CurRadius = Transformation.ModelMaxExtent.y;
}
if (Transformation.ModelMaxExtent.z > CurRadius)
{
CurRadius = Transformation.ModelMaxExtent.z;
}
if (Transformation.ModelMinExtent.x < MinCurRadius)
{
MinCurRadius = Transformation.ModelMinExtent.x;
}
if (Transformation.ModelMinExtent.y < MinCurRadius)
{
MinCurRadius = Transformation.ModelMinExtent.y;
}
if (Transformation.ModelMaxExtent.z < MinCurRadius)
{
MinCurRadius = Transformation.ModelMinExtent.z;
}
float BiggestScale = float.MinValue;
if (Transformation.Scale.x > BiggestScale)
{
BiggestScale = Transformation.Scale.x;
}
if (Transformation.Scale.y > BiggestScale)
{
BiggestScale = Transformation.Scale.y;
}
if (Transformation.Scale.z > BiggestScale)
{
BiggestScale = Transformation.Scale.z;
}
Radius = CurRadius - MinCurRadius;
Radius *= BiggestScale;
Transformation.BoundObject = new BoundingCircle(Transformation.Translation, Radius);
BoundingCircle Circle1 = Transformation.BoundObject as BoundingCircle;
CentrePoint = Circle1.CentrePoint;
Radius = Circle1.Radius;
}
/// <summary>
/// Creates new food sprites
/// </summary>
/// <param name="position">Position of the sprite</param>
public FoodSprite(Vector2 position)
{
System.Random rand = new System.Random();
this.position = position - new Vector2(20, 20);
this.bounds = new BoundingCircle(position + new Vector2(16, 16), 8);
this.Velocity = new Vector2(100, 100);
this.Acceleration = new Vector2(20, 20);
}
/// <summary>
/// Creates a new coin sprite
/// </summary>
/// <param name="position">The position of the sprite in the game</param>
public CoinSprite(Vector2 position, float width, float height)
{
this.position = position;
this.bounds = new BoundingCircle(position - new Vector2(-8, -8), 8);
velocity = new Vector2(10, 0);
windowWidth = width;
windowHeight = height;
}
public static bool Collide(BoundingCircle circle, BoundingCircle otherCircle)
{
MyVector3 VectorToOther = otherCircle.CentrePoint - circle.CentrePoint;
float CombinedRadiusSq = (otherCircle.Radius + circle.Radius);
CombinedRadiusSq *= CombinedRadiusSq;
return(MyVector3.LengthSquared(VectorToOther) <= CombinedRadiusSq);
}
public Football(FootballGame game)
{
this.game = game;
r = new Random();
this.Reset();
this.bounds = new BoundingCircle(Position, 16);
}
public void Update(GameTime gameTime)
{
float t = (float)gameTime.ElapsedGameTime.TotalSeconds;
Velocity += Acceleration * t;
position += Velocity * t;
this.bounds = new BoundingCircle(position + new Vector2(8, 8), 8);
}
private void DibujarBoundingObjects(Thing thing)
{
BoundingObject[] boundingObjects = (BoundingObject[])thing.CrearBoundingObjects().Clone();
for (int i = 0; i < boundingObjects.Length; i++)
{
boundingObjects[i] = boundingObjects[i].RotateAndTranslate(thing.RotacionEnGrados, thing.Centro);
}
foreach (BoundingObject bo in boundingObjects)
{
if (bo is BoundingCircle)
{
BoundingCircle boc = (BoundingCircle)bo;
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
Gl.glTranslatef(boc.Center.X, boc.Center.Y, GraphicEngine.zValue);
Gl.glBegin(Gl.GL_LINE_STRIP);
Gl.glVertex3f(0, 0, 0);
for (int i = 0; i <= 360; i += 30)
{
float degInRad = (float)(i * Math.PI / 180);
Gl.glVertex3f((float)Math.Cos(degInRad) * boc.Radius, (float)Math.Sin(degInRad) * boc.Radius, GraphicEngine.zValue);
}
Gl.glEnd();
Gl.glTranslatef(-boc.Center.X, -boc.Center.Y, -GraphicEngine.zValue);
Gl.glEnable(Gl.GL_TEXTURE_2D);
}
else if (bo is BoundingRectangle)
{
BoundingRectangle bor = (BoundingRectangle)bo;
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
Gl.glBegin(Gl.GL_LINE_STRIP);
for (int i = 0; i < 5; i++)
{
Gl.glVertex3f(bor.Puntos[i % 4].X, bor.Puntos[i % 4].Y, GraphicEngine.zValue);
}
Gl.glEnd();
Gl.glEnable(Gl.GL_TEXTURE_2D);
}
}
}
public void Init()
{
circle1 = new BoundingCircle(Vector2.UnitY, 2);
circle2 = new BoundingCircle(Vector2.UnitX, 2);
rect1 = BoundingRectangle.FromCircle(circle1);
circle3 = BoundingCircle.FromRectangle(rect1);
rect2 = BoundingRectangle.FromCircle(circle3);
polygon1 = new BoundingPolygon(rect1.Corners());
}
public void Update()
{
if (GravityAffection)
{
Velocity += new Vector2(0, PhysicsMgr.Gravity) * Game.window.deltaTime;
}
Position += Velocity * Game.window.deltaTime;
BoundingCircle.DebugCircleTranslate();
}
/// <summary>
/// Creates a new CollisionObject.
/// </summary>
/// <param name="id">The id of this CollidableRectangle.</param>
/// <param name="bounds">The bounding area of this CollidableRectangle.</param>
public CollisionObject(string id, BoundingCircle bounds)
{
this.bounds = bounds;
this.id = id;
shape = CollisionShapes.Circle;
BroadPhase.Add(this);
}
/// <summary>
/// Creates new obstacle sprite
/// </summary>
/// <param name="velocity">Initial velocity of obstacle</param>
/// <param name="position">Initial position of obstacle</param>
/// <param name="graphics">The graphics device</param>
public ObstacleSprite(Vector2 velocity, Vector2 position, GraphicsDevice graphics, Game game)
{
this.Velocity = velocity;
this.Position = position;
this.graphics = graphics;
this.bounds = new BoundingCircle(position + new Vector2(16, 16), 18);
fire = new FireParticleSystem(game, this);
game.Components.Add(fire);
}
public void IntersectsRectangle()
{
Assert.IsTrue(circle3.Intersects(rect1), "1");
Assert.IsTrue(circle2.Intersects(rect1), "2");
var c = new BoundingCircle(5, 5, 1);
Assert.IsFalse(c.Intersects(rect2), "1");
Assert.IsFalse(c.Intersects(rect2), "2");
}
public static bool Contains(this BoundingCircle a, BoundingCircle b)
{
var distanceX = a.Position.X - b.Position.X;
var distanceY = a.Position.Y - b.Position.Y;
var magnitudeSquared = distanceX * distanceX + distanceY * distanceY;
return(magnitudeSquared < (a.Radius + b.Radius) * (a.Radius + b.Radius));
}
public void Init()
{
circle1 = new BoundingCircle(Vector2D.YAxis, 2);
circle2 = new BoundingCircle(Vector2D.XAxis, 2);
rect1 = BoundingRectangle.FromCircle(circle1);
circle3 = BoundingCircle.FromRectangle(rect1);
rect2 = BoundingRectangle.FromCircle(circle3);
polygon1 = new BoundingPolygon(rect1.Corners());
}
/// <summary>
/// Detects if this BoundingRectangle is colliding with a BoundingCircle
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool CollidesWith(BoundingCircle other)
{
float nearestX = MathHelper.Clamp(other.Center.X, Position.X, Position.X + Size.X);
float nearestY = MathHelper.Clamp(other.Center.Y, Position.Y, Position.Y + Size.Y);
return(Math.Pow(other.Radius, 2) >=
Math.Pow(other.Center.X - nearestX, 2) +
Math.Pow(other.Center.Y - nearestY, 2));
}
void FixedUpdate()
{
ExplosionStrength = FindObjectOfType <ExplosionStrengthText>().slider.value; //Set Strength to be slider value
ExplosionRadius = FindObjectOfType <ExplosionRadiusText>().slider.value; //Set radius to be slider value
//THIS IS HOW YOU DO GRAVITY BUT OPPOSITE THIS REPELS THE OBJECTS
ExplosionBounds = new BoundingCircle(Transformation.Translation, ExplosionRadius); //Set bounds of explosion
Transformation = GetComponent <myTransformation>(); //Get Transformation component of object
BoundingCircle Bounds = new BoundingCircle(new MyVector3(0, 0, 0), ExplosionRadius); //Bounds Of explosion
Bounds = ExplosionBounds as BoundingCircle; //Set bounds to be xplosion bounds
Bounds.CentrePoint = Transformation.Translation; //Make sure centre point is position of expplosion
Object = FindObjectsOfType <MyPhysics>(); //Find all physic objects
for (int i = 0; i < Object.Length; i++)
{
if (Bounds.Intersects(Object[i].Transformation.BoundObject))
{
float Radius = float.MinValue; //Set radius to be minium value
if (Object[i].Transformation.BoundObject is AABB)
{
AABB Box1 = Object[i].Transformation.BoundObject as AABB; //Get the object collision box
if (Box1.MaxExtent.x > Radius)
{
Radius = Box1.MaxExtent.x; //Set radius to be max extent x
}
if (Box1.MaxExtent.y > Radius)
{
Radius = Box1.MaxExtent.y; //Set radius to be max extent y
}
if (Box1.MaxExtent.z > Radius)
{
Radius = Box1.MaxExtent.z; //Set radius to be max extent z
}
}
if (Object[i].Transformation.BoundObject is BoundingCircle)
{
BoundingCircle Sphere1 = Object[i].Transformation.BoundObject as BoundingCircle; //Get the object bounding sphere
Radius = Sphere1.Radius; //Set radius to be object radius
}
ExplosionForce = VectorMaths.VectorNormalized(Object[i].Transformation.Translation - Transformation.Translation) * ExplosionStrength; //Set force of explosion to be normalised of object postion - explosion position
Object[i].Force += ExplosionForce; //Increase object force by explosion force
CentreOfMass = Transformation.Translation; //SEt centre of mass to explosion point
Distance = Object[i].Transformation.Translation - Transformation.Translation; //Distance from object to explosion
Normalised = VectorMaths.VectorNormalized(Distance); //Normalised Distance
ImpactPoint = Normalised * Radius; //Set impact point to be normalised * radius
ExplosionTorque = VectorMaths.VectorCrossProduct(ExplosionForce, CentreOfMass - ImpactPoint); //Toorque os the cross product of explosion force and centre of mass - impact point
Object[i].torque += ExplosionTorque; //Torque is increaess by explosion torque
}
}
}
/// <summary>
/// Warps the coin to a random position on the game area and resets it's collected value
/// </summary>
public void Warp(float width, float height)
{
System.Random rand = new System.Random();
if (Collected)
{
this.position = new Vector2((float)rand.NextDouble() * width, (float)rand.NextDouble() * height);
this.bounds = new BoundingCircle(position - new Vector2(-8, -8), 8);
this.Collected = false;
}
}
public void ContainsPointWorks()
{
var circle = new BoundingCircle(Vector2d.Zero, 10)
{
Position = new Vector2d(10, 5)
};
Assert.False(circle.Contains(Vector2d.Zero));
Assert.True(circle.Contains(new Vector2d(3, 3)));
}
/// <summary>
/// Determine whether another bounding circle intersects with this one
/// </summary>
/// <param name="other">The other bounding circle to test against this bounding circle</param>
public bool Intersects(BoundingCircle other)
{
return Vector2.Distance(Center, other.Center) < Radius + other.Radius;
}
public void Intersects(ref BoundingCircle circle, out bool result)
{
result = false;
for (int index = 0; index < vertexes.Length; ++index)
{
int index2 = (index + 1) % vertexes.Length;
Scalar temp;
LineSegment.GetDistance(ref vertexes[index], ref vertexes[index2], ref circle.Position, out temp);
if (temp <= circle.Radius)
{
result = true;
break;
}
}
}
public bool Intersects(BoundingCircle circle)
{
bool result;
Intersects(ref circle, out result);
return result;
}
public void Contains(ref BoundingCircle circle, out ContainmentType result)
{
Scalar distance;
GetDistance(ref circle.Position, out distance);
distance += circle.Radius;
if (distance <= 0)
{
result = ContainmentType.Contains;
}
else if (distance <= circle.Radius)
{
result = ContainmentType.Intersects;
}
else
{
result = ContainmentType.Disjoint;
}
}
public ContainmentType Contains(BoundingCircle circle)
{
ContainmentType result;
Contains(ref circle, out result);
return result;
}
protected internal override void RunLogic(TimeStep step)
{
Scalar area = MathHelper.Pi * radius * radius;
Scalar density = explosionBody.Mass.Mass / area;
BoundingCircle circle = new BoundingCircle(explosionBody.State.Position.Linear, radius);
Matrix2x3 temp;
ALVector2D.ToMatrix2x3(ref explosionBody.State.Position, out temp);
Matrices matrices = new Matrices();
matrices.SetToWorld(ref temp);
Vector2D relativeVelocity = Vector2D.Zero;
Vector2D velocityDirection = Vector2D.Zero;
Vector2D dragDirection = Vector2D.Zero;
for (int index = 0; index < items.Count; ++index)
{
Wrapper wrapper = items[index];
Body body = wrapper.body;
Matrix2x3 matrix;
Matrix2x3.Multiply(ref matrices.ToBody, ref body.Matrices.ToWorld, out matrix);
ContainmentType containmentType;
BoundingRectangle rect = body.Rectangle;
circle.Contains(ref rect, out containmentType);
if (containmentType == ContainmentType.Intersects)
{
return;
GetTangentCallback callback = delegate(Vector2D centroid)
{
centroid = body.Matrices.ToWorld * centroid;
Vector2D p1 = centroid - explosionBody.State.Position.Linear;
Vector2D p2 = centroid - body.State.Position.Linear;
PhysicsHelper.GetRelativeVelocity(
ref explosionBody.State.Velocity,
ref body.State.Velocity,
ref p1,
ref p2,
out relativeVelocity);
relativeVelocity = p1.Normalized * this.pressurePulseSpeed;
relativeVelocity = -relativeVelocity;
velocityDirection = relativeVelocity.Normalized;
dragDirection = matrices.ToBodyNormal * velocityDirection.LeftHandNormal;
return dragDirection;
};
DragInfo dragInfo = wrapper.affectable.GetExplosionInfo(matrix, radius, callback);
if (dragInfo == null) { continue; }
if (velocityDirection == Vector2D.Zero) { continue; }
if (dragInfo.DragArea < .01f) { continue; }
Scalar speedSq = relativeVelocity.MagnitudeSq;
Scalar dragForceMag = -.5f * density * speedSq * dragInfo.DragArea * dragCoefficient;
Scalar maxDrag = -MathHelper.Sqrt(speedSq) * body.Mass.Mass * step.DtInv;
if (dragForceMag < maxDrag)
{
dragForceMag = maxDrag;
}
Vector2D dragForce = dragForceMag * velocityDirection;
wrapper.body.ApplyForce(dragForce, (body.Matrices.ToBody * matrices.ToWorld) * dragInfo.DragCenter);
}
else if (containmentType == ContainmentType.Contains)
{
Vector2D centroid = body.Matrices.ToWorld * wrapper.affectable.Centroid;
Vector2D p1 = centroid - explosionBody.State.Position.Linear;
Vector2D p2 = centroid - body.State.Position.Linear;
PhysicsHelper.GetRelativeVelocity(
ref explosionBody.State.Velocity,
ref body.State.Velocity,
ref p1,
ref p2,
out relativeVelocity);
relativeVelocity = p1.Normalized * this.pressurePulseSpeed;
relativeVelocity = -relativeVelocity;
velocityDirection = relativeVelocity.Normalized;
dragDirection = matrices.ToBodyNormal * velocityDirection.LeftHandNormal;
DragInfo dragInfo = wrapper.affectable.GetFluidInfo(dragDirection);
if (dragInfo.DragArea < .01f) { continue; }
Scalar speedSq = relativeVelocity.MagnitudeSq;
Scalar dragForceMag = -.5f * density * speedSq * dragInfo.DragArea * dragCoefficient;
Scalar maxDrag = -MathHelper.Sqrt(speedSq) * body.Mass.Mass * step.DtInv;
if (dragForceMag < maxDrag)
{
dragForceMag = maxDrag;
}
Vector2D dragForce = dragForceMag * velocityDirection;
wrapper.body.ApplyForce(dragForce, body.Matrices.ToWorldNormal * dragInfo.DragCenter);
wrapper.body.ApplyTorque(
-body.Mass.MomentOfInertia *
(body.Coefficients.DynamicFriction + density + dragCoefficient) *
body.State.Velocity.Angular);
}
}
}
bool IRaySegmentsCollidable.TryGetRayCollision(Body thisBody, Body raysBody, RaySegmentsShape raySegments, out RaySegmentIntersectionInfo info)
{
bool intersects = false;
RaySegment[] segments = raySegments.Segments;
Scalar[] result = new Scalar[segments.Length];
BoundingCircle bounding = new BoundingCircle(Vector2D.Zero, this.radius);
Matrix2x3 vertexM = thisBody.Matrices.ToBody * raysBody.Matrices.ToWorld;
for (int index = 0; index < segments.Length; ++index)
{
RaySegment segment = segments[index];
Ray ray2;
Vector2D.Transform(ref vertexM, ref segment.RayInstance.Origin, out ray2.Origin);
Vector2D.TransformNormal(ref vertexM, ref segment.RayInstance.Direction, out ray2.Direction);
Scalar temp;
bounding.Intersects(ref ray2, out temp);
if (temp >= 0 && temp <= segment.Length)
{
intersects = true;
result[index] = temp;
continue;
}
else
{
result[index] = -1;
}
}
if (intersects)
{
info = new RaySegmentIntersectionInfo(result);
}
else
{
info = null;
}
return intersects;
}
public void IntersectsRectangle()
{
Assert.IsTrue(circle3.Intersects(rect1), "1");
Assert.IsTrue(circle2.Intersects(rect1), "2");
BoundingCircle c = new BoundingCircle(5, 5, 1);
Assert.IsFalse(c.Intersects(rect2), "1");
Assert.IsFalse(c.Intersects(rect2), "2");
}
