public void AdjacencyList_Filter_SelectesPartOfVertices()
{
int vertex1 = 10;
int vertex2 = 20;
int vertex3 = 30;
int vertex4 = 40;
string edge1 = "20-30";
string edge2 = "30-40";
AdjacencyList <int, string> adjacencyList = new AdjacencyList <int, string>();
adjacencyList.AddVertex(vertex1);
adjacencyList.AddVertex(vertex2);
adjacencyList.AddVertex(vertex3);
adjacencyList.AddVertex(vertex4);
adjacencyList.AddEdge(vertex2, vertex3, edge1);
adjacencyList.AddEdge(vertex3, vertex4, edge2);
IGraph <int, string> filtered = adjacencyList.Filter((v1, v2, ed) => v1 == 20);
Assert.Equal(2, filtered.NumVertices);
Assert.True(filtered.HasVertex(vertex2));
Assert.True(filtered.HasVertex(vertex3));
Assert.Equal(edge1, filtered.FindEdge(vertex2, vertex3));
}
public void ShortestPathSearcher_Integration_DefaultAggregativeWeight()
{
string vertexA = "A", vertexB = "B", vertexC = "C", vertexD = "D";
// Graph A-B, A-C, B-D, B-A
AdjacencyList <string, int> graph = new AdjacencyList <string, int>();
graph.AddVertex(vertexA);
graph.AddVertex(vertexB);
graph.AddVertex(vertexC);
graph.AddVertex(vertexD);
graph.AddEdge(vertexA, vertexB, 10);
graph.AddEdge(vertexB, vertexA, 5);
graph.AddEdge(vertexA, vertexC, 20);
graph.AddEdge(vertexB, vertexD, 10);
ShortestPathSearcher <string, int> searcher = new ShortestPathSearcher <string, int>(graph, vertexA, vertexD, (i) => i);
IEnumerable <EdgeDescriptor <string, int> > path = searcher.FindShortestPath();
Assert.IsNotNull(path);
Assert.AreEqual(2, path.Count());
EdgeDescriptor <string, int> firstDesc = path.First();
Assert.AreEqual("B", firstDesc.Vertex1);
Assert.AreEqual("A", firstDesc.Vertex2);
Assert.AreEqual(5, firstDesc.Edge);
EdgeDescriptor <string, int> lastDesc = path.Last();
Assert.AreEqual("B", lastDesc.Vertex1);
Assert.AreEqual("D", lastDesc.Vertex2);
Assert.AreEqual(10, lastDesc.Edge);
}
public void AdjacencyList_RemoveVertex_RemovesVerticesWithEdges()
{
int vertex1 = 10;
int vertex2 = 20;
int vertex3 = 30;
int vertex4 = 40;
string edge1 = "20-30";
string edge2 = "30-40";
AdjacencyList <int, string> adjacencyList = new AdjacencyList <int, string>();
adjacencyList.AddVertex(vertex1);
adjacencyList.AddVertex(vertex2);
adjacencyList.AddVertex(vertex3);
adjacencyList.AddVertex(vertex4);
adjacencyList.AddEdge(vertex2, vertex3, edge1);
adjacencyList.AddEdge(vertex3, vertex4, edge2);
Assert.Equal(4, adjacencyList.NumVertices);
Assert.Equal(edge1, adjacencyList.FindEdge(vertex2, vertex3));
Assert.Equal(edge2, adjacencyList.FindEdge(vertex3, vertex4));
adjacencyList.RemoveVertex(vertex2);
Assert.Equal(3, adjacencyList.NumVertices);
Assert.Equal(edge2, adjacencyList.FindEdge(vertex3, vertex4));
}
public void ShortestPathSearcher_Integration_CumulativeWeight()
{
string vertexA = "A", vertexB = "B", vertexC = "C";
// Graph A-B=2, A-C=3, B-C=4
AdjacencyList <string, int> graph = new AdjacencyList <string, int>();
graph.AddVertex(vertexA);
graph.AddVertex(vertexB);
graph.AddVertex(vertexC);
graph.AddEdge(vertexA, vertexB, 2);
graph.AddEdge(vertexA, vertexC, 3);
graph.AddEdge(vertexB, vertexC, 4);
ShortestPathSearcher <string, int> searcher = new ShortestPathSearcher <string, int>(graph, vertexB, vertexC, (i) => i)
{
PathWeightCalculation = PathWeightCalculationType.Cumulative
};
IEnumerable <EdgeDescriptor <string, int> > path = searcher.FindShortestPath();
Assert.IsNotNull(path);
Assert.AreEqual(2, path.Count());
EdgeDescriptor <string, int> edge1 = path.First();
Assert.AreEqual("A", edge1.Vertex1);
Assert.AreEqual("B", edge1.Vertex2);
Assert.AreEqual(2, edge1.Edge);
EdgeDescriptor <string, int> edge2 = path.Last();
Assert.AreEqual("A", edge2.Vertex1);
Assert.AreEqual("C", edge2.Vertex2);
Assert.AreEqual(3, edge2.Edge);
}
/// <summary>
/// Генерация нового случайного графа.
/// </summary>
/// <returns>Новый экземпляр сгенерированного графа.</returns>
public MainGraph Generate()
{
var list = new AdjacencyList(vertexCount);
// Создание связного графа с E = V - 1
for (int i = 1; i < vertexCount; i++)
{
list.AddEdge(i, Utility.Rand.Next(0, i - 1));
}
if (vertexCount < 3)
{
return(AdjacencyList.GenerateGraph(list, medCount, villCount));
}
// Добавление новых ребер для создания циклов
int new_edges = Utility.Rand.Next(0, vertexCount * (vertexCount - 1) / 2 - vertexCount);
for (int e = 0; e < new_edges; e++)
{
int i = Utility.Rand.Next(0, vertexCount - 1);
int j = Utility.Rand.Next(0, vertexCount - 1);
if (i != j && !list.IsAdjacent(i, j))
{
list.AddEdge(i, j);
}
}
return(AdjacencyList.GenerateGraph(list, medCount, villCount));
}
public void HasEdgeTest()
{
var list = new AdjacencyList <int>();
list.AddEdge(0, 1);
list.AddEdge(0, 2);
list.AddEdge(1, 2);
Assert.True(list.HasEdge(0, 1));
Assert.True(list.HasEdge(0, 2));
Assert.True(list.HasEdge(1, 2));
// Out of bounds edge
Assert.False(list.HasEdge(3, 1));
}
public void RemoveEdgeTest()
{
var list = new AdjacencyList <int>();
list.AddEdge(0, 1);
list.AddEdge(0, 2);
list.AddEdge(1, 2);
Assert.True(list.RemoveEdge(0, 1));
Assert.True(list.RemoveEdge(0, 2));
Assert.True(list.RemoveEdge(1, 2));
// Cannot remove again
Assert.False(list.RemoveEdge(0, 1));
}
public void TestAddEdgeSourceDoesNotExist()
{
AdjacencyList <int> graph = new AdjacencyList <int>();
graph.AddNode(2);
bool success = graph.AddEdge(1, 2);
Assert.IsFalse(success);
}
public void TestAddEdgeBothDoNotExist()
{
AdjacencyList <int> graph = new AdjacencyList <int>();
graph.AddNode(1);
graph.AddNode(2);
bool success = graph.AddEdge(3, 4);
Assert.IsFalse(success);
}
public void AdjacencyList_FindEdge_LooksForEdgesByVertices()
{
int vertex1 = 10;
int vertex2 = 20;
int vertex3 = 30;
int vertex4 = 40;
string edge1 = "20-30";
string edge2 = "30-40";
AdjacencyList <int, string> adjacencyList = new AdjacencyList <int, string>();
adjacencyList.AddVertex(vertex1);
adjacencyList.AddVertex(vertex2);
adjacencyList.AddVertex(vertex3);
adjacencyList.AddVertex(vertex4);
adjacencyList.AddEdge(vertex2, vertex3, edge1);
adjacencyList.AddEdge(vertex3, vertex4, edge2);
Assert.Equal(edge1, adjacencyList.FindEdge(vertex2, vertex3));
Assert.Equal(edge2, adjacencyList.FindEdge(vertex3, vertex4));
}
public void TestAddEdge()
{
AdjacencyList <int> graph = new AdjacencyList <int>();
graph.AddNode(1);
graph.AddNode(2);
bool success = graph.AddEdge(1, 2);
Assert.AreEqual(2, graph.Count);
Assert.IsTrue(success);
}
public void OutEdgesTest()
{
var list = new AdjacencyList <int>();
list.AddEdge(0, 1);
list.AddEdge(1, 0);
list.AddEdge(0, 2);
list.AddEdge(2, 0);
list.AddEdge(1, 2);
list.AddEdge(2, 1);
// Outgoing Edges
Assert.Equal(new List <int>()
{
1, 2
}, list.OutEdges(0));
Assert.Equal(new List <int>()
{
0, 2
}, list.OutEdges(1));
Assert.Equal(new List <int>()
{
0, 1
}, list.OutEdges(2));
}
public void GraphExtensions_GetOrderedEdges_ReturnsOrderedEdgeDescriptors()
{
IGraph <string, string> graph = new AdjacencyList <string, string>();
graph.AddVertex("BBB");
graph.AddVertex("AAA");
graph.AddVertex("ABA");
graph.AddVertex("BAB");
graph.AddEdge("ABA", "BBB", "aba-bbb");
graph.AddEdge("ABA", "AAA", "aba-aaa");
graph.AddEdge("ABA", "BAB", "aba-bab");
// Those opposite edges will be ignored
graph.AddEdge("AAA", "ABA", "aaa-aba");
graph.AddEdge("BBB", "ABA", "bbb-aba");
var edges = graph.FindVertexDescriptor("ABA").GetOrderedEdges(StringComparer.CurrentCulture);
Assert.Equal(3, edges.Count());
Assert.Equal("AAA", edges.ElementAt(0).Vertex2);
Assert.Equal("BAB", edges.ElementAt(1).Vertex2);
Assert.Equal("BBB", edges.ElementAt(2).Vertex2);
}
protected void LoadInput()
{
//first ensure all the dict are initialized
foreach (var node in _nodes)
{
_adjacencyList.AddVertex(node);
}
//make a link between nodes that have summed values that mod 3 are equals to 0
foreach (var node in _nodes)
{
foreach (var innerNode in _nodes)
{
//when node + innerNode is divisible by three add a link between them
//e.g. 1 will have edges with 2 and 5
if ((node + innerNode) % 3 != 0 || node == innerNode)
{
continue;
}
_adjacencyList.AddEdge(node, innerNode);
_adjacencyList.AddEdge(innerNode, node);
}
}
}
public void TestGetEnumerator()
{
List <int[]> expecteds = new List <int[]>
{
new int[] { 2, 3 },
new int[] { 3 },
new int[] { 1 },
};
AdjacencyList <int> graph = new AdjacencyList <int>();
int one = 1;
int two = 2;
int three = 3;
graph.AddNode(one);
graph.AddNode(two);
graph.AddNode(three);
graph.AddEdge(one, two);
graph.AddEdge(one, three);
graph.AddEdge(two, three);
graph.AddEdge(three, one);
IEnumerator <KeyValuePair <int, List <int> > > enumerator = graph.GetEnumerator();
Assert.IsNotNull(enumerator);
KeyValuePair <int, List <int> > current;
while (enumerator.MoveNext())
{
current = enumerator.Current;
Assert.AreEqual(expecteds[current.Key - 1], current.Value);
}
}
public void PrintNodes()
{
var graph = new AdjacencyList(5);
graph.AddEdge(0, 1);
graph.AddEdge(0, 4);
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(1, 4);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
graph.PrintGraph();
}
void addEdgeToAdjacencyListAfterValidation(int source, int target, float weight)
{
int smaller = source;
int bigger = target;
if (target < source)
{
smaller = target;
bigger = source;
}
if (adjacencyList.isAdjacent(smaller, bigger) == false)
{
adjacencyList.AddEdge(smaller, bigger, weight, nodeContainer);
}
}
public void AddEdgeTest()
{
var list = new AdjacencyList <int>();
// Add edges
Assert.True(list.AddEdge(0, 1));
Assert.True(list.AddEdge(1, 0));
Assert.True(list.AddEdge(0, 2));
Assert.True(list.AddEdge(2, 0));
Assert.True(list.AddEdge(1, 2));
Assert.True(list.AddEdge(2, 1));
// Cannot add duplicate edges
Assert.False(list.AddEdge(1, 2));
Assert.False(list.AddEdge(2, 1));
}
public void TestGetAccessor()
{
AdjacencyList <int> graph = new AdjacencyList <int>();
int one = 1;
int two = 2;
graph.AddNode(one);
graph.AddNode(two);
bool success = graph.AddEdge(one, two);
IList <int> oneEdges = graph[one];
IList <int> twoEdges = graph[two];
Assert.IsTrue(success);
Assert.AreEqual(one, oneEdges.Count);
Assert.AreEqual(two, oneEdges[0]);
Assert.AreEqual(0, twoEdges.Count);
}
public void ReflectiveEdgeTest()
{
var list = new AdjacencyList <int>();
// Add edges
Assert.True(list.AddEdge(0, 1));
Assert.True(list.AddEdge(1, 0));
Assert.True(list.AddEdge(0, 2));
Assert.True(list.AddEdge(2, 0));
Assert.True(list.AddEdge(1, 2));
Assert.True(list.AddEdge(2, 1));
// Has Edges
Assert.True(list.HasEdge(1, 0));
Assert.True(list.HasEdge(2, 0));
Assert.True(list.HasEdge(2, 1));
}
public void Add_Edgs()
{
adjList.Add("A");
adjList.Add("B");
adjList.Add("C");
adjList.Add("D");
adjList.Add("E");
adjList.AddEdge("A", "B");
adjList.AddEdge("A", "C");
adjList.AddEdge("A", "D");
var node = adjList[0]._firstArc;
int i = 0;
do
{
i++;
node = node.nextArc;
} while (node != null);
Assert.AreEqual(3, i);
}
private void Start()
{
#if UNITY_IOS || UNITY_ANDROID
mobileControls.SetActive(true);
#endif
fsm = GetComponent <FloodSoundManager>();
playerCar = player.GetComponent <PlayerCar>();
player.position = startObj.position;
referenceGraph = new AdjacencyList <Vector3>(Vector3.zero);
pathingGraph = new AdjacencyList <Vector3>(Vector3.zero);
for (int i = 0; i < numBlocksHorizontal; i++)
{
for (int j = 0; j < numBlocksVertical; j++)
{
Vector3 pos = new Vector3(i * blockDist, 0, j * blockDist);
foreach (Vector3 neighbor in GetNeighbors(pos))
{
referenceGraph.AddEdge(pos, neighbor);
pathingGraph.AddEdge(pos, neighbor);
}
}
}
//Remove edges until there is no path found
List <KeyValuePair <Vector3, Vector3> > removedEdges = new List <KeyValuePair <Vector3, Vector3> >();
while (AStar(referenceGraph, startObj.position, endObj.position, out List <Vector3> pathIter))
{
path = pathIter;
Vector3 start = referenceGraph.GetRandomVertex();
List <Vector3> neighbors = referenceGraph.FindNeighbours(start);
Vector3 neighbor = neighbors[Random.Range(0, neighbors.Count)];
referenceGraph.RemoveEdge(start, neighbor);
removedEdges.Add(new KeyValuePair <Vector3, Vector3>(start, neighbor));
}
//Add the last removed edge back in
KeyValuePair <Vector3, Vector3> lastEdge = removedEdges.Last();
removedEdges.RemoveAt(removedEdges.Count - 1);
referenceGraph.AddEdge(lastEdge.Key, lastEdge.Value);
//face the player's car in the direction of the first waypoint
float startDir = v3ToInt[(path[1] - path[0]).normalized];
player.eulerAngles = new Vector3(0f, startDir, 0f);
List <Vector3> startNeighborsMids = referenceGraph.FindNeighbours(startObj.position).Select(i => (startObj.position + i) / 2).ToList();
//spawn in roadblock prefabs along 3/4s of blocked edges
int endIdx = removedEdges.Count * 3 / 4;
for (int i = 0; i < endIdx; i++)
{
KeyValuePair <Vector3, Vector3> edge = removedEdges[i];
GameObject toInstantiate = staticRoadBlockPrefabs[Random.Range(0, staticRoadBlockPrefabs.Count)];
Vector3 midpoint = (edge.Key + edge.Value) / 2;
if (startNeighborsMids.Any(x => x == midpoint))
{
continue;
}
Quaternion rot = Quaternion.Euler(0f, Mathf.Abs((edge.Key - edge.Value).x) > 0f ? 90f : 0f, 0f);
Instantiate(toInstantiate, midpoint, rot, obstacles.transform);
pathingGraph.RemoveEdge(edge.Key, edge.Value);
}
//spawn in obstacles along valid edges
HashSet <Vector3> edgeSet = new HashSet <Vector3>();
//prevent items from spawning on edges surrounding player's spawn point
startNeighborsMids.ForEach(i => edgeSet.Add(i));
foreach (Vector3 vertex in referenceGraph.GetAllEdges())
{
foreach (Vector3 neighbor in referenceGraph.FindNeighbours(vertex))
{
Vector3 mid = (vertex + neighbor) / 2;
bool onX = Mathf.Abs((vertex - neighbor).x) > 0;
if (!edgeSet.Contains(mid) && Random.Range(0, 2) > 0)
{
GameObject toInstantiate = roadObstaclePrefabs[Random.Range(0, roadObstaclePrefabs.Count)];
float randStreetOffsetLong = Random.Range(-blockDist / 2, blockDist / 2);
float randStreetOffsetWide = Random.Range(-roadWidth / 4, roadWidth / 4);
Vector3 boundedRandomPosInStreet = mid;
boundedRandomPosInStreet += onX ? new Vector3(randStreetOffsetLong, 0f, randStreetOffsetWide) : new Vector3(randStreetOffsetWide, 0f, randStreetOffsetLong);
Quaternion rot = Quaternion.Euler(0f, onX ? Random.Range(60, 120) : Random.Range(-30, 30), 0f);
Instantiate(toInstantiate, boundedRandomPosInStreet, rot, obstacles.transform);
}
if (!edgeSet.Contains(mid) && Random.Range(0, 3) > 0)
{
GameObject toInstantiate = puddles[Random.Range(0, puddles.Count)];
float randStreetOffsetLong = Random.Range(-blockDist / 2, blockDist / 2);
float randStreetOffsetWide = Random.Range(-roadWidth / 4, roadWidth / 4);
Vector3 boundedRandomPosInStreet = mid;
boundedRandomPosInStreet += onX ? new Vector3(randStreetOffsetLong, 0f, randStreetOffsetWide) : new Vector3(randStreetOffsetWide, 0f, randStreetOffsetLong);
Quaternion rot = Quaternion.Euler(0f, Random.Range(0, 360), 0f);
Instantiate(toInstantiate, boundedRandomPosInStreet, rot, obstacles.transform);
}
edgeSet.Add(mid);
}
}
fullPathLength = path.Count;
StartCoroutine(UpdatePathOnDelay(pathUpdateDelay));
StartCoroutine(EndGameCheckOnDelay(endGameCheckDelay, endObj.position, new Vector3(roadWidth, roadWidth, roadWidth) / 2f, playerLayer));
}
public CityUtil()
{
city_dict.Add(0, "沈阳");
city_dict.Add(1, "北京");
city_dict.Add(2, "天津");
city_dict.Add(3, "石家庄");
city_dict.Add(4, "济南");
city_dict.Add(5, "郑州");
city_dict.Add(6, "南京");
city_dict.Add(7, "杭州");
city_dict.Add(8, "上海");
city_dict.Add(9, "合肥");
city_list.AddVertex("沈阳");
city_list.AddVertex("北京");
city_list.AddVertex("天津");
city_list.AddVertex("石家庄");
city_list.AddVertex("济南");
city_list.AddVertex("郑州");
city_list.AddVertex("南京");
city_list.AddVertex("杭州");
city_list.AddVertex("上海");
city_list.AddVertex("合肥");
city_list.AddEdge("合肥", "杭州");
city_mapping_list[0] = new CityMapping(0, "合肥", "杭州");
city_list.AddEdge("合肥", "郑州");
city_mapping_list[1] = new CityMapping(1, "合肥", "郑州");
city_list.AddEdge("杭州", "郑州");
city_mapping_list[2] = new CityMapping(2, "杭州", "郑州");
city_list.AddEdge("杭州", "南京");
city_mapping_list[3] = new CityMapping(3, "杭州", "南京");
city_list.AddEdge("杭州", "上海");
city_mapping_list[4] = new CityMapping(4, "杭州", "上海");
city_list.AddEdge("郑州", "南京");
city_mapping_list[5] = new CityMapping(5, "郑州", "南京");
city_list.AddEdge("郑州", "石家庄");
city_mapping_list[6] = new CityMapping(6, "郑州", "石家庄");
city_list.AddEdge("南京", "石家庄");
city_mapping_list[7] = new CityMapping(7, "南京", "石家庄");
city_list.AddEdge("南京", "天津");
city_mapping_list[8] = new CityMapping(8, "南京", "天津");
city_list.AddEdge("南京", "济南");
city_mapping_list[9] = new CityMapping(9, "南京", "济南");
city_list.AddEdge("南京", "上海");
city_mapping_list[10] = new CityMapping(10, "南京", "上海");
city_list.AddEdge("上海", "济南");
city_mapping_list[11] = new CityMapping(11, "上海", "济南");
city_list.AddEdge("石家庄", "济南");
city_mapping_list[12] = new CityMapping(12, "石家庄", "济南");
city_list.AddEdge("石家庄", "北京");
city_mapping_list[13] = new CityMapping(13, "石家庄", "北京");
city_list.AddEdge("济南", "天津");
city_mapping_list[14] = new CityMapping(14, "济南", "天津");
city_list.AddEdge("北京", "沈阳");
city_mapping_list[15] = new CityMapping(15, "北京", "沈阳");
city_list.AddEdge("天津", "沈阳");
city_mapping_list[16] = new CityMapping(16, "天津", "沈阳");
city_list.AddEdge("合肥", "济南");
city_mapping_list[17] = new CityMapping(17, "合肥", "济南");
city_list.AddEdge("郑州", "济南");
city_mapping_list[18] = new CityMapping(18, "郑州", "济南");
city_tikcet_mapping["上海"] = new List <string>();
city_tikcet_mapping["上海"].Add("杭州");
city_tikcet_mapping["杭州"] = new List <String>();
city_tikcet_mapping["杭州"].Add("南京");
city_tikcet_mapping["南京"] = new List <string>();
city_tikcet_mapping["南京"].Add("合肥");
city_tikcet_mapping["南京"].Add("郑州");
city_tikcet_mapping["合肥"] = new List <String>();
city_tikcet_mapping["合肥"].Add("郑州");
city_tikcet_mapping["合肥"].Add("济南");
city_tikcet_mapping["郑州"] = new List <String>();
city_tikcet_mapping["郑州"].Add("石家庄");
city_tikcet_mapping["郑州"].Add("济南");
city_tikcet_mapping["济南"] = new List <String>();
city_tikcet_mapping["济南"].Add("石家庄");
city_tikcet_mapping["济南"].Add("天津");
city_tikcet_mapping["石家庄"] = new List <String>();
city_tikcet_mapping["石家庄"].Add("北京");
city_tikcet_mapping["北京"] = new List <String>();
city_tikcet_mapping["北京"].Add("沈阳");
city_tikcet_mapping["天津"] = new List <String>();
city_tikcet_mapping["天津"].Add("北京");
city_tikcet_mapping["天津"].Add("沈阳");
}
public void Add(T source, T target)
{
_adjacencyList.AddEdge(source, target, 0);
}
public virtual Edge AddEdge(Vertex source, Vertex target, int weight) => adjacencyList.AddEdge(source, target, weight);
