/// <summary> /// Constructs a MagicBox instance for the given recipient entities and target position. /// </summary> /// <param name="recipientEntities">The recipient entities.</param> /// <param name="targetPosition">The target position.</param> public MagicBox(RCSet <Entity> recipientEntities, RCNumVector targetPosition) { this.commonTargetPosition = RCNumVector.Undefined; this.targetPositions = new Dictionary <Entity, RCNumVector>(); /// Check if we shall keep formation of the recipient entities. RCNumRectangle boundingBox = this.CalculateBoundingBox(recipientEntities); if (!boundingBox.Contains(targetPosition)) { RCNumVector boundingBoxCenter = (2 * boundingBox.Location + boundingBox.Size) / 2; foreach (Entity entity in recipientEntities) { RCNumVector boxLocationToEntityVector = entity.MotionControl.PositionVector.Read() - boundingBox.Location; RCNumVector magicBox = entity.MotionControl.IsFlying ? AIR_MAGIC_BOX : GROUND_MAGIC_BOX; if (boxLocationToEntityVector.X > magicBox.X || boxLocationToEntityVector.Y > magicBox.Y) { /// Entity is outside of the magic box -> don't keep formation. this.commonTargetPosition = targetPosition; break; } /// Calculate the target position of the entity. this.targetPositions[entity] = targetPosition + entity.MotionControl.PositionVector.Read() - boundingBoxCenter; } } else { /// Target position is inside the bounding box -> don't keep formation. this.commonTargetPosition = targetPosition; } }
/// <see cref="EntityPlacementConstraint.CheckImpl"/> protected override RCSet <RCIntVector> CheckImpl(Scenario scenario, RCIntVector position, RCSet <Entity> entitiesToIgnore) { RCIntRectangle objArea = new RCIntRectangle(position, scenario.Map.CellToQuadSize(this.EntityType.Area.Read().Size)); RCSet <RCIntVector> retList = new RCSet <RCIntVector>(); for (int absY = objArea.Top; absY < objArea.Bottom; absY++) { for (int absX = objArea.Left; absX < objArea.Right; absX++) { RCIntVector absQuadCoords = new RCIntVector(absX, absY); if (absQuadCoords.X >= 0 && absQuadCoords.X < scenario.Map.Size.X && absQuadCoords.Y >= 0 && absQuadCoords.Y < scenario.Map.Size.Y) { /// Collect all the entities that are on the ground, are too close and not to be ignored. RCIntRectangle checkedQuadRect = new RCIntRectangle(absQuadCoords - this.minimumDistance, this.checkedQuadRectSize); RCNumRectangle checkedArea = (RCNumRectangle)scenario.Map.QuadToCellRect(checkedQuadRect) - new RCNumVector(1, 1) / 2; RCSet <T> entitiesTooClose = scenario.GetElementsOnMap <T>(checkedArea, MapObjectLayerEnum.GroundObjects); if (entitiesTooClose.Any(entityTooClose => !entitiesToIgnore.Contains(entityTooClose))) { retList.Add(absQuadCoords - position); } } } } return(retList); }
/// <summary> /// Gets the scenario elements of the given type that are attached to at least one of the given layers of the map inside the given area. /// </summary> /// <typeparam name="T">The type of the scenario elements to get.</typeparam> /// <param name="area"> /// <param name="firstLayer">The first layer to search in.</param> /// <param name="furtherLayers">List of the further layers to search in.</param> /// The area to search. /// </param> /// <returns> /// A list that contains the scenario elements of the given type that are attached to at least one of the given layers of the map inside /// the given area. /// </returns> public RCSet <T> GetElementsOnMap <T>(RCNumRectangle area, MapObjectLayerEnum firstLayer, params MapObjectLayerEnum[] furtherLayers) where T : ScenarioElement { if (area == RCNumRectangle.Undefined) { throw new ArgumentNullException("area"); } if (furtherLayers == null) { throw new ArgumentNullException("furtherLayers"); } RCSet <T> retList = new RCSet <T>(); foreach (MapObject mapObj in this.mapObjects[firstLayer].GetContents(area)) { T elementAsT = mapObj.Owner as T; if (elementAsT != null) { retList.Add(elementAsT); } } foreach (MapObjectLayerEnum furtherLayer in furtherLayers) { foreach (MapObject mapObj in this.mapObjects[furtherLayer].GetContents(area)) { T elementAsT = mapObj.Owner as T; if (elementAsT != null) { retList.Add(elementAsT); } } } return(retList); }
/// <summary> /// Computes the distance between two rectangles on the map. /// </summary> /// <param name="fromRectangle">The first rectangle on the map.</param> /// <param name="toRectangle">The second rectangle on the map.</param> /// <returns>The computed distance between the given rectangles.</returns> public static RCNumber ComputeDistance(RCNumRectangle fromRectangle, RCNumRectangle toRectangle) { /// The distance is 0 in case of intersection. if (fromRectangle.IntersectsWith(toRectangle)) { return(0); } /// Calculate the relative position. bool isOnLeftSide = fromRectangle.Right <= toRectangle.Left; bool isOnRightSide = toRectangle.Right <= fromRectangle.Left; bool isAbove = fromRectangle.Bottom <= toRectangle.Top; bool isBelow = toRectangle.Bottom <= fromRectangle.Top; /// Handle the 8 possible cases. if (isOnLeftSide && isAbove && !isOnRightSide && !isBelow) { return(MapUtils.ComputeDistance( new RCNumVector(fromRectangle.Right, fromRectangle.Bottom), new RCNumVector(toRectangle.Left, toRectangle.Top))); } else if (isOnRightSide && isAbove && !isOnLeftSide && !isBelow) { return(MapUtils.ComputeDistance( new RCNumVector(fromRectangle.Left, fromRectangle.Bottom), new RCNumVector(toRectangle.Right, toRectangle.Top))); } else if (isOnLeftSide && isBelow && !isOnRightSide && !isAbove) { return(MapUtils.ComputeDistance( new RCNumVector(fromRectangle.Right, fromRectangle.Top), new RCNumVector(toRectangle.Left, toRectangle.Bottom))); } else if (isOnRightSide && isBelow && !isOnLeftSide && !isAbove) { return(MapUtils.ComputeDistance( new RCNumVector(fromRectangle.Left, fromRectangle.Top), new RCNumVector(toRectangle.Right, toRectangle.Bottom))); } else if (isAbove && !isOnLeftSide && !isOnRightSide && !isBelow) { return(toRectangle.Top - fromRectangle.Bottom); } else if (isOnRightSide && !isOnLeftSide && !isAbove && !isBelow) { return(fromRectangle.Left - toRectangle.Right); } else if (isBelow && !isOnLeftSide && !isOnRightSide && !isAbove) { return(fromRectangle.Top - toRectangle.Bottom); } else if (isOnLeftSide && !isOnRightSide && !isAbove && !isBelow) { return(toRectangle.Left - fromRectangle.Right); } else { throw new InvalidOperationException("Impossible case!"); } }
/// <summary> /// Sets the location of this map object. /// </summary> /// <param name="newLocation">The new location of this map object.</param> public void SetLocation(RCNumRectangle newLocation) { if (this.owner == null) { throw new ObjectDisposedException("MapObject"); } if (newLocation == RCNumRectangle.Undefined) { throw new ArgumentNullException("newLocation"); } if (this.location != newLocation) { if (this.BoundingBoxChanging != null) { this.BoundingBoxChanging(this); } this.location = newLocation; this.quadraticPositionCache.Invalidate(); this.quadraticShadowPositionCache.Invalidate(); if (this.BoundingBoxChanged != null) { this.BoundingBoxChanged(this); } } }
/// <summary> /// Calculates the map coordinates of the window. /// </summary> /// <returns>The calculated map coordinates of the window.</returns> private RCNumRectangle CalculateWindowMapCoords() { RCNumRectangle pixelWindowPixelCoords = new RCNumRectangle(this.pixelWindowCache.Value.Location - MapWindowBase.HALF_VECTOR, this.pixelWindowCache.Value.Size); RCNumVector topLeftCornerMapCoords = this.mapToPixelGridTransformation.TransformBA(pixelWindowPixelCoords.Location); RCNumVector bottomRightCornerMapCoords = this.mapToPixelGridTransformation.TransformBA(pixelWindowPixelCoords.Location + pixelWindowPixelCoords.Size); return(new RCNumRectangle(topLeftCornerMapCoords, bottomRightCornerMapCoords - topLeftCornerMapCoords)); }
private void Form1_MouseUp(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Right && this.currentMode == Mode.Creating) { RCNumVector sizeVect = this.currentPos - this.beginPos; if (sizeVect.X > 0 && sizeVect.Y > 0) { TestContent newContent = new TestContent(new RCNumRectangle(this.beginPos, sizeVect)); this.stopwatch.Reset(); this.stopwatch.Start(); this.contentManager.AttachContent(newContent); this.stopwatch.Stop(); this.avgAttachContent.NewItem((int)this.stopwatch.ElapsedMilliseconds); this.nonSelectedContents.Add(newContent); this.Invalidate(); } this.currentMode = Mode.None; } else if (e.Button == MouseButtons.Left && this.currentMode == Mode.Selecting) { RCNumVector sizeVect = this.currentPos - this.beginPos; if (sizeVect.X > 0 && sizeVect.Y > 0) { foreach (TestContent content in this.selectedContents) { this.nonSelectedContents.Add(content); } this.selectedContents.Clear(); RCNumRectangle selBox = new RCNumRectangle(this.beginPos, sizeVect); this.stopwatch.Reset(); this.stopwatch.Start(); RCSet <TestContent> contents = this.contentManager.GetContents(selBox); this.stopwatch.Stop(); this.avgGetContentInBox.NewItem((int)this.stopwatch.ElapsedMilliseconds); foreach (TestContent content in contents) { this.nonSelectedContents.Remove(content); this.selectedContents.Add(content); } this.Invalidate(); } this.currentMode = Mode.None; } else if (e.Button == MouseButtons.Left && this.currentMode == Mode.Dragging) { foreach (TestContent draggedContent in this.selectedContents) { this.stopwatch.Reset(); this.stopwatch.Start(); draggedContent.BoundingBox += this.currentPos - this.beginPos; this.stopwatch.Stop(); this.avgPositionChange.NewItem((int)this.stopwatch.ElapsedMilliseconds); } this.Invalidate(); this.currentMode = Mode.None; } }
/// <summary> /// Checks whether the given target entity is in the attack range of this weapon. /// </summary> /// <param name="targetEntity">The target entity.</param> /// <returns>True if the given target entity is in the attack range of this weapon; otherwise false.</returns> public bool IsEntityInRange(Entity targetEntity) { if (!this.CanTargetEntity(targetEntity)) { return(false); } RCNumRectangle ownerArea = this.owner.Read().Area; RCNumRectangle targetArea = targetEntity.Area; return(this.IsInRange(MapUtils.ComputeDistance(ownerArea, targetArea))); }
/// <summary> /// Sets the area of the corresponding element type in map coordinates. /// </summary> /// <param name="area">The rectangle that defines the area.</param> public void SetArea(RCNumRectangle area) { if (this.metadata.IsFinalized) { throw new InvalidOperationException("Already finalized!"); } if (area == RCNumRectangle.Undefined) { throw new ArgumentNullException("area"); } this.area = new ConstValue <RCNumRectangle>(area); }
/// <summary> /// Constructs a MinimapPixel instance. /// </summary> /// <param name="targetScenario">Reference to the target scenario.</param> /// <param name="pixelCoords">The coordinates of this pixel on the minimap image.</param> /// <param name="mapToMinimapTransformation">Coordinate transformation between the map (A) and minimap (B) coordinate-systems.</param> public MinimapPixel(Scenario targetScenario, RCIntVector pixelCoords, RCCoordTransformation mapToMinimapTransformation) { this.isDisposed = false; this.pixelCoords = pixelCoords; /// Calculate the area on the map covered by this pixel. RCNumVector minimapPixelTopLeft = pixelCoords - (new RCNumVector(1, 1) / 2); RCNumVector minimapPixelBottomRight = pixelCoords + (new RCNumVector(1, 1) / 2); RCNumVector mapRectTopLeft = mapToMinimapTransformation.TransformBA(minimapPixelTopLeft); RCNumVector mapRectBottomRight = mapToMinimapTransformation.TransformBA(minimapPixelBottomRight); this.coveredArea = new RCNumRectangle(mapRectTopLeft, mapRectBottomRight - mapRectTopLeft); this.coveredArea.Intersect(new RCNumRectangle(new RCNumVector(0, 0), targetScenario.Map.CellSize) - (new RCNumVector(1, 1) / 2)); /// Find the quadratic tiles whose centers are inside the covered area. RCIntVector cellRectTopLeft = this.coveredArea.Location.Round(); RCIntVector cellRectBottomRight = (this.coveredArea.Location + this.coveredArea.Size).Round(); RCIntRectangle cellRect = new RCIntRectangle(cellRectTopLeft, cellRectBottomRight - cellRectTopLeft + new RCIntVector(1, 1)); RCIntRectangle quadRect = targetScenario.Map.CellToQuadRect(cellRect); RCIntVector coveredQuadTilesTopLeft = RCIntVector.Undefined; RCIntVector coveredQuadTilesBottomRight = RCIntVector.Undefined; for (int quadCoordX = quadRect.Left; quadCoordX < quadRect.Right; quadCoordX++) { for (int quadCoordY = quadRect.Top; quadCoordY < quadRect.Bottom; quadCoordY++) { RCNumRectangle quadTileRect = (RCNumRectangle)targetScenario.Map.QuadToCellRect(new RCIntRectangle(quadCoordX, quadCoordY, 1, 1)) - (new RCNumVector(1, 1) / 2); RCNumVector quadTileRectCenter = (quadTileRect.Location + quadTileRect.Location + quadTileRect.Size) / 2; if (this.coveredArea.Contains(quadTileRectCenter)) { RCIntVector quadCoords = new RCIntVector(quadCoordX, quadCoordY); if (coveredQuadTilesTopLeft == RCIntVector.Undefined) { coveredQuadTilesTopLeft = quadCoords; } if (coveredQuadTilesBottomRight == RCIntVector.Undefined || quadCoords.Y > coveredQuadTilesBottomRight.Y || quadCoords.X > coveredQuadTilesBottomRight.X) { coveredQuadTilesBottomRight = quadCoords; } } } } this.coveredQuadTiles = new RCIntRectangle(coveredQuadTilesTopLeft, coveredQuadTilesBottomRight - coveredQuadTilesTopLeft + new RCIntVector(1, 1)); }
/// <see cref="IMapWindow.MapToWindowRect"/> public RCIntRectangle MapToWindowRect(RCNumRectangle mapRect) { if (mapRect == RCNumRectangle.Undefined) { throw new ArgumentNullException("mapRect"); } if (this.isDisposed) { throw new ObjectDisposedException("IMapWindow"); } RCIntVector topLeftCornerWindowCoords = this.mapToPixelGridTransformation.TransformAB(mapRect.Location).Round() - this.pixelWindowCache.Value.Location; RCIntVector bottomRightCornerWindowCoords = this.mapToPixelGridTransformation.TransformAB(mapRect.Location + mapRect.Size).Round() - this.pixelWindowCache.Value.Location; return(new RCIntRectangle(topLeftCornerWindowCoords, bottomRightCornerWindowCoords - topLeftCornerWindowCoords + new RCIntVector(1, 1))); }
/// <see cref="ISelectionManagerBC.AddEntitiesToSelection"/> public void AddEntitiesToSelection(RCNumRectangle selectionBox) { if (this.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } if (this.localPlayer == PlayerEnum.Neutral) { throw new InvalidOperationException("Selection manager not initialized!"); } this.Update(); foreach (Entity entityToAdd in this.ActiveScenario.GetElementsOnMap <Entity>(selectionBox, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.GroundObjects)) { this.AddEntityToSelection(entityToAdd); } }
/// <see cref="IMapWindow.WindowToMapRect"/> public RCNumRectangle WindowToMapRect(RCIntRectangle windowRect) { if (windowRect == RCIntRectangle.Undefined) { throw new ArgumentNullException("windowRect"); } if (this.isDisposed) { throw new ObjectDisposedException("IMapWindow"); } RCNumRectangle windowRectPixelCoords = new RCNumRectangle(this.pixelWindowCache.Value.Location + windowRect.Location - MapWindowBase.HALF_VECTOR, windowRect.Size); RCNumVector topLeftCornerMapCoords = this.mapToPixelGridTransformation.TransformBA(windowRectPixelCoords.Location); RCNumVector bottomRightCornerMapCoords = this.mapToPixelGridTransformation.TransformBA(windowRectPixelCoords.Location + windowRectPixelCoords.Size); return(new RCNumRectangle(topLeftCornerMapCoords, bottomRightCornerMapCoords - topLeftCornerMapCoords)); }
/// <see cref="IMapEditorService.PlaceTerrainObject"/> public bool PlaceTerrainObject(RCIntVector position, string terrainObject) { if (this.scenarioManager.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } if (position == RCIntVector.Undefined) { throw new ArgumentNullException("position"); } if (terrainObject == null) { throw new ArgumentNullException("terrainObject"); } ITerrainObjectType terrainObjType = this.scenarioManager.ActiveScenario.Map.Tileset.GetTerrainObjectType(terrainObject); RCIntVector navCellCoords = this.mapWindowBC.AttachedWindow.WindowToMapCoords(position).Round(); IQuadTile quadTileAtPos = this.scenarioManager.ActiveScenario.Map.GetCell(navCellCoords).ParentQuadTile; RCIntVector topLeftQuadCoords = quadTileAtPos.MapCoords - terrainObjType.QuadraticSize / 2; ITerrainObject placedTerrainObject = null; if (topLeftQuadCoords.X >= 0 && topLeftQuadCoords.Y >= 0 && topLeftQuadCoords.X < this.scenarioManager.ActiveScenario.Map.Size.X && topLeftQuadCoords.Y < this.scenarioManager.ActiveScenario.Map.Size.Y) { IQuadTile targetQuadTile = this.scenarioManager.ActiveScenario.Map.GetQuadTile(topLeftQuadCoords); placedTerrainObject = this.mapEditor.PlaceTerrainObject(this.scenarioManager.ActiveScenario.Map, targetQuadTile, terrainObjType); } if (placedTerrainObject != null) { RCNumRectangle terrObjRect = new RCNumRectangle(this.scenarioManager.ActiveScenario.Map.GetQuadTile(placedTerrainObject.MapCoords).GetCell(new RCIntVector(0, 0)).MapCoords, placedTerrainObject.CellSize) - new RCNumVector(1, 1) / 2; foreach (Entity affectedEntity in this.scenarioManager.ActiveScenario.GetElementsOnMap <Entity>(terrObjRect, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.GroundObjects)) { if (affectedEntity.CheckPlacementConstraints(affectedEntity.MapObject.QuadraticPosition.Location, new RCSet <Entity>()).Count != 0) { affectedEntity.DetachFromMap(); this.scenarioManager.ActiveScenario.RemoveElementFromScenario(affectedEntity); affectedEntity.Dispose(); } } } return(placedTerrainObject != null); }
/// <summary> /// Gets the map objects inside the given area of the given layers. /// </summary> /// <param name="area">The area to search.</param> /// <param name="firstLayer">The first layer to search in.</param> /// <param name="furtherLayers">List of the further layers to search in.</param> /// <returns>A list that contains the map objects inside the given area of the given layers.</returns> public RCSet <MapObject> GetMapObjects(RCNumRectangle area, MapObjectLayerEnum firstLayer, params MapObjectLayerEnum[] furtherLayers) { if (area == RCNumRectangle.Undefined) { throw new ArgumentNullException("area"); } if (furtherLayers == null) { throw new ArgumentNullException("furtherLayers"); } RCSet <MapObject> retList = this.mapObjects[firstLayer].GetContents(area); foreach (MapObjectLayerEnum furtherLayer in furtherLayers) { retList.UnionWith(this.mapObjects[furtherLayer].GetContents(area)); } return(retList); }
/// <summary> /// Creates a map object for this scenario element to the given location in the given layer of the map. /// </summary> /// <param name="location">The location of the created map object on the map.</param> /// <param name="layer">The layer of the created map object.</param> /// <returns>The created map object.</returns> protected MapObject CreateMapObject(RCNumRectangle location, MapObjectLayerEnum layer) { if (this.scenario.Read() == null) { throw new InvalidOperationException("This scenario element doesn't not belong to a scenario!"); } if (location == RCNumRectangle.Undefined) { throw new ArgumentNullException("location"); } MapObject mapObject = new MapObject(this); mapObject.SetLocation(location); this.mapContext.GetMapObjectLayer(layer).AttachContent(mapObject); this.mapObjectsOfThisElementByLayer[layer].Add(mapObject); this.mapObjectsOfThisElement.Add(mapObject, layer); return(mapObject); }
/// <see cref="IFogOfWarBC.GetAllMapObjectsInWindow"/> public IEnumerable <MapObject> GetAllMapObjectsInWindow(RCIntRectangle quadWindow) { if (this.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } /// Collect the currently visible entities inside the given window. RCNumRectangle cellWindow = (RCNumRectangle)this.ActiveScenario.Map.QuadToCellRect(quadWindow) - new RCNumVector(1, 1) / 2; RCSet <MapObject> mapObjectsOnMap = this.ActiveScenario.GetMapObjects( cellWindow, MapObjectLayerEnum.GroundObjects, MapObjectLayerEnum.GroundMissiles, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.AirMissiles); foreach (MapObject mapObject in mapObjectsOnMap) { if (this.runningFowsCount == 0) { yield return(mapObject); } else { bool breakLoop = false; for (int col = mapObject.QuadraticPosition.Left; !breakLoop && col < mapObject.QuadraticPosition.Right; col++) { for (int row = mapObject.QuadraticPosition.Top; !breakLoop && row < mapObject.QuadraticPosition.Bottom; row++) { if (this.fowCacheMatrix.GetFowStateAtQuadTile(new RCIntVector(col, row)) == FOWTypeEnum.None) { /// Found at least 1 quadratic tile where the entity is visible. yield return(mapObject); breakLoop = true; } } } } } }
/// <summary> /// Constructs a MapObject instance. /// </summary> /// <param name="owner">Reference to the scenario element that owns this map object.</param> public MapObject(ScenarioElement owner) { if (owner == null) { throw new ArgumentNullException("owner"); } if (owner.ElementType.AnimationPalette == null) { throw new ArgumentException("The type of the given scenario element has no animation palette defined!", "owner"); } this.currentAnimations = new AnimationPlayer[owner.ElementType.AnimationPalette.Count]; this.quadraticPositionCache = new CachedValue <RCIntRectangle>(() => { RCIntVector topLeft = this.location.Location.Round(); RCIntVector bottomRight = (this.location.Location + this.location.Size).Round(); RCIntRectangle cellRect = new RCIntRectangle(topLeft.X, topLeft.Y, Math.Max(1, bottomRight.X - topLeft.X), Math.Max(1, bottomRight.Y - topLeft.Y)); return(this.owner.Scenario.Map.CellToQuadRect(cellRect)); }); this.quadraticShadowPositionCache = new CachedValue <RCIntRectangle>(() => { if (this.owner.ElementType.ShadowOffset == RCNumVector.Undefined || this.shadowTransition == new RCNumVector(0, 0)) { return(RCIntRectangle.Undefined); } RCNumRectangle shiftedLocation = this.location + (this.owner.ElementType.ShadowOffset + this.shadowTransition - this.location.Size / 2); RCIntVector topLeft = shiftedLocation.Location.Round(); RCIntVector bottomRight = (shiftedLocation.Location + shiftedLocation.Size).Round(); RCIntRectangle cellRect = new RCIntRectangle(topLeft.X, topLeft.Y, Math.Max(1, bottomRight.X - topLeft.X), Math.Max(1, bottomRight.Y - topLeft.Y)); return(this.owner.Scenario.Map.CellToQuadRect(cellRect)); }); this.owner = owner; this.location = RCNumRectangle.Undefined; this.shadowTransition = new RCNumVector(0, 0); }
/// <see cref="ISelectionManagerBC.SelectEntitiesOfTheSameType"/> public void SelectEntitiesOfTheSameType(RCNumVector position, RCNumRectangle selectionBox) { if (this.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } if (this.localPlayer == PlayerEnum.Neutral) { throw new InvalidOperationException("Selection manager not initialized!"); } Entity entityAtPos = this.ActiveScenario.GetElementsOnMap <Entity>(position, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.GroundObjects).FirstOrDefault(); if (entityAtPos == null) { return; } this.currentSelection.Clear(); if (BizLogicHelpers.GetMapObjectCurrentOwner(entityAtPos.MapObject) == this.localPlayer && entityAtPos is Unit) { foreach (Entity entityToAdd in this.ActiveScenario.GetElementsOnMap <Entity>(selectionBox, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.GroundObjects)) { if (BizLogicHelpers.GetMapObjectCurrentOwner(entityToAdd.MapObject) == this.localPlayer && entityToAdd.ElementType == entityAtPos.ElementType) // TODO: this might be problematic in case of Terran Siege Tanks! { this.AddEntityToSelection(entityToAdd); } } } else { this.AddEntityToSelection(entityAtPos); } }
/// <summary> /// Updates the velocity and position of this entity. /// </summary> public void Update() { if (this.currentSpeed != 0 || !this.Position.Contains(this.goal)) { this.CalculateAdmissibleVelocities(); MotionController.UpdateVelocity(this, this, this); } if (this.selectedVelocity != null) { this.currentSpeed = this.selectedVelocity.Item1; this.currentDirection = this.selectedVelocity.Item2; this.selectedVelocity = null; RCNumRectangle newPosition = new RCNumRectangle(this.currentPosition + this.Velocity - this.size / 2, this.size); foreach (TestEntity collideWith in this.entities.GetContents(newPosition)) { if (collideWith != this) { this.currentSpeed = 0; this.currentDirection = MapDirection.North; return; } } if (this.BoundingBoxChanging != null) { this.BoundingBoxChanging(this); } this.currentPosition += this.Velocity; if (this.BoundingBoxChanged != null) { this.BoundingBoxChanged(this); } } }
/// <see cref="IMapEditorService.DrawTerrain"/> public void DrawTerrain(RCIntVector position, string terrainType) { if (this.scenarioManager.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } if (position == RCIntVector.Undefined) { throw new ArgumentNullException("position"); } if (terrainType == null) { throw new ArgumentNullException("terrainType"); } RCIntVector navCellCoords = this.mapWindowBC.AttachedWindow.WindowToMapCoords(position).Round(); IIsoTile isotile = this.scenarioManager.ActiveScenario.Map.GetCell(navCellCoords).ParentIsoTile; IEnumerable <IIsoTile> affectedIsoTiles = this.mapEditor.DrawTerrain(this.scenarioManager.ActiveScenario.Map, isotile, this.scenarioManager.ActiveScenario.Map.Tileset.GetTerrainType(terrainType)); foreach (IIsoTile affectedIsoTile in affectedIsoTiles) { RCNumRectangle isoTileRect = new RCNumRectangle(affectedIsoTile.GetCellMapCoords(new RCIntVector(0, 0)), affectedIsoTile.CellSize) - new RCNumVector(1, 1) / 2; foreach (Entity affectedEntity in this.scenarioManager.ActiveScenario.GetElementsOnMap <Entity>(isoTileRect, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.GroundObjects)) { if (affectedEntity.CheckPlacementConstraints(affectedEntity.MapObject.QuadraticPosition.Location, new RCSet <Entity>()).Count != 0) { affectedEntity.DetachFromMap(); this.scenarioManager.ActiveScenario.RemoveElementFromScenario(affectedEntity); affectedEntity.Dispose(); } } } }
public TestContent(RCNumRectangle initialPos) { this.currentPosition = initialPos; }
/// <see cref="ISelectionManagerBC.SelectEntities"/> public void SelectEntities(RCNumRectangle selectionBox) { if (this.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } if (this.localPlayer == PlayerEnum.Neutral) { throw new InvalidOperationException("Selection manager not initialized!"); } bool localPlayerUnitFound = false; Entity localPlayerBuilding = null; Entity localPlayerAddon = null; Entity otherPlayerUnit = null; Entity otherPlayerBuilding = null; Entity otherPlayerAddon = null; Entity other = null; RCSet <Entity> entitiesInBox = this.ActiveScenario.GetElementsOnMap <Entity>(selectionBox, MapObjectLayerEnum.AirObjects, MapObjectLayerEnum.GroundObjects); if (entitiesInBox.Count == 0) { return; } foreach (Entity entity in entitiesInBox) { if (entity is Unit) { /// If the entity is a unit then check its owner. if (entity.Owner != null && entity.Owner.PlayerIndex == (int)this.localPlayer) { /// If owned by the local player then add it to the current selection. if (!localPlayerUnitFound) { this.currentSelection.Clear(); localPlayerUnitFound = true; } this.currentSelection.Add(entity.ID.Read()); if (this.currentSelection.Count == MAX_SELECTION_SIZE) { break; } } else if (otherPlayerUnit == null && !localPlayerUnitFound) { /// If owned by another player then save its reference. otherPlayerUnit = entity; } } else if (entity is Building && !localPlayerUnitFound) { /// If the entity is a building then check its owner. if (entity.Owner != null && entity.Owner.PlayerIndex == (int)this.localPlayer) { if (localPlayerBuilding == null) { localPlayerBuilding = entity; } } else if (otherPlayerBuilding == null) { otherPlayerBuilding = entity; } } else if (entity is Addon && !localPlayerUnitFound) { /// If the entity is an addon then check its owner. if (entity.Owner != null && entity.Owner.PlayerIndex == (int)this.localPlayer) { if (localPlayerAddon == null) { localPlayerAddon = entity; } } else if (otherPlayerAddon == null) { otherPlayerAddon = entity; } } else if (other == null) { other = entity; } } if (localPlayerUnitFound) { return; } this.currentSelection.Clear(); if (localPlayerBuilding != null) { this.currentSelection.Add(localPlayerBuilding.ID.Read()); return; } if (localPlayerAddon != null) { this.currentSelection.Add(localPlayerAddon.ID.Read()); return; } if (otherPlayerUnit != null) { this.currentSelection.Add(otherPlayerUnit.ID.Read()); return; } if (otherPlayerBuilding != null) { this.currentSelection.Add(otherPlayerBuilding.ID.Read()); return; } if (otherPlayerAddon != null) { this.currentSelection.Add(otherPlayerAddon.ID.Read()); return; } if (other != null) { this.currentSelection.Add(other.ID.Read()); return; } }