// </SnippetHitTestingOverviewSnippet10> // <SnippetHitTestingOverviewSnippet11> // Return the result of the hit test to the callback. public HitTestResultBehavior MyHitTestResultCallback(HitTestResult result) { // Retrieve the results of the hit test. IntersectionDetail intersectionDetail = ((GeometryHitTestResult)result).IntersectionDetail; switch (intersectionDetail) { case IntersectionDetail.FullyContains: // Add the hit test result to the list that will be processed after the enumeration. hitResultsList.Add(result.VisualHit); return(HitTestResultBehavior.Continue); case IntersectionDetail.Intersects: // Set the behavior to return visuals at all z-order levels. return(HitTestResultBehavior.Continue); case IntersectionDetail.FullyInside: // Set the behavior to return visuals at all z-order levels. return(HitTestResultBehavior.Continue); default: return(HitTestResultBehavior.Stop); } }
/// <summary> /// 2つのGeometryが一部でも重なっていたらTrueを返す /// </summary> /// <param name="g1"></param> /// <param name="g2"></param> /// <returns></returns> private bool IsOverlapping(Geometry g1, Geometry g2) { IntersectionDetail detail = g1.FillContainsWithDetail(g2); return(detail != IntersectionDetail.Empty); //return (detail != IntersectionDetail.Empty || detail != IntersectionDetail.NotCalculated, detail); }
public HitTestResultBehavior HitTestCallback(HitTestResult result) { // Retrieve the results of the hit test. IntersectionDetail intersectionDetail = ((GeometryHitTestResult)result).IntersectionDetail; switch (intersectionDetail) { case IntersectionDetail.FullyContains: // Add the hit test result to the list: hitList.Add((Rectangle)result.VisualHit); return(HitTestResultBehavior.Continue); case IntersectionDetail.Intersects: // Set the behavior to return visuals at all z-order levels. return(HitTestResultBehavior.Continue); case IntersectionDetail.FullyInside: // Set the behavior to return visuals at all z-order levels. return(HitTestResultBehavior.Continue); default: return(HitTestResultBehavior.Stop); } }
public WpfHitTestResult HitTest(Rect rect, IntersectionDetail detail) { var svgDrawing = this.PerformHitTest(rect, detail); if (svgDrawing == null) { return(WpfHitTestResult.Empty); } string uniqueId = SvgObject.GetUniqueId(svgDrawing); if (string.IsNullOrWhiteSpace(uniqueId)) { return(new WpfHitTestResult(rect, null, svgDrawing)); // return WpfHitTestResult.Empty; } var svgElement = this.GetSvgByUniqueId(uniqueId); if (svgElement == null) { return(new WpfHitTestResult(rect, null, svgDrawing)); // return WpfHitTestResult.Empty; } return(new WpfHitTestResult(rect, svgElement, svgDrawing)); }
//called when data for any output pin is requested public void Evaluate(int SpreadMax) { if (!(FGeometryIn.IsChanged || FGeometryIn2.IsChanged || FTolerance.IsChanged)) { return; } FFullyInside.SliceCount = FFullyContained.SliceCount = FIntersects.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { try { IntersectionDetail detail = FGeometryIn[i].FillContainsWithDetail(FGeometryIn2[i], FTolerance[i], ToleranceType.Absolute); FFullyInside[i] = (detail == IntersectionDetail.FullyInside); FFullyContained[i] = (detail == IntersectionDetail.FullyContains); FIntersects[i] = (detail == IntersectionDetail.Intersects); } catch (Exception e) { FFullyInside[i] = false; FFullyContained[i] = false; FIntersects[i] = false; } } }
/// <summary> /// 2つのRectが一部でも重なっていたらtrueを返す /// </summary> /// <param name="r1"></param> /// <param name="r2"></param> /// <returns></returns> private (bool, IntersectionDetail) IsOverlapping(Rect r1, Rect r2) { RectangleGeometry geo1 = new(r1); IntersectionDetail detail = geo1.FillContainsWithDetail(new RectangleGeometry(r2)); return(detail != IntersectionDetail.Empty, detail); //return (detail != IntersectionDetail.Empty || detail != IntersectionDetail.NotCalculated, detail); }
// <SnippetHitTestingOverviewSnippet13> // Override default hit test support in visual object. protected override GeometryHitTestResult HitTestCore(GeometryHitTestParameters hitTestParameters) { IntersectionDetail intersectionDetail = IntersectionDetail.NotCalculated; // Perform custom actions during the hit test processing. return(new GeometryHitTestResult(this, intersectionDetail)); }
public override int Impact(Tank currentPlayer, Tank[] enemyTankArray) { bounces++; projectile_Finished = false; projectile_Damage = bouncer_BaseDamage * bounces; foreach (Tank tank in enemyTankArray) { IntersectionDetail projectileEnemyIntersection = geometry.FillContainsWithDetail (tank.GetGeometry()); if (projectileEnemyIntersection == IntersectionDetail.Intersects) { game.PlayExplosionSound(); bounces = 0; projectile_Finished = true; currentPlayer.DealDamage(this); return(tank.TakeDamage(this)); } } projectile_Damage = bouncer_BaseDamage; if (bounces >= 3) { game.PlayExplosionSound(); bounces = 0; projectile_Finished = true; return(0); } game.PlaySound(bouncer_SoftHitSoundUri); if (projectile_AngleRadians > Math.PI) { projectile_AngleRadians = Math.PI - (projectile_AngleRadians - Math.PI); } else if (projectile_AngleRadians < 0) { projectile_AngleRadians = Math.Abs(projectile_AngleRadians); } SetAndStartTrajectory( new Point(projectile_TranslateTransform.X, projectile_TranslateTransform.Y - 20), projectile_AngleRadians, projectile_InitialVelocity * 0.9); return(0); }
internal static IntersectionDetail HitTestWithPathGeometry( Geometry geometry1, Geometry geometry2, double tolerance, ToleranceType type) { IntersectionDetail detail = IntersectionDetail.NotCalculated; unsafe { PathGeometryData data1 = geometry1.GetPathGeometryData(); PathGeometryData data2 = geometry2.GetPathGeometryData(); fixed(byte *pbPathData1 = data1.SerializedData) { Debug.Assert(pbPathData1 != (byte *)0); fixed(byte *pbPathData2 = data2.SerializedData) { Debug.Assert(pbPathData2 != (byte *)0); int hr = MilCoreApi.MilUtility_PathGeometryHitTestPathGeometry( &data1.Matrix, data1.FillRule, pbPathData1, data1.Size, &data2.Matrix, data2.FillRule, pbPathData2, data2.Size, tolerance, type == ToleranceType.Relative, &detail); if (hr == (int)MILErrors.WGXERR_BADNUMBER) { // When we encounter NaNs in the renderer, we absorb the error and draw // nothing. To be consistent, we report that the geometry is never hittable. detail = IntersectionDetail.Empty; } else { HRESULT.Check(hr); } } } } Debug.Assert(detail != IntersectionDetail.NotCalculated); return(detail); }
public HitTestResultBehavior MyHitTestResultCallback(HitTestResult result) { // Retrieve the results of the hit test. IntersectionDetail intersectionDetail = ((GeometryHitTestResult)result).IntersectionDetail; ControlOnCanvas controlAdd = null; if (result.VisualHit is Image) { if (((Image)result.VisualHit).TemplatedParent is ControlOnCanvas) { controlAdd = ((Image)result.VisualHit).TemplatedParent as ControlOnCanvas; } } switch (intersectionDetail) { case IntersectionDetail.FullyContains: // Add the hit test result to the list that will be processed after the enumeration. if (controlAdd != null) { hitResultsList.Add(controlAdd); } return(HitTestResultBehavior.Continue); case IntersectionDetail.Intersects: // Set the behavior to return visuals at all z-order levels. if (controlAdd != null) { hitResultsList.Add(controlAdd); } return(HitTestResultBehavior.Continue); case IntersectionDetail.FullyInside: // Set the behavior to return visuals at all z-order levels. if (controlAdd != null) { hitResultsList.Add(controlAdd); } return(HitTestResultBehavior.Continue); default: return(HitTestResultBehavior.Stop); } }
protected HitTestResultBehavior GeometryHitTestResult(HitTestResult result) { IntersectionDetail id = (result as GeometryHitTestResult).IntersectionDetail; if (!AllowIntersectionHits && (id != IntersectionDetail.FullyInside)) { return(HitTestResultBehavior.Continue); } // Insert instead on Add to preserve order of elements from canvas _hitList.Insert(0, result.VisualHit); return(HitTestResultBehavior.Continue); }
private bool HitTestDrawing(GlyphRunDrawing drawing, Geometry geomDisplay, IntersectionDetail detail) { if (drawing != null) { var textBounds = new RectangleGeometry(drawing.Bounds); if (textBounds.FillContainsWithDetail(geomDisplay) == detail) { return(true); } } return(false); }
public bool IntersectsPathSegment(Point startPoint, PathSegment pathSegment, IntersectionDetail intersectionDetail) { return((new PathGeometry() { Figures = { new PathFigure() { StartPoint = startPoint, Segments = { pathSegment } } } }.StrokeContainsWithDetail(GeometryIntersection.stroke, this.geometry) & intersectionDetail) != IntersectionDetail.NotCalculated); }
protected override GeometryHitTestResult HitTestCore(GeometryHitTestParameters hitTestParameters) { var source = (BitmapSource)Source; var rect = new Int32Rect((int)hitTestParameters.HitGeometry.Bounds.Left, (int)hitTestParameters.HitGeometry.Bounds.Top, (int)hitTestParameters.HitGeometry.Bounds.Width, (int)hitTestParameters.HitGeometry.Bounds.Height); int stride = (int)source.PixelWidth * (source.Format.BitsPerPixel / 8); byte[] pixels = new byte[(int)rect.Height * stride]; source.CopyPixels(rect, pixels, stride, 0); if (!pixels.Contains((byte)0)) { } IntersectionDetail intersectionDetail = IntersectionDetail.NotCalculated; // Perform custom actions during the hit test processing. return(new GeometryHitTestResult(this, intersectionDetail)); }
public override int Impact(Tank currentPlayer, Tank[] enemyTankArray) { game.PlayExplosionSound(); int damage = 0; projectile_Finished = false; projectile_Detonated = true; RemoveFromCanvas(); game.GetGame_MainCanvas().Children.Add( grenade_ExplosionPath); grenade_AnimationIncrement = 0; CompositionTarget.Rendering += AnimationEvent; projectile_Damage = grenade_ExplosionDamage; foreach (Tank tank in enemyTankArray) { IntersectionDetail tankExplosionIntersection = tank.GetGeometry().FillContainsWithDetail( grenade_ExplosionGeometry); if (tankExplosionIntersection == IntersectionDetail.Intersects || tankExplosionIntersection == IntersectionDetail.FullyInside || tankExplosionIntersection == IntersectionDetail.FullyContains) { tank.TakeDamage(this); currentPlayer.DealDamage(this); damage += projectile_Damage; } } projectile_Damage = grenade_ImpactDamage; return(damage); }
private void UpdateEvent(object Sender, EventArgs e) { foreach (Tank tank in game_TankArray) { Point point1 = game_Player.GetTankPosition(); IntersectionDetail innerTankMapIntersection = tank.GetTank_Path(false).Data.FillContainsWithDetail(game_Map.GetMap_Path().Data); IntersectionDetail outerTankMapIntersection = tank.GetTank_Path(true).Data.FillContainsWithDetail(game_Map.GetMap_Path().Data); if (outerTankMapIntersection == IntersectionDetail.Empty) { tank.MoveTankDown(); } if (innerTankMapIntersection == IntersectionDetail.Intersects) { tank.MoveTankUp(); } //game_Player.ChangeAngle(point1); } }
HitTestResultBehavior MyHitTestResultCallback(HitTestResult result) { IntersectionDetail intersectionDetail = ((GeometryHitTestResult)result).IntersectionDetail; switch (intersectionDetail) { case IntersectionDetail.FullyContains: { if (!hitResultsList.Contains(result.VisualHit) && (result.VisualHit as FrameworkElement).DataContext is ISelected) { hitResultsTempList.Add(result.VisualHit); } return(HitTestResultBehavior.Continue); } case IntersectionDetail.Intersects: { if (!hitResultsList.Contains(result.VisualHit) && (result.VisualHit as FrameworkElement).DataContext is ISelected) { hitResultsTempList.Add(result.VisualHit); } return(HitTestResultBehavior.Continue); } case IntersectionDetail.FullyInside: { if (!hitResultsList.Contains(result.VisualHit) && (result.VisualHit as FrameworkElement).DataContext is ISelected) { hitResultsTempList.Add(result.VisualHit); } return(HitTestResultBehavior.Continue); } default: { return(HitTestResultBehavior.Stop); } } }
/// <summary> /// This constructor takes a visual and point respresenting a hit. /// </summary> public GeometryHitTestResult( Visual visualHit, IntersectionDetail intersectionDetail) : base(visualHit) { _intersectionDetail = intersectionDetail; }
protected void BaseUpdateEvent(Tank[] enemyTankArray) { foreach (Tank tank in game_TankArray) { int i = game_Gravity; //Assigns a temporary integer variable the value of gravity //for use as a decrement in the following while loop. bool intersectionFound = false; //Assigns a temporary Boolean variable the value false for //use as an argument in the following while loop. while (i > 0 & !intersectionFound) { tank.MoveDown(); IntersectionDetail tankMapIntersection = tank.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { tank.MoveUp(); tank.MoveUp(); intersectionFound = true; //Will stop the while loop if the tank intersects //with the map, stopping gravity from pulling the //tank through the map. tank.SetTank_RotateTransformAngle(game_MapData.angleArray[Convert.ToInt32 (Math.Truncate(tank.GetTank_TranslateTransform().X / game_MapData.angleStep))]); } i--; //Will move the tank down according to the value of //gravity. } if (tank.GetTank_TranslateTransform().X < game_LeftBoundary) { tank.MoveRight(); tank.IncrementFuel(); tank.IncrementFuel(); tank.DecrementDistanceTravelled(); tank.DecrementDistanceTravelled(); //Moves the tank object right if it crosses the left //boundary and corrects the fuel and distance travelled //values. } if (tank.GetPath().ActualWidth + 15 > game_RightBoundary) { tank.MoveLeft(); tank.IncrementFuel(); tank.IncrementFuel(); tank.DecrementDistanceTravelled(); tank.DecrementDistanceTravelled(); //Moves the tank object left if it crosses the right //boundary and corrects the fuel and distance travelled //values. } //This code is done for all Tank objects in the array. } if (game_Projectile.GetProjectile_InMotion()) { if (!game_ProjectileDetonated) { game_Projectile.MoveAlongTrajectory(game_Gravity); } IntersectionDetail projectileMapIntersection = game_Projectile.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); bool enemyHit = false; foreach (Tank tank in enemyTankArray) { IntersectionDetail projectileEnemyIntersection = game_Projectile.GetGeometry().FillContainsWithDetail (tank.GetGeometry()); if (projectileEnemyIntersection == IntersectionDetail.Intersects && !enemyHit) { if (!game_ProjectileDetonated) { game_TurnDamage = game_Projectile.Impact(game_CurrentPlayer, enemyTankArray); } if (game_Projectile.GetProjectile_Finished()) { EndTurn(tank.TakeDamage(game_Projectile) + game_TurnDamage); game_CurrentPlayer.DealDamage(game_Projectile); } else { if (game_Projectile.GetProjectile_Detonated()) { game_ProjectileDetonated = true; } } enemyHit = true; } } if ((projectileMapIntersection == IntersectionDetail.Intersects | projectileMapIntersection == IntersectionDetail.FullyInside) && !enemyHit) { if (!game_ProjectileDetonated) { game_TurnDamage = game_Projectile.Impact(game_CurrentPlayer, enemyTankArray); } if (game_Projectile.GetProjectile_Finished()) { EndTurn(game_TurnDamage); } else { if (game_Projectile.GetProjectile_Detonated()) { game_ProjectileDetonated = true; } } } else if ((game_Projectile.GetProjectile_TranslateTransform().X <game_LeftBoundary | game_Projectile.GetProjectile_TranslateTransform().X> game_RightBoundary) && !enemyHit) { EndTurn(0); } } else if (game_DemoMode) { if (game_NextXLoc > game_CurrentPlayer.GetTank_TranslateTransform().X && game_CurrentPlayer.GetTank_Fuel() != 0) { game_CurrentPlayer.MoveRight(); //Moves the tank right if the game_NextXLoc is to its right. IntersectionDetail tankMapIntersection = game_CurrentPlayer.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { game_CurrentPlayer.MoveUp(); game_CurrentPlayer.MoveUp(); game_CurrentPlayer.SetTank_RotateTransformAngle(game_MapData.angleArray[Convert.ToInt32 (Math.Truncate(game_CurrentPlayer.GetTank_TranslateTransform().X / game_MapData.angleStep))]); } } else if (game_NextXLoc < game_CurrentPlayer.GetTank_TranslateTransform().X && game_CurrentPlayer.GetTank_Fuel() != 0) { game_CurrentPlayer.MoveLeft(); //Moves the tank left if the game_NextXLoc is to its left. IntersectionDetail tankMapIntersection = game_CurrentPlayer.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { game_CurrentPlayer.MoveUp(); game_CurrentPlayer.MoveUp(); game_CurrentPlayer.SetTank_RotateTransformAngle(game_MapData.angleArray[Convert.ToInt32 (Math.Truncate(game_CurrentPlayer.GetTank_TranslateTransform().X / game_MapData.angleStep))]); } } else { FireProjectileRandom(); //Fires the projectile on a random trajectory. } } else { if (game_CurrentPlayer.GetTank_Fuel() != 0) { if (Keyboard.IsKeyDown(Key.A)) { game_CurrentPlayer.MoveLeft(); //Moves the player's Tank object left if the 'A' key is //pressed down. IntersectionDetail tankMapIntersection = game_CurrentPlayer.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { game_CurrentPlayer.MoveUp(); game_CurrentPlayer.MoveUp(); game_CurrentPlayer.SetTank_RotateTransformAngle(game_MapData.angleArray[Convert.ToInt32 (Math.Truncate(game_CurrentPlayer.GetTank_TranslateTransform().X / game_MapData.angleStep))]); } } if (Keyboard.IsKeyDown(Key.D)) { game_CurrentPlayer.MoveRight(); //Moves the player's Tank object right if the 'D' key is //pressed down. IntersectionDetail tankMapIntersection = game_CurrentPlayer.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { game_CurrentPlayer.MoveUp(); game_CurrentPlayer.MoveUp(); game_CurrentPlayer.SetTank_RotateTransformAngle(game_MapData.angleArray[Convert.ToInt32 (Math.Truncate(game_CurrentPlayer.GetTank_TranslateTransform().X / game_MapData.angleStep))]); } } } if (game_AimingIcon.BeingDragged()) { game_AimingIcon.DragIconEvent(); } } }
/// <summary> /// This constructor takes a visual and point respresenting a hit. /// </summary> public GeometryHitTestResult( Visual visualHit, IntersectionDetail intersectionDetail) : base(visualHit) { _intersectionDetail = intersectionDetail; }
/// <summary> /// AccumulateIntersectionDetail - accepts a new IntersectionDetail which is the result /// of "drawingCommandGeometry.FillContainsWithDetail(hitTestGeometry)" and updates /// the current _intersectionDetail, setting _contains as appropriate. /// </summary> /// <param name="intersectionDetail"> /// The IntersectionDetail from hit-testing the current node. /// </param> private void AccumulateIntersectionDetail(IntersectionDetail intersectionDetail) { // Note that: // * "FullyContains" means that the target node contains the hit test-geometry, // * "FullyInside" means that the target node is fully inside the hit-test geometry // The old result cannot be FullyContain, because that would have // triggered a StopWalk and we wouldn't be here Debug.Assert(_intersectionDetail != IntersectionDetail.FullyContains); // The new result cannot be NotCalculated, because we just // calculated! Debug.Assert(intersectionDetail != IntersectionDetail.NotCalculated); // The current _intersectionDetail is computed from its old value and the // new result according the the following table: // \ old + // New \ + NotCalc | Empty | Intersects | FullyInside There // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ is // Empty + Empty | Empty | Intersects | Intersects no // ------------+------------------------------------------------------- Contains // Intersects + Intersects | Intersects | Intersects | Intersects column // ------------+------------------------------------------------------- (see // Contains + Contains | Contains | Contains | Contains assertion // ------------+-------------------------------------------------------- above) // FullyInside + FullInside | Intersects | Intersects | FullyInside if (_intersectionDetail == IntersectionDetail.NotCalculated) // This is the first node { _intersectionDetail = intersectionDetail; // Takes care of the first column. } else if (intersectionDetail == IntersectionDetail.FullyInside // This node is fully inside the hit geometry -- && _intersectionDetail != IntersectionDetail.FullyInside) // -- but we have already encountered a previous node that was not fully inside { _intersectionDetail = IntersectionDetail.Intersects; // Taking care of the second-to-left bottom cell } else if (intersectionDetail == IntersectionDetail.Empty // This node does not touch the hit geometry -- && _intersectionDetail != IntersectionDetail.Empty) // -- but we have already encountered a previous node that was touched { _intersectionDetail = IntersectionDetail.Intersects; // Taking care of the third and fourth cells in the first row } else { // Accept the new result as is _intersectionDetail = intersectionDetail; // Taking care of the second and third row and the diagonal } if (_intersectionDetail == IntersectionDetail.FullyContains) { // The hit geometry is fully contained in the visual, so signal a StopWalk _contains = true; } }
public GeometryHitTestResult(Visual visualHit, IntersectionDetail intersectionDetail) { }
protected void BaseUpdateEvent(Tank[] enemyTankArray) { foreach (Tank tank in game_TankArray) { int i = game_Gravity; //Assigns a temporary integer variable the value of gravity //for use as a decrement in the following while loop. bool intersectionFound = false; //Assigns a temporary Boolean variable the value false for //use as an argument in the following while loop. while (i > 0 & !intersectionFound) { tank.MoveDown(); IntersectionDetail tankMapIntersection = tank.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { tank.MoveUp(); intersectionFound = true; //Will stop the while loop if the tank intersects //with the map, stopping gravity from pulling the //tank through the map. } i--; //Will move the tank down according to the value of //gravity. } if (tank.GetTank_TranslateTransform().X < game_LeftBoundary) { tank.MoveRight(); tank.IncrementFuel(); tank.IncrementFuel(); tank.DecrementDistanceTravelled(); tank.DecrementDistanceTravelled(); //Moves the tank object right if it crosses the left //boundary and corrects the fuel and distance travelled //values. } if (tank.GetPath().ActualWidth + 15 > game_RightBoundary) { tank.MoveLeft(); tank.IncrementFuel(); tank.IncrementFuel(); tank.DecrementDistanceTravelled(); tank.DecrementDistanceTravelled(); //Moves the tank object left if it crosses the right //boundary and corrects the fuel and distance travelled //values. } //This code is done for all Tank objects in the array. } if (game_Projectile.GetProjectile_InMotion()) { double i = game_Projectile.GetProjectile_Speed() * game_Projectile.GetXVelocity(); //Assigns a temporary integer variable for use as a decrement //In the following while loop. bool intersectionFound = false; //Assigns a temporary Boolean variable the value false for //use as an argument in the following while loop. while (i > 0 & !intersectionFound) { game_Projectile.MoveAlongTrajectory(game_Gravity); //Moves the Projectile along its trajectory. IntersectionDetail projectileMapIntersection = game_Projectile.GetGeometry().FillContainsWithDetail (game_Map.GetGeometry()); //Assigns the results from a hitbox test between the Projectile //object and the Map object to a variable. foreach (Tank tank in enemyTankArray) { IntersectionDetail projectileEnemyIntersection = game_Projectile.GetGeometry().FillContainsWithDetail (tank.GetGeometry()); //Assigns the results from a hitbox test between the Projectile //object and the tank object to a variable. if (projectileEnemyIntersection == IntersectionDetail.Intersects & !intersectionFound) { game_MediaPlayer.Open(game_ExplosionSoundUri); game_MediaPlayer.Play(); EndTurn(tank.TakeDamage(game_Projectile)); game_CurrentPlayer.DealDamage(game_Projectile); intersectionFound = true; //If the projectile hits the enemy it will deal damage and //stop the while loop. } } if ((projectileMapIntersection == IntersectionDetail.Intersects | projectileMapIntersection == IntersectionDetail.FullyInside) & !intersectionFound) { game_MediaPlayer.Open(game_ExplosionSoundUri); game_MediaPlayer.Play(); EndTurn(0); intersectionFound = true; //If the projectile hits the map it stops the while loop. } else if ((game_Projectile.GetProjectile_TranslateTransform().X <game_LeftBoundary | game_Projectile.GetProjectile_TranslateTransform().X> game_RightBoundary) & !intersectionFound) { EndTurn(0); intersectionFound = true; //If the projectile leaves the map it stops the while loop. } i--; //Decrements the while loop. } } else if (game_DemoMode) { if (game_NextXLoc > game_CurrentPlayer.GetTank_TranslateTransform().X && game_CurrentPlayer.GetTank_Fuel() != 0) { game_CurrentPlayer.MoveRight(); //Moves the tank right if the game_NextXLoc is to its right. } else if (game_NextXLoc < game_CurrentPlayer.GetTank_TranslateTransform().X && game_CurrentPlayer.GetTank_Fuel() != 0) { game_CurrentPlayer.MoveLeft(); //Moves the tank left if the game_NextXLoc is to its left. } else { FireProjectileRandom(); //Fires the projectile on a random trajectory. } } else { if (game_CurrentPlayer.GetTank_Fuel() != 0) { if (Keyboard.IsKeyDown(Key.A)) { game_CurrentPlayer.MoveLeft(); //Moves the player's Tank object left if the 'A' key is //pressed down. } if (Keyboard.IsKeyDown(Key.D)) { game_CurrentPlayer.MoveRight(); //Moves the player's Tank object right if the 'D' key is //pressed down. } } if (game_AimingIcon.BeingDragged()) { game_AimingIcon.DragIconEvent(); } } }
protected override void UpdateEvent(object sender, EventArgs e) { int i = game_Gravity; bool intersectionFound = false; while (i > 0 & !intersectionFound) { mapLoader_AngleMeasurer.MoveDown(); IntersectionDetail angleMeasurerMapIntersection = mapLoader_AngleMeasurer.GetGeometry(). FillContainsWithDetail(game_Map.GetGeometry()); if (angleMeasurerMapIntersection == IntersectionDetail.Intersects) { mapLoader_AngleMeasurer.MoveUp(); mapLoader_AngleMeasurer.MoveUp(); intersectionFound = true; mapLoader_AngleMeasurer.angleMeasurer_Start = true; } i--; } if (game_NewTurn) { mapLoader_CurrentMapIndex++; if (mapLoader_CurrentMapIndex == mapLoader_MapDataList.Count) { mapLoader_CalculatingAngles = false; } else { game_MainCanvas.Children.Remove(game_Map.GetPath()); game_Map = new Map(this, mapLoader_MapDataList[mapLoader_CurrentMapIndex]); mapLoader_AngleMeasurer.ResetPosition(); mapLoader_AngleMeasurer.angleMeasurer_AngleList = new List <double>(); mapLoader_AngleMeasurer.angleMeasurer_Start = false; } game_NewTurn = false; } else { if (mapLoader_AngleMeasurer.angleMeasurer_TranslateTransform.X >= game_RightBoundary) { string mapName = mapLoader_MapDataList[mapLoader_CurrentMapIndex].mapName; Point[] mapPointArray = mapLoader_MapDataList[mapLoader_CurrentMapIndex].pointArray; mapLoader_MapDataList[mapLoader_CurrentMapIndex] = new Framework.MapData(mapName, mapPointArray, mapLoader_Step) { angleArray = mapLoader_AngleMeasurer.angleMeasurer_AngleList.ToArray() }; game_NewTurn = true; } else if (mapLoader_AngleMeasurer.angleMeasurer_Start) { mapLoader_AngleMeasurer.angleMeasurer_PrevY = mapLoader_AngleMeasurer.angleMeasurer_TranslateTransform.Y; for (int s = 0; s < mapLoader_Step; s++) { mapLoader_AngleMeasurer.MoveRight(); int j = game_Gravity; intersectionFound = false; while (j > 0 & !intersectionFound) { mapLoader_AngleMeasurer.MoveDown(); IntersectionDetail angleMeasurerMapIntersection = mapLoader_AngleMeasurer.GetGeometry(). FillContainsWithDetail(game_Map.GetGeometry()); if (angleMeasurerMapIntersection == IntersectionDetail.Intersects) { mapLoader_AngleMeasurer.MoveUp(); mapLoader_AngleMeasurer.MoveUp(); intersectionFound = true; } j--; } } mapLoader_AngleMeasurer.CalculateNextAngle(); } } }
private bool HitTestDrawing(GeometryDrawing drawing, Geometry geomDisplay, IntersectionDetail detail) { Pen pen = drawing.Pen; Brush brush = drawing.Brush; if (pen != null && brush == null) { if (drawing.Geometry.StrokeContainsWithDetail(pen, geomDisplay) == detail) { return(true); } Geometry geometry = drawing.Geometry; LineGeometry line = null; EllipseGeometry ellipse = null; RectangleGeometry rectangle = null; PathGeometry path = null; if (TryCast.Cast(geometry, out path)) { PathFigureCollection pathFigures = path.Figures; int itemCount = pathFigures.Count; if (itemCount == 1) { if (pathFigures[0].IsClosed && path.FillContainsWithDetail(geomDisplay) == detail) { return(true); } } else { for (int f = 0; f < itemCount; f++) { PathFigure pathFigure = pathFigures[f]; if (pathFigure.IsClosed) { PathFigureCollection testFigures = new PathFigureCollection(); testFigures.Add(pathFigure); PathGeometry testPath = new PathGeometry(); testPath.Figures = testFigures; if (testPath.FillContainsWithDetail(geomDisplay) == detail) { return(true); } } } } } else if (TryCast.Cast(geometry, out line)) { if (line.FillContainsWithDetail(geomDisplay) == detail) { return(true); } } else if (TryCast.Cast(geometry, out ellipse)) { if (ellipse.FillContainsWithDetail(geomDisplay) == detail) { return(true); } } else if (TryCast.Cast(geometry, out rectangle)) { if (rectangle.FillContainsWithDetail(geomDisplay) == detail) { return(true); } } } else if (brush != null && drawing.Geometry.FillContainsWithDetail(geomDisplay) == detail) { return(true); } return(false); }
private bool HitTestDrawing(DrawingGroup group, Geometry geomDisplay, out Drawing hitDrawing, IntersectionDetail detail) { hitDrawing = null; var geomBounds = new RectangleGeometry(group.Bounds); if (geomBounds.FillContainsWithDetail(geomDisplay) == detail) { DrawingGroup groupDrawing = null; GlyphRunDrawing glyRunDrawing = null; GeometryDrawing geometryDrawing = null; DrawingCollection drawings = group.Children; for (int i = drawings.Count - 1; i >= 0; i--) { Drawing drawing = drawings[i]; if (TryCast.Cast(drawing, out geometryDrawing)) { if (HitTestDrawing(geometryDrawing, geomDisplay, detail)) { hitDrawing = geometryDrawing; return(true); } } else if (TryCast.Cast(drawing, out groupDrawing)) { SvgObjectType objectType = SvgObject.GetType(groupDrawing); if (objectType == SvgObjectType.Text) { var textBounds = new RectangleGeometry(groupDrawing.Bounds); if (textBounds.FillContainsWithDetail(geomDisplay) == detail) { hitDrawing = groupDrawing; return(true); } } if (HitTestDrawing(groupDrawing, geomDisplay, out hitDrawing, detail)) { return(true); } } else if (TryCast.Cast(drawing, out glyRunDrawing)) { if (HitTestDrawing(glyRunDrawing, geomDisplay, detail)) { hitDrawing = glyRunDrawing; return(true); } } } return(true); } return(false); }
private Drawing PerformHitTest(Rect rect, IntersectionDetail detail) { if (_svgDrawing == null) { return(null); } var rectDisplay = _displayTransform.TransformBounds(rect); var geomDisplay = new RectangleGeometry(rectDisplay); DrawingGroup groupDrawing = null; GlyphRunDrawing glyRunDrawing = null; GeometryDrawing geometryDrawing = null; Drawing foundDrawing = null; DrawingCollection drawings = _svgDrawing.Children; for (int i = drawings.Count - 1; i >= 0; i--) { Drawing drawing = drawings[i]; if (TryCast.Cast(drawing, out geometryDrawing)) { if (HitTestDrawing(geometryDrawing, geomDisplay, detail)) { string uniqueId = SvgObject.GetUniqueId(drawing); if (!string.IsNullOrWhiteSpace(uniqueId)) { foundDrawing = drawing; break; } } } else if (TryCast.Cast(drawing, out groupDrawing)) { if (SvgObject.GetType(groupDrawing) == SvgObjectType.Text) { var textBounds = new RectangleGeometry(groupDrawing.Bounds); if (textBounds.FillContainsWithDetail(geomDisplay) == detail) { string uniqueId = SvgObject.GetUniqueId(drawing); if (!string.IsNullOrWhiteSpace(uniqueId)) { foundDrawing = drawing; break; } } } if (HitTestDrawing(groupDrawing, geomDisplay, out foundDrawing, detail)) { string uniqueId = SvgObject.GetUniqueId(drawing); if (!string.IsNullOrWhiteSpace(uniqueId)) { foundDrawing = drawing; break; } } } else if (TryCast.Cast(drawing, out glyRunDrawing)) { if (HitTestDrawing(glyRunDrawing, geomDisplay, detail)) { foundDrawing = drawing; break; } } } return(foundDrawing); }
internal unsafe static extern int MilUtility_PathGeometryHitTestPathGeometry( MilMatrix3x2D *pMatrix1, FillRule fillRule1, byte *pPathData1, UInt32 nSize1, MilMatrix3x2D *pMatrix2, FillRule fillRule2, byte *pPathData2, UInt32 nSize2, double rTolerance, bool fRelative, IntersectionDetail* pDetail);
public GeometryHitTestResult(Visual visualHit, IntersectionDetail intersectionDetail) { }
private void MissileEvent(object sender, EventArgs e) { bool fin = true; foreach (Missile missile in airStrike_MissileArray) { if (missile.GetProjectile_InMotion()) { fin = false; if (!missile.GetProjectile_Detonated()) { missile.MoveAlongTrajectory(game.GetGame_Gravity()); } IntersectionDetail projectileMapIntersection = missile.GetGeometry().FillContainsWithDetail (game.GetGame_Map().GetGeometry()); bool enemyHit = false; foreach (Tank tank in airStrike_EnemyTankArray) { IntersectionDetail projectileEnemyIntersection = missile.GetGeometry().FillContainsWithDetail (tank.GetGeometry()); if (projectileEnemyIntersection == IntersectionDetail.Intersects && !enemyHit) { if (!missile.GetProjectile_Detonated()) { game.PlayExplosionSound(); airStrike_TotalDamage += missile.Impact(airStrike_CurrentPlayer, airStrike_EnemyTankArray); } if (missile.GetProjectile_Finished()) { missile.StopTrajectory(); tank.TakeDamage(missile); airStrike_CurrentPlayer.DealDamage(missile); } enemyHit = true; } } if ((projectileMapIntersection == IntersectionDetail.Intersects | projectileMapIntersection == IntersectionDetail.FullyInside) && !enemyHit) { if (!missile.GetProjectile_Detonated()) { game.PlayExplosionSound(); missile.Impact(airStrike_CurrentPlayer, airStrike_EnemyTankArray); } if (missile.GetProjectile_Finished()) { missile.StopTrajectory(); } } else if ((missile.GetProjectile_TranslateTransform().X < game.GetGame_Boundaries()[0] | missile.GetProjectile_TranslateTransform().X > game.GetGame_Boundaries()[1]) && !enemyHit) { missile.StopTrajectory(); } } } if (fin) { CompositionTarget.Rendering -= MissileEvent; projectile_Finished = true; projectile_Detonated = false; game.EndTurn(airStrike_TotalDamage); airStrike_TotalDamage = 0; } }
/// <summary> /// AccumulateIntersectionDetail - accepts a new IntersectionDetail which is the result /// of "drawingCommandGeometry.FillContainsWithDetail(hitTestGeometry)" and updates /// the current _intersectionDetail, setting _contains as appropriate. /// </summary> /// <param name="intersectionDetail"> /// The IntersectionDetail from hit-testing the current node. /// </param> private void AccumulateIntersectionDetail(IntersectionDetail intersectionDetail) { // Note that: // * "FullyContains" means that the target node contains the hit test-geometry, // * "FullyInside" means that the target node is fully inside the hit-test geometry // The old result cannot be FullyContain, because that would have // triggered a StopWalk and we wouldn't be here Debug.Assert(_intersectionDetail != IntersectionDetail.FullyContains); // The new result cannot be NotCalculated, because we just // calculated! Debug.Assert(intersectionDetail != IntersectionDetail.NotCalculated); // The current _intersectionDetail is computed from its old value and the // new result according the the following table: // \ old + // New \ + NotCalc | Empty | Intersects | FullyInside There // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ is // Empty + Empty | Empty | Intersects | Intersects no // ------------+------------------------------------------------------- Contains // Intersects + Intersects | Intersects | Intersects | Intersects column // ------------+------------------------------------------------------- (see // Contains + Contains | Contains | Contains | Contains assertion // ------------+------------------------------------------------------- above) // FullyInside + FullInside | Intersects | Intersects | FullyInside if (_intersectionDetail == IntersectionDetail.NotCalculated) // This is the first node { _intersectionDetail = intersectionDetail; // Takes care of the first column. } else if (intersectionDetail == IntersectionDetail.FullyInside // This node is fully inside the hit geometry -- && _intersectionDetail != IntersectionDetail.FullyInside) // -- but we have already encountered a previous node that was not fully inside { _intersectionDetail = IntersectionDetail.Intersects; // Taking care of the second-to-left bottom cell } else if (intersectionDetail == IntersectionDetail.Empty // This node does not touch the hit geometry -- && _intersectionDetail != IntersectionDetail.Empty) // -- but we have already encountered a previous node that was touched { _intersectionDetail = IntersectionDetail.Intersects; // Taking care of the third and fourth cells in the first row } else { // Accept the new result as is _intersectionDetail = intersectionDetail; // Taking care of the second and third row and the diagonal } if (_intersectionDetail == IntersectionDetail.FullyContains) { // The hit geometry is fully contained in the visual, so signal a StopWalk _contains = true; } }
private void UpdateEvent(object sender, EventArgs e) { //This is the method that will run every time a new frame is //rendered, and so will be used to update the game. IntersectionDetail playerTankBarrierRightIntersection = game_Player.GetTank_Path().Data.FillContainsWithDetail (game_TankBarrierRight.GetTankBarrier_Path().Data); IntersectionDetail playerTankBarrierLeftIntersection = game_Player.GetTank_Path().Data.FillContainsWithDetail (game_TankBarrierLeft.GetTankBarrier_Path().Data); //Assigns the results from hitbox tests between the Tank object //and TankBarrier objects to variables. if (playerTankBarrierRightIntersection == IntersectionDetail.Intersects) { game_Player.MoveLeft(); //Moves the player's Tank left if it is intersecting with //the TankBarrier object to its right. } if (playerTankBarrierLeftIntersection == IntersectionDetail.Intersects) { game_Player.MoveRight(); //Moves the player's Tank right if it is intersecting with //the TankBarrier object to its left. } foreach (Tank tank in game_TankArray) { int i = game_Gravity; //Assigns a temporary integer variable the value of gravity //for use as a decrement in the following while loop. bool intersectionFound = false; //Assigns a temporary Boolean variable the value false for //use as an argument in the following while loop. while (i > 0 & !intersectionFound) { tank.MoveDown(); IntersectionDetail tankMapIntersection = tank.GetTank_Path().Data.FillContainsWithDetail (game_Map.GetMap_Path().Data); //Assigns the results from a hitbox test between the //Tank and the Map to a new variable. if (tankMapIntersection == IntersectionDetail.Intersects) { tank.MoveUp(); intersectionFound = true; //Will stop the while loop if the tank intersects //with the map, stopping gravity from pulling the //tank through the map. } i--; //Will move the tank down according to the value of //gravity. } //This code is done for all Tank objects in the array. } if (game_CurrentProjectile.GetProjectile_InMotion()) { double i = game_CurrentProjectile.GetProjectile_Speed() * game_CurrentProjectile.GetXVelocity(); //Assigns a temporary integer variable for use as a decrement //In the following while loop. bool intersectionFound = false; //Assigns a temporary Boolean variable the value false for //use as an argument in the following while loop. while (i > 0 & !intersectionFound) { game_CurrentProjectile.MoveAlongTrajectory(game_Gravity); //Moves the Projectile along its trajectory. IntersectionDetail projectileMapIntersection = game_CurrentProjectile.GetProjectile_Path().Data.FillContainsWithDetail (game_Map.GetMap_Path().Data); IntersectionDetail projectileEnemyIntersection = game_CurrentProjectile.GetProjectile_Path().Data.FillContainsWithDetail (game_Enemy.GetTank_Path().Data); //Assigns the results from hitbox tests between the Projectile //object and the Map and Enemy Tank objects to variables. if (projectileEnemyIntersection == IntersectionDetail.Intersects) { EndTurn(game_Enemy.TakeDamage(game_CurrentProjectile)); intersectionFound = true; //If the projectile hits the enemy it will deal damage and //stop the while loop. } else if (projectileMapIntersection == IntersectionDetail.Intersects | projectileMapIntersection == IntersectionDetail.FullyInside) { EndTurn(0); intersectionFound = true; //If the projectile hits the map it stop the while loop. } else if (game_CurrentProjectile.GetProjectile_TranslateTransform().X <game_LeftProjectileLimit | game_CurrentProjectile.GetProjectile_TranslateTransform().X> game_RightProjectileLimit) { EndTurn(0); intersectionFound = true; //If the projectile leaves the map it stop the while loop. } i--; //Decrements the while loop. } } else { if (Keyboard.IsKeyDown(Key.A)) { game_Player.MoveLeft(); //Moves the player's Tank object left if the 'A' key is //pressed down. } if (Keyboard.IsKeyDown(Key.D)) { game_Player.MoveRight(); //Moves the player's Tank object right if the 'D' key is //pressed down. } if (game_AimingIcon.GetAimingIcon_BeingDragged()) { game_AimingIcon.DragIconEvent(); } } }
/// <summary> /// Returns true if a given geometry is contained inside this geometry. /// </summary> /// <param name="geometry">The geometry tested for containment</param> /// <param name="tolerance">Acceptable margin of error in distance computation</param> /// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param> public bool FillContains(Geometry geometry, double tolerance, ToleranceType type) { IntersectionDetail detail = FillContainsWithDetail(geometry, tolerance, type); return(detail == IntersectionDetail.FullyContains); }