private void ConnectPartialGraph(PartialGraph pgSource, PartialGraph pgTarget)
{
foreach (StardewVertex vertex in pgSource.Vertices)
{
if (vertex is WarpVertex)
{
var warpVertex = (WarpVertex)vertex;
if (warpVertex.TargetLocation == pgTarget.Location)
{
var newVertex = new StardewVertex(pgTarget.Location, warpVertex.TargetPosition);
pgTarget.AddVertex(newVertex);
var newEdge = new StardewEdge(vertex, newVertex, "Partial graph connection");
pgSource.AddEdge(newEdge);
foreach (StardewVertex targetVertex in pgTarget.Vertices)
{
// Player vertex only needs to connect away from itself, all warp vertices and the target vertex must have an edge going to them
if (targetVertex != pgTarget.PlayerVertex)
{
var e = new StardewEdge(newVertex, targetVertex, $"From {newVertex.Location} to {targetVertex.Location}");
pgTarget.AddEdge(e);
}
}
}
}
}
}
public void Populate()
{
foreach (GameLocation location in this.gameLocations)
{
var partialGraph = new PartialGraph(location);
partialGraph.Populate();
this.PartialGraphs.Add(partialGraph);
}
var farmBuildings = Game1.getFarm().buildings;
foreach (Building building in farmBuildings)
{
var indoors = building.indoors.Value;
if (indoors != null && indoors is AnimalHouse)
{
var partialGraph = new PartialGraph((AnimalHouse)indoors);
partialGraph.Populate();
this.PartialGraphs.Add(partialGraph);
}
}
foreach (PartialGraph pgSource in this.PartialGraphs)
{
foreach (PartialGraph pgTarget in this.PartialGraphs)
{
if (pgSource != pgTarget)
{
this.ConnectPartialGraph(pgSource, pgTarget);
}
}
}
foreach (PartialGraph partialGraph in this.PartialGraphs)
{
this.AddVertexRange(partialGraph.Vertices);
this.AddEdgeRange(partialGraph.Edges);
}
Func <StardewEdge, double> edgeCost = (x) => x.Cost;
this.dijkstra = new DijkstraShortestPathAlgorithm <StardewVertex, StardewEdge>(this, edgeCost);
this.distObserver = new VertexDistanceRecorderObserver <StardewVertex, StardewEdge>(edgeCost);
this.distObserver.Attach(this.dijkstra);
this.predecessorObserver = new VertexPredecessorRecorderObserver <StardewVertex, StardewEdge>();
this.predecessorObserver.Attach(this.dijkstra);
}
public void Create()
{
var a = Game1.currentLocation.warps;
foreach (GameLocation loc in Game1.locations)
{
//graph.AddVertex(loc.Name);
}
partialGraphs = new Dictionary <GameLocation, PartialGraph>();
//var edgeCosts = new List<Dictionary<Edge<ExtendedWarp>, double>>();
foreach (GameLocation loc in Game1.locations)
{
if (loc.Name == "Farm")
{
// TODO Connect barns/coops
}
// TODO add player and target vertex and connect every node to it
var partialGraph = new PartialGraph(loc);
// Calculate which warps should correspond to a vertex. Dont add warps which are very close.
var extWarpsToInclude = new List <ExtendedWarp>();
for (int i = 0; i < loc.warps.Count; i++)
{
var extWarpNew = new ExtendedWarp(loc.warps.ElementAt(i), loc);
bool shouldAdd = true;
foreach (ExtendedWarp extWarpIncluded in extWarpsToInclude)
{
if (extWarpNew.TargetLocation == extWarpIncluded.TargetLocation && ExtendedWarp.Distance(extWarpNew, extWarpIncluded) < 5)
{
shouldAdd = false;
break;
}
}
if (shouldAdd)
{
extWarpsToInclude.Add(extWarpNew);
partialGraph.AddVertex(extWarpsToInclude.Last());
}
}
// Create edges for partial graphs
for (int i = 0; i < extWarpsToInclude.Count; i++)
{
var extWarp1 = extWarpsToInclude.ElementAt(i);
for (int j = 0; j < extWarpsToInclude.Count; j++)
{
var LocTo = Game1.getLocationFromName(loc.warps.ElementAt(j).TargetName);
var extWarp2 = extWarpsToInclude.ElementAt(j);
var path = PathFindController.findPath(new Point(extWarp1.X, extWarp1.Y), new Point(extWarp2.X, extWarp2.Y), new PathFindController.isAtEnd(PathFindController.isAtEndPoint), loc, Game1.player, 9999);
double dist;
string edgeLabel;
if (path != null)
{
dist = (float)path.Count;
// TODO Player can run diagonally. Account for that.
edgeLabel = loc.Name + " - " + dist + "c";
}
else
{
dist = (int)Vector2.Distance(new Vector2(extWarp1.X, extWarp1.Y), new Vector2(extWarp2.X, extWarp2.Y));
edgeLabel = loc.Name + " - " + dist + "d";
}
var edge = new LabelledEdge <ExtendedWarp>(extWarp1, extWarp2, edgeLabel, new GraphvizColor(255, 255, 255, 255), dist);
partialGraph.AddEdge(edge);
}
partialGraph.AddVertex(extWarp1);
}
partialGraph.AddPlayerVertex(new ExtendedWarp(new Warp(0, 0, "None", 0, 0, false), loc));
partialGraph.ConnectPlayerVertex();
partialGraphs.Add(loc, partialGraph);
}
// Combine partial graphs into one
foreach (var partialGraph in partialGraphs.Values)
{
this.AddVertexRange(partialGraph.Vertices);
this.AddEdgeRange(partialGraph.Edges);
}
for (int i = 0; i < partialGraphs.Count; i++)
{
var graph1 = partialGraphs.Values.ElementAt(i);
for (int j = 0; j < partialGraphs.Count; j++)
{
var graph2 = partialGraphs.Values.ElementAt(j);
foreach (ExtendedWarp warp1 in graph1.Vertices)
{
if (warp1.OriginLocation.name == "Saloon")
{
}
if (graph2.VertexCount > 0 && warp1.TargetLocation == graph2.Vertices.ElementAt(0).OriginLocation)
{
var copyVertex = new ExtendedWarp((Warp)warp1, warp1.OriginLocation);// copy to make the graph visually clearer
var edgeToCopy = new LabelledEdge <ExtendedWarp>(warp1, copyVertex, "Warp", new GraphvizColor(255, 255, 255, 255), 0);
this.AddVertex(copyVertex);
this.AddEdge(edgeToCopy);
foreach (ExtendedWarp warp2 in graph2.Vertices)
{
var newEdge = new LabelledEdge <ExtendedWarp>(copyVertex, warp2, warp2.OriginLocation.Name, new GraphvizColor(255, 255, 255, 255), ExtendedWarp.Distance(copyVertex, warp2));
// TODO: Calculate cost
this.AddEdge(newEdge);
if (warp2.TargetLocation?.Name == "Saloon")
{
}
}
}
}
}
}
GraphvizAlgorithm <ExtendedWarp, LabelledEdge <ExtendedWarp> > graphviz = new GraphvizAlgorithm <ExtendedWarp, LabelledEdge <ExtendedWarp> >(this);
graphviz.FormatVertex += (sender2, args) => args.VertexFormatter.Label = args.Vertex.Label;
graphviz.FormatEdge += (sender2, args) => { args.EdgeFormatter.Label.Value = args.Edge.Label; };
graphviz.FormatEdge += (sender2, args) => { args.EdgeFormatter.FontGraphvizColor = args.Edge.Color; };
graphviz.ImageType = GraphvizImageType.Jpeg;
graphviz.Generate(new FileDotEngine(), "C:\\Users\\Gunnar\\Desktop\\graph123.jpeg");
//var alg = new QuickGraph.Algorithms.ShortestPath.UndirectedDijkstraShortestPathAlgorithm<ExtendedWarp, Edge<ExtendedWarp>>;
}
