Beispiel #1
0
 public Punk(String inEntityType, int inTotalLife, Nez.Tiled.TiledMap inMap, bool enemyHasGun, int ntargetPositionRange) : base(inEntityType, inTotalLife, inMap, enemyHasGun, ntargetPositionRange)
 {
     EntityType          = inEntityType;
     TileMap             = inMap;
     TotalLife           = inTotalLife;
     CurrentLife         = TotalLife;
     CollisionLayer      = TileMap.getLayer <TiledTileLayer>("collisionLayer");
     WeightedGraph       = new WeightedGridGraph(CollisionLayer);
     Start               = new Point(1, 1);
     End                 = new Point(10, 10);
     WeightedSearchPath  = WeightedGraph.search(Start, End);
     EnemyCanShootGun    = enemyHasGun;
     TargetPositionRange = ntargetPositionRange;
 }
 /// <summary>
 /// note that the origin is the top left so this position will represent that
 /// </summary>
 /// <returns>The world position.</returns>
 /// <param name="tilemap">Tilemap.</param>
 public Vector2 getWorldPosition(TiledMap tilemap)
 {
     return(new Vector2(x * tilemap.tileWidth, y * tilemap.tileHeight));
 }
 /// <summary>
 /// Rectangle that encompases this tile with origin on the top left
 /// </summary>
 /// <returns>The tile rectangle.</returns>
 /// <param name="tilemap">Tilemap.</param>
 public Rectangle getTileRectangle(TiledMap tilemap)
 {
     return(new Rectangle(x * tilemap.tileWidth, y * tilemap.tileHeight, tilemap.tileWidth, tilemap.tileHeight));
 }
 public TiledIsometricTiledLayer(TiledMap map, string name, int width, int height) : this(map, name, width, height, new TiledTile[width * height])
 {
 }
 public TiledIsometricTiledLayer(TiledMap map, string name, int width, int height, TiledTile[] tiles) : base(map, name, width, height, tiles)
 {
 }
Beispiel #6
0
 public TiledMapMover(TiledTileLayer collisionLayer)
 {
     this.collisionLayer = collisionLayer;
     tiledMap            = collisionLayer.tiledMap;
     Assert.isNotNull(collisionLayer, nameof(collisionLayer) + " is required");
 }
Beispiel #7
0
 public TiledTilesetTile(int id, TiledMap tiledMap)
 {
     Id       = id;
     TiledMap = tiledMap;
 }
Beispiel #8
0
 public TiledTilesetTile(int id, TiledMap tiledMap)
 {
     this.id       = id;
     this.tiledMap = tiledMap;
 }
 /// <summary>
 /// returns the bounds Rectangle of the passed in tile
 /// </summary>
 /// <returns>The bounds for tile.</returns>
 /// <param name="tile">Tile.</param>
 /// <param name="tilemap">Tilemap.</param>
 public static Rectangle getBoundsForTile(TiledTile tile, TiledMap tilemap)
 {
     return(new Rectangle(tile.x * tilemap.tileWidth, tile.y * tilemap.tileHeight, tilemap.tileWidth, tilemap.tileHeight));
 }
Beispiel #10
0
 public TiledMapMover(TiledTileLayer collisionLayer)
 {
     Insist.IsNotNull(collisionLayer, nameof(collisionLayer) + " is required");
     this.CollisionLayer = collisionLayer;
     TiledMap            = collisionLayer.TiledMap;
 }
Beispiel #11
0
 /// <summary>
 /// note that the origin is the top left so this position will represent that
 /// </summary>
 /// <returns>The world position.</returns>
 /// <param name="tilemap">Tilemap.</param>
 public Vector2 GetWorldPosition(TiledMap tilemap)
 {
     return(new Vector2(X * tilemap.TileWidth, Y * tilemap.TileHeight));
 }
Beispiel #12
0
 /// <summary>
 /// Rectangle that encompases this tile with origin on the top left
 /// </summary>
 /// <returns>The tile rectangle.</returns>
 /// <param name="tilemap">Tilemap.</param>
 public Rectangle GetTileRectangle(TiledMap tilemap)
 {
     return(new Rectangle(X * tilemap.TileWidth, Y * tilemap.TileHeight, tilemap.TileWidth, tilemap.TileHeight));
 }
Beispiel #13
0
        public void DrawTile(Batcher batcher, Vector2 position, float layerDepth, int x, int y, float scale)
        {
            var tile = GetTile(x, y);

            if (tile == null)
            {
                return;
            }

            var t          = TiledMap.IsometricTileToWorldPosition(x, y);
            var tileRegion = tile.TextureRegion;

            // for the y position, we need to take into account if the tile is larger than the tileHeight and shift. Tiled uses
            // a bottom-left coordinate system and MonoGame a top-left
            var rotation = 0f;

            var spriteEffects = SpriteEffects.None;

            if (tile.FlippedHorizonally)
            {
                spriteEffects |= SpriteEffects.FlipHorizontally;
            }
            if (tile.FlippedVertically)
            {
                spriteEffects |= SpriteEffects.FlipVertically;
            }
            if (tile.FlippedDiagonally)
            {
                if (tile.FlippedHorizonally && tile.FlippedVertically)
                {
                    spriteEffects ^= SpriteEffects.FlipVertically;
                    rotation       = MathHelper.PiOver2;
                    t.X           += TiledMap.TileHeight + (tileRegion.SourceRect.Height - TiledMap.TileHeight);
                    t.Y           -= (tileRegion.SourceRect.Width - TiledMap.TileWidth);
                }
                else if (tile.FlippedHorizonally)
                {
                    spriteEffects ^= SpriteEffects.FlipVertically;
                    rotation       = -MathHelper.PiOver2;
                    t.Y           += TiledMap.TileHeight;
                }
                else if (tile.FlippedVertically)
                {
                    spriteEffects ^= SpriteEffects.FlipHorizontally;
                    rotation       = MathHelper.PiOver2;
                    t.X           += TiledMap.TileWidth + (tileRegion.SourceRect.Height - TiledMap.TileHeight);
                    t.Y           += (TiledMap.TileWidth - tileRegion.SourceRect.Width);
                }
                else
                {
                    spriteEffects ^= SpriteEffects.FlipHorizontally;
                    rotation       = -MathHelper.PiOver2;
                    t.Y           += TiledMap.TileHeight;
                }
            }

            // if we had no rotations (diagonal flipping) shift our y-coord to account for any non-tileSized tiles to account for
            // Tiled being bottom-left origin
            if (rotation == 0)
            {
                t.Y += (TiledMap.TileHeight - tileRegion.SourceRect.Height);
            }

            // Scale the tile's relative position, but not the origin
            t = t * new Vector2(scale) + position;

            batcher.Draw(tileRegion.Texture2D, t, tileRegion.SourceRect, Color, rotation, Vector2.Zero, scale, spriteEffects, layerDepth);
        }
Beispiel #14
0
        /// <summary>
        /// casts a line from start to end returning the first solid tile it intersects. Note that start and end and clamped to the tilemap
        /// bounds so make sure you pass in valid positions else you may get odd results!
        /// </summary>
        /// <param name="start">Start.</param>
        /// <param name="end">End.</param>
        public new TiledTile Linecast(Vector2 start, Vector2 end)
        {
            var direction = end - start;

            // worldToTilePosition clamps to the tilemaps bounds so no need to worry about overlow
            var startCell = TiledMap.IsometricWorldToTilePosition(start);
            var endCell   = TiledMap.IsometricWorldToTilePosition(end);

            start.X /= TiledMap.TileWidth;
            start.Y /= TiledMap.TileHeight;

            // what tile are we on
            var intX = startCell.X;
            var intY = startCell.Y;

            // ensure our start cell exists
            if (intX < 0 || intX >= TiledMap.Width || intY < 0 || intY >= TiledMap.Height)
            {
                return(null);
            }

            // which way we go
            var stepX = Math.Sign(direction.X);
            var stepY = Math.Sign(direction.Y);

            // Calculate cell boundaries. when the step is positive, the next cell is after this one meaning we add 1.
            // If negative, cell is before this one in which case dont add to boundary
            var boundaryX = intX + (stepX > 0 ? 1 : 0);
            var boundaryY = intY + (stepY > 0 ? 1 : 0);

            // determine the value of t at which the ray crosses the first vertical tile boundary. same for y/horizontal.
            // The minimum of these two values will indicate how much we can travel along the ray and still remain in the current tile
            // may be infinite for near vertical/horizontal rays
            var tMaxX = (boundaryX - start.X) / direction.X;
            var tMaxY = (boundaryY - start.Y) / direction.Y;

            if (direction.X == 0f)
            {
                tMaxX = float.PositiveInfinity;
            }
            if (direction.Y == 0f)
            {
                tMaxY = float.PositiveInfinity;
            }

            // how far do we have to walk before crossing a cell from a cell boundary. may be infinite for near vertical/horizontal rays
            var tDeltaX = stepX / direction.X;
            var tDeltaY = stepY / direction.Y;

            // start walking and returning the intersecting tiles
            var tile = Tiles[intX + intY * Width];

            if (tile != null)
            {
                return(tile);
            }

            while (intX != endCell.X || intY != endCell.Y)
            {
                if (tMaxX < tMaxY)
                {
                    intX  += stepX;
                    tMaxX += tDeltaX;
                }
                else
                {
                    intY  += stepY;
                    tMaxY += tDeltaY;
                }

                tile = Tiles[intX + intY * Width];
                if (tile != null)
                {
                    return(tile);
                }
            }

            return(null);
        }
Beispiel #15
0
        /// <summary>
        /// note that world position assumes that the Vector2 was normalized to be in the tilemaps coordinates. i.e. if the tilemap
        /// is not at 0,0 then the world position should be moved so that it takes into consideration the tilemap offset from 0,0.
        /// Example: if the tilemap is at 300,300 then the passed in value should be worldPos - (300,300)
        /// </summary>
        /// <returns>The tile at world position.</returns>
        /// <param name="pos">Position.</param>
        public new TiledTile GetTileAtWorldPosition(Vector2 pos)
        {
            var tilePos = TiledMap.IsometricWorldToTilePosition(pos);

            return(GetTile(tilePos.X, tilePos.Y));
        }