private void DrawTile(SpriteBatch batch, Map map, TmxLayerTile tile) { TmxTileset tileset = map.GetTilesetForTile(tile); if (tileset == null) { return; } Texture2D tilesetTexture = map.Textures[tileset]; var effect = SpriteEffects.None; var offset = Vector2.Zero; var rotation = 0.0f; if (tile.DiagonalFlip) { rotation = -MathHelper.PiOver2; offset.Y -= tileset.TileHeight; effect |= SpriteEffects.FlipHorizontally; } if (tile.HorizontalFlip) { if (tile.DiagonalFlip) { effect ^= SpriteEffects.FlipVertically; } else { effect ^= SpriteEffects.FlipHorizontally; } } if (tile.VerticalFlip) { if (!tile.DiagonalFlip) { effect ^= SpriteEffects.FlipVertically; } else { effect ^= SpriteEffects.FlipHorizontally; } } var sourceRect = map.GetSourceRectangleForTile(tileset, tile); batch.Draw( tilesetTexture, new Vector2(tileset.TileWidth * tile.X, tileset.TileHeight * tile.Y) - offset, sourceRect, Color.White, rotation, Vector2.Zero, 1, effect, 0); }
private void AddTileVertices(Vertex[] vertices, int verticeIndex, TmxLayerTile tileItem, int tilesetColumns) { var xIndex = (tileItem.Gid - 1) % tilesetColumns; var yIndex = (tileItem.Gid - 1) / tilesetColumns; AddTileVertices(vertices, verticeIndex, xIndex, yIndex, new Vector2f(tileItem.X, tileItem.Y)); }
/// <summarY> /// Draws the map /// </summarY> /// <param name="map">The map to draw</param> /// <param name="camera">The position to draw from</param> /// <param name="orientation">The rotation to draw from in degrees</param> public void RenderMap(SpriteBatch spriteBatch, Map map, Vector2 camera, float orientation, int cellSize, string wallsLayer) { TmxMap mapData = map.Data; int slices = viewport.Width; float halfFov = FOV / 2; float focalLength = slices / 2 / (float)Math.Tan(halfFov); float cameraAngle = orientation * (float)(Math.PI / 180.0f); float sliceAngle = FOV / slices; float beginAngle = cameraAngle - halfFov; // draw ceiling and floor spriteBatch.Draw(blankTexture, new Rectangle(0, 0, viewport.Width, viewport.Height / 2), Color.FromNonPremultiplied(23, 14, 8, 255)); spriteBatch.Draw(blankTexture, new Rectangle(0, viewport.Height / 2, viewport.Width, viewport.Height / 2), Color.DarkKhaki); // draw all wallslices for (int x = 0; x < slices; x++) { float angle = beginAngle + x * sliceAngle; RayCaster.HitData castData; if (!RayCaster.RayIntersectsGrid(camera, angle, cellSize, out castData, map.GetIsTileOccupiedFunction(wallsLayer))) { continue; } // get the texture slice int tileIndex = (int)(castData.tileCoordinates.Y * mapData.Width + castData.tileCoordinates.X); TmxLayer wallLayer = mapData.Layers[wallsLayer]; TmxLayerTile tile = wallLayer.Tiles[tileIndex]; TmxTileset tileset = map.GetTilesetForTile(tile); if (tileset == null) { continue; } // fix fisheye for distance and get slice height float distance = (float)(castData.rayLength * Math.Cos(angle - cameraAngle)); int sliceHeight = (int)(cellSize * focalLength / distance); zBuffer[x] = distance; // get drawing rectangles Rectangle wallRectangle = new Rectangle(x, viewport.Height / 2 - sliceHeight / 2, 1, sliceHeight); Rectangle textureRectangle = map.GetSourceRectangleForTile(tileset, tile); textureRectangle.X = (int)(textureRectangle.X + (textureRectangle.Width * castData.cellFraction) % cellSize); textureRectangle.Width = 1; // get texture tint float dot = Vector2.Dot(castData.normal, Vector2.UnitY); Color lightingTint = Math.Abs(dot) > 0.9f ? Color.Gray : Color.White; spriteBatch.Draw(map.Textures[tileset], wallRectangle, textureRectangle, lightingTint); } }
public static TileSetAditionalInfo GetTileSetAditionalInfo(this TmxMap map, TmxLayerTile tile, out TmxTileset tileSet) { tileSet = map.GetTileSet(tile); var tileSetColumns = tileSet.Columns.Value == 0 ? 1 : tileSet.Columns.Value; var tileSetWidth = tileSetColumns > 0 ? tileSetColumns * map.TileWidth : map.TileWidth; var tileSetHeight = tileSetColumns > 0 ? (tileSet.TileCount.Value / tileSetColumns) * map.TileWidth : map.TileWidth; var tileSetRows = tileSetHeight / tileSet.TileHeight; var position = new Vector2(tile.X * map.TileWidth, ((tile.Y + 1) * map.TileHeight) - tileSet.TileHeight); var frame = tile.Gid - tileSet.FirstGid; var column = frame <= tileSetColumns ? frame : frame % (float)tileSetColumns; var row = (int)Math.Floor((float)frame / tileSetColumns); var source = new Vector2(column * tileSet.TileWidth, row * tileSet.TileHeight); return(new TileSetAditionalInfo(position, source, tileSetColumns, tileSetRows, tileSetWidth, tileSetHeight)); }
GameObject getBaseGameobject(TmxLayerTile tile) { GameObject go = null; if (tileIdMap.ContainsKey(tile.Gid) && tileIdMap[tile.Gid].Properties.ContainsKey(customProperties["use base prefab"])) { var fabs = prefabs.Where(p => p.name == tileIdMap[tile.Gid].Properties[customProperties["use base prefab"]]).ToList(); if (fabs.Count != 0) { go = Instantiate(fabs.First()); } else { go = new GameObject("Tile"); } } else { go = new GameObject("Tile"); } if (go.GetComponent <SpriteRenderer>() == null && !(tileIdMap.ContainsKey(tile.Gid) && tileIdMap[tile.Gid].Properties.ContainsKey(customProperties["don't render"]) && (tileIdMap[tile.Gid].Properties[customProperties["don't render"]].ToLower() != "true"))) { go.AddComponent <SpriteRenderer>(); } return(go); }
/// <summary> /// Gets the acctual gid of a TilesetTile and returns the tileset that the tile is from- /// </summary> /// <param name="map">The map where the TilesetTile is from.</param> /// <param name="layerTile">The TilesetTile to find the correct gid from.</param> /// <param name="toFindTileset">The correct Tileset.</param> /// <returns>The gid value.</returns> private int GetGid(TmxMap map, TmxLayerTile layerTile, out TmxTileset toFindTileset) { int gid = layerTile.Gid; toFindTileset = null; // Empty tile, do nothing if (gid == 0) { return(-1); } // Get the acctual gid value gid--; // Get the correct tileset with the gid value for (int j = 0; j < map.Tilesets.Count; j++) { gid -= map.Tilesets[j].TileCount ?? 0; if (gid <= 0) { toFindTileset = map.Tilesets[j]; break; } } // set gid to a positive value again return(gid + toFindTileset.TileCount ?? 0); }
private void SpawnTile(TmxLayerTile tile, int x, int y, TmxLayer layer, GridLayerConfig gridLayerConfig, int layerNumber) { Transform container = GetContainer("TileLayers"); GridTile spawnedTile = null; if (gridLayerConfig != null) { if (gridLayerConfig.OverridePrefab) { spawnedTile = Instantiate(gridLayerConfig.OverridePrefab, scene.transform); } else { spawnedTile = Instantiate(config.GridTilePrefab, scene.transform); } } else { spawnedTile = Instantiate(config.GridTilePrefab); } Sprite sprite = GetTileSprite(tile.Gid); ColliderConfig conf = GetColliderConfig(tile.Gid); spawnedTile.Initialize(sprite, x, y, gridLayerConfig, conf, layer.Name, layerNumber); GridTileLayerManager.main.AddTile(spawnedTile, layer.Name, container); }
private void DrawVisibleTiles(SpriteBatch batch, Map map, TmxLayer layer, Camera camera) { TmxMap mapData = map.Data; Rectangle cameraBounds = camera.GetBounds(); // calculate how many tiles to draw int cameraTilesWidth = ((int)camera.Width / mapData.TileWidth) + 2; int cameraTilesHeight = ((int)camera.Height / mapData.TileHeight) + 2; // get camera position in tiles int xCameraStartTile = (int)((camera.Position.X - cameraBounds.Width / 2) / mapData.TileWidth); int yCameraStartTile = (int)((camera.Position.Y - cameraBounds.Height / 2) / mapData.TileHeight); int xCameraEndTile = xCameraStartTile + cameraTilesWidth; int yCameraEndTile = yCameraStartTile + cameraTilesHeight; // clamp values ClampValue(ref xCameraStartTile, mapData.Width); ClampValue(ref xCameraEndTile, mapData.Width); ClampValue(ref yCameraStartTile, mapData.Height); ClampValue(ref yCameraEndTile, mapData.Height); for (int y = yCameraStartTile; y < yCameraEndTile; y++) { for (int x = xCameraStartTile; x < xCameraEndTile; x++) { TmxLayerTile tile = layer.Tiles[y * mapData.Width + x]; DrawTile(batch, map, tile); } } }
/// <summary> /// Gets the gid values of the tiles in an array. The gid are not the acctual gid values of the map, but the gid /// values of the tileset. Assume tileset a has 10 tiles and tileset b has 10 tiles. If at position 1 there is /// the tileset tile 1 of tileset a and at position 2 the tileset tile 1 of tileset b then the gid values of the /// return array are the same. To put it simply, just use one tileset and one layer for this method. /// </summary> /// <param name="mapName">The name of the map to get the gid values from.</param> /// <param name="prefabs">A list of all prefabs and their local position.</param> /// <returns>The gid values of the map.</returns> public Fast2DArray <int> GetReplacableMap(string mapName, out PropertyDict properties, out List <PrefabLocations> prefabs) { prefabs = new List <PrefabLocations>(); TmxMap map = LoadMap(mapName); properties = map.Properties; Fast2DArray <int> retArr = new Fast2DArray <int>(map.Width, map.Height); if (map.TileLayers.Count == 0) { throw new Exception("Replacable map " + mapName + " has no tile layers!"); } else if (map.TileLayers.Count > 1) { Debug.LogWarning("Replacable map " + mapName + " has more than 1 tile layer. I am only reading the first layer!"); } if (map.Tilesets.Count != 1) { Debug.LogWarning("Replacable map " + mapName + " has not only 1 tileset. This might cause issues!"); } for (int t = 0; t < map.TileLayers[0].Tiles.Count; t++) { TmxLayerTile layerTile = map.TileLayers[0].Tiles[t]; int gid = GetGid(map, layerTile, out _); retArr.Set(gid, layerTile.X, map.Height - layerTile.Y - 1); } //LoadAllObjects(map, atX, atY, loadedGameobjects); // Go through each objectlayer and spawn their objects for (int i = 0; i < map.ObjectGroups.Count; i++) { for (int j = 0; j < map.ObjectGroups[i].Objects.Count; j++) { // Try to get the prefab if (TiledDict.Instance.TryGetObject(map.ObjectGroups[i].Objects[j].Type, out GameObject obj) == false) { continue; } // Instantiate and position the object Vector3 pos; pos.x = ((float)map.ObjectGroups[i].Objects[j].X / map.TileWidth); pos.y = map.Height - ((float)map.ObjectGroups[i].Objects[j].Y / map.TileHeight); pos.z = 0f; prefabs.Add(new PrefabLocations { Prefab = obj, Position = pos }); } } return(retArr); }
public override void Init( TmxLayerTile tmxLayerTile, TmxMap _ ) { gid = tmxLayerTile.Gid; horizontalFlip = tmxLayerTile.HorizontalFlip; verticalFlip = tmxLayerTile.VerticalFlip; diagonalFlip = tmxLayerTile.DiagonalFlip; }
public override void Init( TmxLayerTile tmxLayerTile, TmxMap tmxMap ) { int tileGid = tmxLayerTile.Gid; int tileFrame = TmxUtil.GetTileFrame(tileGid, tmxMap); kind = GetKind(tileFrame); }
public override void Draw(TimeSpan gameTime) { /* * Der einzige Weg (von dem ich bis jetzt weiß) eine Textur zu laden ist, eine neue Entity mit der Sprite-Komponente zu erstellen und * diese Entity dem EntityManager hinzuzufügen. * Das soll aber nur ein einziges mal passieren, darum diese Abfrage. */ if (!init) { EntityManager.Add(new Entity().AddComponent(new Transform2D()).AddComponent(thisSprite)); init = true; } foreach (TmxLayer layer in tmxMap.Layers) { for (int i = 0; i < layer.Tiles.Count; i++) { TmxLayerTile currentTile = layer.Tiles[i]; /* GID = Global ID * Exkurs: GIDs in einer Tiled-Map * Eine TileSheet hat z.B das Format 5x6 (5 Zeilen und 6 Spalten). * Tiles in diesem Sheet werden der Reihe nach durchnummeriert (Also hat das erste Tile oben links die GID 1). * Die ID ist über alle Tilesheets einzigartig, das heißt, dass wenn man zwei Tilesheets hat, das erste die IDs von 1 bis 31 * und das zweite Tilesheet hat die IDs 32 bis 62. * Bei welcher GID das Tilesheet anfängt ist in der "FirstGid" Eigenschaft gespeichert. */ int gid = currentTile.Gid - tileset.FirstGid; //TODO: Verstehen int column = gid % ((int)tileset.Image.Width / tileset.TileWidth); int row = (int)(gid / (tileset.Image.Width / tileset.TileWidth)); /* * Unsere Tiles sind in einer jpg-Datei gespeichert. Wird wissen wie viel Abstand die Teils zum Rand (Spacing) und zueinander (Margin) haben. * Damit können wir berechnen, welches Rechteck auf dem Bild unser gesuchtes Tile ist. */ int tilesheetX = tileset.Spacing + column * (tileset.TileWidth + tileset.Margin); int tilesheetY = tileset.Spacing + row * (tileset.TileHeight + tileset.Margin); int worldX = currentTile.X * tileset.TileWidth; int worldY = currentTile.Y * tileset.TileHeight; Rectangle tilesheetRectangle = new Rectangle(tilesheetX, tilesheetY, tileset.TileWidth, tileset.TileHeight); this.layer.SpriteBatch.Draw(thisSprite.Texture, new Vector2(worldX, worldY), tilesheetRectangle, Color.White, 0f, new Vector2(), Vector2.One, SpriteEffects.None, 1f, AddressMode.PointClamp); } } }
private Tile GetTile(TmxLayerTile tile, TmxTileset tileset) { int code = int.Parse(tileset.Tiles[tile.Gid - 1].Properties["Code"]); TermColor foreground = TermColor.Parse(tileset.Tiles[tile.Gid - 1].Properties["Foreground"]); TermColor background = TermColor.Parse(tileset.Tiles[tile.Gid - 1].Properties["Background"]); Character character = new Character(code, foreground, background); Vector2D position = new Vector2D(tile.X, tile.Y); bool collideable = bool.Parse(tileset.Tiles[tile.Gid - 1].Properties["Collideable"]); return(new Tile(character, position, collideable)); }
public Rectangle GetTileRectangle(TmxLayerTile tile) { if (!IsValidTile(tile)) { return(new Rectangle()); } return(new Rectangle( (int)(RelativeTileID(tile) % _tilesAcross) * TileWidth, (int)(RelativeTileID(tile) / _tilesAcross) * TileHeight, TileWidth, TileHeight)); }
public static Rectangle GetTileSourceRect(TmxMap map, TmxLayerTile tile) { TmxTileset tileset = GetTilesetForTile(map, tile); if (tileset == null) { return(Rectangle.Empty); } int relativeGid = tile.Gid - tileset.FirstGid; int tileColumn = relativeGid % tileset.Columns.Value; int tileRow = (int)Math.Floor((double)relativeGid / tileset.Columns.Value); return(new Rectangle(tileColumn * tileset.TileWidth, tileRow * tileset.TileHeight, tileset.TileWidth, tileset.TileHeight)); }
public static TmxTileset GetTilesetForTile(TmxMap map, TmxLayerTile tile) { TmxTileset currentTileset = null; foreach (var tileset in map.Tilesets.OrderByDescending(_ => _.FirstGid)) { if (tile.Gid >= tileset.FirstGid) { currentTileset = tileset; return(currentTileset); } } return(currentTileset); }
public bool HandleReplaceTileCollision(TmxLayerTile tile, TileLookupEnum collisionTile, TileLookupEnum newTile) { if (tile.Gid != TileLookup.GetTileValue(collisionTile)) { return(false); } //_detailLayer.RemoveTile(tile.X, tile.Y); tile.Gid = TileLookup.GetTileValue(newTile); _tiledMapRenderer.CollisionLayer.RemoveTile(tile.X, tile.Y); return(true); }
public Vector2 Move(Vector2 velocity, Entity entity, string collisionLayer = "collision") { TmxLayer layer = Data.Layers[collisionLayer]; Vector2 newPosition = entity.position + velocity; Rectangle sweptBounds = new Rectangle((int)(newPosition.X - entity.Width / 2), (int)(newPosition.Y - entity.Height / 2), entity.Width, entity.Height); // create swept rectangle sweptBounds = Rectangle.Union(sweptBounds, entity.BoundingBox); int minTileX = sweptBounds.Left / Data.TileWidth; int minTileY = sweptBounds.Top / Data.TileHeight; int maxTileX = sweptBounds.Right / Data.TileWidth + 1; int maxTileY = sweptBounds.Bottom / Data.TileHeight + 1; for (int y = minTileY; y < maxTileY; y++) { for (int x = minTileX; x < maxTileX; x++) { if (x < 0 || x >= Data.Width || y < 0 || y >= Data.Height) { continue; } TmxLayerTile tile = layer.Tiles[y * Data.Width + x]; if (GetTilesetForTile(tile) == null) { continue; } Rectangle tileBounds = GetTileBounds(x, y); Rectangle intersection = Rectangle.Intersect(tileBounds, sweptBounds); if (intersection.Width < intersection.Height) { velocity.X += -Math.Sign(velocity.X) * intersection.Width; } else { velocity.Y += -Math.Sign(velocity.Y) * intersection.Height; } } } return(velocity); }
public void Init <T>( TmxLayer tmxLayer, TmxMap tmxMap ) where T : Tile, new() { int nTiles = tmxLayer.Tiles.Count; tiles = new List <Tile>(nTiles); for (var i = 0; i < nTiles; i++) { TmxLayerTile tmxLayerTile = tmxLayer.Tiles[i]; T tile = new T(); tile.Init(tmxLayerTile, tmxMap); tiles.Add(tile); } }
private TmxTilesetTile GetTilesetTile(TmxLayerTile tile, TmxTileset tileset) { int id = tile.Gid - tileset.FirstGid; //var a = tileset.Tiles.Where(x => x.Value.Id == id).ToList(); var tilesList = tileset.Tiles.ToList(); var r = tilesList.Where(x => x.Value.Id == id).FirstOrDefault(); if (r.Value == null) { Logger.GetOrCreate("BrTiledLoader").Log(Logger.LogLevel.Info, "Invalid tile at " + tile.X + ", " + tile.Y + ". Id is " + id + ", gid is " + tile.Gid); } return(r.Value); }
/// <summary> /// Initializes a new instance of the <see cref="LayerTile" /> class. /// </summary>> /// <param name="tmxTile">The TMX parsed tile.</param> /// <param name="tileset">Th</param> public LayerTile(TmxLayerTile tmxTile, Tileset tileset) { this.X = tmxTile.X; this.Y = tmxTile.Y; this.HorizontalFlip = tmxTile.HorizontalFlip; this.VerticalFlip = tmxTile.VerticalFlip; this.DiagonalFlip = tmxTile.DiagonalFlip; if (tileset != null) { this.Tileset = tileset; this.Id = tmxTile.Gid - this.Tileset.FirstGid; this.TilesetTile = this.Tileset.TilesTable[this.Id]; } }
public TmxTileset GetTilesetForTile(TmxLayerTile tile) { // TODO: fix tileset choosing, might have to refactor the tiledSharp lib for it // we now assume that tilesets are ordered in ascending order by gid int tilesetCount = Data.Tilesets.Count; for (int i = 0; i < tilesetCount; i++) { TmxTileset tileset = Data.Tilesets[tilesetCount - 1 - i]; if (tile.Gid >= tileset.FirstGid) { return(tileset); } } return(null); }
void GenerateTile(TmxLayerTile tile) { if (tile.Gid < 0) { return; } float x = tile.X; float z = tile.Y; Vector3 normal = Vector3.up; vertices.Add(new Vector3(-x, 0, z)); vertices.Add(new Vector3(-x + 1, 0, z)); vertices.Add(new Vector3(-x + 1, 0, z - 1)); vertices.Add(new Vector3(-x, 0, z - 1)); normals.Add(normal); normals.Add(normal); normals.Add(normal); normals.Add(normal); triangles.Add(squareCount * 4); triangles.Add((squareCount * 4) + 1); triangles.Add((squareCount * 4) + 3); triangles.Add((squareCount * 4) + 1); triangles.Add((squareCount * 4) + 2); triangles.Add((squareCount * 4) + 3); Vector2 texture = tiles[tile.Gid - 1]; float fiddleLeft = 0.005f; float fiddleRight = 0.005f; float fiddleTop = 0.005f; float fiddleBottom = 0.005f; float left = tileUnit * texture.x + tileUnit - fiddleLeft; float top = tileUnit * texture.y + fiddleTop; float right = tileUnit * texture.x + fiddleRight; float bottom = tileUnit * texture.y + tileUnit - fiddleBottom; uv.Add(new Vector2(left, top)); uv.Add(new Vector2(right, top)); uv.Add(new Vector2(right, bottom)); uv.Add(new Vector2(left, bottom)); squareCount++; }
void DrawMesh(int tileCountX, int tileCountZ, TmxLayer layer) { //Vector3 startingPosition = new Vector3(-tileCountX / 2 - unitSize / 2, 0f, -tileCountZ / 2 - unitSize / 2); Vector3 startingPosition = new Vector3(-unitSize / 2, 0f, -unitSize / 2); int index = 0; LayerType layerType = (LayerType)Tools.IntParseFast(layer.Properties["Type"]); int numTiles = 0; for (int z = 0; z < tileCountZ; z++) { for (int x = 0; x < tileCountX; x++) { TmxLayerTile tile = layer.Tiles[(tileCountZ - z - 1) * tileCountX + x]; float xPos = startingPosition.x + x * unitSize; float yPos = startingPosition.z + z * unitSize; int tileId = tile.Gid - 1; if (tileId == -1) { continue; } numTiles += 1; Vector3 currentPosition = new Vector3(xPos, startingPosition.y, -yPos - 2f); if (prefab != null) { GameObject block = Instantiate(prefab); block.transform.SetParent(prefabContainer); block.transform.position = new Vector3(tile.X, -tile.Y, 0f); } DrawVertex(index + 2, currentPosition); DrawVertex(index + 1, currentPosition, unitSize); DrawVertex(index, currentPosition, unitSize, unitSize); DrawVertex(index + 5, currentPosition); DrawVertex(index + 4, currentPosition, unitSize, unitSize); DrawVertex(index + 3, currentPosition, 0, unitSize); AssignUv(index, tiles[tileId], tileSize); index += 6; } } }
public static TmxTileset GetTileSet(this TmxMap map, TmxLayerTile tile) { TmxTileset tileSet = null; for (var i = 0; i < map.Tilesets.Count; i++) { var isHigher = tile.Gid >= map.Tilesets[i].FirstGid; if (isHigher && i >= map.Tilesets.Count - 1) { tileSet = map.Tilesets[i]; } else if (isHigher && tile.Gid < map.Tilesets[i + 1].FirstGid) { tileSet = map.Tilesets[i]; } } return(tileSet); }
public Rectangle GetSourceRectangleForTile(TmxTileset tileset, TmxLayerTile tile) { Rectangle source = new Rectangle(); int tileWidth = tileset.TileWidth; int tileHeight = tileset.TileHeight; int tilesInHorizontalAxis = tileset.Image.Width.GetValueOrDefault() / tileWidth; // depending on the tile gid get the correct tile coordinates int tileIndex = tile.Gid - tileset.FirstGid; int xTilePos = tileIndex / tilesInHorizontalAxis; int yTilePos = tileIndex - xTilePos * tilesInHorizontalAxis; source.Width = tileWidth; source.Height = tileHeight; source.X = yTilePos * tileWidth; source.Y = xTilePos * tileHeight; return(source); }
private TmxTileset GetTileset(TmxLayerTile tile, List <TmxTileset> tilesets) { if (tilesets.Count > 1) { for (int i = 0; i < tilesets.Count; i++) { TmxTileset currTileset = tilesets[i]; if (tile.Gid >= currTileset.FirstGid && tile.Gid < currTileset.FirstGid + currTileset.TileCount && (tile.Gid - currTileset.FirstGid) < currTileset.TileCount) { return(currTileset); } } } else { //if the number of tilesets is only one, then that must be the tileset the tile belongs to. return(tilesets[0]); } return(null); }
void DrawTile(SpriteBatch spriteBatch, TmxLayerTile tile, bool indoor, bool skipVisible) { if (tile.Gid == 0) { return; //Only not Empty tile } //Convert to world size float x = tile.X * _map.TileWidth; float y = tile.Y * _map.TileHeight; if (indoor && raycast(new Vector2(x, y), GameMain.mainPlayer.position, Layer.Ceiling, RaycastType.Continuous)) { return; } if (skipVisible && isTileInView(new Vector2(x, y))) { return; } spriteBatch.Draw(_tileset, Tools.GetDrawRect((int)x, (int)y, tileSize), GetGidRect(tile.Gid), Color.White); }
private Direction tileDirection(TmxLayerTile tile) { var dir = Direction.Up; if (tile.DiagonalFlip && tile.HorizontalFlip && !tile.VerticalFlip) { dir = Direction.Right; } if (tile.DiagonalFlip && !tile.HorizontalFlip && tile.VerticalFlip) { dir = Direction.Left; } if (!tile.DiagonalFlip && tile.HorizontalFlip && tile.VerticalFlip) { dir = Direction.Down; } return(dir); }
void DrawMesh(int tileCountX, int tileCountZ, TmxLayer layer) { //Vector3 startingPosition = new Vector3(-tileCountX / 2 - unitSize / 2, 0f, -tileCountZ / 2 - unitSize / 2); Vector3 startingPosition = new Vector3(-unitSize / 2, 0f, -unitSize / 2); int index = 0; for (int z = 0; z < tileCountZ; z++) { for (int x = 0; x < tileCountX; x++) { //LayerType layerType = (LayerType)Tools.IntParseFast(layer.Properties["Type"]); TmxLayerTile tile = layer.Tiles[(tileCountZ - z - 1) * tileCountX + x]; int tileId = tile.Gid - 1; if (tileId == -1) { continue; } Vector3 currentPosition = new Vector3(startingPosition.x + x * unitSize, startingPosition.y, startingPosition.z + z * unitSize); DrawVertex(index + 2, currentPosition); DrawVertex(index + 1, currentPosition, unitSize); DrawVertex(index, currentPosition, unitSize, unitSize); DrawVertex(index + 5, currentPosition); DrawVertex(index + 4, currentPosition, unitSize, unitSize); DrawVertex(index + 3, currentPosition, 0, unitSize); AssignUv(index, tiles[tileId], tileSize); /*if (layerType == LayerType.Wall) * { * SpawnWall(tileCountX, tileCountZ, tile.X, tile.Y); * } else if (layerType == LayerType.Water) * { * SpawnWater(tileCountX, tileCountZ, tile.X, tile.Y); * }*/ index += 6; } } }