/// <summary> /// Copy the bounds, focus object, and deadzone info from an existing camera. /// </summary> /// <param name="camera">The camera you want to copy from.</param> /// <returns>A reference to this <code>FlxCamera</code> object.</returns> public FlxCamera copyFrom(FlxCamera camera) { if (camera.Bounds == null) { this.Bounds = null; } else { if (this.Bounds == null) { this.Bounds = new FlxRect(); } this.Bounds.copyFrom(camera.Bounds); } this.Target = camera.Target; if (this.Target != null) { if (camera.Deadzone == null) { this.Deadzone = null; } else { if (this.Deadzone == null) { this.Deadzone = new FlxRect(); } this.Deadzone.copyFrom(camera.Deadzone); } } return(this); }
/// <summary> /// Check and see if this object is currently on screen. /// Differs from <code>FlxObject</code>'s implementation /// in that it takes the actual graphic into account, /// not just the hitbox or bounding box or whatever. /// </summary> /// <param name="camera">Specify which game camera you want. If null getScreenXY() will just grab the first global camera.</param> /// <returns>Whether the object is on screen or not.</returns> override public bool onScreen(FlxCamera camera = null) { if (camera == null) { camera = FlxG.camera; } getScreenXY(_tagPoint, camera); _tagPoint.X = _tagPoint.X - Offset.X; _tagPoint.Y = _tagPoint.Y - Offset.Y; /* * if (((angle == 0) || (_bakedRotation > 0)) && (scale.x == 1) && (scale.y == 1)) * return ((_point.x + frameWidth > 0) && (_point.x < Camera.width) && (_point.y + frameHeight > 0) && (_point.y < Camera.height)); */ float halfWidth = FrameWidth / 2; float halfHeight = FrameHeight / 2; float absScaleX = (Scale.X > 0) ? Scale.X : -Scale.X; float absScaleY = (Scale.Y > 0) ? Scale.Y : -Scale.Y; float radius = (float)Math.Sqrt((halfWidth * halfWidth) + (halfHeight * halfHeight)) * ((absScaleX >= absScaleY) ? absScaleX : absScaleY); _tagPoint.X = _tagPoint.X + halfWidth; _tagPoint.Y = _tagPoint.Y + halfHeight; return((_tagPoint.X + radius > 0) && (_tagPoint.X - radius < camera.Width) && (_tagPoint.Y + radius > 0) && (_tagPoint.Y - radius < camera.Height)); }
/// <summary> /// Checks to see if a point in 2D world space overlaps this <code>FlxSprite</code> object's current displayed pixels. /// This check is ALWAYS made in screen space, and always takes scroll factors into account. /// </summary> /// <param name="point">The point in world space you want to check.</param> /// <param name="mask">Used in the pixel hit test to determine what counts as solid.</param> /// <param name="camera">Specify which game camera you want. If null getScreenXY() will just grab the first global camera.</param> /// <returns></returns> public bool pixelOverlapPoint(FlxPoint point, uint mask = 0xFF, FlxCamera camera = null) { throw new NotImplementedException(); /* * if(Camera == null) * Camera = FlxG.camera; * getScreenXY(_point,Camera); * _point.x = _point.x - offset.x; * _point.y = _point.y - offset.y; * _flashPoint.x = (Point.x - Camera.scroll.x) - _point.x; * _flashPoint.y = (Point.y - Camera.scroll.y) - _point.y; * return framePixels.hitTest(_flashPointZero,Mask,_flashPoint); */ }
/// <summary> /// While this doesn't override <code>FlxBasic.DrawDebug()</code>, the behavior is very similar. /// Based on this path data, it draws a simple lines-and-boxes representation of the path /// if the visual debug mode was toggled in the debugger overlay. You can use <code>DebugColor</code> /// and <code>DebugScrollFactor</code> to control the path's appearance. /// </summary> /// <param name="camera">The camera object the path will draw to.</param> public void DrawDebug(FlxCamera camera) { throw new NotImplementedException(); /* * if(nodes.length <= 0) * return; * if(Camera == null) * Camera = FlxG.camera; * * //Set up our global flash graphics object to draw out the path * var gfx:Graphics = FlxG.flashGfx; * gfx.clear(); * * //Then fill up the object with node and path graphics * var node:FlxPoint; * var nextNode:FlxPoint; * var i:uint = 0; * var l:uint = nodes.length; * while(i < l) * { * //get a reference to the current node * node = nodes[i] as FlxPoint; * * //find the screen position of the node on this camera * _point.x = node.x - int(Camera.scroll.x*debugScrollFactor.x); //copied from getScreenXY() * _point.y = node.y - int(Camera.scroll.y*debugScrollFactor.y); * _point.x = int(_point.x + ((_point.x > 0)?0.0000001:-0.0000001)); * _point.y = int(_point.y + ((_point.y > 0)?0.0000001:-0.0000001)); * * //decide what color this node should be * var nodeSize:uint = 2; * if((i == 0) || (i == l-1)) * nodeSize *= 2; * var nodeColor:uint = debugColor; * if(l > 1) * { * if(i == 0) * nodeColor = FlxG.GREEN; * else if(i == l-1) * nodeColor = FlxG.RED; * } * * //draw a box for the node * gfx.beginFill(nodeColor,0.5); * gfx.lineStyle(); * gfx.drawRect(_point.x-nodeSize*0.5,_point.y-nodeSize*0.5,nodeSize,nodeSize); * gfx.endFill(); * * //then find the next node in the path * var linealpha:Number = 0.3; * if(i < l-1) * nextNode = nodes[i+1]; * else * { * nextNode = nodes[0]; * linealpha = 0.15; * } * * //then draw a line to the next node * gfx.moveTo(_point.x,_point.y); * gfx.lineStyle(1,debugColor,linealpha); * _point.x = nextNode.x - int(Camera.scroll.x*debugScrollFactor.x); //copied from getScreenXY() * _point.y = nextNode.y - int(Camera.scroll.y*debugScrollFactor.y); * _point.x = int(_point.x + ((_point.x > 0)?0.0000001:-0.0000001)); * _point.y = int(_point.y + ((_point.y > 0)?0.0000001:-0.0000001)); * gfx.lineTo(_point.x,_point.y); * * i++; * } * * //then stamp the path down onto the game buffer * Camera.buffer.draw(FlxG.flashGfxSprite); */ }
/// <summary> /// Override this function to draw custom "debug mode" graphics to the /// specified camera while the debugger's visual mode is toggled on. /// </summary> /// <param name="camera">Which camera to draw the debug visuals to.</param> public virtual void drawDebug(FlxCamera camera = null) { }
/// <summary> /// Override this function to draw custom "debug mode" graphics to the /// specified camera while the debugger's visual mode is toggled on. /// </summary> /// <param name="camera">Which camera to draw the debug visuals to.</param> public virtual void drawDebug(FlxCamera camera = null) { }
/// <summary> /// Check and see if this object is currently on screen. /// Differs from <code>FlxObject</code>'s implementation /// in that it takes the actual graphic into account, /// not just the hitbox or bounding box or whatever. /// </summary> /// <param name="camera">Specify which game camera you want. If null getScreenXY() will just grab the first global camera.</param> /// <returns>Whether the object is on screen or not.</returns> public override bool onScreen(FlxCamera camera = null) { if (camera == null) { camera = FlxG.camera; } getScreenXY(_tagPoint, camera); _tagPoint.X = _tagPoint.X - Offset.X; _tagPoint.Y = _tagPoint.Y - Offset.Y; /* if (((angle == 0) || (_bakedRotation > 0)) && (scale.x == 1) && (scale.y == 1)) return ((_point.x + frameWidth > 0) && (_point.x < Camera.width) && (_point.y + frameHeight > 0) && (_point.y < Camera.height)); */ float halfWidth = FrameWidth / 2; float halfHeight = FrameHeight / 2; float absScaleX = (Scale.X > 0) ? Scale.X : -Scale.X; float absScaleY = (Scale.Y > 0) ? Scale.Y : -Scale.Y; float radius = (float)Math.Sqrt((halfWidth * halfWidth) + (halfHeight * halfHeight)) * ((absScaleX >= absScaleY) ? absScaleX : absScaleY); _tagPoint.X = _tagPoint.X + halfWidth; _tagPoint.Y = _tagPoint.Y + halfHeight; return ((_tagPoint.X + radius > 0) && (_tagPoint.X - radius < camera.Width) && (_tagPoint.Y + radius > 0) && (_tagPoint.Y - radius < camera.Height)); }
/// <summary> /// Checks to see if a point in 2D world space overlaps this <code>FlxSprite</code> object's current displayed pixels. /// This check is ALWAYS made in screen space, and always takes scroll factors into account. /// </summary> /// <param name="point">The point in world space you want to check.</param> /// <param name="mask">Used in the pixel hit test to determine what counts as solid.</param> /// <param name="camera">Specify which game camera you want. If null getScreenXY() will just grab the first global camera.</param> /// <returns></returns> public bool pixelOverlapPoint(FlxPoint point, uint mask = 0xFF, FlxCamera camera = null) { throw new NotImplementedException(); /* if(Camera == null) Camera = FlxG.camera; getScreenXY(_point,Camera); _point.x = _point.x - offset.x; _point.y = _point.y - offset.y; _flashPoint.x = (Point.x - Camera.scroll.x) - _point.x; _flashPoint.y = (Point.y - Camera.scroll.y) - _point.y; return framePixels.hitTest(_flashPointZero,Mask,_flashPoint); */ }
/// <summary> /// While this doesn't override <code>FlxBasic.DrawDebug()</code>, the behavior is very similar. /// Based on this path data, it draws a simple lines-and-boxes representation of the path /// if the visual debug mode was toggled in the debugger overlay. You can use <code>DebugColor</code> /// and <code>DebugScrollFactor</code> to control the path's appearance. /// </summary> /// <param name="camera">The camera object the path will draw to.</param> public void DrawDebug(FlxCamera camera) { throw new NotImplementedException(); /* if(nodes.length <= 0) return; if(Camera == null) Camera = FlxG.camera; //Set up our global flash graphics object to draw out the path var gfx:Graphics = FlxG.flashGfx; gfx.clear(); //Then fill up the object with node and path graphics var node:FlxPoint; var nextNode:FlxPoint; var i:uint = 0; var l:uint = nodes.length; while(i < l) { //get a reference to the current node node = nodes[i] as FlxPoint; //find the screen position of the node on this camera _point.x = node.x - int(Camera.scroll.x*debugScrollFactor.x); //copied from getScreenXY() _point.y = node.y - int(Camera.scroll.y*debugScrollFactor.y); _point.x = int(_point.x + ((_point.x > 0)?0.0000001:-0.0000001)); _point.y = int(_point.y + ((_point.y > 0)?0.0000001:-0.0000001)); //decide what color this node should be var nodeSize:uint = 2; if((i == 0) || (i == l-1)) nodeSize *= 2; var nodeColor:uint = debugColor; if(l > 1) { if(i == 0) nodeColor = FlxG.GREEN; else if(i == l-1) nodeColor = FlxG.RED; } //draw a box for the node gfx.beginFill(nodeColor,0.5); gfx.lineStyle(); gfx.drawRect(_point.x-nodeSize*0.5,_point.y-nodeSize*0.5,nodeSize,nodeSize); gfx.endFill(); //then find the next node in the path var linealpha:Number = 0.3; if(i < l-1) nextNode = nodes[i+1]; else { nextNode = nodes[0]; linealpha = 0.15; } //then draw a line to the next node gfx.moveTo(_point.x,_point.y); gfx.lineStyle(1,debugColor,linealpha); _point.x = nextNode.x - int(Camera.scroll.x*debugScrollFactor.x); //copied from getScreenXY() _point.y = nextNode.y - int(Camera.scroll.y*debugScrollFactor.y); _point.x = int(_point.x + ((_point.x > 0)?0.0000001:-0.0000001)); _point.y = int(_point.y + ((_point.y > 0)?0.0000001:-0.0000001)); gfx.lineTo(_point.x,_point.y); i++; } //then stamp the path down onto the game buffer Camera.buffer.draw(FlxG.flashGfxSprite); */ }
/// <summary> /// Copy the bounds, focus object, and deadzone info from an existing camera. /// </summary> /// <param name="camera">The camera you want to copy from.</param> /// <returns>A reference to this <code>FlxCamera</code> object.</returns> public FlxCamera copyFrom(FlxCamera camera) { if (camera.Bounds == null) { this.Bounds = null; } else { if (this.Bounds == null) { this.Bounds = new FlxRect(); } this.Bounds.copyFrom(camera.Bounds); } this.Target = camera.Target; if (this.Target != null) { if (camera.Deadzone == null) { this.Deadzone = null; } else { if (this.Deadzone == null) { this.Deadzone = new FlxRect(); } this.Deadzone.copyFrom(camera.Deadzone); } } return this; }