public bool Contains(RectangleXZ other) { if (other._maxZ > this._maxZ || other._minZ < this._minZ || other._maxX > this._maxX) { return(false); } return(other._minX >= this._minX); }
/// <summary> /// Determines whether another rectangle overlaps this one (and vice versa). /// </summary> /// <param name="other">The other rectangle.</param> /// <returns><c>true</c> if they overlap, otherwise false.</returns> public bool Overlaps(RectangleXZ other) { if ((other._maxX <= _minX) || (other._minX >= _maxX)) { return(false); } return((other._maxZ > _minZ) && (other._minZ < _maxZ)); }
public bool Overlaps(RectangleXZ other) { if (other._maxX <= this._minX || other._minX >= this._maxX) { return(false); } if (other._maxZ <= this._minZ) { return(false); } return(other._minZ < this._maxZ); }
public static RectangleXZ MinMaxRect(float minX, float minZ, float maxX, float maxZ) { RectangleXZ rectangleXZ = new RectangleXZ() { _minX = minX, _minZ = minZ, _maxX = maxX, _maxZ = maxZ }; return(rectangleXZ); }
/// <summary> /// Determines whether another rectangle overlaps this one (and vice versa). /// </summary> /// <param name="other">The other rectangle.</param> /// <returns><c>true</c> if they overlap, otherwise false.</returns> public bool Overlaps(RectangleXZ other) { if ((other._maxX <= _minX) || (other._minX >= _maxX)) { return false; } return ((other._maxZ > _minZ) && (other._minZ < _maxZ)); }
/// <summary> /// Determines whether an<paramref name="other"/> rectangle is contained inside this rectangle. /// </summary> /// <param name="other">The rectangle to check.</param> /// <returns><c>true</c> if contained or identical, otherwise false.</returns> public bool Contains(RectangleXZ other) { return ((other._maxZ <= _maxZ) && (other._minZ >= _minZ) && (other._maxX <= _maxX) && (other._minX >= _minX)); }
/// <summary> /// Initializes a new instance of the <see cref="ProgressiveVectorField"/> class. /// </summary> /// <param name="group">The group.</param> /// <param name="path">The path.</param> /// <param name="options">The options.</param> public ProgressiveVectorField(TransientGroup<IUnitFacade> group, Path path, VectorFieldOptions options) { Ensure.ArgumentNotNull(group, "group"); this.group = group; _currentPath = path; var modelUnit = group.modelUnit; _unitProperties = modelUnit; var pathOptions = modelUnit.pathFinderOptions; // cache options locally _allowCornerCutting = pathOptions.allowCornerCutting; _allowDiagonals = !pathOptions.preventDiagonalMoves; _announceAllNodes = modelUnit.pathNavigationOptions.announceAllNodes; _obstacleStrengthFactor = options.obstacleStrengthFactor; _builtInContainment = options.builtInContainment; _updateInterval = options.updateInterval; _paddingIncrease = options.paddingIncrease; _maxExtraPadding = options.maxExtraPadding; _boundsPadding = options.boundsPadding; _boundsRecalculateThreshold = options.boundsRecalculateThreshold; _expectedGroupGrowthFactor = 1f + options.expectedGroupGrowthFactor; // pre-allocate lists memory _openSet = new SimpleQueue<Cell>(31); _tempWalkableNeighbours = new DynamicArray<Cell>(8); _extraTempWalkableNeighbours = new DynamicArray<Cell>(8); _groupBounds = new RectangleXZ(group.centerOfGravity, _boundsPadding, _boundsPadding); }
private bool ConstructGroupBounds(bool forceConstruction = false) { int membersCount = group.count; if (membersCount == 0) { return false; } // find minimum and maximum coordinates for the group float minX = float.MaxValue, minZ = float.MaxValue, maxX = float.MinValue, maxZ = float.MinValue; Vector3 groupCog = Vector3.zero; for (int i = 0; i < membersCount; i++) { var member = group[i]; if (member == null) { continue; } var pos = member.position; if (pos.x < minX) { minX = pos.x; } if (pos.z < minZ) { minZ = pos.z; } if (pos.x > maxX) { maxX = pos.x; } if (pos.z > maxZ) { maxZ = pos.z; } // sum up all unit positions groupCog += pos; } // divide the summed up unit positions by the unit count, in order to get the "average group position" or center of gravity groupCog /= membersCount; if (!forceConstruction && ((groupCog - _groupBounds.center).sqrMagnitude < (_boundsRecalculateThreshold * _boundsRecalculateThreshold))) { // if not forcing the construction, check whether the group has moved from its last group bounds center enough return false; } // push the minimum and maximum values by the bounds padding and the potential extra padding resultant from growing bounds var padding = _boundsPadding + _extraPadding; minX -= padding; minZ -= padding; maxX += padding; maxZ += padding; float yPos = groupCog.y; // find minimum and maximum cells, in order to construct the group bounds "cell-aligned" Vector3 vecMinXZ = new Vector3(minX, yPos, minZ); Cell minXZ = _grid.GetCell(vecMinXZ, true); minX = minXZ.position.x; minZ = minXZ.position.z; Vector3 vecMaxXZ = new Vector3(maxX, yPos, maxZ); Cell maxXZ = _grid.GetCell(vecMaxXZ, true); maxX = maxXZ.position.x; maxZ = maxXZ.position.z; // finally, actually instantiate the new group bounds _groupBounds = new RectangleXZ(minX, minZ, (maxX - minX), (maxZ - minZ)); return true; }
private GridSection[] CreateSubSections(Vector3 start) { var subSectionsX = Math.Max(this.subSectionsX, 1); var subSectionsZ = Math.Max(this.subSectionsZ, 1); var overLap = this.subSectionsCellOverlap * this.cellSize; var subSectionWidth = ((this.sizeX + ((subSectionsX - 1) * this.subSectionsCellOverlap)) * this.cellSize) / (subSectionsX * 1.0f); var subSectionDepth = ((this.sizeZ + ((subSectionsZ - 1) * this.subSectionsCellOverlap)) * this.cellSize) / (subSectionsZ * 1.0f); var subSectionCount = subSectionsX * subSectionsZ; var gridSections = new GridSection[subSectionCount]; int idx = 0; for (int i = 0; i < subSectionsX; i++) { for (int j = 0; j < subSectionsZ; j++) { var rect = new RectangleXZ( start.x + (subSectionWidth * i) - (overLap * i), start.z + (subSectionDepth * j) - (overLap * j), subSectionWidth, subSectionDepth); gridSections[idx++] = new GridSection(rect); } } return gridSections; }
/// <summary> /// Determines whether an<paramref name="other"/> rectangle is contained inside this rectangle. /// </summary> /// <param name="other">The rectangle to check.</param> /// <returns><c>true</c> if contained or identical, otherwise false.</returns> public bool Contains(RectangleXZ other) { return((other._maxZ <= _maxZ) && (other._minZ >= _minZ) && (other._maxX <= _maxX) && (other._minX >= _minX)); }
/// <summary> /// Initializes a new instance of the <see cref="GridSection"/> class. /// </summary> /// <param name="rect">The rectangle defining the section.</param> public GridSection(RectangleXZ rect) { this.bounds = rect; this.lastChanged = -1f; }
private bool ConstructGroupBounds(bool forceConstruction = false) { int membersCount = group.count; if (membersCount == 0) { return false; } // find minimum and maximum coordinates for the group float minX = float.MaxValue, minZ = float.MaxValue, maxX = float.MinValue, maxZ = float.MinValue; Vector3 groupCog = Vector3.zero; for (int i = 0; i < membersCount; i++) { var member = group[i]; if (member == null) { continue; } var pos = member.position; if (pos.x < minX) { minX = pos.x; } if (pos.z < minZ) { minZ = pos.z; } if (pos.x > maxX) { maxX = pos.x; } if (pos.z > maxZ) { maxZ = pos.z; } // sum up all unit positions groupCog += pos; } // divide the summed up unit positions by the unit count, in order to get the "average group position" or center of gravity groupCog /= membersCount; if (!forceConstruction && ((groupCog - _groupBounds.center).sqrMagnitude < (_boundsRecalculateThreshold * _boundsRecalculateThreshold))) { // if not forcing the construction, check whether the group has moved from its last group bounds center enough return false; } // first grid is the one where the group center is var grid = GridManager.instance.GetGrid(groupCog); if (grid == null) { return false; } if (_portalNewGroupThreshold <= 0f) { // if we have not set our portal new group threshold yet, then do it (based on diagonal cell size) _portalNewGroupThreshold = (grid.cellSize * Consts.SquareRootTwo) + 0.1f; } _grids.Clear(); AddGrid(grid); // push the minimum and maximum values by the bounds padding and the potential extra padding resultant from growing bounds var padding = _boundsPadding + _extraPadding; minX -= padding; minZ -= padding; maxX += padding; maxZ += padding; float yPos = groupCog.y; // find minimum and maximum cells, in order to construct the group bounds "cell-aligned" and in order to add all relevant grids Vector3 vecMinXZ = new Vector3(minX, yPos, minZ); var gridMinXZ = GridManager.instance.GetGrid(vecMinXZ); // bottom left corner grid if (gridMinXZ != null) { AddGrid(gridMinXZ); Cell minXZ = gridMinXZ.GetCell(vecMinXZ, true); minX = minXZ.position.x; minZ = minXZ.position.z; } Vector3 vecMaxXZ = new Vector3(maxX, yPos, maxZ); var gridMaxXZ = GridManager.instance.GetGrid(vecMaxXZ); // top right corner grid if (gridMaxXZ != null) { AddGrid(gridMaxXZ); Cell maxXZ = gridMaxXZ.GetCell(vecMaxXZ, true); maxX = maxXZ.position.x; maxZ = maxXZ.position.z; } // top left corner grid var gridMinXMaxZ = GridManager.instance.GetGrid(new Vector3(minX, yPos, maxZ)); AddGrid(gridMinXMaxZ); // bottom right corner grid var gridMaxXMinZ = GridManager.instance.GetGrid(new Vector3(maxX, yPos, minZ)); AddGrid(gridMaxXMinZ); // finally, actually instantiate the new group bounds _groupBounds = new RectangleXZ(minX, minZ, (maxX - minX), (maxZ - minZ)); return true; }