Exemple #1
0
 private static void DrawOverlay(TownGeometry geometry, StringBuilder sb)
 {
     foreach (var patch in geometry.Overlay)
     {
         sb.Append(patch.Shape.ToSvgPolygon("overlay", $" id=\"{patch.Id}\""));
     }
 }
        private void DrawRoads(TownGeometry geometry, StringBuilder sb)
        {
            Roads                         = new GameObject("Roads");
            Roads.layer                   = LayerMask.NameToLayer("Map");
            Roads.transform.parent        = child;
            Roads.transform.localPosition = Vector3.zero;
            Cube cube;

            foreach (var road in geometry.Roads)
            {
                Geom.Vector2 last = new Geom.Vector2(0, 0);
                foreach (var current in road)
                {
                    if (last.x != 0 && last.y != 0)
                    {
                        float MovedlastX = ScaleToWorldWithOffset(last.x, town.townOffset.x);
                        float MovedlastY = ScaleToWorldWithOffset(last.y, town.townOffset.y);

                        float MovedcurrentX = ScaleToWorldWithOffset(current.x, town.townOffset.x);
                        float MovedcurrentY = ScaleToWorldWithOffset(current.y, town.townOffset.y);

                        cube = new Cube("Road", GetLineVertices(
                                            MovedlastX,
                                            MovedcurrentX,
                                            MovedlastY,
                                            MovedcurrentY,
                                            3
                                            ), .2f, rendererOptions.RoadMaterial, Roads.transform, false, true);
                        cube.Transform.localPosition = new Vector3(0, 1000f, 0);
                        cube.GameObject.layer        = LayerMask.NameToLayer("Map");
                    }
                    last = current;
                }
            }
        }
Exemple #3
0
        private void DrawRoads(TownGeometry geometry, StringBuilder sb)
        {
            Roads = new GameObject("Roads");
            Roads.transform.parent        = child;
            Roads.transform.localPosition = Vector3.zero;
            Cube cube;

            foreach (var road in geometry.Roads)
            {
                Vector2 last = new Vector2(0, 0);
                foreach (var current in road)
                {
                    if (last.x != 0 && last.y != 0)
                    {
                        cube = new Cube("Road", GetLineVertices(
                                            last.x,
                                            current.x,
                                            last.y,
                                            current.y,
                                            2
                                            ), 0.2f, rendererOptions.RoadMaterial, Roads.transform);
                        cube.Transform.localPosition = Vector3.zero;
                    }
                    last = current;
                }
            }
        }
        private void DrawWalls(TownGeometry geometry, StringBuilder sb)
        {
            WallsMesh = new GameObject("WallsMesh");
            WallsMesh.transform.parent = child;
            Walls = new GameObject("Walls");
            Walls.transform.parent = child;
            var replacedGates = new List <Geom.Vector2>();

            foreach (var wall in geometry.Walls)
            {
                var start = wall.A;
                var end   = wall.B;

                if (geometry.Gates.Contains(start))
                {
                    replacedGates.Add(start);
                    start  = start + Geom.Vector2.Scale(end - start, 0.3f);
                    wall.A = start;
                    geometry.Gates.Add(start);
                }

                if (geometry.Gates.Contains(end))
                {
                    replacedGates.Add(end);
                    end    = end - Geom.Vector2.Scale(end - start, 0.3f);
                    wall.B = end;
                    geometry.Gates.Add(end);
                }
                new Cube("Wall", GetLineVertices(
                             start.x,
                             end.x,
                             start.y,
                             end.y
                             ), 0.1f, WallMaterial, Walls.transform);
                new Cube("WallMesh", GetLineVertices(
                             start.x,
                             end.x,
                             start.y,
                             end.y
                             ), 4, WallMaterial, WallsMesh.transform, false);
            }

            foreach (var replacedGate in replacedGates.Distinct())
            {
                geometry.Gates.Remove(replacedGate);
            }

            foreach (var tower in geometry.Towers)
            {
                new Cube("Tower", GetVertices(4, 4, tower.x - 2, tower.y - 2), 0.1f, TowerMaterial, Walls.transform);
                new Cube("TowerMesh", GetVertices(4, 4, tower.x - 2, tower.y - 2), 8, TowerMaterial, WallsMesh.transform, false);
            }

            foreach (var gate in geometry.Gates)
            {
                new Cube("Gate", GetVertices(4, 4, gate.x - 2, gate.y - 2), 0.1f, GateMaterial, Walls.transform);
                new Cube("GateMesh", GetVertices(4, 4, gate.x - 2, gate.y - 2), 6, GateMaterial, WallsMesh.transform, false);
            }
        }
Exemple #5
0
 private static void DrawRoads(TownGeometry geometry, StringBuilder sb)
 {
     foreach (var road in geometry.Roads)
     {
         var path = string.Join(" ", road.Select(v => v.ToString()));
         sb.Append($"<polyline class=\"road-outer\" points=\"{path}\"  />");
         sb.Append($"<polyline class=\"road-inner\" points=\"{path}\"  />");
     }
 }
        private void DrawOverlay(TownGeometry geometry, StringBuilder sb)
        {
            List <Vector3> vertices = new List <Vector3>();
            var            overlays = new GameObject("Overlays");

            overlays.transform.parent = child;
            foreach (var patch in geometry.Overlay)
            {
                foreach (var vertex in patch.Shape.Vertices)
                {
                    vertices.Add(new Vector3(vertex.x, 0, vertex.y));
                }
                new MeshUtils.Polygon("Patch", vertices, 0.05f, OverlayMaterial, overlays.transform, true);
                vertices.Clear();
            }
        }
Exemple #7
0
        private static void DrawWalls(TownGeometry geometry, StringBuilder sb)
        {
            var replacedGates = new List <Vector2>();

            foreach (var wall in geometry.Walls)
            {
                var start = wall.A;
                var end   = wall.B;

                if (geometry.Gates.Contains(start))
                {
                    replacedGates.Add(start);
                    start  = start + Vector2.Scale(end - start, 0.3f);
                    wall.A = start;
                    geometry.Gates.Add(start);
                }

                if (geometry.Gates.Contains(end))
                {
                    replacedGates.Add(end);
                    end    = end - Vector2.Scale(end - start, 0.3f);
                    wall.B = end;
                    geometry.Gates.Add(end);
                }
                sb.Append($"<line x1=\"{start.x}\" y1=\"{start.y}\" x2=\"{end.x}\" y2=\"{end.y}\" class=\"wall\" />");
            }

            foreach (var replacedGate in replacedGates.Distinct())
            {
                geometry.Gates.Remove(replacedGate);
            }

            foreach (var tower in geometry.Towers)
            {
                sb.Append($"<rect width=\"8\" height=\"8\" x=\"{tower.x - 4}\" y=\"{tower.y - 4}\" class=\"tower\" />");
            }

            foreach (var gate in geometry.Gates)
            {
                sb.Append($"<rect width=\"8\" height=\"8\" x=\"{gate.x - 4}\" y=\"{gate.y - 4}\" class=\"gate\" />");
            }
        }
Exemple #8
0
        public TownGeometry GetTownGeometry(TownOptions options)
        {
            var geometry = new TownGeometry();

            var buildingShapes = new List <Polygon> ();

            foreach (var patch in Patches.Where(p => p.Area != null))
            {
                buildingShapes.AddRange(patch.Area.GetGeometry());
            }

            var buildingPlacer = new BuildingPlacer(buildingShapes);
            var buildings      = buildingPlacer.PopulateBuildings();

            geometry.Buildings.AddRange(buildings);
            if (options.Walls)
            {
                geometry.Walls.AddRange(CityWall.GetEdges().Union(Castle.Wall.GetEdges()).Distinct());
                geometry.Towers.AddRange(CityWall.Towers.Union(Castle.Wall.Towers));
                geometry.Gates.AddRange(CityWall.Gates.Union(Castle.Wall.Gates));
            }
            else
            {
                var castleWall = CityWall.GetEdges().Union(Castle.Wall.GetEdges()).Distinct().SelectMany(e => new [] { e.A, e.B }).Where(w => Castle.Patch.Shape.Vertices.Contains(w)).ToList();
                var towers     = CityWall.Towers.Union(Castle.Wall.Towers).Intersect(castleWall);
                var gates      = CityWall.Gates.Union(Castle.Wall.Gates).Intersect(castleWall);
                geometry.Walls.AddRange(Edge.FromPointList(castleWall));
                geometry.Towers.AddRange(towers);
                geometry.Gates.AddRange(gates);
            }
            geometry.Roads.AddRange(Roads);
            geometry.Roads.AddRange(Streets);

            geometry.Overlay.AddRange(Patches);
            geometry.Water.AddRange(Patches.Where(p => p.Water).Select(p => p.Shape));
            geometry.WaterBorder = new Polygon(WaterBorder);

            return(geometry);
        }
 private void DrawRoads(TownGeometry geometry, StringBuilder sb)
 {
     Roads = new GameObject("Roads");
     Roads.transform.parent = child;
     foreach (var road in geometry.Roads)
     {
         Geom.Vector2 last = new Geom.Vector2(0, 0);
         foreach (var current in road)
         {
             if (last.x != 0 && last.y != 0)
             {
                 new Cube("Road", GetLineVertices(
                              last.x,
                              current.x,
                              last.y,
                              current.y,
                              2
                              ), 0.2f, RoadMaterial, Roads.transform);
             }
             last = current;
         }
     }
 }
        //private void DrawWallSplines(TownGeometry geometry, StringBuilder sb)
        //{

        //    var FenceSpline = new GameObject("FenceSpline");
        //    FenceSpline.transform.parent = child;
        //    FenceSpline.transform.localPosition = Vector3.zero;

        //    // we now - annoyingly - have a start and an end node to deal with from the outset...

        //    // so if first    Former.StartNode.transform.position = new Vector3();

        //    // if second  Former.EndNode.transform.position = new Vector3();

        //    // if subsequent SplineNode node = Former.AddNodeImmediately();    node.transform.position = new Vector3();

        //    var replacedGates = new List<Geom.Vector2>();

        //    for (int i = 0; i < geometry.Walls.Count; i++)
        //    {

        //        // for some reason the first line is the circumference we don't want that?

        //        if (i == 0)
        //        {
        //            continue;
        //        }

        //        Edge wall = (Edge)geometry.Walls[i];
        //        var splineFormer = GameObject.Instantiate(TownHolder.Instance.FenceSplineFormer, FenceSpline.transform);

        //        splineFormer.name = String.Format("{0}_Wall{1}", town.name, i);

        //        splineFormer.transform.localPosition = Vector3.zero;

        //        var Former = splineFormer.GetComponent<SplineFormer>();


        //        var start = wall.A;
        //        var end = wall.B;

        //        if (wall.A == wall.B)
        //            continue;

        //        Former.SegmentsNumber = Math.Max(1, (int)Mathf.Sqrt(Geom.Vector2.DistanceSquare(wall.A, wall.B)));


        //        // optionally offset the ends to fit the Gates
        //        if (geometry.Gates.Contains(start))
        //        {
        //            replacedGates.Add(start);
        //            start = start + Geom.Vector2.Scale(end - start, 0.3f);
        //            wall.A = start;
        //            geometry.Gates.Add(start);
        //        }

        //        if (geometry.Gates.Contains(end))
        //        {
        //            replacedGates.Add(end);
        //            end = end - Geom.Vector2.Scale(end - start, 0.3f);
        //            wall.B = end;
        //            geometry.Gates.Add(end);
        //        }


        //        float MovedstartX = ScaleToWorldWithOffset(start.x, town.townOffset.x);
        //        float MovedstartY = ScaleToWorldWithOffset(start.y, town.townOffset.y);

        //        float MovedendX = ScaleToWorldWithOffset(end.x, town.townOffset.x);
        //        float MovedendY = ScaleToWorldWithOffset(end.y, town.townOffset.y);
        //        float startPlace, endPlace;


        //        startPlace = GetTerrainPos(MovedstartX, MovedstartY).y;

        //        endPlace = GetTerrainPos(MovedendX, MovedendY).y;


        //        Former.StartNode.transform.position = new Vector3(MovedstartX, startPlace, MovedstartY);

        //        Former.EndNode.transform.position = new Vector3(MovedendX, endPlace, MovedendY);

        //    }

        //    MakeFenceFromEdges(geometry, FenceSpline, replacedGates, town.CityWall.GetEdges(), "CityWall");
        //    MakeFenceFromEdges(geometry, FenceSpline, replacedGates, town.Market.Edges, "Market");
        //}

        //private void MakeFenceFromEdges(TownGeometry geometry, GameObject FenceSpline, List<Geom.Vector2> replacedGates, IEnumerable<Edge> EdgeIEnumerable, string prettyName)
        //{
        //    int i = 0;

        //    foreach (var (wall, splineFormer) in from wall in EdgeIEnumerable
        //                                         let splineFormer = GameObject.Instantiate(TownHolder.Instance.FenceSplineFormer, FenceSpline.transform)
        //                                         select (wall, splineFormer))
        //    {
        //        splineFormer.name = String.Format("{0}_Wall{1}{2}", town.name, prettyName, i);
        //        splineFormer.transform.localPosition = Vector3.zero;
        //        var Former = splineFormer.GetComponent<SplineFormer>();
        //        var start = wall.A;
        //        var end = wall.B;
        //        if (wall.A == wall.B)
        //            continue;
        //        Former.SegmentsNumber = Math.Max(1, (int)Mathf.Sqrt(Geom.Vector2.DistanceSquare(wall.A, wall.B)));
        //        // optionally offset the ends to fit the Gates
        //        if (geometry.Gates.Contains(start))
        //        {
        //            replacedGates.Add(start);
        //            start = start + Geom.Vector2.Scale(end - start, 0.3f);
        //            wall.A = start;
        //            geometry.Gates.Add(start);
        //        }

        //        if (geometry.Gates.Contains(end))
        //        {
        //            replacedGates.Add(end);
        //            end = end - Geom.Vector2.Scale(end - start, 0.3f);
        //            wall.B = end;
        //            geometry.Gates.Add(end);
        //        }

        //        float MovedstartX = ScaleToWorldWithOffset(start.x, town.townOffset.x);
        //        float MovedstartY = ScaleToWorldWithOffset(start.y, town.townOffset.y);
        //        float MovedendX = ScaleToWorldWithOffset(end.x, town.townOffset.x);
        //        float MovedendY = ScaleToWorldWithOffset(end.y, town.townOffset.y);
        //        float startPlace, endPlace;
        //        startPlace = GetTerrainPos(MovedstartX, MovedstartY).y;
        //        endPlace = GetTerrainPos(MovedendX, MovedendY).y;
        //        Former.StartNode.transform.position = new Vector3(MovedstartX, startPlace, MovedstartY);
        //        Former.EndNode.transform.position = new Vector3(MovedendX, endPlace, MovedendY);

        //        i = i + 1;
        //    }
        //}

        private void DrawWalls(TownGeometry geometry, StringBuilder sb)
        {
            return;


            Cube cube;

            WallsMesh = new GameObject("WallsMesh");
            WallsMesh.transform.parent        = child;
            WallsMesh.transform.localPosition = Vector3.zero;
            Walls = new GameObject("Walls");
            Walls.transform.parent        = child;
            Walls.transform.localPosition = Vector3.zero;
            var replacedGates = new List <Geom.Vector2>();

            foreach (var wall in geometry.Walls)
            {
                var start = wall.A;
                var end   = wall.B;

                if (wall.A == wall.B)
                {
                    continue;
                }

                if (geometry.Gates.Contains(start))
                {
                    replacedGates.Add(start);
                    start  = start + Geom.Vector2.Scale(end - start, 0.3f);
                    wall.A = start;
                    geometry.Gates.Add(start);
                }

                if (geometry.Gates.Contains(end))
                {
                    replacedGates.Add(end);
                    end    = end - Geom.Vector2.Scale(end - start, 0.3f);
                    wall.B = end;
                    geometry.Gates.Add(end);
                }


                float MovedstartX = ScaleToWorldWithOffset(start.x, town.townOffset.x);
                float MovedstartY = ScaleToWorldWithOffset(start.y, town.townOffset.y);

                float MovedendX = ScaleToWorldWithOffset(end.x, town.townOffset.x);
                float MovedendY = ScaleToWorldWithOffset(end.y, town.townOffset.y);
                float startPlace, endPlace;

                var thing = TownGlobalObjectService.MapMagicObjectRef.tiles.FindByWorldPosition(MovedstartX, MovedstartY);
                // var thing = TownGlobalObjectService.MapMagicObjectRef.tiles.FindByWorldPosition(start.x, start.y);
                // if (thing !=null) // sigh
                if (false)
                {
                    Terrain     ter     = thing.ActiveTerrain;
                    TerrainData terData = ter.terrainData;
                    startPlace = terData.GetHeight((int)MovedstartX, (int)MovedstartY);
                }
                else
                {
                    startPlace = GetTerrainPos(MovedstartX, MovedstartY).y;
                }

                // if (thing != null) // sigh
                if (false)
                {
                    thing = TownGlobalObjectService.MapMagicObjectRef.tiles.FindByWorldPosition(MovedendX, MovedendY);
                    Terrain     ter     = thing.ActiveTerrain;
                    TerrainData terData = ter.terrainData;
                    endPlace = terData.GetHeight((int)MovedendX, (int)MovedendY);
                }
                else
                {
                    endPlace = GetTerrainPos(MovedendX, MovedendY).y;
                }


                //cube = new Cube("Wall", GetLineVertices(
                //    ScaleToWorldWithOffset(start.x, town.townOffset.x),
                //     ScaleToWorldWithOffset(end.x, town.townOffset.x),
                //     ScaleToWorldWithOffset(start.y, town.townOffset.y),
                //     ScaleToWorldWithOffset(end.y, town.townOffset.y)
                //), 0.1f, rendererOptions.WallMaterial, Walls.transform);
                //cube.Transform.localPosition = Vector3.zero;


                //cube = new Cube("WallMesh", GetLineVertices(
                //     ScaleToWorldWithOffset(start.x, town.townOffset.x),
                //     ScaleToWorldWithOffset(end.x, town.townOffset.x),
                //     ScaleToWorldWithOffset(start.y, town.townOffset.y),
                //     ScaleToWorldWithOffset(end.y, town.townOffset.y)
                //), 4, rendererOptions.WallMaterial, WallsMesh.transform, true);


                cube = new Cube("WallMesh", GetLineVertices(
                                    MovedstartX,
                                    MovedendX,
                                    MovedstartY,
                                    MovedendY
                                    ), 4, rendererOptions.WallMaterial, WallsMesh.transform, true);


                //Mesh mesh = cube.MeshFilter.mesh;
                //Vector3[] vertices = mesh.vertices;
                //UnityEngine.Vector2[] uvs = new UnityEngine.Vector2[vertices.Length];

                //for (int i = 0; i < uvs.Length; i++)
                //{
                //    uvs[i] = new UnityEngine.Vector2(vertices[i].x, vertices[i].z);
                //}
                //mesh.RecalculateNormals();
                //mesh.RecalculateTangents();

                //mesh.uv = uvs;

                //cube.MeshFilter.mesh.uv = uvs;
                cube.Transform.localPosition = new Vector3(0, (startPlace), 0);
            }

            foreach (var replacedGate in replacedGates.Distinct())
            {
                geometry.Gates.Remove(replacedGate);
            }

            if (options.Towers)
            {
                foreach (var tower in geometry.Towers)
                {
                    cube = new Cube("Tower", TownMeshRendererUtils.GetVertices(4, 4, tower.x - 2, tower.y - 2), 0.1f, rendererOptions.TowerMaterial, Walls.transform);
                    cube.Transform.localPosition = Vector3.zero;
                    cube = new Cube("TowerMesh", TownMeshRendererUtils.GetVertices(4, 4, tower.x - 2, tower.y - 2), 8, rendererOptions.TowerMaterial, WallsMesh.transform, false);
                    cube.Transform.localPosition = Vector3.zero;
                }

                foreach (var gate in geometry.Gates)
                {
                    cube = new Cube("Gate", TownMeshRendererUtils.GetVertices(4, 4, gate.x - 2, gate.y - 2), 0.1f, rendererOptions.GateMaterial, Walls.transform);
                    cube.Transform.localPosition = Vector3.zero;
                    cube = new Cube("GateMesh", TownMeshRendererUtils.GetVertices(4, 4, gate.x - 2, gate.y - 2), 6, rendererOptions.GateMaterial, WallsMesh.transform, false);
                    cube.Transform.localPosition = Vector3.zero;
                }
            }
        }
        private void DrawOverlay(TownGeometry geometry, StringBuilder sb)
        {
            MeshUtils.Polygon poly;
            List <Vector3>    vertices = new List <Vector3>();
            var overlays = new GameObject("Overlays");

            overlays.gameObject.layer = LayerMask.NameToLayer(CamMapLayer);

            overlays.transform.parent        = child;
            overlays.transform.localPosition = new Vector3(0, 0, 0); // Vector3.zero;
            foreach (var patch in geometry.Overlay)
            {
                if (patch.Water)
                {
                    continue;
                }
                if (patch.Area.GetType() == typeof(EmptyArea))
                {
                    continue;
                }
                if (patch.Area.GetType() == typeof(FarmArea))
                {
                    continue;                                            // here exclude outlying areas. you could put this back.
                }
                var   type           = patch.Area.ToString();
                float previousOffset = 900f;
                foreach (var vertex in patch.Shape.Vertices)
                {
                    float MovedX = ScaleToWorldWithOffset(vertex.x, town.townOffset.x);
                    float MovedY = ScaleToWorldWithOffset(vertex.y, town.townOffset.y);

                    //    MapMagic.Terrains.TerrainTile tileFound = TownGlobalObjectService.MapMagicObjectRef.tiles.FindByWorldPosition(MovedX, MovedY);

                    try
                    {
                        var         thing   = TownGlobalObjectService.MapMagicObjectRef.tiles.FindByWorldPosition(vertex.x, vertex.y);
                        Terrain     ter     = thing.ActiveTerrain;
                        TerrainData terData = ter.terrainData;
                        previousOffset = terData.GetHeight((int)MovedX, (int)MovedY) + 900;
                        vertices.Add(new Vector3(
                                         MovedX,
                                         previousOffset,
                                         MovedY));
                    }
                    catch // (Exception ex)
                    {
                        if (patch.IsCityCenter)
                        {
                            previousOffset = 0f;
                        }

                        //  Debug.Log(ex.Message);
                        vertices.Add(new Vector3(
                                         MovedX,
                                         previousOffset,
                                         MovedY));
                    }
                }

                float    offset = 3f;
                Material mat;
                if (patch.HasCastle)
                {
                    // offset = 3.4f;
                    mat = rendererOptions.CastleGroundMaterial;
                }
                else if (patch.IsCityCenter)
                {
                    //  offset = 3.2f;
                    mat = rendererOptions.CityCenterGround;
                }
                else if (patch.WithinWalls)
                {
                    if (type == "Town.RichArea")
                    {
                        mat = rendererOptions.RichArea;
                    }
                    else if (type == "Town.PoorArea")
                    {
                        mat = rendererOptions.PoorArea;
                    }
                    else
                    {
                        mat = rendererOptions.WithinWallsGroundMaterial;
                    }
                }
                else
                {
                    if (!options.Farm && type == "Town.EmptyArea")
                    {
                        mat = rendererOptions.HiddenCity;
                    }
                    else if (options.Farm && type == "Town.FarmArea")
                    {
                        // mat = rendererOptions.FarmArea;
                        mat = rendererOptions.HiddenCity;
                    }

                    else
                    {
                        mat = rendererOptions.OuterCityGroundMaterial;
                    }
                }
                poly = new MeshUtils.Polygon(patch.Area.GetType().ToString(), vertices, offset, mat, overlays.transform, false);
                poly.GameObject.layer        = LayerMask.NameToLayer(CamMapLayer);
                poly.Transform.localPosition = Vector3.zero;

                if (patch.IsCityCenter)
                {
                    poly.GameObject.isStatic = false;
                    poly.GameObject.AddComponent <LerpToGround>();
                }

                vertices.Clear();
            }
        }
Exemple #12
0
        public string DrawTown()
        {
            var bounds = _town.GetCityWallsBounds().Expand(100);

            //var sb = new StringBuilder(@"<?xml version=""1.0"" standalone=""yes""?>");
            //sb.Append($"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1500\" height=\"1500\" viewBox=\"{bounds.ToSvgViewport()}\">");

            //sb.Append(@"<defs><style type=""text/css""><![CDATA[");
            //sb.Append(".building { stroke-width: 0.1; stroke: #777; fill: #DDD; }");
            //sb.Append(".building-description { visibility: hidden; font-size: 4; font-family: Verdana; fill: #666; }");
            //sb.Append(".wall { stroke-width: 5; stroke: black; fill: none; }");
            //sb.Append(".road-outer { stroke-width: 3.6; stroke: black; fill: none; }");
            //sb.Append(".road-inner { stroke-width: 3; stroke: white; fill: none; }");
            //sb.Append(".tower { fill: black; }");
            //sb.Append(".water { fill: #7799FF; fill-opacity: 0.6; stroke: none; }");
            //sb.Append(".overlay { fill: #FFFF00; fill-opacity: 0.2; stroke: black; stroke-width: 0.5; }");
            //sb.Append("]]></style></defs>");

            //sb.Append(@"<rect width=""1500"" height=""1500"" x=""0"" y=""0"" fill=""#FCFCFA"" />");

            geometry = _town.GetTownGeometry(_options);

            //foreach (var water in geometry.Water)
            //{
            //    sb.Append(water.ToSvgPolygon("water"));
            //}

            //var id = 0;
            foreach (var building in geometry.Buildings)
            {
                //    Instantiate<GameObject>(Prefab, new Vector3(building.Shape.Center.x, 0, building.Shape.Center.y), Quaternion.identity);

                //   var hover = $"onmouseover =\"document.getElementById('building{id}').style.visibility = 'visible'\" onmouseout=\"document.getElementById('building{id}').style.visibility = 'hidden'\"";
                //    sb.Append(building.Shape.ToSvgPolygon("building", hover));
                //    id++;
            }

            //DrawRoads(geometry, sb);
            //DrawWalls(geometry, sb);

            //id = 0;
            //foreach (var building in geometry.Buildings)
            //{
            //    sb.Append("<text z-index=\"9\" id=\"building" + id + "\" class=\"building-description\" x=\"" + building.Shape.Vertices[0].x + "\" y=\"" + building.Shape.Vertices[0].y +
            //              "\">" + building.Description + "</text>");
            //    id++;
            //}

            //if (_options.Overlay)
            //{
            //    DrawOverlay(geometry, sb);
            //}

            ////sb.Append(geometry.WaterBorder.ToSvgPolygon("road-outer"));

            //sb.Append($"<text x=\"{bounds.X + 20}\" y=\"{bounds.Y + 30}\">" + _options.Seed + "</text>");

            //sb.Append("</svg>");
            //return sb.ToString();
            return("");
        }
Exemple #13
0
        private void DrawOverlay(TownGeometry geometry, StringBuilder sb)
        {
            MeshUtils.Polygon poly;
            List <Vector3>    vertices = new List <Vector3> ();
            var overlays = new GameObject("Overlays");

            overlays.transform.parent        = child;
            overlays.transform.localPosition = Vector3.zero;
            foreach (var patch in geometry.Overlay)
            {
                if (patch.Water)
                {
                    continue;
                }
                var type = patch.Area.ToString();
                foreach (var vertex in patch.Shape.Vertices)
                {
                    vertices.Add(new Vector3(vertex.x, -3f, vertex.y));
                }
                float    offset = 3f;
                Material mat;
                if (patch.HasCastle)
                {
                    offset = 3.4f;
                    mat    = rendererOptions.CastleGroundMaterial;
                }
                else if (patch.IsCityCenter)
                {
                    offset = 3.2f;
                    mat    = rendererOptions.CityCenterGround;
                }
                else if (patch.WithinWalls)
                {
                    if (type == "Town.RichArea")
                    {
                        mat = rendererOptions.RichArea;
                    }
                    else if (type == "Town.PoorArea")
                    {
                        mat = rendererOptions.PoorArea;
                    }
                    else
                    {
                        mat = rendererOptions.WithinWallsGroundMaterial;
                    }
                }
                else
                {
                    if (type == "Town.FarmArea")
                    {
                        mat = rendererOptions.FarmArea;
                    }
                    else
                    {
                        mat = rendererOptions.OuterCityGroundMaterial;
                    }
                }
                poly = new MeshUtils.Polygon("Patch", vertices, offset, mat, overlays.transform, true);
                poly.Transform.localPosition = Vector3.zero;
                vertices.Clear();
            }
        }