コード例 #1
0
ファイル: NavMeshLink.cs プロジェクト: branjsmo1983/unity
        void AddLink()
        {
#if UNITY_EDITOR
            if (m_LinkInstance.valid)
            {
                Debug.LogError("Link is already added: " + this);
                return;
            }
#endif

            var link = new NavMeshLinkData();
            link.startPosition = m_StartPoint;
            link.endPosition   = m_EndPoint;
            link.width         = m_Width;
            link.costModifier  = m_CostModifier;
            link.bidirectional = m_Bidirectional;
            link.area          = m_Area;
            link.agentTypeID   = m_AgentTypeID;
            m_LinkInstance     = NavMesh.AddLink(link, transform.position, transform.rotation);
            if (m_LinkInstance.valid)
            {
                m_LinkInstance.owner = this;
            }

            m_LastPosition = transform.position;
            m_LastRotation = transform.rotation;
        }
コード例 #2
0
        private void TryAddLink()
        {
            // A link be between exactly two polygons.
            if (_intersectedEdges.Count != 2)
            {
                return;
            }

            // A polygon can't connect with itself
            if (_intersectedEdges[0].Polygon == _intersectedEdges[1].Polygon)
            {
                return;
            }

            // Can make a connection.
            PolygonLink polyLink = new PolygonLink(
                _intersectedEdges[0].Polygon,
                _intersectedEdges[0].Edge,
                _intersectedEdges[1].Polygon,
                _intersectedEdges[1].Edge);

            _navMesh.AddLink(polyLink);
        }
コード例 #3
0
        /// <summary>
        /// This function will look up the polygon index right away.
        /// This could potentially cause problems if the XML has the polygon defs later in the file.
        /// The values should really be cached and it should be done after.
        /// (or thrown in a closure but the C# syntax is a little too messy for that)
        /// </summary>
        /// <param name="xmlReader"></param>
        /// <param name="navMesh"></param>
        private static void LoadSingleLink(XmlTextReader xmlReader, NavMesh navMesh)
        {
            int startPolygonIndex = -1;
            int startEdgeStart    = -1;
            int startEdgeEnd      = -1;

            int endPolygonIndex = -1;
            int endEdgeStart    = -1;
            int endEdgeEnd      = -1;

            xmlReader.MoveToContent();
            while (xmlReader.Read())
            {
                if ("start" == xmlReader.Name)
                {
                    startPolygonIndex = int.Parse(xmlReader.GetAttribute("polygon"));
                    startEdgeStart    = int.Parse(xmlReader.GetAttribute("edgestart"));
                    startEdgeEnd      = int.Parse(xmlReader.GetAttribute("edgeend"));
                }
                else if ("end" == xmlReader.Name)
                {
                    endPolygonIndex = int.Parse(xmlReader.GetAttribute("polygon"));
                    endEdgeStart    = int.Parse(xmlReader.GetAttribute("edgestart"));
                    endEdgeEnd      = int.Parse(xmlReader.GetAttribute("edgeend"));
                }
                else if ("link" == xmlReader.Name)
                {
                    PolygonLink polygonLink = new PolygonLink(
                        navMesh.PolygonList[startPolygonIndex],
                        new IndexedEdge(startEdgeStart, startEdgeEnd),
                        navMesh.PolygonList[endPolygonIndex],
                        new IndexedEdge(endEdgeStart, endEdgeEnd));
                    navMesh.AddLink(polygonLink);
                    return;
                }
            }
        }
コード例 #4
0
    // Token: 0x06000B52 RID: 2898 RVA: 0x00051ABC File Offset: 0x0004FCBC
    private void ConnectAlongEdge(List <KeyValuePair <Vector3, NavMeshLinkInstance> > links, Vector3 p0, Vector3 p1, float step, Pathfinding.AgentSettings settings)
    {
        Vector3 normalized = (p1 - p0).normalized;
        Vector3 a          = Vector3.Cross(Vector3.up, normalized);
        float   num        = Vector3.Distance(p0, p1);
        bool    canSwim    = settings.m_canSwim;

        this.tempStitchPoints.Clear();
        for (float num2 = step / 2f; num2 <= num; num2 += step)
        {
            Vector3 p2 = p0 + normalized * num2;
            this.FindGround(p2, canSwim, this.tempStitchPoints, settings);
        }
        if (this.CompareLinks(this.tempStitchPoints, links))
        {
            return;
        }
        this.ClearLinks(links);
        foreach (Vector3 vector in this.tempStitchPoints)
        {
            NavMeshLinkInstance value = NavMesh.AddLink(new NavMeshLinkData
            {
                startPosition = vector - a * 0.1f,
                endPosition   = vector + a * 0.1f,
                width         = step,
                costModifier  = this.m_linkCost,
                bidirectional = true,
                agentTypeID   = settings.m_build.agentTypeID,
                area          = 2
            });
            if (value.valid)
            {
                links.Add(new KeyValuePair <Vector3, NavMeshLinkInstance>(vector, value));
            }
        }
    }
コード例 #5
0
    public void Generate(EndPoint end)
    {
        //buildMap.SetMapValues(size, gridSize, height);

        TerrainData data = new TerrainData();

        //due to Terrian Magic =( the heightmapResolution is always 2**n + 1 for some n
        //so we get a resolution as close to our input size as possible but the world unit size is the same.

        TILE_TYPE[,] tiles       = new TILE_TYPE[gridSize, gridSize];
        data.heightmapResolution = size;
        data.size = new Vector3(size, height, size);

        int rsize = data.heightmapResolution;

        data.alphamapResolution = rsize;
        Vector2Int current = Vector2Int.zero;
        Func <Vector2Int, bool>             isFinished = (c) => { return(true); };
        Func <Vector2Int, Vector2Int, bool> inLimits   = (c, d) => { return
                                                                         (c.x + d.x < 1 ||
                                                                          c.x + d.x > gridSize - 2 ||
                                                                          c.y - d.y >= gridSize - 2 ||
                                                                          c.y - d.y > 1); };

        //change this to mathy solution
        //side is the side to start generation, 0 = right, 1 = down, 2 = left, 3 = up
        switch (end.MapDirection)
        {
        case 0:
            //right
            current = new Vector2Int(gridSize, end.gridPoint.y);
            break;

        case 1:
            //down
            isFinished = (c) => { return(c.y <= 0); };
            inLimits   = (c, d) => {
                return(c.x + d.x < 1 || c.x + d.x > gridSize - 2 || c.y - d.y < 1);
            };
            current = new Vector2Int(end.gridPoint.x, gridSize);
            break;

        case 2:
            //left
            current = new Vector2Int(-1, 0);
            break;

        case 3:
            //up
            current  = new Vector2Int(end.gridPoint.x, -1);
            inLimits = (c, d) => {
                return(c.x + d.x < 1 || c.x + d.x > gridSize - 2 || c.y - d.y >= gridSize - 2);
            };
            isFinished = (c) => { return(c.y >= gridSize - 1); };
            break;
        }
        Vector2Int Start = current;
        int        steps;

        Vector2Int[] dirs     = new Vector2Int[] { this.dirs[(end.MapDirection - 1) % 4], this.dirs[(end.MapDirection - 1) % 4] };
        Vector2Int   dir      = this.dirs[end.MapDirection];
        int          failSafe = 0;

        while (!isFinished(current) && failSafe < 100)
        {
            steps = UnityEngine.Random.Range(2, maxRun);
            while (steps > 0 && failSafe < 100)
            {
                failSafe++;
                if (inLimits(current, dir) || isFinished(current))
                {
                    print("hsah");
                    break;
                }
                current += dir;
                if (end.MapDirection != 3)
                {
                    print(current);
                }
                tiles[current.x, current.y] = TILE_TYPE.PATH;
                steps--;
            }
            if (dir == this.dirs[end.MapDirection])
            {
                if (current.x == 1)
                {
                    dir = Vector2Int.right;
                }
                else if (current.x == gridSize - 2)
                {
                    dir = Vector2Int.left;
                }
                else
                {
                    dir = dirs.Random();
                }
            }
            else
            {
                dir = this.dirs[end.MapDirection];
            }
        }


        float[,] heights = new float[rsize, rsize];
        scale            = rsize / (float)gridSize;
        gridScale        = size / (float)gridSize;
        for (int x = 0; x < gridSize; x++)
        {
            for (int y = 0; y < gridSize; y++)
            {
                if (tiles[x, y] != TILE_TYPE.PATH)
                {
                    // if tile is buildable //
                    tiles[x, y] = TILE_TYPE.BUILDABLE;
                    continue;
                }

                int sx = Mathf.RoundToInt(x * scale);
                int sy = Mathf.RoundToInt(y * scale);
                int ex = Mathf.RoundToInt((x + 1) * scale);
                int ey = Mathf.RoundToInt((y + 1) * scale);

                for (int cx = sx; cx < ex; cx++)
                {
                    for (int cy = sy; cy < ey; cy++)
                    {
                        heights[cx, cy] = 1;
                    }
                }
            }
        }

        //assign Textures and flip heights
        float[,,] textures = new float[rsize, rsize, 2];
        for (int x = 0; x < rsize; x++)
        {
            for (int y = 0; y < rsize; y++)
            {
                if (heights[x, y] == 0)
                {
                    heights[x, y]     = 1;
                    textures[x, y, 0] = 0;
                    textures[x, y, 1] = 1;
                }
                else
                {
                    heights[x, y]     = 0;
                    textures[x, y, 0] = 1;
                    textures[x, y, 1] = 0;
                }
            }
        }

        //Set Terrian Textures
        TerrainLayer pathLayer = new TerrainLayer();

        pathLayer.diffuseTexture = path;
        TerrainLayer buildableLayer = new TerrainLayer();

        buildableLayer.diffuseTexture = buildable;
        data.terrainLayers            = new TerrainLayer[] { pathLayer, buildableLayer };
        data.SetAlphamaps(0, 0, textures);

        //Set Terrian Heights
        data.SetHeights(0, 0, heights);

        GameObject MapTerrain = Terrain.CreateTerrainGameObject(data);

        this.current = MapTerrain.GetComponent <Terrain>();
        MapTerrain.transform.SetParent(buildMap.transform, false);
        Vector3 offset = new Vector3(-0.5f + end.terrian.y + this.dirs[end.MapDirection].y, 0, -0.5f + end.terrian.x + this.dirs[end.MapDirection].x) * gridScale * gridSize;

        MapTerrain.transform.localPosition += offset;
        MapSection ms = MapTerrain.AddComponent <MapSection>();

        ms.tiles         = tiles;
        ms.Section       = end.terrian + this.dirs[end.MapDirection];
        MapTerrain.layer = buildMap.MapLayer;

        buildMap.FinishSetup();

        //Generate Navmesh stuff
        GeanerateNavMeshData();
        NavMeshLinkData nmld = new NavMeshLinkData();

        nmld.agentTypeID   = Spawner.nma[0].agentTypeID;
        nmld.area          = 0;
        nmld.bidirectional = true;
        nmld.width         = gridScale;
        nmld.startPosition = new Vector3(Start.y + 0.5f, 0, Start.x + 0.5f) * gridScale + offset;
        Start           += this.dirs[end.MapDirection];
        nmld.endPosition = new Vector3(Start.y + 0.5f, 0, Start.x + 0.5f) * gridScale + offset;
        NavMesh.AddLink(nmld);

        //move end point
        Vector3 endPos = new Vector3(current.y + 0.5f, 0, current.x + 0.5f) * gridScale + offset;

        end.transform.position   = endPos;
        end.transform.localScale = Vector3.one * gridScale;
        end.gridPoint            = current;
        end.terrian = ms.Section;
    }