public TmxMap(XElement mapElement) { foreach (var attribute in mapElement.Attributes()) { switch (attribute.Name.LocalName.ToLower()) { case "version": Version = attribute.Value; break; case "orientation": Orientation = (MapOrientation)Enum.Parse(typeof(MapOrientation), attribute.Value, true); break; case "width": Width = int.Parse(attribute.Value); break; case "height": Height = int.Parse(attribute.Value); break; case "tilewidth": TileWidth = int.Parse(attribute.Value); break; case "tileheight": TileHeight = int.Parse(attribute.Value); break; case "backgroundcolor": string hex = attribute.Value.TrimStart('#'); BackgroundColor = new Color(Convert.ToByte(hex.Substring(0, 2), 16), Convert.ToByte(hex.Substring(2, 2), 16), Convert.ToByte(hex.Substring(4, 2), 16)); break; } } foreach (var subElement in mapElement.Elements()) { switch (subElement.Name.LocalName.ToLower()) { case "tileset": var ts = new TmxTileset(subElement); Tilesets.Add(ts.Name, ts); break; case "layer": var l = new TmxLayer(subElement); Layers.Add(l.Name, l); break; } } }
public Map(string name, int width, int height, int tileWidth, int tileHeight, MapOrientation orientation = MapOrientation.Isometric) : base(name) { backgroundColor = new Color(0, 0, 0, 255); this.width = width; this.height = height; this.tileWidth = tileWidth; this.tileHeight = tileHeight; startX = -1; startY = -1; layers = new List <Layer>(); this.orientation = orientation; eventLayer = new EventLayer(width, height); loadEvents = new List <Event>(); loadNPCs = new List <EntityLoadInfo>(); loadEnemyGroups = new List <EnemyGroup>(); }
public Camera(Engine engine, Map map, int posX = -1, int posY = -1) { this.engine = engine; this.map = map; cameraSpeed = 10.0f; immediateCamera = false; selectedTileX = -1; selectedTileY = -1; orientation = map.Orientation; tileWidth = map.TileWidth; tileHeight = map.TileHeight; halfTileWidth = tileWidth / 2; halfTileHeight = tileHeight / 2; if (orientation == MapOrientation.Isometric) { unitsPerPixelX = 2.0f / tileWidth; unitsPerPixelY = 2.0f / tileHeight; } else { unitsPerPixelX = 1.0f / tileWidth; unitsPerPixelY = 1.0f / tileHeight; } viewWidth = engine.Graphics.ViewWidth; halfViewWidth = viewWidth / 2; viewHeight = engine.Graphics.ViewHeight; halfViewHeight = viewHeight / 2; if (posX >= 0 && posY >= 0) { SetPosition(posX, posY); } else if (map.StartX >= 0 && map.StartY >= 0) { SetPosition(map.StartX, map.StartY); } else { SetPosition(map.Width / 2.0f, map.Height / 2.0f); } }
private void DrawTile(int x, int y, int width, int height, Color color, MapOrientation orientation = MapOrientation.Isometric) { if (orientation == MapOrientation.Orthogonal) { SDL.SDL_Rect rect = new SDL.SDL_Rect(); rect.x = x; rect.y = y; rect.w = width; rect.h = height; SDL.SDL_SetRenderDrawBlendMode(game.ren, SDL.SDL_BlendMode.SDL_BLENDMODE_BLEND); SDL.SDL_SetRenderDrawColor(game.ren, color.R, color.G, color.B, color.Alpha); SDL.SDL_RenderDrawRect(game.ren, ref rect); } else { SDL.SDL_SetRenderDrawBlendMode(game.ren, SDL.SDL_BlendMode.SDL_BLENDMODE_BLEND); SDL.SDL_SetRenderDrawColor(game.ren, color.R, color.G, color.B, color.Alpha); int leftX = x; int leftY = y; int topX = x + width / 2; int topY = y - height / 2; int rightX = x + width; int rightY = y; int bottomX = x + width / 2; int bottomY = y + height / 2; //int x1 = x; //int x2 = x + width / 2; //int x3 = x + width; //int y1 = y; //int y2 = y + height / 2; //int y3 = y + height; SDL.SDL_RenderDrawLine(game.ren, leftX, leftY, topX, topY); SDL.SDL_RenderDrawLine(game.ren, topX, topY, rightX, rightY); SDL.SDL_RenderDrawLine(game.ren, rightX, rightY, bottomX, bottomY); SDL.SDL_RenderDrawLine(game.ren, bottomX, bottomY, leftX, leftY); } }
// This must be called in order for rotation and position offset to by applied public void RenderPoints(SuperTile tile, MapOrientation orientation, Vector2 gridSize) { if (orientation == MapOrientation.Isometric) { m_Position = IsometricTransform(m_Position, tile, gridSize); m_Position.x += gridSize.x * 0.5f; m_Position.y += tile.m_Height - gridSize.y; for (int i = 0; i < m_Points.Length; i++) { m_Points[i] = IsometricTransform(m_Points[i], tile, gridSize); } // Also, we are forced to use polygon colliders for isometric projection if (m_CollisionShapeType == CollisionShapeType.Ellipse || m_CollisionShapeType == CollisionShapeType.Rectangle) { m_CollisionShapeType = CollisionShapeType.Polygon; } } ApplyRotationToPoints(); m_Points = m_Points.Select(p => p + m_Position).ToArray(); }
public ExtendedMap(MapSpan span) : base(span) { mapOrientation = MapOrientation.NorthUp; }
public static void Import(UTiledImportSettings settings) { String mapFilename = settings.MapFilename; XDocument input = XDocument.Load(mapFilename); String mapDirectory = Path.GetDirectoryName(mapFilename) + "/" + Path.GetFileNameWithoutExtension(mapFilename); String meshDirectory = mapDirectory + "/" + "meshes"; String matDirectory = mapDirectory + "/" + "materials"; if (!Directory.Exists(mapDirectory)) { Directory.CreateDirectory(mapDirectory); } if (!Directory.Exists(meshDirectory)) { Directory.CreateDirectory(meshDirectory); } if (!Directory.Exists(matDirectory)) { Directory.CreateDirectory(matDirectory); } MapOrientation mapOrientation = MapOrientation.Unknown; switch (input.Document.Root.Attribute("orientation").Value) { case "orthogonal": mapOrientation = MapOrientation.Orthogonal; break; case "isometric": mapOrientation = MapOrientation.Isometric; break; case "staggered": mapOrientation = MapOrientation.Staggered; break; default: mapOrientation = MapOrientation.Unknown; break; } if (mapOrientation != MapOrientation.Orthogonal) { throw new NotSupportedException("UTiled supports only orthogonal maps"); } String mapName = Path.GetFileNameWithoutExtension(mapFilename); Int32 mapWidth = Convert.ToInt32(input.Document.Root.Attribute("width").Value); Int32 mapHeight = Convert.ToInt32(input.Document.Root.Attribute("height").Value); Int32 mapTileWidth = Convert.ToInt32(input.Document.Root.Attribute("tilewidth").Value); Int32 mapTileHeight = Convert.ToInt32(input.Document.Root.Attribute("tileheight").Value); Dictionary <UInt32, SourceData> gid2sprite = new Dictionary <UInt32, SourceData>(); Dictionary <String, List <UTiledProperty> > spriteprops = new Dictionary <string, List <UTiledProperty> >(); List <String> imageList = new List <string>(); GameObject mapGameObject = new GameObject(); mapGameObject.name = mapName; if (input.Document.Root.Element("properties") != null) { UTiledProperties props = mapGameObject.AddComponent <UTiledProperties>(); foreach (var pElem in input.Document.Root.Element("properties").Elements("property")) { props.Add(pElem.Attribute("name").Value, pElem.Attribute("value").Value); } } Int32 tsNum = 1; foreach (var elem in input.Document.Root.Elements("tileset")) { UInt32 FirstGID = Convert.ToUInt32(elem.Attribute("firstgid").Value); XElement tsElem = elem; if (elem.Attribute("source") != null) { XDocument tsx = XDocument.Load(Path.Combine(Path.GetDirectoryName(mapFilename), elem.Attribute("source").Value)); tsElem = tsx.Root; } List <UTiledProperty> tilesetProps = new List <UTiledProperty>(); if (tsElem.Element("properties") != null) { foreach (var pElem in tsElem.Element("properties").Elements("property")) { tilesetProps.Add(new UTiledProperty() { Name = pElem.Attribute("name").Value, Value = pElem.Attribute("value").Value }); } } Int32 tsTileWidth = tsElem.Attribute("tilewidth") == null ? 0 : Convert.ToInt32(tsElem.Attribute("tilewidth").Value); Int32 tsTileHeight = tsElem.Attribute("tileheight") == null ? 0 : Convert.ToInt32(tsElem.Attribute("tileheight").Value); Int32 tsSpacing = tsElem.Attribute("spacing") == null ? 0 : Convert.ToInt32(tsElem.Attribute("spacing").Value); Int32 tsMargin = tsElem.Attribute("margin") == null ? 0 : Convert.ToInt32(tsElem.Attribute("margin").Value); Int32 tsTileOffsetX = 0; Int32 tsTileOffsetY = 0; if (tsElem.Element("tileoffset") != null) { tsTileOffsetX = Convert.ToInt32(tsElem.Element("tileoffset").Attribute("x").Value); tsTileOffsetY = Convert.ToInt32(tsElem.Element("tileoffset").Attribute("y").Value); } if (tsElem.Element("image") != null) { XElement imgElem = tsElem.Element("image"); String tsImageFileName = Path.Combine(Path.GetDirectoryName(mapFilename), imgElem.Attribute("source").Value); if (!File.Exists(tsImageFileName)) { throw new Exception("Cannot find referenced tilesheet: " + tsImageFileName); } if (!imageList.Contains(tsImageFileName)) { imageList.Add(tsImageFileName); } TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(tsImageFileName); importer.textureType = TextureImporterType.Sprite; importer.spriteImportMode = SpriteImportMode.Multiple; importer.filterMode = FilterMode.Point; importer.spritePixelsToUnits = settings.PixelsPerUnit; // Reflection Hack because this is a private method to get the non scaled size of the texture object[] args = new object[2] { 0, 0 }; MethodInfo mi = typeof(TextureImporter).GetMethod("GetWidthAndHeight", BindingFlags.NonPublic | BindingFlags.Instance); mi.Invoke(importer, args); Int32 tsImageWidth = (int)args[0]; Int32 tsImageHeight = (int)args[1]; // yea, it's lame and should be a public method - vote for it here: // http://feedback.unity3d.com/suggestions/get-original-width-and-height-of List <SpriteMetaData> spritesmeta = new List <SpriteMetaData>(importer.spritesheet); UInt32 gid = FirstGID; for (int y = tsImageHeight - tsTileHeight - tsMargin; y >= tsMargin; y -= tsTileHeight + tsSpacing) { for (int x = tsMargin; x < tsImageWidth - tsMargin; x += tsTileWidth + tsSpacing) { if (x + tsTileWidth > tsImageWidth - tsMargin) { continue; } SpriteMetaData s = new SpriteMetaData(); s.name = String.Format(String.Format("{0}_{1}_{2}", Path.GetFileNameWithoutExtension(mapFilename), tsNum, gid)); s.rect = new Rect(x, y, tsTileWidth, tsTileHeight); s.pivot = new Vector2(tsTileWidth / 2, tsTileHeight / 2); s.alignment = 0; if (tilesetProps.Count > 0) { spriteprops[s.name] = new List <UTiledProperty>(); foreach (var item in tilesetProps) { spriteprops[s.name].Add(item); } } if (spritesmeta.Any(sx => sx.name.Equals(s.name))) { spritesmeta.RemoveAll(sx => sx.name.Equals(s.name)); } spritesmeta.Add(s); gid2sprite[gid] = new SourceData() { textureSize = new Vector2(tsImageWidth, tsImageHeight), offsetX = tsTileOffsetX, offsetY = tsTileOffsetY, spriteName = s.name, }; gid++; } } foreach (var tileElem in tsElem.Elements("tile")) { UInt32 id = Convert.ToUInt32(tileElem.Attribute("id").Value); String spriteName = String.Format(String.Format("{0}_{1}_{2}", Path.GetFileNameWithoutExtension(mapFilename), tsNum, id + FirstGID)); if (tileElem.Element("properties") != null) { if (!spriteprops.ContainsKey(spriteName)) { spriteprops[spriteName] = new List <UTiledProperty>(); } foreach (var pElem in tileElem.Element("properties").Elements("property")) { spriteprops[spriteName].Add(new UTiledProperty() { Name = pElem.Attribute("name").Value, Value = pElem.Attribute("value").Value }); } } } importer.spritesheet = spritesmeta.ToArray(); AssetDatabase.WriteImportSettingsIfDirty(tsImageFileName); AssetDatabase.LoadAssetAtPath(tsImageFileName, typeof(Texture2D)); AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate); } tsNum++; } List <UnityEngine.Object> sprites = new List <UnityEngine.Object>(); foreach (var tsImageFileName in imageList) { sprites.AddRange(AssetDatabase.LoadAllAssetRepresentationsAtPath(tsImageFileName)); } Int32 lCount = 1; Int32 olCount = 1; Int32 sortOrder = 1; float xoff = mapWidth * mapTileWidth - mapWidth * mapTileWidth / 2; float yoff = mapHeight * mapTileHeight - mapHeight * mapTileHeight / 2 + mapTileHeight; foreach (var lElem in input.Document.Root.Elements()) { if (lElem.Name.LocalName.Equals("layer")) { bool importMesh = false; bool importCollision = false; if (settings.TileLayerSettings.Length >= lCount) { importCollision = settings.TileLayerSettings[lCount - 1].GenerateCollisionMesh; importMesh = settings.TileLayerSettings[lCount - 1].GenerateRenderMesh; } if (!importMesh && !importCollision) { lCount++; continue; } GameObject layerGameObject = new GameObject(); layerGameObject.transform.parent = mapGameObject.transform; layerGameObject.name = lElem.Attribute("name") == null ? "Unnamed" : lElem.Attribute("name").Value; float layerOpacity = lElem.Attribute("opacity") == null ? 1.0f : Convert.ToSingle(lElem.Attribute("opacity").Value); bool layerVisible = lElem.Attribute("visible") == null ? true : lElem.Attribute("visible").Equals("1"); UTiledLayerSettings layerSettings = layerGameObject.AddComponent <UTiledLayerSettings>(); layerSettings.sortingOrder = sortOrder; layerSettings.opacity = layerOpacity; EditorUtility.DisplayProgressBar("UTiled", "Generating Prefabs for " + settings.TileLayerSettings[lCount - 1].LayerName, (float)(lCount - 1) / settings.TileLayerSettings.Length); if (lElem.Element("properties") != null) { UTiledProperties props = layerGameObject.AddComponent <UTiledProperties>(); foreach (var pElem in lElem.Element("properties").Elements("property")) { props.Add(pElem.Attribute("name").Value, pElem.Attribute("value").Value); } } if (lElem.Element("data") != null) { List <UInt32> gids = new List <UInt32>(); if (lElem.Element("data").Attribute("encoding") != null || lElem.Element("data").Attribute("compression") != null) { // parse csv formatted data if (lElem.Element("data").Attribute("encoding") != null && lElem.Element("data").Attribute("encoding").Value.Equals("csv")) { foreach (var gid in lElem.Element("data").Value.Split(",\n\r".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)) { gids.Add(Convert.ToUInt32(gid)); } } else if (lElem.Element("data").Attribute("encoding") != null && lElem.Element("data").Attribute("encoding").Value.Equals("base64")) { Byte[] data = Convert.FromBase64String(lElem.Element("data").Value); if (lElem.Element("data").Attribute("compression") == null) { // uncompressed data for (int i = 0; i < data.Length; i += sizeof(UInt32)) { gids.Add(BitConverter.ToUInt32(data, i)); } } else { throw new NotSupportedException(String.Format("Compression '{0}' not supported.", lElem.Element("data").Attribute("compression").Value)); } } else { throw new NotSupportedException(String.Format("Encoding '{0}' not supported. UTiled supports csv or base64", lElem.Element("data").Attribute("encoding").Value)); } } else { // parse xml formatted data foreach (var tElem in lElem.Element("data").Elements("tile")) { gids.Add(Convert.ToUInt32(tElem.Attribute("gid").Value)); } } List <MeshData> meshes = new List <MeshData>(); for (int i = 0; i < gids.Count; i++) { UInt32 ID = gids[i] & ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG); if (ID > 0) { SourceData sd = gid2sprite[ID]; Sprite source = (Sprite)sprites.First(s => s.name.Equals(sd.spriteName)); String texFile = AssetDatabase.GetAssetPath(source.texture); Boolean tdFlipHorizontally = Convert.ToBoolean(gids[i] & FLIPPED_HORIZONTALLY_FLAG); Boolean tdFlipVertically = Convert.ToBoolean(gids[i] & FLIPPED_VERTICALLY_FLAG); Boolean tdFlipDiagonally = Convert.ToBoolean(gids[i] & FLIPPED_DIAGONALLY_FLAG); Int32 meshId = 0; if (meshes.Any(m => m.materialName.Equals(texFile))) { meshId = meshes.IndexOf(meshes.First(x => x.materialName.Equals(texFile))); } else { meshes.Add(new MeshData() { materialName = texFile }); meshId = meshes.Count - 1; } int triStart = meshes[meshId].verts.Count; meshes[meshId].tris.AddRange(new int[] { triStart, triStart + 1, triStart + 2, triStart + 2, triStart + 3, triStart }); for (int j = 0; j < 4; j++) { meshes[meshId].norms.Add(new Vector3(0, 0, -1)); } if (mapOrientation == MapOrientation.Orthogonal) { float x = i % mapWidth; float y = mapHeight - Mathf.Floor(i / mapWidth) - 1; Rect colLoc = new Rect( (x * mapTileWidth - xoff) / settings.PixelsPerUnit, (y * mapTileHeight + mapTileHeight - yoff) / settings.PixelsPerUnit, (float)mapTileWidth / settings.PixelsPerUnit, (float)mapTileHeight / settings.PixelsPerUnit ); meshes[meshId].colverts.Add(new Vector3(colLoc.xMin, colLoc.yMax, 0)); meshes[meshId].colverts.Add(new Vector3(colLoc.xMax, colLoc.yMax, 0)); meshes[meshId].colverts.Add(new Vector3(colLoc.xMax, colLoc.yMin, 0)); meshes[meshId].colverts.Add(new Vector3(colLoc.xMin, colLoc.yMin, 0)); Vector3[] loc = new Vector3[] { new Vector3((x * mapTileWidth - xoff + sd.offsetX) / settings.PixelsPerUnit, (y * mapTileHeight + mapTileHeight - yoff + sd.offsetY + source.rect.height * sd.textureSize.y / source.texture.height) / settings.PixelsPerUnit), new Vector3((x * mapTileWidth - xoff + sd.offsetX + source.rect.width * sd.textureSize.x / source.texture.width) / settings.PixelsPerUnit, (y * mapTileHeight + mapTileHeight - yoff + sd.offsetY + source.rect.height * sd.textureSize.y / source.texture.height) / settings.PixelsPerUnit), new Vector3((x * mapTileWidth - xoff + sd.offsetX + source.rect.width * sd.textureSize.x / source.texture.width) / settings.PixelsPerUnit, (y * mapTileHeight + mapTileHeight - yoff + sd.offsetY) / settings.PixelsPerUnit), new Vector3((x * mapTileWidth - xoff + sd.offsetX) / settings.PixelsPerUnit, (y * mapTileHeight + mapTileHeight - yoff + sd.offsetY) / settings.PixelsPerUnit) }; if (tdFlipDiagonally) { Vector3 pivot = new Vector3(loc[0].x + (loc[1].x - loc[0].x) / 2, loc[0].y + (loc[3].y - loc[0].y) / 2); for (int j = 0; j < loc.Length; j++) { Vector3 direction = pivot - loc[j]; direction = Quaternion.Euler(new Vector3(0, 0, -90)) * direction; loc[j] = direction + pivot; } tdFlipVertically = !tdFlipVertically; } if (tdFlipHorizontally) { Vector3 temp = loc[0]; loc[0] = loc[1]; loc[1] = temp; temp = loc[3]; loc[3] = loc[2]; loc[2] = temp; } if (tdFlipVertically) { Vector3 temp = loc[0]; loc[0] = loc[3]; loc[3] = temp; temp = loc[1]; loc[1] = loc[2]; loc[2] = temp; } meshes[meshId].verts.AddRange(loc); } Rect uvRect = new Rect( source.rect.x / source.texture.width, source.rect.y / source.texture.height, source.rect.width / source.texture.width, source.rect.height / source.texture.height ); meshes[meshId].uvs.AddRange(new Vector2[] { new Vector2(uvRect.xMin, uvRect.yMax), new Vector2(uvRect.xMax, uvRect.yMax), new Vector2(uvRect.xMax, uvRect.yMin), new Vector2(uvRect.xMin, uvRect.yMin) }); } } List <MeshData> collMesh = new List <MeshData>(); collMesh.Add(new MeshData()); Int32 currentColMesh = 0; for (int i = 0; i < meshes.Count; i++) { String spriteMatFileName = String.Format("{0}/{1}-{2}.mat", matDirectory, layerGameObject.name, Path.GetFileNameWithoutExtension(meshes[i].materialName)); Material spriteMat = (Material)AssetDatabase.LoadAssetAtPath(spriteMatFileName, typeof(Material)); if (importMesh) { if (spriteMat == null) { spriteMat = new Material(Shader.Find("Sprites/Default")); spriteMat.SetFloat("PixelSnap", 1); spriteMat.EnableKeyword("PIXELSNAP_ON"); spriteMat.color = new Color(1, 1, 1, layerOpacity); spriteMat.mainTexture = (Texture2D)AssetDatabase.LoadAssetAtPath(meshes[i].materialName, typeof(Texture2D)); AssetDatabase.CreateAsset(spriteMat, spriteMatFileName); } else { spriteMat.SetFloat("PixelSnap", 1); spriteMat.EnableKeyword("PIXELSNAP_ON"); spriteMat.color = new Color(1, 1, 1, layerOpacity); spriteMat.mainTexture = (Texture2D)AssetDatabase.LoadAssetAtPath(meshes[i].materialName, typeof(Texture2D)); EditorUtility.SetDirty(spriteMat); } } if (importCollision) { for (int j = 0; j < meshes[i].colverts.Count; j += 4) { if (collMesh[currentColMesh].colverts.Count >= 64997) { collMesh.Add(new MeshData()); currentColMesh++; } Int32 v1, v2, v3, v4; v1 = FindVertIndex(meshes[i].colverts[j], collMesh[currentColMesh].colverts); if (v1 == -1) { collMesh[currentColMesh].colverts.Add(meshes[i].colverts[j]); collMesh[currentColMesh].norms.Add(meshes[i].norms[j]); collMesh[currentColMesh].uvs.Add(meshes[i].uvs[j]); v1 = collMesh[currentColMesh].colverts.Count - 1; } v2 = FindVertIndex(meshes[i].colverts[j + 1], collMesh[currentColMesh].colverts); if (v2 == -1) { collMesh[currentColMesh].colverts.Add(meshes[i].colverts[j + 1]); collMesh[currentColMesh].norms.Add(meshes[i].norms[j + 1]); collMesh[currentColMesh].uvs.Add(meshes[i].uvs[j + 1]); v2 = collMesh[currentColMesh].colverts.Count - 1; } v3 = FindVertIndex(meshes[i].colverts[j + 2], collMesh[currentColMesh].colverts); if (v3 == -1) { collMesh[currentColMesh].colverts.Add(meshes[i].colverts[j + 2]); collMesh[currentColMesh].norms.Add(meshes[i].norms[j + 2]); collMesh[currentColMesh].uvs.Add(meshes[i].uvs[j + 2]); v3 = collMesh[currentColMesh].colverts.Count - 1; } v4 = FindVertIndex(meshes[i].colverts[j + 3], collMesh[currentColMesh].colverts); if (v4 == -1) { collMesh[currentColMesh].colverts.Add(meshes[i].colverts[j + 3]); collMesh[currentColMesh].norms.Add(meshes[i].norms[j + 3]); collMesh[currentColMesh].uvs.Add(meshes[i].uvs[j + 3]); v4 = collMesh[currentColMesh].colverts.Count - 1; } collMesh[currentColMesh].tris.AddRange(new int[] { v1, v2, v3, v3, v4, v1 }); } } if (importMesh) { int totalMeshReq = Convert.ToInt32(Mathf.Ceil((float)meshes[i].verts.Count / 65000f)); for (int j = 0; j < totalMeshReq; j++) { var verts = meshes[i].verts.Skip(j * 65000).Take(65000).ToArray(); var tris = meshes[i].tris.Skip(j * 97500).Take(97500).Select(t => t - j * 65000).ToArray(); var norms = meshes[i].norms.Skip(j * 65000).Take(65000).ToArray(); var uvs = meshes[i].uvs.Skip(j * 65000).Take(65000).ToArray(); GameObject layerMeshObject = new GameObject(); layerMeshObject.transform.parent = layerGameObject.transform; layerMeshObject.name = String.Format("{0} - {1}", Path.GetFileNameWithoutExtension(meshes[i].materialName), j + 1); MeshFilter filter = layerMeshObject.AddComponent <MeshFilter>(); MeshRenderer renderer = layerMeshObject.AddComponent <MeshRenderer>(); renderer.sortingOrder = sortOrder; renderer.sharedMaterial = spriteMat; renderer.castShadows = false; renderer.receiveShadows = false; String meshFileName = String.Format("{0}/{1}-{2}-{3}-{4}-{5}.asset", meshDirectory, layerGameObject.name, Path.GetFileNameWithoutExtension(meshes[i].materialName), lCount, i + 1, j + 1); Mesh mesh = (Mesh)AssetDatabase.LoadAssetAtPath(meshFileName, typeof(Mesh)); if (mesh == null) { mesh = new Mesh() { vertices = verts, triangles = tris, normals = norms, uv = uvs, }; AssetDatabase.CreateAsset(mesh, meshFileName); } else { mesh.Clear(false); mesh.vertices = verts; mesh.triangles = tris; mesh.normals = norms; mesh.uv = uvs; EditorUtility.SetDirty(mesh); } filter.mesh = mesh; } } } if (importCollision) { for (int i = 0; i < collMesh.Count; i++) { GameObject layerColMeshObject = new GameObject(); layerColMeshObject.transform.parent = layerGameObject.transform; layerColMeshObject.name = String.Format("Collision Mesh - {0}", i + 1); MeshFilter colFilter = layerColMeshObject.AddComponent <MeshFilter>(); MeshCollider collider = layerColMeshObject.AddComponent <MeshCollider>(); String colMeshFileName = String.Format("{0}/{1}-{2}-{3}-collision.asset", meshDirectory, layerGameObject.name, lCount, i + 1); Mesh colMesh = (Mesh)AssetDatabase.LoadAssetAtPath(colMeshFileName, typeof(Mesh)); if (colMesh == null) { colMesh = new Mesh() { vertices = collMesh[i].colverts.ToArray(), triangles = collMesh[i].tris.ToArray(), normals = collMesh[i].norms.ToArray(), uv = collMesh[i].uvs.ToArray(), }; AssetDatabase.CreateAsset(colMesh, colMeshFileName); } else { colMesh.Clear(false); colMesh.vertices = collMesh[i].colverts.ToArray(); colMesh.triangles = collMesh[i].tris.ToArray(); colMesh.normals = collMesh[i].norms.ToArray(); colMesh.uv = collMesh[i].uvs.ToArray(); EditorUtility.SetDirty(colMesh); } colFilter.mesh = colMesh; collider.sharedMesh = colMesh; } } } layerGameObject.SetActive(layerVisible); AssetDatabase.SaveAssets(); lCount++; sortOrder++; } else if (lElem.Name.LocalName.Equals("objectgroup")) { bool importlayer = false; if (settings.ObjectLayerSettings.Length >= olCount) { importlayer = settings.ObjectLayerSettings[olCount - 1].ImportLayer; } if (!importlayer) { olCount++; continue; } GameObject layerGameObject = new GameObject(); layerGameObject.transform.parent = mapGameObject.transform; layerGameObject.name = lElem.Attribute("name") == null ? "Unnamed" : lElem.Attribute("name").Value; float layerOpacity = lElem.Attribute("opacity") == null ? 1.0f : Convert.ToSingle(lElem.Attribute("opacity").Value); bool layerVisible = lElem.Attribute("visible") == null ? true : lElem.Attribute("visible").Equals("1"); string layerColor = lElem.Attribute("color") == null ? "#a0a0a4" : lElem.Attribute("color").Value; // #a0a0a4 is Tiled's default grey, but won't be in the file unless manually set layerGameObject.SetActive(layerVisible); UTiledLayerSettings layerSettings = layerGameObject.AddComponent <UTiledLayerSettings>(); layerSettings.opacity = layerOpacity; layerSettings.sortingOrder = sortOrder; if (lElem.Element("properties") != null) { UTiledProperties props = layerGameObject.AddComponent <UTiledProperties>(); foreach (var pElem in lElem.Element("properties").Elements("property")) { props.Add(pElem.Attribute("name").Value, pElem.Attribute("value").Value); } } foreach (var oElem in lElem.Elements("object")) { string oName = oElem.Attribute("name") == null ? "Unnamed" : oElem.Attribute("name").Value; string oType = oElem.Attribute("type") == null ? null : oElem.Attribute("type").Value; float? oX = oElem.Attribute("x") == null ? null : (float?)Convert.ToSingle(oElem.Attribute("x").Value); float? oY = oElem.Attribute("y") == null ? null : (float?)Convert.ToSingle(oElem.Attribute("y").Value); float? oWidth = oElem.Attribute("width") == null ? null : (float?)Convert.ToSingle(oElem.Attribute("width").Value); float? oHeight = oElem.Attribute("height") == null ? null : (float?)Convert.ToSingle(oElem.Attribute("height").Value); uint? tileGID = oElem.Attribute("gid") == null ? null : (uint?)Convert.ToUInt32(oElem.Attribute("gid").Value); bool oVisible = oElem.Attribute("visible") == null ? true : oElem.Attribute("visible").Equals("1"); GameObject obj = new GameObject(); obj.transform.parent = layerGameObject.transform; obj.name = oName; obj.SetActive(oVisible); if (oElem.Element("properties") != null || oType != null) { UTiledProperties props = obj.AddComponent <UTiledProperties>(); if (oElem.Element("properties") != null) { foreach (var pElem in oElem.Element("properties").Elements("property")) { props.Add(pElem.Attribute("name").Value, pElem.Attribute("value").Value); } } if (oType != null) { props.ObjectType = oType; } } if (oElem.Element("ellipse") != null && oX.HasValue && oY.HasValue && oWidth.HasValue && oHeight.HasValue) { obj.AddComponent <CircleCollider2D>(); obj.transform.localScale = new Vector3(oWidth.Value / settings.PixelsPerUnit, oHeight.Value / settings.PixelsPerUnit, 1); obj.transform.localPosition = new Vector3((oX.Value - .5f * mapWidth * mapTileWidth + .5f * oWidth.Value) / settings.PixelsPerUnit, (-1 * (oY.Value - .5f * mapHeight * mapTileHeight + .5f * oHeight.Value)) / settings.PixelsPerUnit, 0); if (oWidth.Value != oHeight.Value) { Debug.LogWarning("Unity does not support Ellispe, importing as Circle: " + obj.name); } } else if (oElem.Element("polygon") != null && oX.HasValue && oY.HasValue) { PolygonCollider2D collider = obj.AddComponent <PolygonCollider2D>(); obj.transform.localPosition = new Vector3((oX.Value - .5f * mapWidth * mapTileWidth) / settings.PixelsPerUnit, (-1 * (oY.Value - .5f * mapHeight * mapTileHeight)) / settings.PixelsPerUnit, 0); List <Vector2> points = new List <Vector2>(); foreach (var point in oElem.Element("polygon").Attribute("points").Value.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)) { String[] coord = point.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); points.Add(new Vector2(Convert.ToSingle(coord[0]) / settings.PixelsPerUnit, (-1f * Convert.ToSingle(coord[1])) / settings.PixelsPerUnit)); } collider.points = points.ToArray(); } else if (oElem.Element("polyline") != null && oX.HasValue && oY.HasValue) { EdgeCollider2D collider = obj.AddComponent <EdgeCollider2D>(); obj.transform.localPosition = new Vector3((oX.Value - .5f * mapWidth * mapTileWidth) / settings.PixelsPerUnit, (-1 * (oY.Value - .5f * mapHeight * mapTileHeight)) / settings.PixelsPerUnit, 0); List <Vector2> points = new List <Vector2>(); foreach (var point in oElem.Element("polyline").Attribute("points").Value.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)) { String[] coord = point.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); points.Add(new Vector2(Convert.ToSingle(coord[0]) / settings.PixelsPerUnit, (-1 * Convert.ToSingle(coord[1])) / settings.PixelsPerUnit)); } collider.points = points.ToArray(); } else if (tileGID.HasValue) { SourceData sd = gid2sprite[tileGID.Value]; Sprite source = (Sprite)sprites.First(s => s.name.Equals(sd.spriteName)); obj.transform.localPosition = new Vector3((oX.Value - .5f * mapWidth * mapTileWidth + .5f * source.rect.width) / settings.PixelsPerUnit, (-1 * (oY.Value - .5f * mapHeight * mapTileHeight - .5f * source.rect.height)) / settings.PixelsPerUnit, 0); SpriteRenderer sr = obj.AddComponent <SpriteRenderer>(); sr.sprite = source; sr.sortingOrder = sortOrder; sr.color = new Color(1, 1, 1, layerSettings.opacity); BoxCollider2D collider = obj.AddComponent <BoxCollider2D>(); collider.size = new Vector2(source.rect.width / settings.PixelsPerUnit, source.rect.height / settings.PixelsPerUnit); } else if (!tileGID.HasValue && oX.HasValue && oY.HasValue && oWidth.HasValue && oHeight.HasValue) { obj.AddComponent <BoxCollider2D>(); obj.transform.localScale = new Vector3(oWidth.Value / settings.PixelsPerUnit, oHeight.Value / settings.PixelsPerUnit, 1); obj.transform.localPosition = new Vector3((oX.Value - .5f * mapWidth * mapTileWidth + .5f * oWidth.Value) / settings.PixelsPerUnit, (-1 * (oY.Value - .5f * mapHeight * mapTileHeight + .5f * oHeight.Value)) / settings.PixelsPerUnit, 0); } } olCount++; sortOrder++; } } String mapPrefapFile = mapDirectory + "/" + String.Format("{0}.prefab", mapName); GameObject mapPrefab = PrefabUtility.CreatePrefab(mapPrefapFile, mapGameObject); EditorUtility.SetDirty(mapPrefab); GameObject.DestroyImmediate(mapGameObject); AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate); }
public override void DrawTileSelected(int x, int y, int width, int height, MapOrientation oriention = MapOrientation.Isometric) { x += transX; y += transY; DrawTile(x, y, width, height, Microsoft.Xna.Framework.Color.Gold * 0.48f, oriention); }
private void DrawTile(int x, int y, int width, int height, Microsoft.Xna.Framework.Color color, MapOrientation oriention = MapOrientation.Isometric) { x += transX; y += transY; if (oriention == MapOrientation.Orthogonal) { var rect = new Microsoft.Xna.Framework.Rectangle(x, y, width, height); batch.DrawRectangle(rect, color); } else { float x1 = x; float x2 = x + width / 2; float x3 = x + width; float y1 = y; float y2 = y + height / 2; float y3 = y + height; batch.DrawLine(new Microsoft.Xna.Framework.Vector2(x1, y2), new Microsoft.Xna.Framework.Vector2(x2, y1), color); batch.DrawLine(new Microsoft.Xna.Framework.Vector2(x2, y1), new Microsoft.Xna.Framework.Vector2(x3, y2), color); batch.DrawLine(new Microsoft.Xna.Framework.Vector2(x3, y2), new Microsoft.Xna.Framework.Vector2(x2, y3), color); batch.DrawLine(new Microsoft.Xna.Framework.Vector2(x2, y3), new Microsoft.Xna.Framework.Vector2(x1, y2), color); } }
public void MapToScreen(float mapX, float mapY, out int screenX, out int screenY, MapOrientation orientation) { MapToScreen(mapX, mapY, shakyCamX, shakyCamY, out screenX, out screenY, orientation); }
public static Map ImportMap(string mapFilename) { XDocument input = XDocument.Load(mapFilename); MapOrientation mapOrientation = MapOrientation.Unsupported; switch (input.Document.Root.Attribute("orientation").Value) { case "orthogonal": mapOrientation = MapOrientation.Orthogonal; break; case "isometric": mapOrientation = MapOrientation.Isometric; break; case "staggered": mapOrientation = MapOrientation.Staggered; break; case "hexagonal": mapOrientation = MapOrientation.Hexagonal; break; default: mapOrientation = MapOrientation.Unsupported; break; } if (mapOrientation == MapOrientation.Unsupported) { throw new NotSupportedException("Map - Unsupported map type: " + input.Document.Root.Attribute("orientation").Value); } String mapName = Path.GetFileNameWithoutExtension(mapFilename); float mapWidth = Convert.ToSingle(input.Document.Root.Attribute("width").Value); float mapHeight = Convert.ToSingle(input.Document.Root.Attribute("height").Value); float mapTileWidth = Convert.ToSingle(input.Document.Root.Attribute("tilewidth").Value); float mapTileHeight = Convert.ToSingle(input.Document.Root.Attribute("tileheight").Value); MapRenderOrder mapRenderOrder = MapRenderOrder.LeftDown; if (input.Document.Root.Attribute("renderorder") != null) { switch (input.Document.Root.Attribute("renderorder").Value) { case "right-down": mapRenderOrder = MapRenderOrder.RightDown; break; case "right-up": mapRenderOrder = MapRenderOrder.RightUp; break; case "left-down": mapRenderOrder = MapRenderOrder.LeftDown; break; case "left-up": mapRenderOrder = MapRenderOrder.LeftUp; break; default: mapRenderOrder = MapRenderOrder.Unsupported; break; } if (mapRenderOrder == MapRenderOrder.Unsupported) { throw new NotSupportedException("UTiled - Unsupported map render order: " + input.Document.Root.Attribute("renderorder").Value); } } Debug.Log("Map Name: " + mapName); Debug.Log(" " + mapWidth + "x" + mapHeight + " (" + mapTileWidth + "x" + mapTileHeight + ")"); Debug.Log(" RenderOrder: " + mapRenderOrder.ToString()); Dictionary <UInt32, Tile> gidToSprite = new Dictionary <UInt32, Tile>(); Int32 tsNum = 1; foreach (var elem in input.Document.Root.Elements("tileset")) { UInt32 FirstGID = Convert.ToUInt32(elem.Attribute("firstgid").Value); XElement tsElem = elem; String tsImageBaseDir = Path.GetDirectoryName(mapFilename); if (elem.Attribute("source") != null) { XDocument tsx = XDocument.Load(Path.Combine(tsImageBaseDir, elem.Attribute("source").Value)); tsElem = tsx.Root; tsImageBaseDir = Path.GetDirectoryName(Path.Combine(tsImageBaseDir, elem.Attribute("source").Value)); } /* * List<UTiledProperty> tilesetProps = new List<UTiledProperty>(); * if (tsElem.Element("properties") != null) * foreach (var pElem in tsElem.Element("properties").Elements("property")) * tilesetProps.Add(new UTiledProperty() { Name = pElem.Attribute("name").Value, Value = pElem.Attribute("value").Value }); */ Int32 tsTileWidth = tsElem.Attribute("tilewidth") == null ? 0 : Convert.ToInt32(tsElem.Attribute("tilewidth").Value); Int32 tsTileHeight = tsElem.Attribute("tileheight") == null ? 0 : Convert.ToInt32(tsElem.Attribute("tileheight").Value); Int32 tsSpacing = tsElem.Attribute("spacing") == null ? 0 : Convert.ToInt32(tsElem.Attribute("spacing").Value); Int32 tsMargin = tsElem.Attribute("margin") == null ? 0 : Convert.ToInt32(tsElem.Attribute("margin").Value); Int32 tsTileOffsetX = 0; Int32 tsTileOffsetY = 0; if (tsElem.Element("tileoffset") != null) { tsTileOffsetX = Convert.ToInt32(tsElem.Element("tileoffset").Attribute("x").Value); tsTileOffsetY = Convert.ToInt32(tsElem.Element("tileoffset").Attribute("y").Value); } foreach (var tile in elem.Elements("tile")) { UInt32 gid = Convert.ToUInt32(tile.Attribute("id").Value); var image = tile.Element("image"); if (image == null) { continue; } string exits = null; /* * Debug.LogError("Properties: " + tile.Elements("properties")); * foreach (var property in tile.Elements("properties")) { * } */ XElement properties = tile.Element("properties"); /* * if (properties != null) { * * foreach (var property in properties.Elements ("property")) { * Debug.LogError("Attribute: " + property.Name); * if (property.Attribute ("name") != null && property.Attribute("name").Value == "exits") { * exits = property.Attribute("value").Value; * break; * } * } * } */ float imageWidth = Convert.ToSingle(image.Attribute("width").Value); float imageHeight = Convert.ToSingle(image.Attribute("height").Value); string sourceFile = image.Attribute("source").Value; Tile tileObject = new Tile(sourceFile, properties); gidToSprite[gid + FirstGID] = tileObject; } } List <UInt32> gids = null; foreach (var lElem in input.Document.Root.Elements()) { if (lElem.Name.LocalName.Equals("layer")) { gids = parseLayer(lElem); } } if (gids == null) { return(null); } return(new Map((int)mapWidth, (int)mapHeight, gidToSprite, gids)); }
public TilePolygonCollection(SuperTile tile, TileIdMath tileId, SuperImportContext importContext, MapOrientation orientation) { m_ImportContext = importContext; m_Tile = tile; m_TileId = tileId; m_Transform = m_Tile.GetTransformMatrix(m_TileId.FlipFlags, orientation); CollectTilePolygons(); }
private void DrawTile(int x, int y, int width, int height, System.Drawing.Pen pen, MapOrientation oriention = MapOrientation.Isometric) { if (oriention == MapOrientation.Orthogonal) { var rect = new System.Drawing.Rectangle(x, y, width, height); gfx.DrawRectangle(pen, rect); } else { float x1 = x; float x2 = x + width / 2; float x3 = x + width; float y1 = y; float y2 = y + height / 2; float y3 = y + height; System.Drawing.PointF[] poly = new System.Drawing.PointF[5]; poly[0].X = x1; poly[0].Y = y2; poly[1].X = x2; poly[1].Y = y1; poly[2].X = x3; poly[2].Y = y2; poly[3].X = x2; poly[3].Y = y3; poly[4].X = x1; poly[4].Y = y2; gfx.DrawPolygon(pen, poly); } }
public void GetTRS(FlipFlags flags, MapOrientation orientation, out Vector3 xfTranslate, out Vector3 xfRotate, out Vector3 xfScale) { float inversePPU = 1.0f / m_Sprite.pixelsPerUnit; float width = m_Width * inversePPU; float height = m_Height * inversePPU; bool flippedHorizontally = FlipFlagsMask.FlippedHorizontally(flags); bool flippedVertically = FlipFlagsMask.FlippedVertically(flags); bool rotatedDiagonally = FlipFlagsMask.RotatedDiagonally(flags); bool rotatedHexagonally120 = FlipFlagsMask.RotatedHexagonally120(flags); xfTranslate = Vector3.zero; xfRotate = Vector3.zero; xfScale = Vector3.one; if (flags != FlipFlags.None) { if (orientation == MapOrientation.Hexagonal) { if (rotatedDiagonally) { xfRotate.z -= 60; } if (rotatedHexagonally120) { xfRotate.z -= 120; } } else if (rotatedDiagonally) { xfRotate.z = -90.0f; flippedHorizontally = FlipFlagsMask.FlippedVertically(flags); flippedVertically = !FlipFlagsMask.FlippedHorizontally(flags); } xfScale.x = flippedHorizontally ? -1.0f : 1.0f; xfScale.y = flippedVertically ? -1.0f : 1.0f; var matScale = Matrix4x4.Scale(xfScale); var matRotate = Matrix4x4.Rotate(Quaternion.Euler(xfRotate)); if (orientation == MapOrientation.Hexagonal) { // Hex tiles use the center of the tile for transforms var anchor = new Vector3(width * 0.5f, height * 0.5f); var transformed = matScale.MultiplyPoint(anchor); transformed = matRotate.MultiplyPoint(transformed); xfTranslate.x = anchor.x - transformed.x; xfTranslate.y = anchor.y - transformed.y; } else { // Mulitply the corners for our tile against rotation and scale matrices to see what our translation should be to get the tile back to the bottom-left origin var points = new Vector3[] { new Vector3(0, height, 0), new Vector3(width, height, 0), new Vector3(width, 0, 0), }; points = points.Select(p => matScale.MultiplyPoint(p)).ToArray(); points = points.Select(p => matRotate.MultiplyPoint(p)).ToArray(); var minX = points.Select(p => p.x).Min(); var minY = points.Select(p => p.y).Min(); xfTranslate.x = -minX; xfTranslate.y = -minY; } } // Each tile may have an additional offset xfTranslate.x += m_TileOffsetX * inversePPU; xfTranslate.y -= m_TileOffsetY * inversePPU; }
public override void DrawTileGrid(int x, int y, int width, int height, MapOrientation oriention = MapOrientation.Isometric) { x += transX; y += transY; DrawTile(x, y, width, height, new Color(245, 222, 179, 128), oriention); }
public Matrix4x4 GetTransformMatrix(FlipFlags ff, MapOrientation orientation) { var inversePPU = 1.0f / m_Sprite.pixelsPerUnit; var offset = new Vector2(m_TileOffsetX * inversePPU, -m_TileOffsetY * inversePPU); var matOffset = Matrix4x4.Translate(offset); if (ff == FlipFlags.None) { return(matOffset); } bool flipHorizontal = FlipFlagsMask.FlippedHorizontally(ff); bool flipVertical = FlipFlagsMask.FlippedVertically(ff); bool flipDiagonal = FlipFlagsMask.RotatedDiagonally(ff); bool rotateHex120 = FlipFlagsMask.RotatedHexagonally120(ff); float width = m_Width * inversePPU; float height = m_Height * inversePPU; var tileCenter = new Vector2(width, height) * 0.5f; Matrix4x4 matTransIn = Matrix4x4.identity; Matrix4x4 matFlip = Matrix4x4.identity; Matrix4x4 matTransOut = Matrix4x4.identity; // Go to the tile center matTransIn = Matrix4x4.Translate(-tileCenter); if (orientation == MapOrientation.Hexagonal) { if (flipDiagonal) { matFlip *= Rotate60Matrix; } if (rotateHex120) { matFlip *= Rotate120Matrix; } if (flipHorizontal) { matFlip *= HorizontalFlipMatrix; } if (flipVertical) { matFlip *= VerticalFlipMatrix; } matTransOut = Matrix4x4.Translate(tileCenter); } else { if (flipHorizontal) { matFlip *= HorizontalFlipMatrix; } if (flipVertical) { matFlip *= VerticalFlipMatrix; } if (flipDiagonal) { matFlip *= DiagonalFlipMatrix; } // Go out of the tile center if (!flipDiagonal) { matTransOut = Matrix4x4.Translate(tileCenter); } else { // Compensate for width and height being different dimensions float diff = (height - width) * 0.5f; tileCenter.x += diff; tileCenter.y -= diff; matTransOut = Matrix4x4.Translate(tileCenter); } } // Put it all together return(matOffset * matTransOut * matFlip * matTransIn); }
public void ScreenToMap(float screenX, float screenY, float camX, float camY, out float mapX, out float mapY, MapOrientation orientation) { if (orientation == MapOrientation.Isometric) { IsoScreenToMap(screenX, screenY, camX, camY, out mapX, out mapY); } else { OrthoScreenToMap(screenX, screenY, camX, camY, out mapX, out mapY); } }
public void ScreenToMap(float screenX, float screenY, out float mapX, out float mapY, MapOrientation orientation) { ScreenToMap(screenX, screenY, shakyCamX, shakyCamY, out mapX, out mapY, orientation); }
public TmxMap() { Layers = new List <Layer>(); Objects = new List <TmxObject>(); Orientation = MapOrientation.Orthogonal; }
public static Vector3 ToVector3(float width, float height, float inversePPU, MapOrientation mapOrientation, ObjectAlignment objectAlignment) { width *= inversePPU; height *= inversePPU; float dx = 0; float dy = 0; if (objectAlignment == ObjectAlignment.Unspecified) { objectAlignment = mapOrientation == MapOrientation.Isometric ? ObjectAlignment.Bottom : ObjectAlignment.BottomLeft; } switch (objectAlignment) { case ObjectAlignment.BottomLeft: dx = 0; dy = 0; break; case ObjectAlignment.Top: dx = -width * 0.5f; dy = -height; break; case ObjectAlignment.TopRight: dx = -width; dy = -height; break; case ObjectAlignment.TopLeft: dx = 0; dy = -height; break; case ObjectAlignment.Left: dx = 0; dy = -height * 0.5f; break; case ObjectAlignment.Center: dx = -width * 0.5f; dy = -height * 0.5f; break; case ObjectAlignment.Right: dx = -width; dy = -height * 0.5f; break; case ObjectAlignment.Bottom: dx = -width * 0.5f; dy = 0; break; case ObjectAlignment.BottomRight: dx = -width; dy = 0; break; } return(new Vector3(dx, dy, 0)); }
public override void DrawTileSelected(int x, int y, int width, int height, MapOrientation oriention = MapOrientation.Isometric) { x += transX; y += transY; DrawTile(x, y, width, height, selectPen, oriention); }
public abstract void DrawTileSelected(int x, int y, int width, int height, MapOrientation oriention = MapOrientation.Isometric);
public override void DrawTileSelected(int x, int y, int width, int height, MapOrientation oriention = MapOrientation.Isometric) { x += transX; y += transY; DrawTile(x, y, width, height, new Color(255, 215, 0, 128), oriention); }
public void MapToScreen(float mapX, float mapY, float camX, float camY, out int screenX, out int screenY, MapOrientation orientation) { if (orientation == MapOrientation.Isometric) { IsoMapToScreen(mapX, mapY, camX, camY, out screenX, out screenY); } else { OrthoMapToScreen(mapX, mapY, camX, camY, out screenX, out screenY); } }
private TilePolygonCollection AcquireTilePolygonCollection(SuperTile tile, TileIdMath tileId, MapOrientation orientation) { TilePolygonCollection polygons; if (m_TilePolygonDatabase.TryGetValue(tileId.ImportedlTileId, out polygons)) { return(polygons); } // If we're here then we don't have a polygon collection for this tile yet polygons = new TilePolygonCollection(tile, tileId, m_ImportContext, orientation); m_TilePolygonDatabase.Add(tileId.ImportedlTileId, polygons); return(polygons); }
void DrawGrid(float size_x, float size_y, int count_x, int count_y, Vector3 pos, Quaternion rot, MapOrientation type, Color c) { float h = count_y * size_y; float w = count_x * size_x; Gizmos.color = c; Vector3 trans; if (oriantion == MapOrientation.xSwaped) { trans = new Vector3(-1, 1, 1); } else if (oriantion == MapOrientation.ySwaped) { trans = new Vector3(1, -1, 1); } else if (oriantion == MapOrientation.xySwaped) { trans = new Vector3(-1, -1, 1); } else { trans = new Vector3(1, 1, 1); } for (int i = 0; i < count_x + 1; i++) { float x = (i * size_x); Vector3 start = rot * Vector3.Scale( new Vector3( x, 0, 0 ), trans); Vector3 end = rot * Vector3.Scale( new Vector3( x, h, 0 ), trans); Gizmos.DrawLine(start + pos, end + pos); } for (int i = 0; i < count_y + 1; i++) { float y = (i * size_y); Vector3 start = rot * Vector3.Scale( new Vector3( 0, y, 0 ), trans); Vector3 end = rot * Vector3.Scale( new Vector3( w, y, 0 ), trans); Gizmos.DrawLine(start + pos, end + pos); } Gizmos.color = Color.white; }