public static VeggieObject growPlant(VeggieObject thisVeggie)
    {
        if (thisVeggie != null)
        {
            float lightAff = CommonGameObjects.veggieProperties [thisVeggie.plantID, 6];
            float waterAff = CommonGameObjects.veggieProperties [thisVeggie.plantID, 4];
            //float soilAff = CommonGameObjects.veggieProperties [thisVeggie.plantID, 5];
            float affFactor = Mathf.Min(thisVeggie.lightEnergy / lightAff, thisVeggie.waterEnergy / waterAff);
            //float affFactor = Mathf.Min(thisVeggie.lightEnergy/lightAff,thisVeggie.waterEnergy/waterAff, thisVeggie.soilEnergy/soilAff);

            float totalEnergy = affFactor * lightAff + affFactor * waterAff;
            //float totalEnergy = affFactor*lightAff + affFactor*waterAff+ affFactor*soilAff;

            thisVeggie.bioMass += totalEnergy;

            float usingEnegry = thisVeggie.bioMass * CommonGameObjects.veggieProperties [thisVeggie.plantID, 12];
            thisVeggie.bioMass = Mathf.Clamp(thisVeggie.bioMass - usingEnegry, 0, 500);

            thisVeggie.lightEnergy = 0;
            thisVeggie.waterEnergy = 0;
            //thisVeggie.soilEnergy = 0;

            if (thisVeggie.bioMass < bioMassMinimum)
            {
                thisVeggie = null;
            }
        }
        return(thisVeggie);
    }
Пример #2
0
    public static VeggieObject assignVeggieProps(int idNum, int zone, Vector3 pos)
    {
        int   theIDNum = idNum + zone * 5;
        float isPlaced = (float)rand.NextDouble();

        if (isPlaced < veggieProperties[theIDNum, 11])
        {
            VeggieObject thisVeggie = new VeggieObject();
            thisVeggie.plantID = theIDNum;
            int yRot = rand.Next(0, 360);
            thisVeggie.rot     = Quaternion.Euler(new Vector3(0, yRot, 0));
            thisVeggie.zoneNum = zone;
            thisVeggie.bioMass = 1f;
            thisVeggie.pos     = pos;
            return(thisVeggie);
        }
        else
        {
            return(null);
        }
    }
    public static IEnumerator createVeggieMap2()
    {
        Debug.Log("Creating Veggiemap!");
        yield return(new WaitForSeconds(0.01f));

        bool  fin = true;
        float sT  = Time.realtimeSinceStartup;

        VeggieObject[][]        vm1;
        int[][]                 zm;
        float[][]               wm;//, soilMap;
        List <VeggieObject>[][] aboveGroundComp;
        List <VeggieObject>[][] belowGroundComp;

        lock (GameManager.tSets)
        {
            vm1 = (VeggieObject[][])GameManager.tSets.globalVeggieMap.Clone();
            zm  = (int[][])GameManager.tSets.globalZoneMap.Clone();
            wm  = (float[][])GameManager.tSets.globalWaterMap.Clone();
        }

        VeggieObject[][] seedMap = new VeggieObject[vm1.Length][];
        //soilMap = new float[vm1.Length][];
        for (int i = 0; i < vm1.Length; i++)
        {
            seedMap [i] = new VeggieObject[vm1 [i].Length];
            //soilMap [i] = new float[vm1 [i].Length];
        }

        aboveGroundComp = new List <VeggieObject> [vm1.Length][];
        belowGroundComp = new List <VeggieObject> [vm1.Length][];

        for (int i = 0; i < vm1.Length; i++)
        {
            aboveGroundComp [i] = new List <VeggieObject> [vm1[i].Length];
            for (int j = 0; j < aboveGroundComp [i].Length; j++)
            {
                aboveGroundComp [i] [j] = new List <VeggieObject> ();
            }

            belowGroundComp [i] = new List <VeggieObject> [vm1[i].Length];
            for (int j = 0; j < belowGroundComp [i].Length; j++)
            {
                belowGroundComp [i] [j] = new List <VeggieObject> ();
            }
        }

        lock (GameManager.lSets)
        {
            GameManager.lSets.totalToFill += vm1.Length * vm1.Length * (ageOfWorld * 3 + 1);
        }

        yield return(new WaitForSeconds(1f));

        CustomThreadPool.Instance.QueueUserTask(() =>
        {
            System.Random rand = new System.Random();

            Debug.Log("Veggiemap " + vm1.Length + "x" + vm1.Length + " started");
            for (int x = 0; x < vm1.Length; x++)
            {
                for (int z = 0; z < vm1[x].Length; z++)
                {
                    Vector3 zoneIndex = GameManager.gamemapToGamemap(new Vector3(x, 0, z), 6, 2);
                    int zoneNum       = zm[(int)zoneIndex.x][(int)zoneIndex.z];

                    seedMap[x][z] = CommonGameObjects.assignVeggieProps(rand.Next(0, 5), zoneNum, GameManager.gamemapToWorld(new Vector3(x, 0, z), 6));
                    //soilMap[x][z] =  (float)rand.NextDouble();
                }

                lock (GameManager.lSets)
                {
                    GameManager.lSets.totalFilled += vm1.Length;
                }
                Thread.Sleep(0);
            }

            for (int a = 0; a < ageOfWorld; a++)
            {
                for (int x = 0; x < vm1.Length; x++)
                {
                    for (int z = 0; z < vm1[x].Length; z++)
                    {
                        VeggieObject currentV = seedMap[x][z];
                        if (currentV != null)
                        {
                            float bioM      = currentV.bioMass;
                            float convConst = (1 / CommonGameObjects.veggieProperties [currentV.plantID, 0]) / (1 / CommonGameObjects.veggieProperties [currentV.plantID, 2]);
                            float roi       = Mathf.Pow(6 * bioM / Mathf.PI / convConst, 1f / 3f) / 2;
                            float aboveRoI  = CommonGameObjects.veggieProperties [currentV.plantID, 13] * roi;
                            float belowRoI  = CommonGameObjects.veggieProperties [currentV.plantID, 14] * roi;
                            currentV.width  = roi * 2;

                            float thisHeight = Mathf.Pow(6 * currentV.bioMass / Mathf.PI / Mathf.Pow(1 / convConst, 2), 1f / 3f);
                            currentV.height  = thisHeight;

                            int smallerAI = (int)Mathf.Min(x, Mathf.Ceil(aboveRoI));
                            int smallerAJ = (int)Mathf.Min(z, Mathf.Ceil(aboveRoI));
                            int largerAI  = (int)Mathf.Min(vm1.Length - x - 1, Mathf.Ceil(aboveRoI));
                            int largerAJ  = (int)Mathf.Min(vm1.Length - z - 1, Mathf.Ceil(aboveRoI));

                            int smallerBI = (int)Mathf.Min(x, Mathf.Ceil(belowRoI));
                            int smallerBJ = (int)Mathf.Min(z, Mathf.Ceil(belowRoI));
                            int largerBI  = (int)Mathf.Min(vm1.Length - x - 1, Mathf.Ceil(belowRoI));
                            int largerBJ  = (int)Mathf.Min(vm1.Length - z - 1, Mathf.Ceil(belowRoI));

                            for (int i = -smallerAI; i <= largerAI; i++)
                            {
                                for (int j = -smallerAJ; j <= largerAJ; j++)
                                {
                                    float dist = calcPlantDistance(x, z, x + i, z + j);
                                    if (dist <= aboveRoI)
                                    {
                                        aboveGroundComp[x + i][z + j].Add(currentV);
                                    }
                                }
                            }

                            for (int i = -smallerBI; i <= largerBI; i++)
                            {
                                for (int j = -smallerBJ; j <= largerBJ; j++)
                                {
                                    float dist = calcPlantDistance(x, z, x + i, z + j);
                                    if (dist <= belowRoI)
                                    {
                                        belowGroundComp[x + i][z + j].Add(currentV);
                                    }
                                }
                            }
                        }
                    }

                    lock (GameManager.lSets)
                    {
                        GameManager.lSets.totalFilled += vm1.Length;
                    }
                    Thread.Sleep(0);
                }

                for (int x = 0; x < vm1.Length; x++)
                {
                    for (int z = 0; z < vm1[x].Length; z++)
                    {
                        float totalSoilComp  = 0;
                        float totalWaterComp = 0;
                        float totalLightComp = 0;

                        foreach (VeggieObject vO in aboveGroundComp[x][z])
                        {
                            totalLightComp += Mathf.Pow(vO.height + 1, 6);
                        }

                        foreach (VeggieObject vO in belowGroundComp[x][z])
                        {
                            totalWaterComp += CommonGameObjects.veggieProperties[vO.plantID, 4];
                            totalSoilComp  += CommonGameObjects.veggieProperties[vO.plantID, 5];
                        }

                        foreach (VeggieObject vO in aboveGroundComp[x][z])
                        {
                            float thisLightComp  = Mathf.Pow(vO.height + 1, 6);
                            float lightForGrowth = thisLightComp / totalLightComp;

                            Vector3 compIndex = GameManager.worldToGamemap(vO.pos, 6);
                            float distance    = calcPlantDistance(x, z, (int)compIndex.x, (int)compIndex.z);

                            vO.lightEnergy += lightForGrowth * resourceEfficiencyFromDistance(distance, vO.plantID, true);
                        }

                        foreach (VeggieObject vO in belowGroundComp[x][z])
                        {
                            float thisWaterComp  = CommonGameObjects.veggieProperties[vO.plantID, 4];
                            float waterForGrowth = thisWaterComp / totalWaterComp * wm[x][z];
                            //float thisSoilComp = CommonGameObjects.veggieProperties[vO.plantID,5];
                            //float soilForGrowth = thisSoilComp/totalSoilComp*soilMap[x][z];

                            Vector3 compIndex = GameManager.worldToGamemap(vO.pos, 6);
                            float distance    = calcPlantDistance(x, z, (int)compIndex.x, (int)compIndex.z);

                            //vO.bioMass += (waterForGrowth+soilForGrowth)*resourceEfficiencyFromDistance(distance,vO.plantID,false);
                            vO.waterEnergy += (waterForGrowth) * resourceEfficiencyFromDistance(distance, vO.plantID, false);
                        }
                    }

                    lock (GameManager.lSets)
                    {
                        GameManager.lSets.totalFilled += vm1.Length;
                    }
                    Thread.Sleep(0);
                }

                for (int x = 0; x < vm1.Length; x++)
                {
                    for (int z = 0; z < vm1[x].Length; z++)
                    {
                        seedMap[x][z] = growPlant(seedMap[x][z]);
                    }
                    lock (GameManager.lSets)
                    {
                        GameManager.lSets.totalFilled += vm1.Length;
                    }
                    Thread.Sleep(0);
                }
            }
        },
                                                (ts) =>
        {
            fin = false;
        });

        while (fin)
        {
            yield return(new WaitForSeconds(0.5f));
        }

        lock (GameManager.tSets)
        {
            GameManager.tSets.globalVeggieMap = (VeggieObject[][])seedMap.Clone();
            GameManager.tSets.isVeggieSet     = true;
            float eT = Mathf.Round(100f * (Time.realtimeSinceStartup - sT)) / 100f;
            Debug.Log("Veggiemap finished after " + eT + " seconds");
        }
    }