public void Import()
{
var mapReader = new MapReader();
mapReader.Read(_mapFile);
var buildingMaker = new BuildingMaker(mapReader, _buildingMaterial);
var roadMaker = new RoadMaker(mapReader, _roadMaterial);
Process(buildingMaker, "Importing buildings");
Process(roadMaker, "Importing roads");
}
public int CalcShortestSolutionWithExtra()
{
BuildingMaker maker = new BuildingMaker();
Building startState = maker.BuildingForPuzzle2Input();
Building endState = maker.SolvedBuilding(startState);
MoveMaker mover = new MoveMaker();
List <BuildingMove> possibleSolutions = new List <BuildingMove>();
Stopwatch watch = new Stopwatch();
watch.Start();
int lowestSolution = mover.CalcMoveDepthAStar(startState, endState);
watch.Stop();
Console.WriteLine("It took " + watch.Elapsed.ToString() + " to process");
return(lowestSolution);
}
public int CalcAStarSolution()
{
BuildingMaker maker = new BuildingMaker();
//Building startState = maker.TestPuzzleInput();
Building startState = maker.BuildingForPuzzleInput();
Building endState = maker.SolvedBuilding(startState);
MoveMaker mover = new MoveMaker();
Stopwatch watch = new Stopwatch();
watch.Start();
int lowestLongSolution = mover.CalcMoveDepthAStar(startState, endState);
watch.Stop();
Console.WriteLine("It took " + watch.Elapsed.ToString() + " to process, with result " + lowestLongSolution);
return(lowestLongSolution);
}
void Start()
{
PVMax = PV;
upgradeLink = GetComponent<BuildingUpgrade> ();
makerLink = GetComponent<BuildingMaker> ();
}
protected override IEnumerable <ImageData> UseConverter <TParam> (TParam parameter)
{
var sectorBoundaries = parameter as IGameSectorBoundaries;
var divisorX = (int)MathF.Round(sectorBoundaries.MaxSectorX / 1024);
var divisorY = (int)MathF.Round(sectorBoundaries.MaxSectorX / 1024);
var x = Randomness.Instance.From(0, divisorX) * 1024; //Randomness.Instance.From(sectorBoundaries.MinSectorX + 200, sectorBoundaries.MaxSectorX - 200);
var y = Randomness.Instance.From(0, divisorY) * 1024; //Randomness.Instance.From(sectorBoundaries.MinSectorY + 200, sectorBoundaries.MaxSectorY - 200);
var centers = Randomness.Instance.From(2, 12);
var tileSize = 0;
while (centers >= 0)
{
ImageData streetCenter;
if (CenterNodes.Count == 0)
{
streetCenter = StreetCenterMaker.Create(new MovementBehaviour()
{
X = x,
Y = y
});
streetCenter.LayerDepth -= CityLayer;
CenterNodes.Add(streetCenter.Position);
tileSize = (int)MathF.Round(streetCenter.Width);
centers--;
yield return(streetCenter);
}
else
{
var lastNode = Nodes.Last();
var nextPosition = new MovementBehaviour()
{
X = lastNode.Item2.X,
Y = lastNode.Item2.Y
};
switch (lastNode.Item1)
{
case Up:
nextPosition.Y -= tileSize;
break;
case Down:
nextPosition.Y += tileSize;
break;
case Left:
nextPosition.X -= tileSize;
break;
case Right:
nextPosition.X += tileSize;
break;
}
if (CenterNodes.Any(t => Vector2.Distance(t, nextPosition) <= tileSize) || Nodes.Any(t => Vector2.Distance(t.Item2, nextPosition) <= tileSize / 2))
{
centers--;
continue;
}
streetCenter = StreetCenterMaker.Create(nextPosition);
streetCenter.LayerDepth -= CityLayer;
CenterNodes.Add(streetCenter.Position);
centers--;
yield return(streetCenter);
}
var streetSize = Randomness.Instance.From(2, 14);
var lastStreetUp = 1;
var lastStreetDown = 1;
var lastStreetLeft = 1;
var lastStreetRight = 1;
while (streetSize-- >= 0)
{
var nextDirection = Randomness.Instance.From(0, 4);
switch (nextDirection)
{
case Up:
var streetUp = new MovementBehaviour()
{
X = streetCenter.Position.X,
Y = streetCenter.Position.Y - streetCenter.Height * lastStreetUp
};
if (Nodes.Any(t => Vector2.Distance(t.Item2, streetUp) <= tileSize / 2))
{
break;
}
lastStreetUp++;
var streetUpImageData = StreetVerticalMaker.Create(streetUp);
streetUpImageData.LayerDepth -= CityLayer;
Nodes.Add(new Tuple <int, Vector2>(Up, streetUp));
yield return(streetUpImageData);
break;
case Down:
var streetDown = new MovementBehaviour()
{
X = streetCenter.Position.X,
Y = streetCenter.Position.Y + streetCenter.Height * lastStreetDown
};
if (Nodes.Any(t => Vector2.Distance(t.Item2, streetDown) <= tileSize))
{
break;
}
lastStreetDown++;
var streetDownImageData = StreetVerticalMaker.Create(streetDown);
streetDownImageData.LayerDepth -= CityLayer;
Nodes.Add(new Tuple <int, Vector2>(Down, streetDown));
yield return(streetDownImageData);
break;
case Left:
var streetLeft = new MovementBehaviour()
{
X = streetCenter.Position.X - streetCenter.Width * lastStreetLeft,
Y = streetCenter.Position.Y
};
if (Nodes.Any(t => Vector2.Distance(t.Item2, streetLeft) <= tileSize))
{
break;
}
lastStreetLeft++;
var streeLeftImageData = StreetHorizontalMaker.Create(streetLeft);
streeLeftImageData.LayerDepth -= CityLayer;
Nodes.Add(new Tuple <int, Vector2>(Left, streetLeft));
yield return(streeLeftImageData);
break;
case Right:
default:
var streetRight = new MovementBehaviour()
{
X = streetCenter.Position.X + streetCenter.Width * lastStreetRight,
Y = streetCenter.Position.Y
};
if (Nodes.Any(t => Vector2.Distance(t.Item2, streetRight) <= tileSize))
{
break;
}
lastStreetRight++;
var streetRightImageData = StreetHorizontalMaker.Create(streetRight);
streetRightImageData.LayerDepth -= CityLayer;
Nodes.Add(new Tuple <int, Vector2>(Right, streetRight));
yield return(streetRightImageData);
break;
}
}
}
//build cities in between
//get maxed out
var buildings = Randomness.Instance.From(5, 20);
while (buildings-- >= 0)
{
//var atmostUp = Nodes.FirstOrDefault(m => m.Item2.Y == Nodes.Min(n => n.Item2.Y));
//var atmostDown = Nodes.FirstOrDefault(m => m.Item2.Y == Nodes.Max(n => n.Item2.Y));
//var atmostLeft = Nodes.FirstOrDefault(m => m.Item2.X == Nodes.Min(n => n.Item2.X));
//var atmostRight = Nodes.FirstOrDefault(m => m.Item2.X == Nodes.Max(n => n.Item2.X));
var selectedNode = Nodes.ElementAt(Randomness.Instance.From(0, Nodes.Count - 1));
var buildingSize = Randomness.Instance.From(2, 3);
//var nextDirection = Randomness.Instance.From(0, 4);
var buildingTopCreated = false;
while (buildingSize-- >= 0)
{
ImageData nextBuildingChunk = null;
MovementBehaviour nextPosition = null;
switch (selectedNode.Item1)
{
case Up:
nextPosition = new MovementBehaviour()
{
X = selectedNode.Item2.X - (tileSize * buildingSize),
Y = selectedNode.Item2.Y
};
break;
case Down:
nextPosition = new MovementBehaviour()
{
X = selectedNode.Item2.X + (tileSize * buildingSize),
Y = selectedNode.Item2.Y
};
break;
case Left:
nextPosition = new MovementBehaviour()
{
X = selectedNode.Item2.X,
Y = selectedNode.Item2.Y + (tileSize * buildingSize)
};
break;
case Right:
nextPosition = new MovementBehaviour()
{
X = selectedNode.Item2.X,
Y = selectedNode.Item2.Y + (tileSize * buildingSize)
};
break;
}
if (Nodes.Any(t => Vector2.Distance(t.Item2, nextPosition) <= tileSize / (buildingSize == 0 ? 1: buildingSize)) ||
CenterNodes.Any(t => Vector2.Distance(t, nextPosition) <= tileSize) ||
Buildings.Any(t => Vector2.Distance(t, nextPosition) <= tileSize))
{
continue;
}
if (!buildingTopCreated)
{
nextBuildingChunk = BuildingMaker.Create(nextPosition);
buildingTopCreated = true;
}
else
{
nextBuildingChunk = BuildingTopMaker.Create(nextPosition);
}
Buildings.Add(nextPosition);
yield return(nextBuildingChunk);
}
}
CityLayer -= DrawingPlainOrder.MicroPlainStep;
}
