public TreeGenes(TreeGenes parent, float mutationRate = 0.1f)
 {
     color        = new Color(Mutation(mutationRate) ? Random.Range(0f, 1f) : parent.color.r, Mutation(mutationRate) ? Random.Range(0f, 1f) : parent.color.g, Mutation(mutationRate) ? Random.Range(0f, 1f) : parent.color.b, 1f);
     fruitColor   = new Color(Mutation(mutationRate) ? Random.Range(0f, 1f) : parent.fruitColor.r, Mutation(mutationRate) ? Random.Range(0f, 1f) : parent.fruitColor.g, Mutation(mutationRate) ? Random.Range(0f, 1f) : parent.fruitColor.b, 1f);
     branchLenght = Mutation(mutationRate) ? Random.Range(minBranchLenght, maxBranchLenght) : parent.branchLenght;
     maxBranch    = Mutation(mutationRate) ? Random.Range(2, 8) : parent.maxBranch;
 }
 void Init(TreeGenes genes)
 {
     this.genes = genes;
     cooldown   = new Cooldown(4f);
     sr         = GetComponent <SpriteRenderer>();
     sr.color   = genes.color;
     branches   = new LineRenderer[genes.maxBranch];
     for (int i = 0; i < branches.Length; i++)
     {
         GameObject go = new GameObject($"Branch {i}");
         branches[i]           = go.AddComponent <LineRenderer>();
         go.transform.position = transform.position;
         go.transform.parent   = transform;
         branches[i].material  = branchMaterial;
         Vector3[] positions = { transform.position, (Vector2)transform.position + MathOperations.AngleToVector(Random.Range(0, 360), genes.branchLenght) };
         branches[i].positionCount = 2;
         branches[i].SetPositions(positions);
         branches[i].startWidth     = 0.1f;
         branches[i].endWidth       = 0.1f;
         branches[i].startColor     = Color.Lerp(genes.color, genes.fruitColor, 0.5f);         //genes.color;
         branches[i].endColor       = Color.Lerp(genes.color, genes.fruitColor, 0.5f);
         branches[i].numCapVertices = 3;
     }
     GetSpawnPoints();
     maxGrow = genes.maxBranch;
 }
Example #3
0
        public static void GerminateTree(TreeGenes genes, Vector3 position, GameObject gameObject, GameObject fruitPrefab)
        {
            TreeBehavior newTree = gameObject.GetComponent <TreeBehavior>();

            newTree.fruitPrefab          = fruitPrefab;
            newTree.transform.position   = new Vector3(position.x, 0, position.z);
            newTree.transform.rotation   = Quaternion.Euler(Vector3.up * Random.Range(0, 360));
            newTree.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
            newTree.Start();

            newTree.growDropRatio  = genes.growDropRatio * GetDrift();
            newTree.lifespan       = (int)(genes.lifespan * GetDrift());
            newTree.fastGrowTime   = (int)(genes.fastGrowTime * GetDrift());
            newTree.mediumGrowTime = (int)(genes.mediumGrowTime * GetDrift());
            newTree.slowGrowTime   = (int)(genes.slowGrowTime * GetDrift());
            newTree.age            = 0;
        }
Example #4
0
    private void RandomPoop()
    {
        if (seedInPoop == null)
        {
            return;
        }

        if (Random.value < poopChance)
        {
            if (LocationUtil.IsInShade(transform.position))
            {
                return;
            }

            GameObject newGameObject = Instantiate(treePrefab, transform.position, transform.rotation);
            ReproductionUtil.GerminateTree(seedInPoop, transform.position, newGameObject, fruitPrefab);
            seedInPoop = null;
        }
    }
Example #5
0
    void OnTriggerEnter(Collider triggerCollider)
    {
        if (triggerCollider.gameObject.name.StartsWith("Fruit"))
        {
            var fruit = triggerCollider.gameObject.GetComponent <FruitBehavior>();
            seedInPoop = fruit.genes;

            if (fruit.genes == null)
            {
                energy          += energyPerFruit;
                energyFromFruit += energyPerFruit;
            }
            else
            {
                energy          += energyPerTreeFruit;
                energyFromFruit += energyPerTreeFruit;
            }

            Destroy(fruit.gameObject);
            Destroy(fruit);
            food = null;

            fruitEaten++;
            stats.numFruitEaten++;

            if (stats.recordFruitEaten < fruitEaten)
            {
                stats.recordFruitEaten = fruitEaten;
            }

            RememberThisPlace();
        }

        else if (triggerCollider.gameObject.name.StartsWith("Percepticon"))
        {
            var targetBlob = triggerCollider.gameObject.GetComponentInParent <BlobBehavior>();

            if (targetBlob == null || targetBlob.size < size / predationLimit)
            {
                var deltaEnergy = (int)(energyPerFruit * targetBlob.size);

                food             = null;
                energy          += deltaEnergy;
                energyFromBlobs += deltaEnergy;
                targetBlob.die   = true;
                blobsEaten++;
                stats.numBlobsEaten++;

                if (stats.recordBlobsEaten < blobsEaten)
                {
                    stats.recordBlobsEaten = blobsEaten;
                }

                RememberThisPlace();
                return;
            }

            if (targetBlob.Equals(rival))
            {
                int hurtRivalAmount = (int)(size * size * size * currentSpeed * currentSpeed * aggression * 100);
                int hurtSelfAmount  = hurtRivalAmount / 2;
                int hurtFromRival   = (int)(rival.size * rival.size * rival.size * rival.currentSpeed * rival.currentSpeed * rival.aggression * 100);
                int hurtRivalSelf   = hurtFromRival / 2;
                int totalSelfHurt   = hurtSelfAmount + hurtFromRival;
                int totalRivalHurt  = hurtRivalAmount + hurtRivalSelf;

                if (totalSelfHurt > energy && totalRivalHurt > rival.energy)
                {
                    if (energy > rival.energy)
                    {
                        energy      -= rival.energy;
                        rival.energy = 0;
                    }
                    else
                    {
                        rival.energy -= energy;
                        energy        = 0;
                    }
                }
                else
                {
                    energy       -= totalSelfHurt;
                    rival.energy -= totalRivalHurt;
                }


                if (hurtRivalAmount > hurtFromRival && rival.partner != null && partner == null)
                {
                    rival.partner.partner = this;
                    partner       = rival.partner;
                    rival.partner = null;
                }

                else if (hurtRivalAmount < hurtFromRival && rival.partner == null && partner != null)
                {
                    partner.partner = rival;
                    rival.partner   = partner;
                    partner         = null;
                }

                if (rival.energy <= 0)
                {
                    rival = null;
                }
                else if (energy > 0)
                {
                    // make them flee each other after the encounter
                    predator = rival;
                    transform.Rotate(0f, 180f, 0f);
                    rival.predator = this;

                    rival.rival = null;
                    rival       = null;
                }
            }

            if (targetBlob.Equals(partner) && status.Equals(BlobStatusType.Providing) && energy > reserveEnergy)
            {
                var energyToProvide = Math.Abs(reserveEnergy - energy);
                energy         -= energyToProvide;
                partner.energy += energyToProvide;
            }
        }

        //else if (triggerCollider.gameObject.name.StartsWith("Tree"))
        //{
        //    var targetTree = triggerCollider.gameObject.GetComponentInParent<TreeBehavior>();

        //    if (targetTree.transform.localScale.x < size)
        //    {
        //        Destroy(targetTree.gameObject);
        //        Destroy(targetTree);
        //    }
        //}
    }