예제 #1
0
 /// <summary>
 /// Default constructor requires a name, the bounds of the object, the orientation of projection, and a collection of properties assigned to the object
 /// </summary>
 /// <param name="name"></param>
 /// <param name="bounds"></param>
 /// <param name="orientation"></param>
 /// <param name="properties"></param>
 public MapObject(string name, Rectangle bounds, Orientation orientation, PropertyCollection properties)
 {
     Name = name;
     Bounds = bounds;
     Orientation = orientation;
     Properties = properties;
 }
예제 #2
0
        public ObjectContent(XmlNode node)
        {
            if (node.Attributes[AttributeNames.MapObjectAttributes.Name] != null)
                Name = node.Attributes[AttributeNames.MapObjectAttributes.Name].Value;

            if (node.Attributes[AttributeNames.MapObjectAttributes.Type] != null)
                Type = node.Attributes[AttributeNames.MapObjectAttributes.Type].Value;

            if (node[AttributeNames.MapObjectAttributes.Properties] != null)
                properties = new PropertyCollection(node[AttributeNames.MapObjectAttributes.Properties]);

            int x = 0, y = 0, width = 0, height = 0;

            if (node.Attributes[AttributeNames.MapObjectAttributes.X] != null)
                x = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.X].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Y] != null)
                y = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Y].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Width] != null)
                width = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Width].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Height] != null)
                height = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Height].Value);

            Bounds = new Rectangle(x, y, width, height);

            string objectPoints = String.Empty;

            if (node.Attributes[AttributeNames.MapObjectAttributes.GID] != null)
            {
                objectType = MapObjectType.Tile;
                GID = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.GID].Value);
            }
            else if (node.Attributes[AttributeNames.MapObjectAttributes.Polygon] != null)
            {
                objectType = MapObjectType.Polygon;
                objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polygon].Value;
            }
            else if (node.Attributes[AttributeNames.MapObjectAttributes.Polyline] != null)
            {
                objectType = MapObjectType.Polyline;
                objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polyline].Value;
            }

            if(!String.IsNullOrEmpty(objectPoints))
            {
                string[] splitPoints = objectPoints.Split(' ');
                foreach(string splitPoint in splitPoints)
                {
                    string[] coordinates = splitPoint.Split(',');

                    float coordinateX = 0f, coordinateY = 0f;
                    float.TryParse(coordinates[0], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateX);
                    float.TryParse(coordinates[1], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateY);

                    points.Add(new Point((int)x, (int)y));
                }
            }
        }
예제 #3
0
 /// <summary>
 /// Main constructor used to instantiate a tile when data is known at import
 /// </summary>
 /// <param name="texture"></param>
 /// <param name="source"></param>
 /// <param name="width"></param>
 /// <param name="height"></param>
 public Tile(Texture texture, Rectangle source, int width, int height)
 {
     ID = Guid.NewGuid();
     IsEmpty = false;
     Texture = texture;
     SourceTextureBounds = source;
     Width = width;
     Height = height;
 }
예제 #4
0
 public TileContent(Rectangle source, PropertyCollection properties)
 {
     SourceTextureBounds = source;
     this.properties = properties;
 }
예제 #5
0
        internal void RenderTexture(IntPtr textureHandle, float positionX, float positionY, Rectangle source)
        {
            Debug.Assert(textureHandle != IntPtr.Zero, Errors.E_TEXTURE_NULL);

            int width = source.Width;
            int height = source.Height;

            // SDL only accepts integer positions (x,y) in the rendering Rect
            SDL.SDL_Rect destinationRectangle = new SDL.SDL_Rect() { x = (int)positionX, y = (int)positionY, w = width, h = height };
            SDL.SDL_Rect sourceRectangle = new SDL.SDL_Rect() { x = source.X, y = source.Y, w = width, h = height };

            int result = SDL.SDL_RenderCopy(Handle, textureHandle, ref sourceRectangle, ref destinationRectangle);
            if (Utilities.IsError(result))
            {
                throw new Exception(Utilities.GetErrorMessage("SDL_RenderCopy"));
            }
        }
예제 #6
0
 internal void RenderTexture(IntPtr textureHandle, float positionX, float positionY, int sourceWidth, int sourceHeight)
 {
     Rectangle source = new Rectangle(0, 0, sourceWidth, sourceHeight);
     RenderTexture(textureHandle, positionX, positionY, source);
 }
예제 #7
0
        /// <summary>
        /// Based on a passed tile index, create a Tile by looking up which TileSet it belongs to, assign the proper TilSet texture,
        /// and find the bounds of the rectangle that encompasses the correct tile texture within the total tileset texture.
        /// </summary>
        /// <param name="tileIndex">Index of the tile (GID) within the map file</param>
        /// <param name="tileSets">Enumerable list of tilesets used to find out which tileset a tile belongs to</param>
        /// <param name="tileLayerType"></param>
        /// <returns></returns>
        private Tile CreateTile(int tileIndex, IEnumerable<TileSetContent> tileSets)
        {
            if (tileSets == null) throw new ArgumentNullException("tileSets");

            Tile tile = new Tile();

            // we don't want to look up tiles with ID 0 in tile sets because Tiled Map Editor treats ID 0 as an empty tile
            if (tileIndex > Tile.EmptyTileID)
            {
                Texture tileSetTexture = null;
                Rectangle source = new Rectangle();

                foreach (TileSetContent tileSet in tileSets)
                {
                    if (tileIndex - tileSet.FirstGID < tileSet.Tiles.Count)
                    {
                        tileSetTexture = tileSet.Texture;
                        source = tileSet.Tiles[tileIndex - tileSet.FirstGID].SourceTextureBounds;
                        break;
                    }
                }

                tile = new Tile(tileSetTexture, source, TileWidth, TileHeight);
            }

            return tile;
        }
예제 #8
0
 public void Draw(float x, float y, Rectangle sourceBounds)
 {
     Draw((int)x, (int)y, sourceBounds);
 }
예제 #9
0
        public void Draw(int x, int y, Rectangle sourceBounds)
        {
            Assert.IsNotNull(Handle, Errors.E_TEXTURE_NULL);
            Assert.IsNotNull(renderer, Errors.E_RENDERER_NULL);

            renderer.RenderTexture(Handle, x, y, sourceBounds);
        }
예제 #10
0
 /// <summary>
 /// Determines if two rectangles intersect.
 /// </summary>
 /// <param name="rectangle">Rectangle.</param>
 public bool Intersects(Rectangle rectangle)
 {
     return rectangle.Left <= Right && Left <= rectangle.Right && rectangle.Top <= Bottom && Top <= rectangle.Bottom;
 }
예제 #11
0
        public Vector GetIntersectionDepth(Rectangle rectangle)
        {
            // Calculate half sizes.
            float halfWidthA = this.Width / 2.0f;
            float halfHeightA = this.Height / 2.0f;
            float halfWidthB = rectangle.Width / 2.0f;
            float halfHeightB = rectangle.Height / 2.0f;

            // Calculate centers.
            Vector centerA = new Vector(this.Left + halfWidthA, this.Top + halfHeightA);
            Vector centerB = new Vector(rectangle.Left + halfWidthB, rectangle.Top + halfHeightB);

            // Calculate current and minimum-non-intersecting distances between centers.
            float distanceX = centerA.X - centerB.X;
            float distanceY = centerA.Y - centerB.Y;
            float minDistanceX = halfWidthA + halfWidthB;
            float minDistanceY = halfHeightA + halfHeightB;

            // If we are not intersecting at all, return (0, 0).
            if (Math.Abs(distanceX) >= minDistanceX || Math.Abs(distanceY) >= minDistanceY)
                return Vector.Zero;

            // Calculate and return intersection depths.
            float depthX = distanceX > 0 ? minDistanceX - distanceX : -minDistanceX - distanceX;
            float depthY = distanceY > 0 ? minDistanceY - distanceY : -minDistanceY - distanceY;
            return new Vector(depthX, depthY);
        }
예제 #12
0
 public bool Contains(Rectangle rectangle)
 {
     if (Left <= rectangle.Left && Right >= rectangle.Right && Top <= rectangle.Top && Bottom >= rectangle.Bottom)
         return true;
     else
         return false;
 }
예제 #13
0
        private void GenerateTileSourceRectangles()
        {
            // process the tilesets, calculate tiles to fit in each set, calculate source rectangles
            foreach (TileSetContent tileSet in tileSets)
            {
                int imageWidth = tileSet.Texture.Width;
                int imageHeight = tileSet.Texture.Height;

                imageWidth -= tileSet.Margin * 2;
                imageHeight -= tileSet.Margin * 2;

                int tileCountX = 0;
                while ((tileCountX + 1) * tileSet.TileWidth <= imageWidth)
                {
                    tileCountX++;
                    imageWidth -= tileSet.Spacing;
                }

                int tileCountY = 0;
                while ((tileCountY + 1) * tileSet.TileHeight <= imageHeight)
                {
                    tileCountY++;
                    imageHeight -= tileSet.Spacing;
                }

                for (int y = 0; y < tileCountY; y++)
                {
                    for (int x = 0; x < tileCountX; x++)
                    {
                        int rx = tileSet.Margin + x * (tileSet.TileWidth + tileSet.Spacing);
                        int ry = tileSet.Margin + y * (tileSet.TileHeight + tileSet.Spacing);
                        Rectangle source = new Rectangle(rx, ry, tileSet.TileWidth, tileSet.TileHeight);

                        int index = tileSet.FirstGID + (y * tileCountX + x);
                        PropertyCollection tileProperties = new PropertyCollection();
                        if (tileSet.TileProperties.ContainsKey(index))
                            tileProperties = tileSet.TileProperties[index];

                        TileContent tile = new TileContent(source, tileProperties);
                        tileSet.Tiles.Add(tile);
                    }
                }
            }
        }