public void Initiate() { if (CinematographyAttributes.lensFovData != null && (cameraList != null && cameraList.Count > 0)) { initiated = true; return; } ProCamsLensDataTable.Instance.LoadData(); CinematographyAttributes.lensFovData = ProCamsLensDataTable.Instance.GetFilmFormat("35mm 16:9 Aperture (1.78:1)").GetLensKitData(0)._fovDataset; CinematographyAttributes.standardNoise = Instantiate(Resources.Load("Handheld_tele_mild", typeof(NoiseSettings))) as NoiseSettings; //FrameTypeList = new List<FramingType>() { FramingType.ExtremeLong, FramingType.Full, FramingType.Waist, FramingType.ExtremeCloseUp }; // problem information may not be useful here problemStates = GameObject.FindGameObjectWithTag("Problem").GetComponent <UnityProblemCompiler>(); // locations are the basic anchor for camera positioning tileMap = GameObject.FindGameObjectWithTag("Locations").GetComponent <TileGraph>(); // actors var actorHost = GameObject.FindGameObjectWithTag("ActorHost"); actors = new List <GameObject>(); for (int i = 0; i < actorHost.transform.childCount; i++) { actors.Add(actorHost.transform.GetChild(i).gameObject); } initiated = true; Debug.Log("Initiated"); }
// finalLoc teleports this render somewhere once it's complete. // Note that it will still render around the origin before teleporting away, so DON'T SET FINALLOC TO ZERO // UNLESS YOU'RE DELETING IMMEDIATELY / ONLY RENDERING ONE. public static Dictionary <TileNode, RenderedTileInfo> FinalRender(TileGraph g, Vector3 loc, List <float> fitVals, GameObject parent) { Dictionary <TileNode, RenderedTileInfo> ret = RenderNodes(g, parent); renderedGraph.transform.position = loc; DisplayFitness df = renderedGraph.AddComponent <DisplayFitness>(); df.fitnessValues = fitVals; return(ret); }
// // Summary: // Divide the x-z plane of the ground into a grid given the cell size void MakeGraph() { Bounds bounds = ground.GetComponent <Renderer>().bounds; Vector3 xzBoundsCenter = bounds.center + new Vector3(0, bounds.extents.y, 0); Vector3 gridTopLeft = xzBoundsCenter + new Vector3(-bounds.extents.x, 0, bounds.extents.z); int maxRowCount = (int)Mathf.Floor(bounds.size.z / cellSize); int maxColCount = (int)Mathf.Floor(bounds.size.x / cellSize); Tile[,] grid = new Tile[maxRowCount, maxColCount]; Vector3 offsetToCenter = new Vector3(cellSize / 2, 0, -cellSize / 2); for (int r = 0; r < grid.GetLength(0); r++) { for (int c = 0; c < grid.GetLength(1); c++) { // World space point that corresponds to the center of the tile Vector3 worldPoint = gridTopLeft + new Vector3(c * cellSize, 0, -(r * cellSize)) + offsetToCenter; // Determine overlapping obstacles TileType tileType = TileType.Free; Collider[] colliders = Physics.OverlapSphere(worldPoint, cellSize / 4); if (colliders != null && colliders.Length > 0) { bool foundCollision = true; // Check for collision with someone other than ourselves Collider ourCollider = ground.GetComponent <Collider>(); if (ourCollider != null) { foundCollision = false; for (int i = 0; i < colliders.Length; i++) { if (colliders[i] != ourCollider) { foundCollision = true; break; } } } // if we don't have a collider, we are definitely colliding with something else if (foundCollision) { tileType = TileType.Obstacle; } } // Make tile grid[r, c] = new Tile(new Vector2Int(r, c), tileType, worldPoint); } } graph = new TileGraph(grid); }
private void AddRoadsFromTemplateToMap(ObjectTemplate template, Map map, MapInfo info, string roadType) { var tileGraph = new TileGraph(info.Tiles, TileInfo.Free); var roads = template.Objects.Where(o => o.RoadOptions != RoadOptions.None && o.Type == ObjectTemplate.RoadTemplate).ToArray(); int count = info.Roads.Nodes.Count; ScriptObject road1, road2; for (int i = 0; i < roads.Length; i += 2) { road1 = roads[i]; road2 = roads[i + 1]; var start = info.Roads.FindNode(new Point(road1.X, road1.Y)); if (start == null) { start = new RoadGraphNode(new Point(road1.X, road1.Y), !road1.RoadOptions.HasFlag(RoadOptions.Join) && roads.Count(r2 => road1.X == r2.X && road1.Y == r2.Y) == 1, true); info.Roads.Nodes.AddLast(start); } var end = info.Roads.FindNode(new Point(road2.X, road2.Y)); if (end == null) { end = new RoadGraphNode(new Point(road2.X, road2.Y), !road2.RoadOptions.HasFlag(RoadOptions.Join) && roads.Count(r2 => road2.X == r2.X && road2.Y == r2.Y) == 1, true); info.Roads.Nodes.AddLast(end); } start.LinkTo(end); road1.Type = roadType; road2.Type = roadType; info.Roads.Segments.Add(new Tuple <ScriptObject, ScriptObject>(road1, road2)); tileGraph.UpdateTiles(new[] { map.PositionToCoordinates(start.Position), map.PositionToCoordinates(end.Position) }, TileInfo.Road); } IEnumerable <RoadGraphNode> nodes = info.Roads.Nodes.Skip(count).ToArray(); var endpoints = from r in nodes where !r.CanBeConnected && r.Neighbors.Count == 1 select r; foreach (var endpoint in endpoints) { foreach (var node in nodes) { if (node != endpoint && (node.Position - endpoint.Position).VectorLengthSquared() < endpointConnectionRange * endpointConnectionRange) { endpoint.LinkTo(node); } } } }
public void Process(Map map, MapInfo info) { this.map = map; this.info = info; this.tileGraph = new TileGraph(info.Tiles, invalidTiles); this.random = new Random(info.MapId); this.heightConstraints = new Grid <byte>(map.HeightMap.Width, map.HeightMap.Height); for (int i = 0; i < map.Tiles.Width; i++) { for (int j = 0; j < map.Tiles.Height; j++) { heightConstraints[i, j] = 255; var invalidNeighbors = tileGraph.GetNeighbors(i, j, invalidTileRadius, false, true); foreach (var neighbor in invalidNeighbors) { if (map.HeightMap.CheckCoordinates(neighbor.X, neighbor.Y)) { int distance = System.Math.Max(System.Math.Abs(neighbor.X - i), System.Math.Abs(neighbor.Y - j)); heightConstraints[i, j] = (byte)System.Math.Min(heightConstraints[i, j], map.HeightMap[neighbor.X, neighbor.Y] + (distance - 1) * MaxHeightDifferencePerTile); } } } } int min, max; switch (info.Settings.NumberOfCliffs) { case Frequency.Low: min = 0; max = (int)(map.Tiles.Count / lowDivisor); break; case Frequency.High: min = (int)(map.Tiles.Count / mediumDivisor); max = (int)(map.Tiles.Count / highDivisor); break; default: min = (int)(map.Tiles.Count / lowDivisor); max = (int)(map.Tiles.Count / mediumDivisor); break; } int count = random.Next(min, max); for (int i = 0; i < count && !info.IsCancellationRequested; i++) { AddCliff(); } }
public void Process(Map map, MapInfo info) { if (info.Settings.Scenery.Rocks.Count == 0) { return; } this.info = info; this.tileGraph = new TileGraph(info.Tiles, invalidTiles); int count; switch (Frequency) { case Frequency.High: count = map.Tiles.Count / 1000; break; case Frequency.Low: count = map.Tiles.Count / 3000; break; default: count = map.Tiles.Count / 2000; break; } Random random = new Random(info.MapId); int width = map.HeightMap.MapWidth * (int)Map.TileWidth; int height = map.HeightMap.MapHeight * (int)Map.TileWidth; while (count > 0 && !info.IsCancellationRequested) { float x = random.Next(width); float y = random.Next(height); var coordinates = map.PositionToCoordinates(new Point(x, y)); if (info.IsWithinStartingRange(coordinates, 10)) { continue; } if (IsTileValid(coordinates.X, coordinates.Y)) { int rock = random.Next(info.Settings.Scenery.Rocks.Count); map.Objects.Add(info.ObjectFactory.CreateObject(info.Settings.Scenery.Rocks[rock], x, y, 0, (float)(((random.NextDouble() * 2) - 1) * System.Math.PI))); count--; } } }
public static Stack <TileNode> Astar(TileGraph tg, TileNode start, TileNode end) { frontier = new SimplePriorityQueue <TileNode, float>(); frontier.Enqueue(start, 0f); node_dict = new Dictionary <TileNode, NodeInfo>(); List <TileNode> Expanded = new List <TileNode>(); while (frontier.Count > 0) { } return(Path); }
public void Process(Map map, MapInfo info) { this.map = map; this.info = info; this.tileGraph = new TileGraph(info.Tiles, invalidTiles); this.random = new Random(info.MapId); for (int i = 0; i < map.HeightMap.Width - 1; i++) { for (int j = 1; j < map.HeightMap.Height - 1; j++) { Flatten(i, j); } } }
public static Stack <TileNode> Astar(TileGraph tg, TileNode start, TileNode end) { frontier = new SimplePriorityQueue <TileNode, float>(); frontier.Enqueue(start, 0f); //node_dict = new Dictionary<TileNode, NodeInfo>(); node_dict = DijkstraInitialDictLoad(start, tg); List <TileNode> Expanded = new List <TileNode>(); TileNode v; TileNode other; float cost_so_far; float edge_weight; float dist_to_node; float manhattanDistance; while (frontier.Count > 0) { v = frontier.Dequeue(); cost_so_far = node_dict[v].dist; Expanded.Add(v); List <Edge> experiment = tg.getAdjacentEdges(v) as List <Edge>; foreach (Edge adj_edge in tg.getAdjacentEdges(v)) { other = adj_edge.getNeighbor(v); edge_weight = adj_edge.weight; dist_to_node = node_dict[other].dist; manhattanDistance = Mathf.Abs(end.transform.position.z - other.transform.position.z) + Mathf.Abs(end.transform.position.x - other.transform.position.x); if (cost_so_far + edge_weight < dist_to_node) { node_dict[other].dist = cost_so_far + edge_weight; node_dict[other].heuristic = node_dict[other].dist + manhattanDistance; node_dict[other].parent = v; } if (!Expanded.Any(node => node.isEqual(other)) && !frontier.Any(node => node.isEqual(other))) { frontier.Enqueue(other, node_dict[other].heuristic); } } } Path = NodeDictToPath(node_dict, start, end); return(Path); }
public void Process(Map map, MapInfo info) { var graph = new TileGraph(info.Tiles, TileInfo.Free); var generator = new RampGenerator(info.MapId); foreach (var area in info.FlattenedAreas) { if (info.IsCancellationRequested) { return; } var coordinates = map.PositionToCoordinates(area.Center); var height = (byte)graph.GetNeighbors(coordinates, (int)(area.Radius / Map.TileWidth) + 3, true, true).Average(c => map.HeightMap[c.X, c.Y]); generator.GenerateFlatArea(map, coordinates, height, (int)(area.Radius / Map.TileWidth), area.Radius); } }
public void Process(Map map, MapInfo info) { this.map = map; this.info = info; this.tileGraph = new TileGraph(info.Tiles, TileInfo.Structure | TileInfo.Cliff); this.roadsLeadingOutOfMap = new List <RoadGraphEdge>(); this.random = new Random(info.MapId); AddRoadsBetweenNodes(); AddRoadsLeadingOutOfMapForDanglingNodes(); AddAdditionalRoadsLeadingOutOfMap(); CheckTightCurves(); AddOffsets(); }
public static Stack <TileNode> Dijkstra(TileGraph tg, TileNode start, TileNode end) { frontier = new SimplePriorityQueue <TileNode, float>(); frontier.Enqueue(start, 0f); node_dict = DijkstraInitialDictLoad(start, tg); List <TileNode> Expanded = new List <TileNode>(); TileNode v; TileNode other; float edge_weight; float dist_to_node; float cost_so_far; while (frontier.Count > 0) { v = frontier.Dequeue(); cost_so_far = node_dict[v].dist; Expanded.Add(v); //List<Edge> experiment = tg.getAdjacentEdges(v) as List<Edge>; foreach (Edge adj_edge in tg.getAdjacentEdges(v)) { other = adj_edge.getNeighbor(v); edge_weight = adj_edge.weight; dist_to_node = node_dict[other].dist; if (cost_so_far + edge_weight < dist_to_node) { node_dict[other].dist = cost_so_far + edge_weight; node_dict[other].parent = v; } if (!Expanded.Any(node => node.isEqual(other)) && !frontier.Any(node => node.isEqual(other))) { frontier.Enqueue(other, node_dict[other].dist); } } } Path = NodeDictToPath(node_dict, start, end); return(Path); }
// Use this for initialization public void Start() { teleporterTiles = new Dictionary <int, List <GameObject> >(); teleporterPads = new Dictionary <int, GameObject>(); receiverTile = new Dictionary <int, GameObject>(); levelSelectTeleporterTile = new Dictionary <int, List <GameObject> >(); // MinX = float.MaxValue; // MinZ = float.MaxValue; // MaxX = float.MinValue; // MaxZ = float.MinValue; //this is only going tobe attached to an empty object but center //it at the origin anyway gameObject.transform.position = Vector3.zero; _recentlyVisitedTiles = new List <DJ_Point>(); _tileGlowTimes = new List <float>(); _recentlyLaserVisitedTiles = new List <DJ_Point>(); _tileLaserGlowTimes = new Dictionary <DJ_Point, float>(); _prevPlayerPos = new DJ_Point(int.MaxValue, int.MaxValue); tilePool = new Stack <TileNode>(); tileMap = new Dictionary <DJ_Point, TileNode>(DJ_PointComparer.Default); // Instantiate the checkpoint system checkpointList = new List <DJ_Point>(); exitPoint = new DJ_Point(0, 0); levelselectList = new List <DJ_Point>(); onBeat = false; //Instantiate level select points tileGraph = new TileGraph(this.gameObject, m_tilePrefab); LinkTeleporters(); LinkLevelSelectTeleporters(); tileMap = tileGraph.tileMap; //print (tilegraph); }
private static Dictionary <TileNode, NodeInfo> DijkstraInitialDictLoad(TileNode start, TileGraph tg) { node_dict = new Dictionary <TileNode, NodeInfo>(); foreach (TileNode tn in tg.nodes) { NodeInfo ni = new NodeInfo(); if (start.isEqual(tn)) { ni.dist = 0f; } node_dict[tn] = ni; } return(node_dict); }
public void Process(Map map, MapInfo info) { InitializeTypes(); this.map = map; this.info = info; this.tiles = new TileGraph(info.Tiles, TileInfo.Base | TileInfo.FuelDepotFar | TileInfo.FlagFar); this.resourcesPlayer = map.Players.FirstOrDefault(p => p.Properties["playerName"].Value.Equals("Resources")); this.axesOfSymmetry = new SymmetryAnalyzer().Analyze(map, info.StartingPositions); this.villagePositions = new List <Point>(); this.random = new Random(info.MapId); // There are always at least two axes which should intersect at the map center. Point center = axesOfSymmetry[0].Intersect(axesOfSymmetry[1]); // Generate a village in the center. if (random.Next(3) == 0) { GenerateVillage(center, villages[random.Next(villages.Count)]); } // Generate two villages along the primary axis. if (random.Next(3) == 0) { Point[] positions = new Point[2]; var direction = axesOfSymmetry[0].IsVertical ? new Point(0, 1) : new Point(1, axesOfSymmetry[0].Slope).Normalize(); var maxLength = System.Math.Min(center.X, center.Y); do { float distance = (float)random.NextDouble() * maxLength; positions[0] = center + direction * distance; positions[1] = center - direction * distance; }while (!CheckVillagePositions(positions) && !info.IsCancellationRequested); GenerateVillages(positions); } // Generate a village for every player. if (random.Next(3) == 0) { Point[] positions = null; int count = 0; do { positions = GetRandomMirroredPositions(); count++; }while (!CheckVillagePositions(positions) && !info.IsCancellationRequested); if (count < 100) { GenerateVillages(positions); } } while (smallFlag.Info.Count < 2 * info.NumberOfPlayers && !info.IsCancellationRequested) { GenerateResource(random.NextDouble() < 0.5 ? smallFlag : largeFlag); } while (smallFuelDepot.Info.Count < 2 * info.NumberOfPlayers && !info.IsCancellationRequested) { GenerateResource(random.NextDouble() < 0.5 ? smallFuelDepot : largeFuelDepot); } }
public static List <Vector3> Pathfind(TileGraph graph, Node fromNode, Node toNode) { List <Vector3> waypoints = new List <Vector3>(); //TODO : implement Dijkstra List <PathfindingNode> openList = new List <PathfindingNode>(); List <PathfindingNode> closedList = new List <PathfindingNode>(); Dictionary <Node, PathfindingNode> pathfindingNodes = new Dictionary <Node, PathfindingNode>(); pathfindingNodes.Add(fromNode, new PathfindingNode(fromNode)); openList.Add(pathfindingNodes[fromNode]); while (openList.Count > 0 && !DoesListContainNode(toNode, closedList)) { //TODO find connections from the lowest cost so far point to all connected points // How do I know what the lowest cost so far is? openList.Sort(); PathfindingNode smallestCostSoFar = openList[0]; // How do we get connections? foreach (Node connectedNode in smallestCostSoFar.graphNode.connections.Keys) { if (!DoesListContainNode(connectedNode, closedList)) { if (!DoesListContainNode(connectedNode, openList)) { float costToConnectedNode = smallestCostSoFar.costSoFar + smallestCostSoFar.graphNode.connections[connectedNode]; PathfindingNode predecessor = smallestCostSoFar; pathfindingNodes.Add(connectedNode, new PathfindingNode(connectedNode, costToConnectedNode, predecessor)); openList.Add(pathfindingNodes[connectedNode]); } else { // Is my connection from the current processing node faster than the existing connectino to this node? // If so, update it. float currentCostToTarget = pathfindingNodes[connectedNode].costSoFar; float costToTargetThroughCurrentNode = smallestCostSoFar.costSoFar + smallestCostSoFar.graphNode.connections[connectedNode]; if (costToTargetThroughCurrentNode < currentCostToTarget) { pathfindingNodes[connectedNode].costSoFar = costToTargetThroughCurrentNode; pathfindingNodes[connectedNode].predecessor = smallestCostSoFar; } } } } closedList.Add(smallestCostSoFar); openList.Remove(smallestCostSoFar); }//end of while loop - pathfinding complete //TODO fill out waypoints //Destination node is on closed list //All of its predecessors are on the closed list for (PathfindingNode waypoint = pathfindingNodes[toNode]; waypoint != null; waypoint = waypoint.predecessor) { waypoints.Add(waypoint.graphNode.pos); Debug.Log(waypoint.graphNode.pos); } waypoints.Reverse(); return(waypoints); }
public void Generate() { graph = GraphGenerator.GenerateGraph(); }
public static Dictionary <TileNode, RenderedTileInfo> RenderNodes(TileGraph g, GameObject parent) { renderedGraph = new GameObject(); renderedGraph.transform.position = Vector3.zero; if (parent != null) { renderedGraph.transform.parent = parent.transform; } GameObject origin = new GameObject(); origin.name = "Origin"; origin.transform.parent = renderedGraph.transform; Dictionary <TileNode, RenderedTileInfo> renderedTiles = new Dictionary <TileNode, RenderedTileInfo>(); //List<TileNode> nodesToRemove = new List<TileNode>(); renderedTiles.Add(g.nodes[0], new RenderedTileInfo(g.nodes[0].type, Vector3.zero, 0, g.nodes[0], renderedGraph)); // Unexplored nodes HAVE BEEN RENDERED but have not been explored for connections. Queue <TileNode> unexploredNodes = new Queue <TileNode>(); // Explored nodes HAVE BEEN RENDERED and have been explored. List <TileNode> exploredNodes = new List <TileNode>(); unexploredNodes.Enqueue(g.nodes[0]); while (unexploredNodes.Count > 0) { TileNode curr = unexploredNodes.Dequeue(); exploredNodes.Add(curr); // For each node connected to this one... foreach (TileNode newTile in curr.connectedNodes) { if (renderedTiles.ContainsKey(newTile)) { continue; } Vector3 doorLoc = renderedTiles[curr].GetDoorLoc(); Vector3 firstDoor = doorLoc; Vector3 tileLoc = Vector3.zero; float rotation = 0; bool placeable = true; for (int d = 0; d < newTile.type.doorLocs.Length; d++) { int rotationCount = 0; for (rotation = (newTile.seed % 4) * 90; rotationCount < 4; rotation += 90, rotationCount++) { do { tileLoc = doorLoc - Quaternion.Euler(0, rotation, 0) * newTile.type.doorLocs[d]; placeable = true; for (int k = 0; k < newTile.type.boundingBoxes.Length; k++) { if (!newTile.type.boundingBoxes[k].IsPlaceable(tileLoc, rotation)) { placeable = false; break; } } if (placeable) { break; } doorLoc = renderedTiles[curr].GetDoorLoc(); } while (doorLoc != firstDoor); if (placeable) { break; } } if (placeable) { break; } } if (!placeable) { continue; } RenderedTileInfo newRenderedTile = new RenderedTileInfo(newTile.type, tileLoc, rotation, newTile, renderedGraph); // door detection should do this. //renderedTiles[connections[j]].OccupyLastDoor(newRenderedTile); renderedTiles.Add(newTile, newRenderedTile); unexploredNodes.Enqueue(newTile); } } List <TileNode> nodesToRemove = new List <TileNode>(); foreach (TileNode t in g.nodes) { if (!renderedTiles.ContainsKey(t)) { nodesToRemove.Add(t); } } // Backpropogate removed nodes. foreach (TileNode t in nodesToRemove) { g.nodes.Remove(t); } // Backpropogate removed node connections. foreach (TileNode t in g.nodes) { foreach (TileNode r in nodesToRemove) { t.connectedNodes.Remove(r); } } // Check for other connections to remove. foreach (TileNode t in g.nodes) { List <TileNode> connsToRemove = new List <TileNode>(); foreach (TileNode c in t.connectedNodes) { bool found = false; foreach (RenderedTileInfo r in renderedTiles[t].connectedTiles) { if (c == r.sourceNode) { found = true; } } if (!found) { connsToRemove.Add(c); } } foreach (TileNode c in connsToRemove) { t.RemoveConnectedNode(c); } } return(renderedTiles); }
public void Process(Map map, MapInfo info) { if (info.Settings.Scenery.Trees.Count == 0) { return; } this.info = info; this.tileGraph = new TileGraph(info.Tiles, invalidTiles); int min, max; double formula = map.Tiles.Count / 300.0; switch (info.Settings.NumberOfTrees) { case Frequency.High: min = max = (int)(formula * 6); break; case Frequency.Low: min = max = (int)(formula * 1.5); break; default: min = max = (int)(formula * 3); break; } Random random = new Random(info.MapId); IList <ScriptObject> trees = new List <ScriptObject>(); int width = map.HeightMap.MapWidth * (int)Map.TileWidth; int height = map.HeightMap.MapHeight * (int)Map.TileWidth; int count = random.Next(min, max + 1); while (trees.Count < count && !info.IsCancellationRequested) { float x = random.Next(width); float y = random.Next(height); for (int j = 0; j < random.Next(20); j++) { float dx = (float)(random.NextDouble() * 40) + 10; float dy = (float)(random.NextDouble() * 40) + 10; int direction = random.Next(3); switch (direction) { case 1: dx *= -1; break; case 2: dy *= -1; break; } x = (x + dx + width) % width; y = (y + dy + height) % height; var coordinates = map.PositionToCoordinates(new Point(x, y)); if (info.IsWithinStartingRange(coordinates, 10)) { continue; } if (IsTileValid(coordinates.X, coordinates.Y)) { int tree = random.Next(info.Settings.Scenery.Trees.Count); trees.Add(info.ObjectFactory.CreateObject(info.Settings.Scenery.Trees[tree], x, y, 0, (float)(((random.NextDouble() * 2) - 1) * System.Math.PI))); } } } for (int i = 0; i < trees.Count - 1; i++) { if (trees[i] != null) { for (int j = i + 1; j < trees.Count; j++) { if (trees[j] != null && trees[i].SquaredDistanceOnGround(trees[j]) < 100) { trees[j] = null; } } map.Objects.Add(trees[i]); } } }