public static void CircleCollider_IsHitByTest(
float cx, float cy, float r,
float rx, float ry, float directionX, float directionY, float distance,
bool shouldHit, float ix = 0f, float iy = 0f, float nx = 0f, float ny = 0f)
{
using (var circleBody = new DynamicBody()) {
circleBody.SetWorldPosition(new Vector2(cx, cy));
circleBody.Collider = new CircleCollider(r);
circleBody.Initialize(null);
var ray = new LineSegment(new Vector2(rx, ry), new Vector2(directionX, directionY), distance);
Assert.AreEqual(shouldHit, circleBody.Collider.IsHitBy(ray, out var hit));
if (shouldHit)
{
var normal = new Vector2(nx, ny);
var intersection = new Vector2(ix, iy);
Assert.AreEqual(normal.X, hit.Normal.X, 0.0001f);
Assert.AreEqual(normal.Y, hit.Normal.Y, 0.0001f);
Assert.AreEqual(intersection.X, hit.ContactPoint.X, 0.0001f);
Assert.AreEqual(intersection.Y, hit.ContactPoint.Y, 0.0001f);
Assert.AreEqual(circleBody.Collider, hit.Collider);
}
}
}
// Start is called before the first frame update
void Start()
{
dynamicBody = GetComponent <DynamicBody>();
DragManager.OnDragEnded += OnLaunch;
DragManager.OnDrag += OnPlanning;
}
public void ApplyCollision(IEventTriggerer eventTriggerer, DynamicBody body)
{
var perp = _line.Normal.Perpendicular();
var impulse = perp*-1.8*perp.Dot(body.Velocity); //TODO: requires mass;
body.State = new BodyState(body.Position, body.Velocity + impulse, false);
}
public DynamicBodyUnitEntity(Team team, DynamicBody body, float angle, RootEntity root) : base(team, body, angle, root)
{
AnimationComponent animation = new AnimationComponent(root);
GetComponent <BodyComponent>().SetAnimationComponent(animation);
AddComponent(animation);
}
public Vector2 CalculateForce(DynamicBody body)
{
var path = (_centre - body.Position);
if(path.Length < 10)
return Vector2.Zero;
return path.Normal*(_magnitude/10);
}
public static void PolygonCollider_ContainsPoint(float x1, float y1, float w, float h, float x2, float y2, bool shouldContain)
{
using (var quadBody = new DynamicBody()) {
quadBody.SetWorldPosition(new Vector2(x1, y1));
quadBody.Collider = PolygonCollider.CreateRectangle(w, h);
quadBody.Initialize(null);
Assert.AreEqual(shouldContain, quadBody.Collider.Contains(new Vector2(x2, y2)));
}
}
public void SwitchToLunging()
{
if (_movementDirection != Vector2.Zero)
{
DynamicBody.ApplyLinearImpulse(20.0f * Vector2.Normalize(_movementDirection));
CurrentState = State.Lunging;
PlayNewCharacterAnimation();
_lungeTime = 0;
}
}
private void MoveTowards(Vector2 to)
{
Vector2 v = to * MovementSpeed;
if (IsPlayerSucking())
{
v = to * MovementSpeed * Tweak.SUCK_SPEED_MULTIPLIER;
}
DynamicBody.ApplyForce(v);
}
public static void CircleCollider_ContainsPointTest(float x1, float y1, float r1, float x2, float y2, bool shouldContain)
{
using (var circleBody = new DynamicBody()) {
circleBody.SetWorldPosition(new Vector2(x1, y1));
circleBody.Collider = new CircleCollider(r1);
var circle = circleBody.Collider as CircleCollider;
circleBody.Initialize(null);
Assert.AreEqual(shouldContain, circle.Contains(new Vector2(x2, y2)));
}
}
public static void PolygonCollider_ContainsPolygon(float x1, float y1, float w1, float h1, float x2, float y2, float w2, float h2, bool shouldContain)
{
using (var quadBody1 = new DynamicBody())
using (var quadBody2 = new DynamicBody()) {
quadBody1.SetWorldPosition(new Vector2(x1, y1));
quadBody1.Collider = PolygonCollider.CreateRectangle(w1, w1);
quadBody1.Initialize(null);
quadBody2.SetWorldPosition(new Vector2(x2, y2));
quadBody2.Collider = PolygonCollider.CreateRectangle(w2, w2);
quadBody2.Initialize(null);
Assert.AreEqual(shouldContain, quadBody1.Collider.Contains(quadBody2.Collider));
}
}
public static void CircleCollider_ContainsCircleTest(float x1, float y1, float r1, float x2, float y2, float r2, bool shouldContain)
{
using (var circleBody1 = new DynamicBody())
using (var circleBody2 = new DynamicBody()) {
circleBody1.SetWorldPosition(new Vector2(x1, y1));
circleBody1.Collider = new CircleCollider(r1);
circleBody1.Initialize(null);
circleBody2.SetWorldPosition(new Vector2(x2, y2));
circleBody2.Collider = new CircleCollider(r2);
circleBody2.Initialize(null);
Assert.AreEqual(shouldContain, circleBody1.Collider.Contains(circleBody2.Collider));
}
}
public static void CircleCollider_ContainsQuadTest(float x1, float y1, float r1, float x2, float y2, float w, float h, bool shouldContain)
{
using (var circleBody = new DynamicBody())
using (var quadBody = new DynamicBody()) {
circleBody.SetWorldPosition(new Vector2(x1, y1));
circleBody.Collider = new CircleCollider(r1);
circleBody.Initialize(null);
quadBody.SetWorldPosition(new Vector2(x2, y2));
quadBody.Collider = PolygonCollider.CreateRectangle(w, h);
quadBody.Initialize(null);
Assert.AreEqual(shouldContain, circleBody.Collider.Contains(quadBody.Collider));
}
}
public GameEntryPoint()
{
var graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
_world = new WorldGrid(new AspectStorageContainer());
_player = new Character
{
Position = new Vector2(10, 10)
};
_physics = new GridBasedPhysicsEngine(_world);
_playerBody = new DynamicBody();
}
public void HandleKeyboardInput()
{
_movementDirection = Vector2.Zero;
if (Input.ButtonJustDownMapped((int)Controls.Select))
{
CurrentWeapon = CurrentWeapon == Weapon.Melee ? Weapon.Pistol : Weapon.Melee;
SwitchToIdleOrMoving(CurrentState);
}
switch (CurrentState)
{
case State.Idle:
case State.Run:
{
if (Input.ButtonDownMapped((int)Controls.Attack1))
{
SwitchToAttacking();
break;
}
_movementDirection = GetFacingDirectionFromControls();
if (_movementDirection != Vector2.Zero)
{
_sensorRotation = MathHelper.ToDegrees((float)Math.Atan2(_movementDirection.Y, _movementDirection.X) - MathHelper.PiOver2);
_movementDirection.Normalize();
DynamicBody.ApplyForce(_movementDirection * MOVEMENT_FORCE);
}
break;
}
case State.Attack:
{
if (Input.ButtonDownMapped((int)Controls.Attack1))
{
SuckIn();
}
else
{
SwitchToMoving();
}
break;
}
}
}
public void HandleKeyboardInput()
{
_movementDirection = Vector2.Zero;
switch (CurrentState)
{
case State.Eating:
break;
case State.Idle:
case State.Moving:
{
if (Input.ButtonDownMapped((int)Controls.Suck))
{
SwitchToSucking();
SuckIn();
break;
}
_movementDirection = GetFacingDirectionFromControls();
if (_movementDirection != Vector2.Zero)
{
_sensorRotation = MathHelper.ToDegrees((float)Math.Atan2(_movementDirection.Y, _movementDirection.X) - MathHelper.PiOver2);
_movementDirection.Normalize();
DynamicBody.ApplyForce(_movementDirection * MOVEMENT_FORCE);
}
break;
}
case State.Sucking:
{
if (Input.ButtonDownMapped((int)Controls.Suck))
{
SuckIn();
}
else
{
SwitchToMoving();
}
break;
}
}
}
public static void PolyGonCollider_QuadIsHitByTest(float qx, float qy, float qw, float qh, float rx, float ry, float directionX, float directionY, float distance, bool shouldHit, float ix = 0f, float iy = 0f, float nx = 0f, float ny = 0f)
{
using (var quadBody = new DynamicBody()) {
quadBody.SetWorldPosition(new Vector2(qx, qy));
quadBody.Collider = PolygonCollider.CreateRectangle(qw, qh);
quadBody.Initialize(null);
var ray = new LineSegment(new Vector2(rx, ry), new Vector2(directionX, directionY), distance);
Assert.AreEqual(shouldHit, quadBody.Collider.IsHitBy(ray, out var hit));
if (shouldHit)
{
var normal = new Vector2(nx, ny);
var intersection = new Vector2(ix, iy);
Assert.AreEqual(normal, hit.Normal);
Assert.AreEqual(intersection, hit.ContactPoint);
Assert.AreEqual(quadBody.Collider, hit.Collider);
}
}
}
public static void RectangleCollider_RectangleCollidesWithRectangleTest(float x1, float y1, float w1, float h1, float x2, float y2, float w2, float h2, bool collisionOccured)
{
using (var rectangleBody1 = new DynamicBody())
using (var rectangleBody2 = new DynamicBody()) {
rectangleBody1.SetWorldPosition(new Vector2(x1, y1));
rectangleBody1.Collider = new RectangleCollider(w1, h2);
rectangleBody1.Initialize(null);
rectangleBody2.SetWorldPosition(new Vector2(x2, y2));
rectangleBody2.Collider = new RectangleCollider(w2, h2);
rectangleBody2.Initialize(null);
Assert.AreEqual(collisionOccured, rectangleBody1.Collider.CollidesWith(rectangleBody2.Collider, out var collision1));
Assert.AreEqual(collisionOccured, rectangleBody2.Collider.CollidesWith(rectangleBody1.Collider, out var collision2));
if (collisionOccured)
{
Assert.AreEqual(collision1.MinimumTranslationVector.Length(), collision2.MinimumTranslationVector.Length(), 0.0001f);
Assert.AreEqual(collision1.FirstCollider, collision2.SecondCollider);
Assert.AreEqual(collision1.SecondCollider, collision2.FirstCollider);
Assert.AreEqual(collision1.FirstContainsSecond, collision2.SecondContainsFirst);
Assert.AreEqual(collision1.SecondContainsFirst, collision2.FirstContainsSecond);
var originalPosition = rectangleBody1.WorldTransform.Position;
rectangleBody1.SetWorldPosition(originalPosition + collision1.MinimumTranslationVector);
Assert.False(rectangleBody1.Collider.CollidesWith(rectangleBody2.Collider, out collision1));
rectangleBody1.SetWorldPosition(originalPosition);
rectangleBody2.SetWorldPosition(rectangleBody2.WorldTransform.Position + collision2.MinimumTranslationVector);
Assert.False(rectangleBody2.Collider.CollidesWith(rectangleBody1.Collider, out collision2));
}
else
{
Assert.Null(collision1);
Assert.Null(collision2);
}
}
}
public static void CircleCollider_CollidesWithQuadTest(float x1, float y1, float r1, float x2, float y2, float w, float h, bool collisionOccured)
{
using (var circleBody = new DynamicBody())
using (var quadBody = new DynamicBody()) {
circleBody.SetWorldPosition(new Vector2(x1, y1));
circleBody.Collider = new CircleCollider(r1);
circleBody.Initialize(null);
quadBody.SetWorldPosition(new Vector2(x2, y2));
quadBody.Collider = PolygonCollider.CreateRectangle(w, h);
quadBody.Initialize(null);
Assert.AreEqual(collisionOccured, circleBody.Collider.CollidesWith(quadBody.Collider, out var collision1));
Assert.AreEqual(collisionOccured, quadBody.Collider.CollidesWith(circleBody.Collider, out var collision2));
if (collisionOccured)
{
Assert.AreEqual(collision1.MinimumTranslationVector.Length(), collision2.MinimumTranslationVector.Length(), 0.0001f);
Assert.AreEqual(collision1.FirstCollider, collision2.SecondCollider);
Assert.AreEqual(collision1.SecondCollider, collision2.FirstCollider);
Assert.AreEqual(collision1.FirstContainsSecond, collision2.SecondContainsFirst);
Assert.AreEqual(collision1.SecondContainsFirst, collision2.FirstContainsSecond);
var originalPosition = circleBody.WorldTransform.Position;
circleBody.SetWorldPosition(originalPosition + collision1.MinimumTranslationVector);
Assert.False(circleBody.Collider.CollidesWith(quadBody.Collider, out collision1));
circleBody.SetWorldPosition(originalPosition);
quadBody.SetWorldPosition(quadBody.WorldTransform.Position + collision2.MinimumTranslationVector);
Assert.False(quadBody.Collider.CollidesWith(circleBody.Collider, out collision2));
}
else
{
Assert.Null(collision1);
Assert.Null(collision2);
}
}
}
public static void LineCollider_IsHitByTest(
float x1, float y1, float x2, float y2,
float rx1, float ry1, float rx2, float ry2,
bool shouldHit, float ix = 0f, float iy = 0f, float nx = 0f, float ny = 0f)
{
using (var lineBody = new DynamicBody()) {
lineBody.Collider = new LineCollider(new Vector2(x1, y1), new Vector2(x2, y2));
lineBody.Initialize(null);
var ray = new LineSegment(new Vector2(rx1, ry1), new Vector2(rx2, ry2));
Assert.AreEqual(shouldHit, lineBody.Collider.IsHitBy(ray, out var hit));
if (shouldHit)
{
var normal = new Vector2(nx, ny);
var intersection = new Vector2(ix, iy);
Assert.AreEqual(normal, hit.Normal);
Assert.AreEqual(intersection, hit.ContactPoint);
Assert.AreEqual(lineBody.Collider, hit.Collider);
}
}
}
protected override void Update(GameTime gameTime)
{
lastGameTime = gameTime;
lastDT = (float)lastGameTime.ElapsedGameTime.TotalSeconds;
// update our input
OnBeforeInputUpdate?.Invoke();
Input.Update();
// update the UI
UI.UpdateUI();
// update our game logic
OnBeforeLogicUpdate?.Invoke();
Behavior.UpdateAllBehaviorSystems();
// update physics stuff
OnBeforePhysicsUpdate?.Invoke();
Physics.World.Step(lastDT);
DynamicBody.UpdateAllBodies();
OnEndUpdate?.Invoke();
base.Update(gameTime);
}
private void MoveTowards(Vector2 to)
{
Vector2 v = to * MovementSpeed;
DynamicBody.ApplyForce(v);
}
void OnEnable()
{
boxDetection = serializedObject.targetObject as DynamicBody;
}
public DynamicResponse(DynamicBody body) => Body = body;
protected override void Initialize()
{
this._body = this.Parent as DynamicBody;
}
public Vector2 CalculateForce(DynamicBody body)
{
return _force;
}
void AddGameObject(AddGameObjectRequest
message)
{
var dynamicBody = new DynamicBody();
message.GameObject.Body = dynamicBody;
_physicsObjects.Add(new PhysicsObject(message.GameObject, dynamicBody));
_eventTriggerer.Trigger(new GameObjectAdded(message.GameObject));
}
public bool IsCollision(DynamicBody body, BodyState startState, BodyState endState)
{
var perp = _line.Normal.Perpendicular();
var barrierDistance = perp.Dot(_leftPoint);
var startDistance = perp.Dot(startState.Position) - barrierDistance;
var endDistance = perp.Dot(endState.Position) - barrierDistance;
if (Math.Sign(startDistance) != Math.Sign(endDistance)) {
var path = new Line(startState.Position, endState.Position);
var pathPerp = path.Normal.Perpendicular();
var ballDistance = pathPerp.Dot(startState.Position);
var leftDistance = pathPerp.Dot(_leftPoint);
var rightDistance = pathPerp.Dot(_rightPoint);
if (leftDistance <= ballDistance && ballDistance <= rightDistance)
return true;
}
return false;
}
ICollision CalculateCollision(IBarrier barrier, DynamicBody body, TimeSpan start, TimeSpan end, int depth)
{
var startState = CalculateState(body, start);
var endState = CalculateState(body, end);
if (barrier.IsCollision(body, startState, endState)) {
if (++depth == MaxCollisionDepth)
return new Collision(start, barrier, body);
var middle = TimeSpan.FromSeconds((start + end).TotalSeconds/2.0);
var firstHalfCollision = CalculateCollision(barrier, body, start, middle, depth);
if (firstHalfCollision != null)
return firstHalfCollision;
var secondHalfCollision = CalculateCollision(barrier, body, middle, end, depth);
return secondHalfCollision;
}
return null;
}
public Collision(TimeSpan collisionTime, IBarrier barrier, DynamicBody body)
{
CollisionTime = collisionTime;
Barrier = barrier;
Body = body;
}
BodyState CalculateState(DynamicBody body, TimeSpan elapsed)
{
var position = body.Position + body.Velocity*elapsed.TotalSeconds;
var velocityResult = CalculateVelocity(body, elapsed);
return new BodyState(
position,
velocityResult.Velocity,
velocityResult.IsInRest
);
}
VelocityResult CalculateVelocity(DynamicBody body, TimeSpan elapsed)
{
var impulse = body.Forces.Aggregate(Vector2.Zero,
(current, force) =>
current + force.CalculateForce(body))
*elapsed.TotalSeconds; //TODO: requires mass;
var velocityBeforeResistance = body.Velocity + impulse;
var resistiveImpulse = body.ResistiveForces.Aggregate(Vector2.Zero,
(c, f) =>
c +
f.CalculateForce(body))
*elapsed.TotalSeconds;
var velocity = new Vector2(
AddStickingToZero(velocityBeforeResistance.X, resistiveImpulse.X),
AddStickingToZero(velocityBeforeResistance.Y, resistiveImpulse.Y));
var isInRest = (velocity == Vector2.Zero && resistiveImpulse.Length > impulse.Length);
return new VelocityResult(velocity, isInRest);
}
protected override void LoadContent()
{
base.LoadContent();
var scene = new Scene();
var camera = new Camera();
scene.AddChild(camera);
var physicsModule = scene.AddModule <PhysicsModule>(1f / 60f);
physicsModule.Gravity = new Gravity(new Vector2(0f, -9f));
var circleBody = new DynamicBody();
circleBody.LocalPosition -= new Vector2(0f, 3f);
circleBody.IsKinematic = true;
circleBody.Mass = 3f;
var circleCollider = new CircleCollider(0.75f);
circleBody.Collider = circleCollider;
var circleDrawer = new ColliderDrawer();
circleBody.AddChild(circleDrawer);
circleDrawer.Color = Color.Green;
circleDrawer.LineThickness = 2f;
circleBody.AddChild(new VelocityChanger());
scene.AddChild(circleBody);
for (var y = 0; y < 1; y++)
{
for (var x = 0; x < 1; x++)
{
var smallCircleBody = new DynamicBody {
Name = $"small circle {x}"
};
smallCircleBody.LocalPosition -= new Vector2(-3 + x, -1f + y);
smallCircleBody.IsKinematic = true;
smallCircleBody.Mass = 1f;
var smallCircleCollider = new CircleCollider(0.3f);
smallCircleBody.Collider = smallCircleCollider;
smallCircleBody.PhysicsMaterial = new PhysicsMaterial(1f, 0f);
var smallCircleDrawer = new ColliderDrawer();
smallCircleBody.AddChild(smallCircleDrawer);
smallCircleDrawer.Color = Color.OrangeRed;
smallCircleDrawer.LineThickness = 1f;
scene.AddChild(smallCircleBody);
}
}
var rectangleBody = new Body();
rectangleBody.Collider = PolygonCollider.CreateRectangle(10f, 1f);
rectangleBody.PhysicsMaterial = new PhysicsMaterial(0.5f, 1f);
rectangleBody.LocalPosition -= new Vector2(0f, 4f);
var rectangleDrawer = new ColliderDrawer();
rectangleBody.AddChild(rectangleDrawer);
rectangleDrawer.Color = Color.White;
rectangleDrawer.LineThickness = 1f;
scene.AddChild(rectangleBody);
var angleBody1 = new Body();
angleBody1.Collider = new LineCollider(new Vector2(-8f, 4f), new Vector2(-5f, -3.5f));
angleBody1.PhysicsMaterial = new PhysicsMaterial(0.5f, 1f);
var angleDrawer1 = new ColliderDrawer();
angleBody1.AddChild(angleDrawer1);
angleDrawer1.Color = Color.White;
angleDrawer1.LineThickness = 1f;
scene.AddChild(angleBody1);
var angleBody2 = new Body();
angleBody2.Collider = new LineCollider(new Vector2(8f, 4f), new Vector2(5f, -3.5f));
angleBody2.PhysicsMaterial = new PhysicsMaterial(0.5f, 1f);
var angleDrawer2 = new ColliderDrawer();
angleBody2.AddChild(angleDrawer2);
angleDrawer2.Color = Color.White;
angleDrawer2.LineThickness = 1f;
scene.AddChild(angleBody2);
var lineBody = new Body();
lineBody.Collider = new LineCollider(new Vector2(-8f, 4f), new Vector2(8f, 4f));
lineBody.PhysicsMaterial = new PhysicsMaterial(0.5f, 1f);
var lineDrawer = new ColliderDrawer();
lineBody.AddChild(lineDrawer);
lineDrawer.Color = Color.White;
lineDrawer.LineThickness = 1f;
scene.AddChild(lineBody);
scene.SaveToFile(@"TestGame - CurrentLevel.json", new Serializer());
this.CurrentScene = new Serializer().Deserialize <Scene>(@"TestGame - CurrentLevel.json");
}
public ChampionEntity(uint peerID, Team team, DynamicBody body, float angle, RootEntity root) : base(team, body, angle, root)
{
PeerID = peerID;
}
