Example #1
0
 public ResourceItem(Resource key, Rect value)
 {
     this.key = key;
     this.value = value;
 }
Example #2
0
 /// <summary>
 /// Adds a resource to the resource array.
 /// </summary>
 /// <param name="r">Resource to add</param>
 /// <remarks>
 /// This method should only be used before world generation as it will 
 /// not have an effect unless you re-check for resources on each hex.
 /// </remarks>
 public void AddResource(Resource r)
 {
     resources.Add(r);
     internalResources = resources.ToArray();
     UpdateResourceNames();
 }
Example #3
0
 /// <summary>
 /// Removes a resource from the resource array.
 /// </summary>
 /// <param name="r">Resource to remove</param>
 /// <remarks>
 /// Removing a resource that is referenced elsewhere will cause null reference errors. Only use this
 /// method if you are personally managing the specific resources memory lifetime.
 /// </remarks>
 public void DeleteResource(Resource r)
 {
     resources.Remove(r);
     internalResources = resources.ToArray();
     UpdateResourceNames();
 }
Example #4
0
        /// <summary>
        /// Spawns the provided resource on the tile.
        /// Optional to regenerate the chunk.
        /// </summary>
        /// <remarks>
        /// This can be used to force a resource to spawn, even if against it's rules.
        /// </remarks>
        /// <param name="hex">Hex to spawn the resource on</param>
        /// <param name="r">Resource to spawn</param>
        /// <param name="regenerateChunk">If the parent chunk should be regenerated</param>
        public void SpawnResource(Hex hex, Resource r, bool regenerateChunk)
        {
            //reset resource locations
            hex.resourceLocations.Clear();
            
            //destroy previous resource objects
            if (hex.rObject != null)
            {
                Destroy(hex.rObject);
            }

            //if the resource has a mesh to spawn
            if (r.meshToSpawn != null)
            {
                //calculate y position to spawn the resources
                float y;
                if (hex.localMesh == null)
                {
                    y = (worldManager.hexExt.y); if (y == 0) { y -= ((hex.worldPosition.y + worldManager.hexExt.y) / Random.Range(4, 8)); } else { y = hex.worldPosition.y + worldManager.hexExt.y + hex.currentResource.meshToSpawn.bounds.extents.y; }
                }
                else
                {
                    y = (hex.localMesh.bounds.extents.y); if (y == 0) { y -= ((hex.worldPosition.y + hex.localMesh.bounds.extents.y) / Random.Range(4, 8)); } else { y = hex.worldPosition.y + hex.localMesh.bounds.extents.y + hex.currentResource.meshToSpawn.bounds.extents.y; }
                }

                //spawn a resource for each spawn amount
                for (int i = 0; i < r.meshSpawnAmount; i++)
                {
                    //position setting
                    float x = (worldManager.hexCenter.x + Random.Range(-0.2f, 0.2f));
                    float z = (worldManager.hexCenter.z + Random.Range(-0.2f, 0.2f));
                    hex.resourceLocations.Add(new Vector3(x, y, z));
                }

                //number of resources
                int size = hex.resourceLocations.Count;

                //number of resources to combine
                if (size > 0)
                {
                    //combine instances
                    CombineInstance[] combine = new CombineInstance[size];
                    Matrix4x4 matrix = new Matrix4x4();
                    matrix.SetTRS(Vector3.zero, Quaternion.identity, Vector3.one);

                    //skip first combine instance due to presetting
                    for (int k = 0; k < size; k++)
                    {
                        combine[k].mesh = hex.currentResource.meshToSpawn;
                        matrix.SetTRS(hex.resourceLocations[k], Quaternion.identity, Vector3.one);
                        combine[k].transform = matrix;
                    }

                    //create gameobject to hold the resource meshes 
                    GameObject holder = new GameObject(r.name + " at " + hex.AxialCoordinates, typeof(MeshFilter), typeof(MeshRenderer));

                    //set the gameobject position to the hex position
                    holder.transform.position = hex.worldPosition;
                    holder.transform.parent = hex.parentChunk.transform;

                    //set the resource mesh texture
                    holder.renderer.material.mainTexture = r.meshTexture;

                    //assign the combined mesh to the resource holder gameobject
                    MeshFilter filter = holder.GetComponent<MeshFilter>();
                    filter.mesh = new Mesh();
                    filter.mesh.CombineMeshes(combine);

                    //set the hex's resource object to the resource holder
                    hex.rObject = holder;

                    //UV mapping
                    Rect rectArea;
                    worldManager.textureAtlas.resourceLocations.TryGetValue(r, out rectArea);

                    //temp UV data
                    Vector2[] uv;
                    uv = new Vector2[filter.mesh.vertexCount];

                    //calculate the combined UV data
                    for (int i = 0; i < filter.mesh.vertexCount; i++)
                    {
                        uv[i] = new Vector2(filter.mesh.uv[i].x * rectArea.width + rectArea.x, filter.mesh.uv[i].y * rectArea.height + rectArea.y);
                    }

                    //assign the resource holder's UV data
                    filter.mesh.uv = uv;
                }
            }

            //if needed; regenerate the chunk and it's UV data
            if (regenerateChunk)
            {
                hex.ChangeTextureToResource();
                hex.parentChunk.RegenerateMesh();
            }
        }
Example #5
0
 /// <summary>
 /// Adds a resource to the resource array at the provided index.
 /// </summary>
 /// <param name="r">Resource to add</param>
 /// <param name="index">Index in which to add the resource</param>
 /// <remarks>
 /// This method should only be used before world generation as it will 
 /// not have an effect unless you re-check for resources on each hex.
 /// </remarks>
 public void AddResourceAtIndex(Resource r, int index)
 {
     resources.Insert(index, r);
     internalResources = resources.ToArray();
     UpdateResourceNames();
 }