/// <see cref="ICommandService.SendFastCommandOnMinimap"/> public void SendFastCommandOnMinimap(RCIntVector position) { /// TODO: This is a PROTOTYPE CODE! if (this.scenarioManager.ActiveScenario == null) { throw new InvalidOperationException("No active scenario!"); } if (this.selectionManager.LocalPlayer == PlayerEnum.Neutral) { return; } RCIntVector minimapPixelCoords = position - this.mapWindowBC.Minimap.MinimapPosition.Location; minimapPixelCoords = new RCIntVector(Math.Min(this.mapWindowBC.Minimap.MinimapPosition.Width - 1, Math.Max(0, minimapPixelCoords.X)), Math.Min(this.mapWindowBC.Minimap.MinimapPosition.Height - 1, Math.Max(0, minimapPixelCoords.Y))); IMinimapPixel minimapPixel = this.mapWindowBC.Minimap.GetMinimapPixel(minimapPixelCoords); RCNumVector pixelCenterOnMap = minimapPixel.CoveredArea.Location + minimapPixel.CoveredArea.Size / 2; if (this.selectionManager.CurrentSelection.Count != 0) { this.multiplayerService.PostCommand(new RCCommand(null, this.selectionManager.CurrentSelection.ToArray(), pixelCenterOnMap, -1, null)); } }
/// <summary> /// Constructs a MapWindowBase instance. /// </summary> /// <param name="targetScenario">Reference to the target scenario.</param> protected MapWindowBase(Scenario targetScenario) { if (targetScenario == null) { throw new ArgumentNullException("targetScenario"); } this.isDisposed = false; this.targetScenario = targetScenario; this.windowMapCoordsCache = new CachedValue <RCNumRectangle>(this.CalculateWindowMapCoords); this.cellWindowCache = new CachedValue <RCIntRectangle>(this.CalculateCellWindow); this.quadTileWindowCache = new CachedValue <RCIntRectangle>(this.CalculateQuadTileWindow); this.windowOffsetCache = new CachedValue <RCIntVector>(this.CalculateWindowOffset); this.pixelWindowCache = new CachedValue <RCIntRectangle>(this.CalculatePixelWindow); RCNumVector nullVectorOfPixelGrid = new RCNumVector( (RCNumber)1 / (2 * MapWindowBase.PIXEL_PER_NAVCELL) - (RCNumber)1 / 2, (RCNumber)1 / (2 * MapWindowBase.PIXEL_PER_NAVCELL) - (RCNumber)1 / 2); RCNumVector baseVectorOfPixelGridX = new RCNumVector((RCNumber)1 / MapWindowBase.PIXEL_PER_NAVCELL, 0); RCNumVector baseVectorOfPixelGridY = new RCNumVector(0, (RCNumber)1 / MapWindowBase.PIXEL_PER_NAVCELL); this.mapToPixelGridTransformation = new RCCoordTransformation(nullVectorOfPixelGrid, baseVectorOfPixelGridX, baseVectorOfPixelGridY); this.fullPixelGrid = new RCIntRectangle(new RCIntVector(0, 0), this.targetScenario.Map.CellSize * MapWindowBase.PIXEL_PER_NAVCELL); }
/// <summary> /// Constructs an RCMotionControlTestPage object. /// </summary> public RCMotionControlTestPage() { this.timeSinceLastUpdate = 0; this.brush = UIRoot.Instance.GraphicsPlatform.SpriteManager.CreateSprite(RCColor.Green, new RCIntVector(1, 1), UIWorkspace.Instance.PixelScaling); this.brush.Upload(); this.entities = new BspSearchTree <TestEntity>(new RCNumRectangle(HALF_VECT * (-1), MAP_SIZE), 16, 10); for (int i = 0; i < ENTITY_COUNT; i++) { RCNumVector size; RCNumVector position; TestEntity newEntity; do { size = new RCNumVector(RandomService.DefaultGenerator.Next((int)(MIN_ENTITY_SIZE.X * 1000), (int)(MAX_ENTITY_SIZE.X * 1000)) / (RCNumber)1000, RandomService.DefaultGenerator.Next((int)(MIN_ENTITY_SIZE.Y * 1000), (int)(MAX_ENTITY_SIZE.Y * 1000)) / (RCNumber)1000); position = new RCNumVector(RandomService.DefaultGenerator.Next(MAP_SIZE.X), RandomService.DefaultGenerator.Next(MAP_SIZE.Y)); newEntity = new TestEntity(position, size, this.entities); } while (this.entities.GetContents(newEntity.BoundingBox).Count != 0); this.entities.AttachContent(newEntity); } this.MouseSensor.Move += this.OnMouseMove; UIRoot.Instance.GraphicsPlatform.RenderLoop.FrameUpdate += this.OnUpdate; }
/// <see cref="ISelectionManagerBC.AddRemoveEntityToSelection"/> public void AddRemoveEntityToSelection(RCNumVector position) { 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; } /// If the entity is already selected then remove it from the selection. if (this.currentSelection.Remove(entityAtPos.ID.Read())) { return; } /// Otherwise add it to the current selection if possible. this.AddEntityToSelection(entityAtPos); }
/// <see cref="ScenarioElement.AttachToMap"/> public override bool AttachToMap(RCNumVector position, params ScenarioElement[] elementsToIgnore) { /// Check if the position of this Refinery would align with a VespeneGeyser. RCSet <VespeneGeyser> vespeneGeysersAtPos = this.Scenario.GetElementsOnMap <VespeneGeyser>(position, MapObjectLayerEnum.GroundObjects); if (vespeneGeysersAtPos.Count != 1) { return(false); } VespeneGeyser vespeneGeyserAtPos = vespeneGeysersAtPos.First(); if (this.CalculateArea(position) != vespeneGeyserAtPos.Area) { return(false); } /// Save the VespeneGeyser and detach it from the map. this.underlyingVespeneGeyser.Write(vespeneGeyserAtPos); this.underlyingVespeneGeyser.Read().DetachFromMap(); /// Try to attach the Refinery. bool refineryAttached = base.AttachToMap(position, elementsToIgnore); if (!refineryAttached) { /// If the Refinery could not be attached -> reattach the underlying VespeneGeyser. this.underlyingVespeneGeyser.Read().AttachToMap(position); this.underlyingVespeneGeyser.Write(null); } return(refineryAttached); }
/// <summary> /// Creates an RCCommand object from the given RCPackage. /// </summary> /// <param name="cmdPackage">The RCPackage to be deserialized.</param> /// <returns>The created RCCommand.</returns> public static RCCommand FromPackage(RCPackage cmdPackage) { if (cmdPackage == null) { throw new ArgumentNullException("cmdPackage"); } if (!cmdPackage.IsCommitted) { throw new ArgumentException("The incoming package is not committed!", "cmdPackage"); } if (cmdPackage.PackageFormat.ID != RCCommand.COMMAND_PACKAGEFORMAT) { throw new ArgumentException("The incoming package is not a command package!", "cmdPackage"); } RCNumVector targetPosition = RCNumVector.Undefined; int targetPositionX = cmdPackage.ReadInt(2); int targetPositionY = cmdPackage.ReadInt(3); if (targetPositionX != -1 && targetPositionY != -1) { targetPosition = new RCNumVector(new RCNumber(targetPositionX), new RCNumber(targetPositionY)); } return(new RCCommand( cmdPackage.ReadString(0), cmdPackage.ReadIntArray(1), targetPosition, cmdPackage.ReadInt(4), cmdPackage.ReadString(5))); }
/// <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; } }
/// <summary> /// Attaches this entity to the given quadratic tile on the map. /// </summary> /// <param name="topLeftTile">The quadratic tile at the top-left corner of this entity.</param> /// <param name="elementsToIgnore">An optional list of scenario elements to ignore during attach.</param> /// <returns>True if this entity was successfully attached to the map; otherwise false.</returns> /// <remarks>Note that the caller has to explicitly call MotionControl.Fix to fix this entity after calling this method.</remarks> public bool AttachToMap(IQuadTile topLeftTile, params ScenarioElement[] elementsToIgnore) { ICell topLeftCell = topLeftTile.GetCell(new RCIntVector(0, 0)); RCNumVector position = topLeftCell.MapCoords - new RCNumVector(1, 1) / 2 - this.ElementType.Area.Read().Location; return(this.AttachToMap(position, elementsToIgnore)); }
/// <summary> /// Tries to align the minimap horizontally. /// </summary> /// <param name="minimapControlPixelSize">The size of the minimap control in pixels.</param> /// <param name="mapCellSize">The size of the map in cells.</param> /// <param name="minimapPosition">The position of the minimap on the minimap control in pixels.</param> /// <param name="transformation">The transformation between the map (A) and minimap (B) coordinate-systems.</param> /// <returns>True if the alignment was successfully; otherwise false.</returns> private static bool TryAlignMinimapHorizontally( RCIntVector minimapControlPixelSize, RCIntVector mapCellSize, out RCIntRectangle minimapPosition, out RCCoordTransformation transformation) { RCNumber horzAlignedMinimapHeight = (RCNumber)(minimapControlPixelSize.X * mapCellSize.Y) / (RCNumber)mapCellSize.X; if (horzAlignedMinimapHeight > minimapControlPixelSize.Y) { /// Cannot align horizontally. minimapPosition = RCIntRectangle.Undefined; transformation = null; return(false); } /// Align horizontally int minimapPixelHeight = horzAlignedMinimapHeight > (int)horzAlignedMinimapHeight ? (int)horzAlignedMinimapHeight + 1 : (int)horzAlignedMinimapHeight; minimapPosition = new RCIntRectangle(0, (minimapControlPixelSize.Y - minimapPixelHeight) / 2, minimapControlPixelSize.X, minimapPixelHeight); /// Create the coordinate transformation RCNumVector pixelSizeOnMap = new RCNumVector((RCNumber)mapCellSize.X / (RCNumber)minimapControlPixelSize.X, (RCNumber)mapCellSize.X / (RCNumber)minimapControlPixelSize.X); RCNumVector nullVectorOfMinimap = (pixelSizeOnMap / 2) - (new RCNumVector(1, 1) / 2); RCNumVector baseVectorOfMinimapX = new RCNumVector(pixelSizeOnMap.X, 0); RCNumVector baseVectorOfMinimapY = new RCNumVector(0, pixelSizeOnMap.Y); transformation = new RCCoordTransformation(nullVectorOfMinimap, baseVectorOfMinimapX, baseVectorOfMinimapY); return(true); }
/// <summary> /// Tries to align the minimap vertically. /// </summary> /// <param name="minimapControlPixelSize">The size of the minimap control in pixels.</param> /// <param name="mapCellSize">The size of the map in cells.</param> /// <param name="minimapPosition">The position of the minimap on the minimap control in pixels.</param> /// <param name="transformation">The transformation between the map (A) and minimap (B) coordinate-systems.</param> /// <returns>True if the alignment was successfully; otherwise false.</returns> private static bool TryAlignMinimapVertically( RCIntVector minimapControlPixelSize, RCIntVector mapCellSize, out RCIntRectangle minimapPosition, out RCCoordTransformation transformation) { RCNumber vertAlignedMinimapWidth = (RCNumber)(minimapControlPixelSize.Y * mapCellSize.X) / (RCNumber)mapCellSize.Y; if (vertAlignedMinimapWidth > minimapControlPixelSize.X) { /// Cannot align vertically. minimapPosition = RCIntRectangle.Undefined; transformation = null; return(false); } /// Align vertically int minimapPixelWidth = vertAlignedMinimapWidth > (int)vertAlignedMinimapWidth ? (int)vertAlignedMinimapWidth + 1 : (int)vertAlignedMinimapWidth; minimapPosition = new RCIntRectangle((minimapControlPixelSize.X - minimapPixelWidth) / 2, 0, minimapPixelWidth, minimapControlPixelSize.Y); /// Create the coordinate transformation RCNumVector pixelSizeOnMap = new RCNumVector((RCNumber)mapCellSize.Y / (RCNumber)minimapControlPixelSize.Y, (RCNumber)mapCellSize.Y / (RCNumber)minimapControlPixelSize.Y); RCNumVector nullVectorOfMinimap = (pixelSizeOnMap / 2) - (new RCNumVector(1, 1) / 2); RCNumVector baseVectorOfMinimapX = new RCNumVector(pixelSizeOnMap.X, 0); RCNumVector baseVectorOfMinimapY = new RCNumVector(0, pixelSizeOnMap.Y); transformation = new RCCoordTransformation(nullVectorOfMinimap, baseVectorOfMinimapX, baseVectorOfMinimapY); return(true); }
/// <summary> /// Creates a SCVContinueBuildExecution instance. /// </summary> /// <param name="recipientSCV">The recipient SCV of this command execution.</param> /// <param name="targetPosition">The target position.</param> /// <param name="targetBuildingID">The ID of the target building whose construction to be continued.</param> public SCVContinueBuildExecution(SCV recipientSCV, RCNumVector targetPosition, int targetBuildingID) : base(recipientSCV) { this.targetBuildingID = this.ConstructField <int>("targetBuildingID"); this.TargetPosition = targetPosition; this.targetBuildingID.Write(targetBuildingID); }
/// <summary> /// Gets the list of all velocities that are admissible from the given velocity. /// </summary> /// <param name="currentVelocity">The given velocity.</param> /// <returns>All velocities that are admissible from the given velocity.</returns> public List <RCNumVector> GetAdmissibleVelocities(RCNumVector currentVelocity) { if (!this.velocityGraph.ContainsKey(currentVelocity)) { /// Search the velocity that has a minimum difference to the current velocity. RCNumber minDiff = 0; RCNumVector closestVelocity = RCNumVector.Undefined; foreach (RCNumVector velocity in this.velocityGraph.Keys) { RCNumber diff = MapUtils.ComputeDistance(currentVelocity, velocity); if (closestVelocity == RCNumVector.Undefined || diff < minDiff) { minDiff = diff; closestVelocity = velocity; } } if (closestVelocity == RCNumVector.Undefined) { throw new InvalidOperationException("Impossible case!"); } currentVelocity = closestVelocity; } return(new List <RCNumVector>(this.velocityGraph[currentVelocity])); }
/// <summary> /// Updates this missile if it is in Impacted state. /// </summary> private bool UpdateImpactedState() { /// Update the target entity position and height if it is still on the map. if (this.targetEntity.Read().HasMapObject(MapObjectLayerEnum.GroundObjects, MapObjectLayerEnum.AirObjects)) { this.lastKnownTargetEntityPos.Write(this.targetEntity.Read().MotionControl.PositionVector.Read()); this.lastKnownTargetEntityIsFlying.Write(this.targetEntity.Read().MotionControl.IsFlying ? (byte)0x01 : (byte)0x00); } /// Create an impact indicator map object if it has not yet been created and the missile type defines an impact animation. if (this.impactIndicator == null && this.missileData.MissileType.ImpactAnimation != null) { RCNumVector impactIndicatorPos = this.missileData.MissileType.Speed != null ? this.missilePosition.Read() : this.lastKnownTargetEntityPos.Read(); this.impactIndicator = this.CreateMapObject(this.CalculateArea(impactIndicatorPos), this.lastKnownTargetEntityIsFlying.Read() == 0x01 ? MapObjectLayerEnum.AirMissiles : MapObjectLayerEnum.GroundMissiles); this.impactIndicator.StartAnimation(this.missileData.MissileType.ImpactAnimation, this.missileVelocity); } /// Check if the lifecycle of this missile has already ended. if ((this.launchIndicator == null || this.launchIndicator.IsDestroyed) && (this.missileIndicator == null || this.missileIndicator.IsDestroyed) && (this.impactIndicator == null || this.impactIndicator.IsDestroyed)) { return(false); } return(true); }
/// <summary> /// Gets the scenario elements of the given type that are attached to at least one of the given layers of the map at the given position. /// </summary> /// <typeparam name="T">The type of the scenario elements to get.</typeparam> /// <param name="position">The position 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 scenario elements of the given type that are attached to at least one of the given layers of the map at /// the given position. /// </returns> public RCSet <T> GetElementsOnMap <T>(RCNumVector position, MapObjectLayerEnum firstLayer, params MapObjectLayerEnum[] furtherLayers) where T : ScenarioElement { if (position == RCNumVector.Undefined) { throw new ArgumentNullException("position"); } if (furtherLayers == null) { throw new ArgumentNullException("furtherLayers"); } RCSet <T> retList = new RCSet <T>(); foreach (MapObject mapObj in this.mapObjects[firstLayer].GetContents(position)) { 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(position)) { T elementAsT = mapObj.Owner as T; if (elementAsT != null) { retList.Add(elementAsT); } } } return(retList); }
/// <summary> /// Do SCV activities during construction. /// </summary> private void MakeScvActivityDuringConstruction() { /// Start using the build tool of the SCV and decrease the move-timer. TerranBuilding constructedBuilding = this.RecipientSCV.ConstructionJob.ConstructedBuilding; if (this.timeToNextScvMoveDuringConstruction.Read() > 0) { if (!this.recipientSCV.Read().MotionControl.IsMoving&& this.recipientSCV.Read().Armour.Target == null) { this.recipientSCV.Read().Armour.StartAttack(constructedBuilding.ID.Read(), SCV.SCV_BUILD_TOOL_NAME); } this.timeToNextScvMoveDuringConstruction.Write(this.timeToNextScvMoveDuringConstruction.Read() - 1); return; } /// Generate a random position inside the building area and move the SCV there. /// TODO: do not use the default random generator because the engine shall be deterministic! RCIntRectangle buildingQuadRect = constructedBuilding.MapObject.QuadraticPosition; RCIntRectangle buildingCellRect = this.Scenario.Map.QuadToCellRect(buildingQuadRect); RCNumVector movePosition = new RCNumVector( RandomService.DefaultGenerator.Next(buildingCellRect.Left, buildingCellRect.Right), RandomService.DefaultGenerator.Next(buildingCellRect.Top, buildingCellRect.Bottom)); this.recipientSCV.Read().MotionControl.StartMoving(movePosition); this.recipientSCV.Read().Armour.StopAttack(); /// Reset the timer. this.timeToNextScvMoveDuringConstruction.Write(TIME_BETWEEN_SCV_MOVES); }
/// <see cref="IValueRead<MapDirection>.Read"/> public MapDirection Read() { RCNumVector currentHeadingVector = new RCNumVector(0, 0); foreach (IValueRead <RCNumVector> headingVector in this.headingVectors) { currentHeadingVector = headingVector.Read(); if (currentHeadingVector == RCNumVector.Undefined) { throw new InvalidOperationException("Heading vector cannot be RCNumVector.Undefined!"); } if (currentHeadingVector != new RCNumVector(0, 0)) { break; } } if (currentHeadingVector != this.lastKnownHeadingVector) { this.CalculateMapDirection(currentHeadingVector); this.lastKnownHeadingVector = currentHeadingVector; } return(this.cachedMapDirection); }
/// <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)); }
/// <summary> /// Computes the distance between two points on the map. /// </summary> /// <param name="fromCoords">The first point on the map.</param> /// <param name="toCoords">The second point on the map.</param> /// <returns>The computed distance between the given points.</returns> public static RCNumber ComputeDistance(RCNumVector fromCoords, RCNumVector toCoords) { RCNumber horz = (toCoords.X - fromCoords.X).Abs(); RCNumber vert = (toCoords.Y - fromCoords.Y).Abs(); RCNumber diff = (horz - vert).Abs(); return((horz < vert ? horz : vert) * RCNumber.ROOT_OF_TWO + diff); }
/// <see cref="PathTrackerBase.OnAttaching"/> public override bool OnAttaching(RCNumVector position) { if (this.pathfinderAgent != null) { throw new InvalidOperationException("The controlled entity has already been attached to the map!"); } this.pathfinderAgent = this.pathfinder.PlaceAgent(this.ControlledEntity.ElementType.ObstacleArea.Read() + position.Round(), this); return(this.pathfinderAgent != null); }
/// <summary> /// Called when a mouse button has been pushed over the page. /// </summary> private void OnMouseMove(UISensitiveObject sender, UIMouseEventArgs evtArgs) { RCNumVector mapCoordinates = new RCNumVector(evtArgs.Position) / CELL_SIZE - HALF_VECT; foreach (TestEntity entity in this.entities.GetContents()) { entity.SetGoal(mapCoordinates); } }
/// <summary> /// Scrolls the center of this window to the given position on the map. /// </summary> /// <param name="targetPosition">The coordinates of the target position on the map.</param> public void ScrollTo(RCNumVector targetPosition) { if (targetPosition == RCNumVector.Undefined) { throw new ArgumentNullException("targetPosition"); } this.desiredWindowCenterMapCoords = targetPosition; this.InvalidateCaches(); }
/// <see cref="ICommandExecutionFactory.StartCommandExecution"/> public void StartCommandExecution(RCSet <Entity> entitySet, RCNumVector targetPosition, int targetEntityID, string parameter) { RCSet <T> entitiesToHandle = this.CollectEntitiesToHandle(entitySet); foreach (CmdExecutionBase commandExecution in this.CreateCommandExecutions(entitiesToHandle, entitySet, targetPosition, targetEntityID, parameter)) { commandExecution.AttachToScenario(); } }
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; } }
/// <see cref="ScenarioElement.AttachToMap"/> public override bool AttachToMap(RCNumVector position, params ScenarioElement[] elementsToIgnore) { bool attachToMapSuccess = base.AttachToMap(position, elementsToIgnore); if (attachToMapSuccess) { this.MotionControl.Fix(); } return(attachToMapSuccess); }
/// <see cref="ScenarioElement.AttachToMap"/> public override bool AttachToMap(RCNumVector position, params ScenarioElement[] elementsToIgnore) { bool attachToMapSuccess = base.AttachToMap(position, elementsToIgnore); if (attachToMapSuccess) { this.MotionControl.Fix(); this.MapObject.StartAnimation(ANIMATION_NAME, this.MotionControl.VelocityVector); } return(attachToMapSuccess); }
/// <summary> /// Constructs a TestEntity instance. /// </summary> /// <param name="startPosition">The initial position of the test entity.</param> /// <param name="size">The size of the test entity.</param> /// <param name="entities">The map content manager that stores the entities.</param> public TestEntity(RCNumVector startPosition, RCNumVector size, ISearchTree <TestEntity> entities) { this.currentPosition = startPosition; this.size = size; this.currentSpeed = 0; this.goal = this.currentPosition; this.currentDirection = MapDirection.North; this.admissableVelocities = new List <Tuple <RCNumber, MapDirection> >(); this.selectedVelocity = null; this.entities = entities; }
/// <see cref="ScenarioElement.DetachFromMap"/> public override RCNumVector DetachFromMap() { RCNumVector currentPosition = this.position.Read(); if (this.destructionMapObject != null) { this.DestroyMapObject(this.destructionMapObject); this.destructionMapObject = null; this.position.Write(RCNumVector.Undefined); } return(currentPosition); }
/// <summary> /// Constructs an RCCommand instance. /// </summary> /// <param name="commandType">The type of the command or null if the type of the command is unknown.</param> /// <param name="recipientEntities">The recipient entities of the command.</param> /// <param name="targetPosition">The target position of the command or RCNumVector.Undefined if the command doesn't have target position.</param> /// <param name="targetEntity">The target entity of the command or -1 if the command doesn't have target entity.</param> /// <param name="parameter">The optional parameter of the command or null if the command doesn't have parameter.</param> public RCCommand(string commandType, int[] recipientEntities, RCNumVector targetPosition, int targetEntity, string parameter) { if (recipientEntities == null || recipientEntities.Length == 0) { throw new ArgumentNullException("recipientEntities"); } this.commandType = commandType; this.recipientEntities = recipientEntities; this.targetPosition = targetPosition; this.targetEntity = targetEntity; this.parameter = parameter; }
/// <summary> /// Helper method for setting the position vector and updating the map object of the owner entity. /// </summary> /// <param name="newPosition">The new value of the position vector.</param> private void SetPosition(RCNumVector newPosition) { if (newPosition == RCNumVector.Undefined) { throw new InvalidOperationException("Undefined position!"); } this.position.Write(newPosition); if (this.owner.Read().MapObject != null) { this.owner.Read().MapObject.SetLocation(this.owner.Read().Area); } }
/// <see cref="IMapWindow.MapToWindowCoords"/> public RCIntVector MapToWindowCoords(RCNumVector mapCoords) { if (mapCoords == RCNumVector.Undefined) { throw new ArgumentNullException("mapCoords"); } if (this.isDisposed) { throw new ObjectDisposedException("IMapWindow"); } return(this.mapToPixelGridTransformation.TransformAB(mapCoords).Round() - this.PixelWindow.Location); }