public override void ComponentLoaded(Entity e, Component c, JObject o)
{
// Do custom handling of the component
switch (c.GetType().Name)
{
case "DrawableComponent":
DrawableComponent drawable = (DrawableComponent)c;
drawable.Drawables.Clear();
if (o["Sources"] != null)
{
IEnumerable <string> sources = o["Sources"].Values <string>();
foreach (string str in sources)
{
GameDrawable d = (GameDrawable)Library[str];
drawable.Add(d.Layer, d);
}
}
if (o["Drawables"] != null)
{
DrawableComponent dd = JsonConvert.DeserializeObject <DrawableComponent>(o.ToString(), new DrawableConverter());
foreach (KeyValuePair <string, List <GameDrawable> > kvp in dd.Drawables)
{
foreach (GameDrawable d in kvp.Value)
{
drawable.Add(kvp.Key, d);
}
}
}
break;
case "FoundationComponent":
FoundationComponent floor = (FoundationComponent)c;
switch (floor.PlanType)
{
case "Fill":
Point start = floor.Plan[0].Offset;
Point end = floor.Plan[1].Offset;
floor.Plan.Clear(); // clear the plan, the for loops will fill it
for (int xx = start.X; xx <= end.X; xx++)
{
for (int yy = start.Y; yy <= end.Y; yy++)
{
floor.Plan.Add(new LocationValue()
{
Offset = new Point(xx, yy)
});
}
}
break;
}
break;
}
}
public override void Update(double dt)
{
if (delayCountdown > 0)
{
delayCountdown -= dt;
}
if (string.IsNullOrWhiteSpace(selectedCategory) || selectedEntityIndex == -1)
{
return;
}
if (isDragging)
{
UpdateDraggables();
}
else
{
DrawableComponent drawable = dataTracker.Get <DrawableComponent>();
PositionComponent drawablePosition = dataTracker.Get <PositionComponent>();
Entity selectedEntity = indexedBuildables[selectedCategory][selectedEntityIndex];
BuildableComponent selectedBuildable = selectedEntity.Get <BuildableComponent>();
FoundationComponent foundation = selectedEntity.Get <FoundationComponent>();
// pick out the tile index that the screen coords intersect
Point index = GetMouseIndex();
// translate the index into a screen position and up the position component
Vector2 dPositiion = World.Map.GetPositionFromIndex(index.X, index.Y);
drawablePosition.X = dPositiion.X;
drawablePosition.Y = dPositiion.Y;
bool spaceTaken = false;
foreach (LocationValue lv in foundation.Plan)
{
if (World.Foundations.SpaceTaken.ContainsKey(new Point(index.X + lv.Offset.X, index.Y + lv.Offset.Y)))
{
spaceTaken = true;
break;
}
}
bool visible = World.Map.IsValidIndex(index.X, index.Y);
foreach (List <GameDrawable> d in drawable.Drawables.Values)
{
foreach (GameDrawable gd in d)
{
gd.Visible = visible;
gd.Alpha = (spaceTaken) ? 0.5f : 0.85f;
}
}
}
}
public void FromCenterPoint_AddsCorrectHardpointGrid()
{
var foundation = FoundationComponent.AtCenterPoint(new Hardpoint(0, 0, 0));
Assert.AreEqual(9, foundation.Position.Hardpoints.Count);
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(-1, -1, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(-1, 0, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(-1, 1, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(0, -1, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(0, 0, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(0, 1, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(1, -1, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(1, 0, 0)));
Assert.IsTrue(foundation.Position.Hardpoints.Contains(new Hardpoint(1, 1, 0)));
}
// called when the selected entity changes
private void SelectEntity()
{
List <string> categories = new List <string>(indexedBuildables.Keys);
DrawableComponent drawable = dataTracker.Get <DrawableComponent>();
Entity selectedEntity = indexedBuildables[selectedCategory][selectedEntityIndex];
BuildableComponent selectedBuildable = selectedEntity.Get <BuildableComponent>();
DrawableComponent selectedDrawable = selectedEntity.Get <DrawableComponent>();
FoundationComponent foundation = selectedEntity.Get <FoundationComponent>();
drawable.Drawables.Clear();
foreach (KeyValuePair <string, List <GameDrawable> > kvp in selectedDrawable.Drawables)
{
foreach (GameDrawable gd in kvp.Value)
{
GameDrawable nd = Serialization.DeepCopy <GameDrawable>(gd);
drawable.Add(kvp.Key, nd);
}
}
}
public void CalculateBoundingBox_UnsortedInput_CalculatesCorrectSize()
{
var foundation = FoundationComponent.AtCenterPoint(new Hardpoint(0, 0, 0));
var testHardpoints = new Hardpoint[]
{
new Hardpoint(-1, -1, 0),
new Hardpoint(-1, 0, 0),
new Hardpoint(-1, 1, 0),
new Hardpoint(0, -1, 0),
new Hardpoint(0, 0, 0),
new Hardpoint(0, 1, 0),
new Hardpoint(1, -1, 0),
new Hardpoint(1, 0, 0),
new Hardpoint(1, 1, 0)
};
var actual = foundation.CalculateBoundingBox(new Position(testHardpoints));
Assert.AreEqual(2, actual.Width, .00001);
Assert.AreEqual(2, actual.Height, .00001);
}
public void CalculateBoundingBox_SortedInput_CalculatesCorrectCorner()
{
var foundation = FoundationComponent.AtCenterPoint(new Hardpoint(0, 0, 0));
var testHardpoints = new[]
{
new Hardpoint(-1, -1, 0),
new Hardpoint(-1, 0, 0),
new Hardpoint(-1, 1, 0),
new Hardpoint(0, -1, 0),
new Hardpoint(0, 0, 0),
new Hardpoint(0, 1, 0),
new Hardpoint(1, -1, 0),
new Hardpoint(1, 0, 0),
new Hardpoint(1, 1, 0)
};
var actual = foundation.CalculateBoundingBox(new Position(testHardpoints));
Assert.AreEqual(-1, actual.Left, .00001);
Assert.AreEqual(-1, actual.Top, .00001);
}
public List <Point> GetValidExitsFromFoundation(Entity entity)
{
// list to hold valid road tiles to move to
List <Point> validLandings = new List <Point>();
FoundationComponent foundation = entity.Get <FoundationComponent>();
PositionComponent position = entity.Get <PositionComponent>();
foreach (LocationValue plot in foundation.Plan)
{
// check the ortho points around the plot position
for (int x = -1; x < 2; x++)
{
for (int y = -1; y < 2; y++)
{
if (Math.Abs(x) == Math.Abs(y))
{
continue;
}
Point p = new Point(position.Index.X + plot.Offset.X + x, position.Index.Y + plot.Offset.Y + y);
if (!Map.IsValidIndex(p.X, p.Y))
{
continue;
}
// can only exit onto roads
if ((!Collisions.Map.ContainsKey(p) || Collisions.Map[p] == PathTypes.ROAD) && !validLandings.Contains(p))
{
validLandings.Add(p);
}
}
}
}
return(validLandings);
}
public void FromCenterPoint_ComponentTypeIsFloor()
{
var foundation = FoundationComponent.AtCenterPoint(new Hardpoint(0, 0, 0));
Assert.AreEqual(FoundationComponentType.Floor, foundation.ComponentType);
}
public void FromCenterPoint_ZLevelIsZero()
{
var foundation = FoundationComponent.AtCenterPoint(new Hardpoint(0, 0, 0));
Assert.AreEqual(0, foundation.Position.ZLevel);
}
private void Entities_EntityAdded(object sender, EntityEventArgs e)
{
Point index = e.Entity.Get <PositionComponent>().Index;
// update the game data
foreach (Component c in e.Entity.Components.Values.ToList())
{
switch (c.GetType().Name)
{
case "CitizenComponent":
CitizenComponent citizen = (CitizenComponent)c;
// fill in the data if it doesn't already exist
if (string.IsNullOrWhiteSpace(citizen.Name))
{
// generate name
string[] names = { "Steve", "John", "Bill" };
citizen.Name = names[Random.Next(0, names.Length)];
}
if (string.IsNullOrWhiteSpace(citizen.Surname))
{
// generate family name
string[] names = { "Johnson", "Miller", "Smith" };
citizen.Surname = names[Random.Next(0, names.Length)];
}
if (citizen.Gender == Gender.BOTH)
{
citizen.Gender = (Gender)Random.Next(1, 3);
}
if (citizen.Age == 0)
{
// generate age
citizen.Age = Random.Next(14, 46);
}
if (citizen.Money == 0)
{
citizen.Money = Random.Next(20, 100);
}
break;
case "CollapsibleComponent":
CollapsibleComponent collapsible = (CollapsibleComponent)c;
if (collapsible.Value == 0)
{
collapsible.Value = CollapsibleComponent.MAX;
}
break;
case "CollisionComponent":
CollisionComponent collision = (CollisionComponent)c;
foreach (LocationValue lv in collision.Plan)
{
Point p = new Point(index.X + lv.Offset.X, index.Y + lv.Offset.Y);
if (Collisions.Map.ContainsKey(p))
{
Collisions.Map[p] = (PathTypes)lv.Value;
}
else
{
Collisions.Map.Add(p, (PathTypes)lv.Value);
}
}
break;
case "CollisionMapComponent":
Collisions = (CollisionMapComponent)c;
break;
case "FoundationComponent":
FoundationComponent floor = (FoundationComponent)c;
// update the floor planner
foreach (LocationValue lv in floor.Plan)
{
Point update = new Point(index.X + lv.Offset.X, index.Y + lv.Offset.Y);
Foundations.SpaceTaken.Add(update, e.Entity.ID);
}
break;
case "FoundationPlannerComponent":
Foundations = (FoundationPlannerComponent)c;
break;
case "GameDateComponent":
Date = (GameDateComponent)c;
break;
case "IsometricMapComponent":
Map = e.Entity.Get <IsometricMapComponent>();
if (Map.Terrain == null)
{
Map.CreateMap(Map.SpriteSheetName, Map.TxWidth, Map.TxHeight, Map.PxTileWidth, Map.PxTileHeight);
// replace the map
e.Entity.RemoveComponent(e.Entity.Get <IsometricMapComponent>());
e.Entity.AddComponent(Map);
}
break;
case "PositionComponent":
PositionComponent position = (PositionComponent)c;
if (!String.IsNullOrWhiteSpace(position.GenerateAt))
{
int xIndex = -1;
int yIndex = -1;
switch (position.GenerateAt)
{
// random
case "Edge":
int side = Random.Next(4);
switch (side)
{
case 0:
// northwest
xIndex = 0;
yIndex = Random.Next(1, Map.TxHeight);
break;
case 1:
// northeast
xIndex = Random.Next(1, Map.TxWidth);
yIndex = 0;
break;
case 2:
// southeast
xIndex = Map.TxWidth - 1;
yIndex = Random.Next(1, Map.TxHeight);
break;
default:
// southwest
xIndex = Random.Next(1, Map.TxWidth);
yIndex = Map.TxHeight - 1;
break;
}
break;
case "NoEdge":
xIndex = Random.Next(1, Map.TxWidth - 1);
yIndex = Random.Next(1, Map.TxHeight - 1);
break;
default:
xIndex = Random.Next(0, Map.TxWidth);
yIndex = Random.Next(0, Map.TxHeight);
break;
}
Vector2 pos = Map.GetPositionFromIndex(xIndex, yIndex);
position.X = pos.X;
position.Y = pos.Y;
position.Index = new Point(xIndex, yIndex);
position.GenerateAt = String.Empty;
index = position.Index;
}
break;
case "RoadComponent":
// setup the road component
RoadComponent road = (RoadComponent)c;
road.BuiltAt = index;
// update the planner
Roads.AddOrUpdate(this, e.Entity, true);
break;
case "RoadPlannerComponent":
Roads = (RoadPlannerComponent)c;
break;
case "SpawnerComponent":
break;
}
}
}
public override BehaviorStatus Update(Entity self, double dt)
{
BehaviorStatus status = base.Update(self, dt);
switch (status)
{
case BehaviorStatus.SUCCESS:
case BehaviorStatus.FAIL:
break;
case BehaviorStatus.RUN:
Entity target = World.Entities.Find(delegate(Entity e) { return(e.ID == TargetID); });
// if invalid target fail out
if (target == null)
{
return(BehaviorStatus.FAIL);
}
if (PathRequest != null)
{
// try to retrieve the path
Path p = PathfinderSystem.GetPath(PathRequest.ID);
if (p == null)
{
// idle for a short bit
AddChild(new IdleBehavior()
{
IdleTime = 0.1
});
return(BehaviorStatus.WAIT);
}
else
{
GeneratedPath = p;
// TODO: check for tPosition = sPosition
if (GeneratedPath.Waypoints.Count == 0)
{
return(BehaviorStatus.FAIL);
}
return(BehaviorStatus.SUCCESS);
}
}
else
{
// make sure the target has a position or foundation
if (!MoveToNearbyRoad)
{
// if the target or self has no position fail out
if (!target.HasComponent <PositionComponent>() || !self.HasComponent <PositionComponent>())
{
return(BehaviorStatus.FAIL);
}
PositionComponent tPosition = target.Get <PositionComponent>();
PositionComponent sPosition = self.Get <PositionComponent>();
if (tPosition.Index == null || tPosition.Index == Point.Zero)
{
tPosition.Index = World.Map.GetIndexFromPosition((int)tPosition.X, (int)tPosition.Y);
}
PathRequest = new PathRequest()
{
Start = sPosition.Index,
End = tPosition.Index
};
if (FollowRoadsOnly)
{
PathRequest.Validation = OnlyRoads;
}
else
{
PathRequest.Validation = AnyPathNotBlocked;
}
PathfinderSystem.RequestPath(PathRequest);
}
else
{
// check for a starting position and ensure the target has a foundation
if (!self.HasComponent <PositionComponent>() || !target.HasComponent <FoundationComponent>() || !target.HasComponent <PositionComponent>())
{
return(BehaviorStatus.FAIL);
}
PositionComponent tPosition = target.Get <PositionComponent>();
FoundationComponent foundation = target.Get <FoundationComponent>();
// list to hold valid road tiles to move to
List <Point> validLandings = World.GetValidExitsFromFoundation(target);
if (validLandings.Count == 0)
{
return(BehaviorStatus.FAIL);
}
else
{
// find a multi-path
PositionComponent sPosition = self.Get <PositionComponent>();
PathRequest = new PathRequest()
{
Start = sPosition.Index,
Ends = validLandings
};
if (FollowRoadsOnly)
{
PathRequest.Validation = OnlyRoads;
}
else
{
PathRequest.Validation = AnyPathNotBlocked;
}
PathfinderSystem.RequestPath(PathRequest);
}
}
}
break;
}
return(BehaviorStatus.WAIT);
}
private void BuildSelected()
{
if (string.IsNullOrWhiteSpace(selectedCategory) || selectedEntityIndex == -1 || delayCountdown > 0)
{
return;
}
Entity selectedEntity = indexedBuildables[selectedCategory][selectedEntityIndex];
BuildableComponent selectedBuildable = selectedEntity.Get <BuildableComponent>();
FoundationComponent foundation = selectedEntity.Get <FoundationComponent>();
// pick out the tile index that the screen coords intersect
Point index = GetMouseIndex();
if (selectedBuildable.DragBuildEnabled)
{
if (isDragging)
{
// actually do the build
foreach (Entity e in draggableEntities)
{
Entity buildable = Serialization.DeepCopy <Entity>(selectedEntity);
if (buildable.HasComponent <PositionComponent>())
{
PositionComponent ep = e.Get <PositionComponent>();
PositionComponent bp = buildable.Get <PositionComponent>();
bp.X = ep.X;
bp.Y = ep.Y;
bp.Index = ep.Index;
bp.GenerateAt = string.Empty;
}
else
{
buildable.AddComponent(e.Get <PositionComponent>());
}
World.Entities.Add(buildable);
World.City.Funds -= selectedBuildable.Cost;
}
ClearDragState();
}
else
{
isDragging = true;
dragStart = index;
dragEnd = new Point(-1, -1);
UpdateDraggables();
}
}
else
{
DrawableComponent drawable = dataTracker.Get <DrawableComponent>();
PositionComponent drawablePosition = dataTracker.Get <PositionComponent>();
// translate the index into a screen position and up the position component
Vector2 dPositiion = World.Map.GetPositionFromIndex(index.X, index.Y);
drawablePosition.X = dPositiion.X;
drawablePosition.Y = dPositiion.Y;
bool spaceTaken = false;
foreach (LocationValue lv in foundation.Plan)
{
if (World.Foundations.SpaceTaken.ContainsKey(new Point(index.X + lv.Offset.X, index.Y + lv.Offset.Y)))
{
spaceTaken = true;
break;
}
}
bool visible = World.Map.IsValidIndex(index.X, index.Y);
if (!visible)
{
return;
}
// don't build over a spot that is already taken, don't build if not enough money
// TODO: the money check shouldn't even allow the building to be selected
if (spaceTaken || World.City.Funds < selectedBuildable.Cost)
{
return;
}
Entity buildable = Serialization.DeepCopy <Entity>(selectedEntity);
if (buildable.HasComponent <PositionComponent>())
{
PositionComponent aPosition = buildable.Get <PositionComponent>();
aPosition.X = drawablePosition.X;
aPosition.Y = drawablePosition.Y;
aPosition.Index = index;
aPosition.GenerateAt = string.Empty;
}
else
{
PositionComponent bPosition = new PositionComponent(drawablePosition.Position);
bPosition.Index = index;
buildable.AddComponent(bPosition);
}
World.Entities.Add(buildable);
World.City.Funds -= selectedBuildable.Cost;
delayCountdown = delay;
}
}
