private bool BoundingBoxesOverlap(CobaltEntity e1, CobaltEntity e2)
{
var p1 = e1.Get <PositionComponent>();
var s1 = e1.Get <SpriteComponent>();
var p2 = e2.Get <PositionComponent>();
var s2 = e2.Get <SpriteComponent>();
var r1Left = p1.X;
var r1Right = p1.X + s1.Rectangle.Width;
var r1Top = p1.Y;
var r1Bottom = p1.Y + s1.Rectangle.Height;
var r2Left = p2.X;
var r2Right = p2.X + s2.Rectangle.Width;
var r2Top = p2.Y;
var r2Bottom = p2.Y + s2.Rectangle.Height;
// AABB. Adapted from: https://gamedev.stackexchange.com/a/913
return(!(r2Left > r1Right ||
r2Right < r1Left ||
r2Top > r1Bottom ||
r2Bottom < r1Top));
}
public void MoveToKeyboardOverridesExistingKeyboardComponent()
{
// The only way to test this is to change the velocity and see if the new velocity number is used
// Set velocity to 100, press D, wait one second; we should move 100px to the right.
var expectedVelocity = 100;
var entity = new CobaltEntity();
entity.MoveToKeyboard(1);
entity.MoveToKeyboard(expectedVelocity);
KeyboardSystem.GenerateKeysCallback(() =>
{
// Press D to move X positively
return(new Keys[] { Keys.D });
});
// Simulate keypress
var keyboardSystem = new KeyboardSystem();
keyboardSystem.Add(entity);
keyboardSystem.Update(1);
var velocitySystem = new VelocitySystem();
velocitySystem.Add(entity);
velocitySystem.Update(1);
Assert.That(entity.Get <PositionComponent>().X, Is.EqualTo(expectedVelocity));
}
public void GetGetsSetComponent()
{
var entity = new CobaltEntity();
var expected = new PositionComponent(1, 2);
entity.Set(expected);
Assert.That(entity.Get <PositionComponent>(), Is.EqualTo(expected));
}
public void Add(CobaltEntity entity)
{
this.entities.Add(entity);
foreach (var system in this.systems)
{
system.Add(entity);
}
}
public void HasReturnsTrueForSetComponents()
{
var entity = new CobaltEntity();
Assert.That(entity.Has <PositionComponent>(), Is.True);
Assert.That(entity.Has <StringComponent>(), Is.False);
Assert.That(entity.Has(typeof(PositionComponent)), Is.True);
Assert.That(entity.Has(typeof(StringComponent)), Is.False);
}
public void MoveToKeyboardSetsKeyboardComponent()
{
var entity = new CobaltEntity();
entity.MoveToKeyboard(100);
var actual = entity.Get <KeyboardComponent>();
Assert.That(actual, Is.Not.Null);
}
public void SetOverwritesPreviousComponentOfThatType()
{
var entity = new CobaltEntity();
var expected = new PositionComponent(1, 2);
entity.Set(new PositionComponent(9, 9));
entity.Set(expected);
Assert.That(entity.Get <PositionComponent>(), Is.EqualTo(expected));
}
public void ConstructorAddsZeroValuePositionComponent()
{
var entity = new CobaltEntity();
Assert.IsTrue(entity.Has <PositionComponent>());
var actual = entity.Get <PositionComponent>();
Assert.That(actual.X, Is.EqualTo(0));
Assert.That(actual.Y, Is.EqualTo(0));
}
protected override void OnAdd(CobaltEntity entity)
{
base.OnAdd(entity);
var collisionComponent = entity.Get <CollisionComponent>();
if (collisionComponent.OnCollide != null)
{
this.collisionComponentsWithCallbacks.Add(collisionComponent);
}
}
public void AddAddsEntitiesWithRequiredComponents()
{
var system = new TestableSystem(new Type[] { typeof(VelocityComponent) });
var expected = new CobaltEntity().Velocity(1, -1);
system.Add(new CobaltEntity());
system.Add(expected);
Assert.That(system.Entities.Count, Is.EqualTo(1));
Assert.That(system.Entities.Single(), Is.EqualTo(expected));
}
public void MoveToKeyboardAddsVelocityComponentWithWASDCallbacksIfOneDoesntExist()
{
var entity = new CobaltEntity();
entity.MoveToKeyboard(10);
Assert.That(entity.Has <VelocityComponent>());
var actual = entity.Get <VelocityComponent>();
Assert.That(actual.X, Is.EqualTo(0));
Assert.That(actual.Y, Is.EqualTo(0));
}
public void VelocityAddsVelocityComponent()
{
var entity = new CobaltEntity();
var expected = new VelocityComponent(11, 22);
entity.Velocity(expected.X, expected.Y);
var actual = entity.Get <VelocityComponent>();
Assert.That(actual.X, Is.EqualTo(expected.X));
Assert.That(actual.Y, Is.EqualTo(expected.Y));
}
public void Add(CobaltEntity entity)
{
foreach (var type in this.requiredComponents)
{
if (!entity.Has(type))
{
return;
}
}
this.Entities.Add(entity);
this.OnAdd(entity);
}
public void MoveToKeyboardAddsPositionComponentIfOneDoesntExist()
{
var entity = new CobaltEntity();
entity.MoveToKeyboard(10);
Assert.That(entity.Has <PositionComponent>());
var actual = entity.Get <PositionComponent>();
Assert.That(actual.X, Is.EqualTo(0));
Assert.That(actual.Y, Is.EqualTo(0));
}
public void MoveSetsPositionComponent()
{
var entity = new CobaltEntity();
var expected = new PositionComponent(171, 201);
entity.Move(expected.X, expected.Y);
var actual = entity.Get <PositionComponent>();
// They're value types, they're two separate instances.
Assert.That(actual.X, Is.EqualTo(expected.X));
Assert.That(actual.Y, Is.EqualTo(expected.Y));
}
public void MoveToKeyboardDoesntOverrideExistingPositionComponent()
{
var expectedX = 100;
var expectedY = 200;
var entity = new CobaltEntity().Move(expectedX, expectedY);
entity.MoveToKeyboard(10);
var actual = entity.Get <PositionComponent>();
Assert.That(actual.X, Is.EqualTo(expectedX));
Assert.That(actual.Y, Is.EqualTo(expectedY));
}
public LocationMapState() : base()
{
this.currentMap = new StaticMap(TmxMapDeserializer.Deserialize("Content/Maps/town.tmx"));
// Create one entity per tile
for (var i = 0; i < this.currentMap.Tiles.Length; i++)
{
var sourceTile = this.currentMap.Tiles[i];
this.Add(new CobaltEntity()
.Tile(this.currentMap.Tileset,
sourceTile.SourceTileX, sourceTile.SourceTileY, this.currentMap.TileWidth, this.currentMap.TileHeight)
.Move(sourceTile.X, sourceTile.Y));
}
this.player = new CobaltEntity().Sprite("Content/Images/Player.png")
.MoveToKeyboard(100)
.Move( // Locate just two tiles above the exit.
this.currentMap.ExitLocationX, this.currentMap.ExitLocationY - 2 * this.currentMap.TileHeight);
this.Add(this.player);
}
public void EntitiesRequirePositionSpriteAndCollisionComponents()
{
var e = new CobaltEntity();
var system = new CollisionSystem();
system.Add(e);
Assert.That(!system.Entities.Any());
// Position component is there by default
e.Set(new SpriteComponent(32, 16));
system.Add(e);
Assert.That(!system.Entities.Any());
e.Set(new CollisionComponent("Player"));
system.Add(e);
Assert.That(system.Entities.Single(), Is.EqualTo(e));
system = new CollisionSystem();
e.Set(new CollisionComponent("Player", "Wall", (p, w) => { }));
system.Add(e);
Assert.That(system.Entities.Single(), Is.EqualTo(e));
}
public void UpdateUpdatesPositionRelativeToElapsedTime()
{
var vX = 17;
var vY = -19;
var velocity = new VelocityComponent(vX, vY);
var pX = 400;
var pY = 128;
var position = new PositionComponent(pX, pY);
var elapsed = 0.7f;
var e = new CobaltEntity();
e.Set(velocity);
e.Set(position);
var system = new VelocitySystem();
system.Add(e);
system.Update(elapsed);
Assert.That(position.X, Is.EqualTo(pX + (elapsed * vX)));
Assert.That(position.Y, Is.EqualTo(pY + (elapsed * vY)));
}
public WorldMapState() : base()
{
this.world = World.Instance;
var worldMap = world.WorldMap;
// Create one entity per tile
for (var i = 0; i < worldMap.Tiles.Length; i++)
{
var sourceTile = worldMap.Tiles[i];
this.Add(new CobaltEntity()
.Tile(worldMap.Tileset,
sourceTile.SourceTileX, sourceTile.SourceTileY, WorldMap.TileWidth, WorldMap.TileHeight)
.Move(sourceTile.X, sourceTile.Y));
}
var player = new CobaltEntity("remove me").Sprite("Content/Images/Player.png")
.MoveToKeyboard(100)
.Move(world.WorldMap.StartingPosition.Item1, world.WorldMap.StartingPosition.Item2);
this.Add(player);
Console.WriteLine($"Moved player to {player.Get<PositionComponent>().AsVector2}");
}
public void UpdateCallsOnCollideWhenCollisionComponentIsSetAndBoundingBoxesOverlap()
{
// Move them so that they overlap, and test.
var wall = new CobaltEntity();
wall.Move(0, 0);
wall.Set(new CollisionComponent("Wall"));
wall.Set(new SpriteComponent(100, 16));
var player = new CobaltEntity();
player.Move(50, 10); // X/Y overlaps wall
player.Set(new SpriteComponent(32, 32));
var wasCallbackCalled = false;
player.Set(new CollisionComponent("Player", "Wall", (p, w) => wasCallbackCalled = true));
var system = new CollisionSystem();
system.Add(wall);
system.Add(player);
Assert.That(system.Entities.Count == 2, "System doesn't have the player and wall entities.");
system.Update(0.1f);
Assert.That(wasCallbackCalled, Is.True);
// Move them so that they don't overlap, and re-test that it didn't trigger the collision resolution action
wasCallbackCalled = false;
player.Move(999, 888);
system.Update(0.1f);
Assert.That(wasCallbackCalled, Is.False);
}
/// <summary>
/// Callback that you can override if you need a system to know when an entity was added.
/// By default, doesn't do anything. For a use-case, see the collision system.
/// </summary>
protected virtual void OnAdd(CobaltEntity entity)
{
}
public void Add(CobaltEntity entity)
{
}
