Пример #1
0
 //responsible for creating the mountain structure
 public void Create()
 {
     //retrieve the mesh filter component
     mesh = GetComponent <MeshFilter>().mesh;
     //sets up a list storing the points of each ring that act as the centre of the borders
     BorderMidPoints = new List <int> {
         2, 6, 10, 14, 18, 22
     };
     //retrieve all vertex points from the mesh
     vertices = mesh.vertices;
     //calculate the height decrease between each ring
     Decrement = Vector3.forward / 3 * 2;
     // set the base height decrease for each ring
     rngBase = (Decrement / 8);
     //create a new hexagon structure for the mesh
     hexVerts = new HexClass();
     //set the mountains peak to be the highest height possible
     vertices[hexVerts.peak] += ((Decrement / 8) * 9);
     //set the height of the range of mountain, connected it to neighbours
     SetRange(tilesBorders);
     //set the slopes of each mountain
     SetSlopes(tilesBorders);
     //set every other vertex based on the slope values
     SmoothSlopes();
     //Apply the height changes to the current mesh
     mesh.vertices = vertices;
     mesh.RecalculateBounds();
 }
Пример #2
0
    //places biome specific prefabs on athe current tile based on a rng value
    public void AddPrefab(List <GameObject> prefab, int RNGHigherValue)
    {
        //retrieve a parentg object
        parent = GameObject.Find("WorldObj");
        //retrieve the mesh filter component
        hexagonMesh = GetComponent <MeshFilter>().mesh;
        //sets up a list storing the points of each ring that act as the centre of the borders
        edgeMidPoints = new List <int> {
            2, 6, 10, 14, 18, 22
        };
        //retrieve all vertex points from the mesh
        vertices = hexagonMesh.vertices;
        //create a new hexagon structure for the mesh
        hexVerts = new HexClass();
        //retreive the position of the peak vertex
        Vector3 worldPt = transform.TransformPoint(vertices[hexVerts.peak]);

        //for every ring within the hexagon
        for (int i = 0; i < hexVerts.NumberOfRings - 1; i++)
        {
            //retrieve every vertex in the current ring
            int[] currentRing = new int[24];
            currentRing = hexVerts.Hexagon[i];

            //for every vertex in the current ring
            for (int j = 0; j < currentRing.Length; j++)
            {
                //retrieve the current vertex
                int currentVert = currentRing[j];
                //retrieve the current vertexes position
                worldPt = transform.TransformPoint(vertices[currentVert]);

                //generate a random number
                int rng = Random.Range(0, 101);
                //if the generated number is within the range
                if (rng > RNGHigherValue)
                {
                    //retrieve one of biome objects at random
                    int randomObj     = Random.Range(0, prefab.Count);
                    var currentPrefab = prefab[randomObj];
                    //place the chosen biome object at the current vertexes world position
                    var temp = Instantiate(currentPrefab, worldPt, Quaternion.identity);
                    //set the objects parent
                    temp.transform.parent = parent.transform;
                }
            }
        }
        //Apply the height changes to the current mesh
        hexagonMesh.vertices = vertices;
        hexagonMesh.RecalculateBounds();
    }
Пример #3
0
    //function which places a city object on a hex tile
    public void PlaceCity(GameObject cityObj, string name)
    {
        //retreives partent objeect for city
        parent = GameObject.Find("WorldObj");
        //retreieves information about the mesh
        hexagonMesh = GetComponent <MeshFilter>().mesh;
        vertices    = hexagonMesh.vertices;
        hexVerts    = new HexClass();
        //calculates a height value which the city must be places
        float scale = cityObj.transform.lossyScale.y / 2 + landHeight;
        //sets the spawn position of the city
        Vector3 spawnPos = transform.TransformPoint(vertices[hexVerts.peak]);

        spawnPos = new Vector3(spawnPos.x, spawnPos.y + scale, spawnPos.z);
        //spawnt the city and set its parent object
        GameObject cityObject = Instantiate(cityObj, spawnPos, Quaternion.identity);

        cityObject.transform.parent = parent.transform;
        //set the citys UI to be the name passed
        GameObject cityNameUI = cityObject.transform.GetChild(1).GetChild(0).GetChild(0).gameObject;

        cityNameUI.GetComponent <Text>().text = name;
    }
Пример #4
0
    public void AlterHex(List <int> coastlineMidPoints)
    {
        hexagonMesh = GetComponent <MeshFilter>().mesh;
        vertices    = hexagonMesh.vertices;
        hexVerts    = new HexClass();
        Vector3 Peakheight = new Vector3(0, 0, landHeight);

        //Set the height of the centre point of the hex to be of the set height value
        vertices[hexVerts.peak] += Peakheight;
        for (int i = 0; i < hexVerts.NumberOfRings; i++)
        {
            int[] currentRing = new int[24];
            //Retreive the index of all the vertexes within the current ring
            currentRing = hexVerts.Hexagon[i];
            for (int j = 0; j < currentRing.Length; j++)
            {
                int     currentVert = currentRing[j];
                Vector3 height      = new Vector3(0, 0, landHeight);
                //Set every vert to be of the height of the set height value
                vertices[currentVert] += height;
            }
            //if the current ring is one of the last 4
            if (i >= hexVerts.NumberOfRings - 4)
            {
                List <int> listPoints = new List <int>();
                //find the height value necessary to lower the current rings height so that it smooths down to the coastline
                float heightDifference = landHeight / (hexVerts.NumberOfRings - (hexVerts.NumberOfRings - 4));
                int   currentVert;
                int   divideNumber;

                Vector3 height;
                //For every side of the hexagon that borders a sea tile
                for (int j = 0; j < coastlineMidPoints.Count; j++)
                {
                    //if the verts on the end on this side for this particular mid point is currently not within a list structure to
                    //be reduced in height then add it
                    if (listPoints.Contains(currentRing[coastlineMidPoints[j] - 2]) == false)
                    {
                        listPoints.Add(currentRing[coastlineMidPoints[j] - 2]);
                    }

                    if (coastlineMidPoints[j] != 22)
                    {
                        if (listPoints.Contains(currentRing[coastlineMidPoints[j] + 2]) == false)
                        {
                            listPoints.Add(currentRing[coastlineMidPoints[j] + 2]);
                        }
                    }
                    else
                    {
                        //if the verts on the end on this side for this particular mid point is currently not within a list structure to
                        //be reduced in height then add it(since the final edge point will loop back to the original vert in the structure)
                        if (listPoints.Contains(currentRing[0]) == false)
                        {
                            listPoints.Add(currentRing[0]);
                        }
                    }

                    //For every vert on the current side that isnt on either end
                    for (int z = coastlineMidPoints[j] - 1; z <= coastlineMidPoints[j] + 1; z++)
                    {
                        //Find the height value which will lower this ring to create a smooth coastline
                        //by using the current ring in the structure and the overall height value
                        currentVert  = currentRing[z];
                        divideNumber = i - (hexVerts.NumberOfRings - 5);
                        height       = new Vector3(0, 0, ((heightDifference * divideNumber)));

                        //if the current ring isn't the most outer ring
                        if (i != hexVerts.NumberOfRings - 1)
                        {
                            //generate a random seed value
                            float Seed   = Random.Range(1.0f, 100f);
                            float xCoord = (float)(i / hexVerts.NumberOfRings) * scale * Seed;
                            float yCoord = (float)(z / coastlineMidPoints.Count) * scale * Seed;
                            //use the x and y co-ordinates to generate a noise value
                            float sample = Mathf.PerlinNoise(xCoord, yCoord);
                            //affect the height by mutliplying it with the noise value
                            height *= (sample);
                        }

                        vertices[currentVert] -= height;
                    }
                }

                //For every end point of the borders are to be affected
                for (int j = 0; j < listPoints.Count; j++)
                {
                    //Find the height value which will lower this ring to create a smooth coastline
                    //by using the current ring in the structure and the overall height value
                    currentVert            = listPoints[j];
                    divideNumber           = i - (hexVerts.NumberOfRings - 5);
                    height                 = new Vector3(0, 0, ((heightDifference * divideNumber)));
                    vertices[currentVert] -= height;
                }
            }
        }
        //Apply the height changes to the current mesh
        hexagonMesh.vertices = vertices;
        hexagonMesh.RecalculateBounds();
    }
Пример #5
0
    //creates hills on the hexagon mesh
    public void AddNoise(int width, int gridHeight, Vector2 currentPos, GameObject UI)
    {
        //retrieves the mesh filter component
        hexagonMesh = GetComponent <MeshFilter>().mesh;
        //sets up a list storing the points of each ring that act as the centre of the borders
        edgeMidPoints = new List <int> {
            2, 6, 10, 14, 18, 22
        };
        //retrieve all vertex points from the mesh
        vertices = hexagonMesh.vertices;
        //create a new hexagon structure for the mesh
        hexVerts = new HexClass();


        //retrieve a height value using perlin noise
        float xCoord = (float)(currentPos.x / width) * scale;
        float yCoord = (float)(currentPos.y / gridHeight) * scale;
        float sample = Mathf.PerlinNoise(xCoord, yCoord);

        //reduce the height value to make it more realistic
        sample = (sample / 3) * 2;
        //set a vector value to act as the centre points height
        Vector3 Peakheight = new Vector3(0, 0, (sample - landHeight));

        //half the heighvalue
        Peakheight /= 2;

        //value representing the amount of rings the hill will take up in the hill structure
        int ringMax = hexVerts.NumberOfRings - 5;
        //value representing how the height of every ring of the hill change in height
        float hillRatio = 0.8f;

        //update the UI's position so it doesn't get hidden by the hill
        UI.transform.position += (((new Vector3(0, (sample - landHeight), 0)) / ringMax) * (ringMax)) / 2;
        //update the peak vertex height to be the peak height
        vertices[hexVerts.peak] += (Peakheight / ringMax) * (ringMax * 0.85f);

        //for every ring the hill will alter
        for (int i = 0; i < hexVerts.NumberOfRings - 5; i++)
        {
            //retrieve every vertex in the current ring
            int[] currentRing = new int[24];
            currentRing = hexVerts.Hexagon[i];
            //calculate the current rings height value
            Vector3 ringHeight = (Peakheight / ringMax) * (ringMax - i);
            //affect the height value by multiplying it by the hill ratio
            ringHeight *= hillRatio;
            //increase the hill ratio tio increase the slope
            hillRatio += 0.1f;
            //for every vertex in the ring
            for (int j = 0; j < currentRing.Length; j++)
            {
                //retrieve the current vertex
                int currentVert = currentRing[j];
                //add the height value to the vertexes position
                vertices[currentVert] += ringHeight;
            }
        }

        //Apply the height changes to the current mesh
        hexagonMesh.vertices = vertices;
        hexagonMesh.RecalculateBounds();
    }