public Node(int gridX, int gridY, Vector3 worldPos, NodeT type) { this.type = type; this.worldPosition = worldPos; this.gridX = gridX; this.gridY = gridY; }
NodeT[,] Load(string filePath) { try { using (StreamReader sr = new StreamReader(filePath)) { string[] lines = sr.ReadToEnd().Split(new[] { '\r', '\n' }, System.StringSplitOptions.RemoveEmptyEntries); NodeT[,] tiles = new NodeT[lines.Length, mapX]; for (int i = 0; i < lines.Length; i++) { string[] nums = lines[i].Split(new[] { ',' }); for (int j = 0; j < Mathf.Min(nums.Length, mapX); j++) { int indexType; if (!int.TryParse(nums[j], out indexType)) { Debug.LogError("Cannot parse" + nums[j]); } tiles[i, j] = (NodeT)indexType; } } return(tiles); } } catch (IOException e) { Debug.Log(e.Message); return(null); } }
/// <summary> /// Constructor /// </summary> public LockFreeQueue() { _count = new ConcurrentInt64(); // ReSharper disable CompareNonConstrainedGenericWithNull _isNullable = default(T) == null; // ReSharper restore CompareNonConstrainedGenericWithNull var node = new NodeT(); _head._ptr = _tail._ptr = node; }
void GenerateMap() { Dictionary <NodeT, GameObject> terrainType = new Dictionary <NodeT, GameObject>() { { NodeT.ROAD, Road }, { NodeT.GRASS, Grass }, { NodeT.FOREST, Forest }, { NodeT.WATER, Water }, { NodeT.MOUNTAIN, Mountain } }; bool[,] used = new bool[mapX, mapX]; for (int x = 0; x < mapX; x++) { for (int y = 0; y < mapY; y++) { GameObject influenceTileObj = Instantiate(influenceTile, offset + new Vector3(x * nodeSizeX, -0.5f, y * nodeSizeY), Quaternion.Euler(90, 0, 0)); influenceTileObj.transform.parent = influenceGrid.transform; influenceTileObj.GetComponent <Renderer>().material.SetFloat("_Glossiness", 0f); if (used[x, y]) { continue; } int x1 = x, y1 = y; NodeT type = tiles[x, y]; while (x1 + 1 < mapX && Enumerable.Range(y, y1 - y + 1).All(i => tiles[x1 + 1, i] == type && !used[x1 + 1, y])) { for (int i = y; i <= y1; ++i) { used[x1 + 1, i] = true; } x1++; } while (y1 + 1 < mapY && Enumerable.Range(x, x1 - x + 1).All(i => tiles[i, y1 + 1] == type && !used[i, y1 + 1])) { for (int i = x; i <= x1; ++i) { used[i, y1 + 1] = true; } y1++; } int rows = x1 - x + 1; int cols = y1 - y + 1; float middleX = (float)(x + x1) / 2f; float middleY = (float)(y + y1) / 2f; GameObject TilePrefab = Instantiate(terrainType[tiles[x, y]], offset + new Vector3(middleX * nodeSizeX, 0, middleY * nodeSizeY), Quaternion.Euler(90, 0, 0)); TilePrefab.transform.localScale = new Vector3(rows, cols, 1f); TilePrefab.transform.parent = this.transform; } } }
Node[,] BuildMap() { Node[,] grid = new Node[mapX, mapX]; for (int x = 0; x < mapX; x++) { for (int y = 0; y < mapY; y++) { Vector3 position = offset + (Vector3.right * x * nodeSizeX) + (Vector3.forward * y * nodeSizeY); NodeT type = (NodeT)tiles[x, y]; grid[x, y] = new Node(x, y, position, type); grid[x, y].influenceTile = influenceGrid.transform.GetChild(x * mapY + y).GetComponent <Renderer>(); } } return(grid); }
/// <summary> /// Enqueue a single element /// </summary> /// <param name="t"></param> public void Enqueue(T t) { // Allocate a new node from the free list var node = new NodeT { _value = t }; // copy enqueued value into node // keep trying until Enqueue is done Boolean bEnqueueNotDone = true; while (bEnqueueNotDone) { // read Tail.ptr and Tail.count together PointerT tail = _tail; // read next ptr and next count together PointerT next = tail._ptr._next; // are tail and next consistent if (tail._count == _tail._count && tail._ptr == _tail._ptr) { // was tail pointing to the last node? if (null == next._ptr) { if (CAS(ref tail._ptr._next, next, new PointerT(node, next._count + 1))) { bEnqueueNotDone = false; } // endif } // endif else // tail was not pointing to last node { // try to swing Tail to the next node CAS(ref _tail, tail, new PointerT(next._ptr, tail._count + 1)); } } // endif } // endloop _count.Increment(); }
protected void ApplyActuator() {// Aqui el Actuator suma los steerings, los aplica a las velocidades, y las limita, teniendo en cuenta los costes NodeT node = Map.NodeFromPosition(position).type; float tCost = GetTerrainCost(position); Steering steering = ApplySteering(); if (velocity.magnitude > 0.1f) { steering += Face.GetSteering(position + velocity, this, interiorAngle, exteriorAngle, 0.1f, false); // Mover a ApplySteering steering += WallAvoidance.GetSteering(this, 10000f, Map.terrainMask, 0.7f, 0.7f, 0.5f, false); steering += AvoidUnits.GetSteering(this, 1000f, false); } velocity += steering.linear * Time.deltaTime / tCost; rotation += steering.angular * Time.deltaTime / tCost; velocity.y = 0; velocity = Vector3.ClampMagnitude(velocity, (float)MaxVelocity / tCost); rotation = Mathf.Clamp(rotation, -MaxRotation, MaxRotation); }
/// <summary> /// constructor that allows caller to specify ptr and count /// </summary> /// <param name="node"></param> /// <param name="c"></param> public PointerT(NodeT node, long c) { _ptr = node; _count = c; }