コード例 #1
0
    public IEnumerator SinkPhase()
    {
        // rotting or sink phase includes time before unit is destroyed: for example to perform rotting animation or sink object into the ground

        float timeBeg;
        float timeEnd;

        float twaiter;

        while (true)
        {
            timeBeg = Time.realtimeSinceStartup;
            twaiter = 0.0f;

            // checking in sinks array, which is already different from main units array

            for (int i = 0; i < sinks.Count; i++)
            {
                GameObject   sink     = sinks[i];
                DoV_LandUnit sinkPars = sink.GetComponent <DoV_LandUnit>();

                if (sinkPars.isSinking == true)
                {
                    if (sinkPars.changeMaterial)
                    {
                        sink.GetComponent <Renderer>().material.color = new Color((148.0f / 255.0f), (0.0f / 255.0f), (211.0f / 255.0f), 1.0f);
                    }

                    // moving sinking object down into the ground
                    if (sink.transform.position.y > -1.0f)
                    {
                        sink.transform.Translate(0, -0.1f, 0, Space.World);
                    }

                    // destroy object if it has sinked enough
                    else if (sink.transform.position.y < -1.0f)
                    {
                        sinks.Remove(sink);
                        Destroy(sink.gameObject);
                    }
                }
            }

            // main coroutine wait statement and performance information collection from sink coroutine
            twaiter = twaiter + 1.0f;
            yield return(new WaitForSeconds(1.0f));

            timeEnd = Time.realtimeSinceStartup;

            timeloops[6] = timeEnd - timeBeg - twaiter;
            timeall[6]   = timeEnd - timeBeg;

            performance[6] = (timeEnd - timeBeg - twaiter) * 100.0f / (timeEnd - timeBeg);

            message6 = ("Sink: " + (sinks.Count).ToString() + "; " + (timeEnd - timeBeg - twaiter).ToString() + "; " + (performance[6]).ToString() + "% ");
        }
    }
コード例 #2
0
    public IEnumerator BoolChecker()
    {
        // additional conditions check to set bool values

        while (true)
        {
            int maxatt = 0;

            for (int i = 0; i < unitss.Count; i++)
            {
                GameObject   obj     = unitss[i];
                DoV_LandUnit objPars = obj.GetComponent <DoV_LandUnit>();
                // Atackable modifications
                if (objPars.noAttackers > maxatt)
                {
                    maxatt = objPars.noAttackers;
                }

                if ((objPars.isAttackable == true) &&
                    (objPars.noAttackers > objPars.maxAttackers))
                {
                    objPars.isAttackable = false;
                }
                else if ((objPars.isAttackable == false) &&
                         (objPars.noAttackers < objPars.maxAttackers))
                {
                    objPars.isAttackable = true;
                }
            }

            // total performance calculation from Battle System

            timeloops[0] = timeloops[1] + timeloops[2] + timeloops[3] + timeloops[4] + timeloops[5] + timeloops[6];
            timeall[0]   = timeall[1] + timeall[2] + timeall[3] + timeall[4] + timeall[5] + timeall[6];



            performance[0] = (performance[1] +
                              performance[2] +
                              performance[3] +
                              performance[4] +
                              performance[5] +
                              performance[6]) / 6.0f;



            message = ("BSystem: " + (unitss.Count).ToString() + "; "
                       //      + (timeEnd-timeBeg-twaiter).ToString() + "; "
                       + (timeloops[0]).ToString() + "; "
                       + (timeall[0]).ToString() + "; "
                       + (performance[0]).ToString() + "% ");

            yield return(new WaitForSeconds(0.5f));
        }
    }
コード例 #3
0
    public void ResetSearching(GameObject go)
    {
        DoV_LandUnit goPars = go.GetComponent <DoV_LandUnit>();

        goPars.isApproaching = false;
        goPars.isAttacking   = false;
        goPars.target        = null;

        go.GetComponent <UnityEngine.AI.NavMeshAgent>().SetDestination(go.transform.position);

        if (goPars.changeMaterial)
        {
            go.GetComponent <Renderer>().material.color = Color.yellow;
        }

        goPars.isReady = true;
    }
コード例 #4
0
    public IEnumerator DeathPhase()
    {
        // Death phase unset all unit activity and prepare to die

        float timeBeg;
        float timeEnd;

        float twaiter;


        while (true)
        {
            timeBeg = Time.realtimeSinceStartup;

            int noDeads = 0;
            twaiter = 0.0f;

            // Getting dying units

            for (int i = 0; i < unitss.Count; i++)
            {
                GameObject   dead     = unitss[i];
                DoV_LandUnit deadPars = dead.GetComponent <DoV_LandUnit>();

                if (deadPars.isDying == true)
                {
                    // If unit is dead long enough, prepare for rotting (sinking) phase and removing from the unitss list

                    if (deadPars.deathCalls > deadPars.maxDeathCalls)
                    {
                        deadPars.isDying   = false;
                        deadPars.isSinking = true;

                        dead.GetComponent <UnityEngine.AI.NavMeshAgent>().enabled = false;
                        sinks.Add(dead);
                        unitss.Remove(dead);
                        int alliance = deadPars.alliance;
                        runits[alliance].Remove(dead);
                        rfunits[alliance].Remove(dead);
                    }

                    // unsetting unit activity and keep it dying
                    else
                    {
                        deadPars.isMovable      = false;
                        deadPars.isReady        = false;
                        deadPars.isApproaching  = false;
                        deadPars.isAttacking    = false;
                        deadPars.isApproachable = false;
                        deadPars.isAttackable   = false;
                        deadPars.isHealing      = false;
                        deadPars.target         = null;

                        // unselecting deads
                        dead.SendMessage("OnUnselected", SendMessageOptions.DontRequireReceiver);
                        dead.transform.gameObject.tag = "Untagged";

                        // unsetting attackers

                        /*		GameObject attTemp;
                         *      for(int j=0;j<deadPars.attackers.Count;j++){
                         *
                         *          attTemp = deadPars.attackers[j];
                         *          DoV_LandUnit attTempPars = attTemp.GetComponent<DoV_LandUnit>();
                         *
                         *          if((attTempPars.isDying == false)&&(attTempPars.isSinking == false)){
                         *              attTemp.GetComponent<NavMeshAgent>().SetDestination(attTemp.transform.position);
                         *              attTempPars.isReady = true;
                         *              attTempPars.isApproaching = false;
                         *              attTempPars.isAttacking = false;
                         *          }
                         *      }
                         *      deadPars.attackers.Clear();
                         */
                        dead.GetComponent <UnityEngine.AI.NavMeshAgent>().SetDestination(dead.transform.position);
                        deadPars.deathCalls = deadPars.deathCalls + 1;

                        if (deadPars.changeMaterial)
                        {
                            dead.GetComponent <Renderer>().material.color = Color.blue;
                        }
                        noDeads = noDeads + 1;
                    }
                }
            }

            // main coroutine wait statement and performance information collection from death coroutine

            twaiter = twaiter + 1.0f;
            yield return(new WaitForSeconds(1.0f));

            timeEnd = Time.realtimeSinceStartup;

            timeloops[5] = timeEnd - timeBeg - twaiter;
            timeall[5]   = timeEnd - timeBeg;

            performance[5] = (timeEnd - timeBeg - twaiter) * 100.0f / (timeEnd - timeBeg);

            message5 = ("Dead: " + (noDeads).ToString() + "; " + (timeEnd - timeBeg - twaiter).ToString() + "; " + (performance[5]).ToString() + "; ");
        }
    }
コード例 #5
0
    public IEnumerator SelfHealingPhase()
    {
        // Self-Healing phase heals damaged units over time

        float timeBeg;
        float timeEnd;

        float twaiter;

        while (true)
        {
            timeBeg = Time.realtimeSinceStartup;

            int noSelfHealers = 0;
            twaiter = 0.0f;


            // checking which units are damaged

            for (int i = 0; i < unitss.Count; i++)
            {
                GameObject   sheal     = unitss[i];
                DoV_LandUnit shealPars = sheal.GetComponent <DoV_LandUnit>();

                if (shealPars.health < shealPars.maxHealth)
                {
                    // if unit has less health than 0, preparing it to die

                    if (shealPars.health < 0.0f)
                    {
                        shealPars.isHealing = false;
                        shealPars.isImmune  = true;
                        shealPars.isDying   = true;
                    }

                    // healing unit
                    else
                    {
                        shealPars.isHealing = true;
                        shealPars.health    = shealPars.health + shealPars.selfHealFactor;
                        noSelfHealers       = noSelfHealers + 1;

                        // if unit health reaches maximum, unset self-healing

                        if (shealPars.health >= shealPars.maxHealth)
                        {
                            shealPars.health    = shealPars.maxHealth;
                            shealPars.isHealing = false;
                            noSelfHealers       = noSelfHealers - 1;
                        }
                    }
                }
            }

            // main coroutine wait statement and performance information collection from self-healing coroutine

            twaiter = twaiter + 3.0f;

            yield return(new WaitForSeconds(3.0f));

            timeEnd = Time.realtimeSinceStartup;

            timeloops[4] = timeEnd - timeBeg - twaiter;
            timeall[4]   = timeEnd - timeBeg;

            performance[4] = (timeEnd - timeBeg - twaiter) * 100.0f / (timeEnd - timeBeg);

            message4 = ("SelfHealing: " + (noSelfHealers).ToString() + "; " + (timeEnd - timeBeg - twaiter).ToString() + "; " + (performance[4]).ToString() + "% ");
        }
    }
コード例 #6
0
    public IEnumerator AttackPhase()
    {
        // Attacking phase set attackers to attack their targets and cause damage when they already approached their targets

        float timeBeg;
        float timeEnd;


        float twaiter;

        float ax;
        float ay;
        float az;

        float tx;
        float ty;
        float tz;

        float Rtarget;

        float stopDist = 2.5f;
        float stoppDistance;



        float tempRand = 0.0f;

        float tempStrength = 1.0f;
        float tempDefence  = 1.0f;

        while (true)
        {
            timeBeg = Time.realtimeSinceStartup;

            twaiter = 0.0f;



            int noAttackers = 0;



            // checking through main unitss array which units are set to approach (isAttacking)

            for (int i = 0; i < unitss.Count; i++)
            {
                GameObject   att     = unitss[i];
                DoV_LandUnit attPars = att.GetComponent <DoV_LandUnit>();

                if (attPars.isAttacking)
                {
                    GameObject   targ     = attPars.target;
                    DoV_LandUnit targPars = targ.GetComponent <DoV_LandUnit>();

                    ax = att.transform.position.x;
                    ay = att.transform.position.y;
                    az = att.transform.position.z;

                    tx = targ.transform.position.x;
                    ty = targ.transform.position.y;
                    tz = targ.transform.position.z;

                    UnityEngine.AI.NavMeshAgent attNav  = att.GetComponent <UnityEngine.AI.NavMeshAgent>();
                    UnityEngine.AI.NavMeshAgent targNav = targ.GetComponent <UnityEngine.AI.NavMeshAgent>();

                    attNav.stoppingDistance = attNav.radius / (att.transform.localScale.x) + targNav.radius / (targ.transform.localScale.x);

                    // distance between attacker and target

                    Rtarget       = Mathf.Sqrt((tx - ax) * (tx - ax) + (ty - ay) * (ty - ay) + (tz - az) * (tz - az));
                    stoppDistance = (stopDist + att.transform.localScale.x * targ.transform.localScale.x * attNav.stoppingDistance);


                    // if target moves away, resetting back to approach target phase

                    if (Rtarget > stoppDistance)
                    {
                        attPars.isApproaching = true;
                        attPars.isAttacking   = false;
                    }

                    // if targets becomes immune, attacker is reset to start searching for new target
                    else if (targPars.isImmune == true)
                    {
                        attPars.isAttacking = false;
                        attPars.isReady     = true;


                        targPars.attackers.Remove(att);
                        targPars.noAttackers = targPars.noAttackers - 1;

                        if (attPars.changeMaterial)
                        {
                            att.GetComponent <Renderer>().material.color = Color.yellow;
                        }
                    }

                    // attacker starts attacking their target
                    else
                    {
                        noAttackers = noAttackers + 1;

                        if (attPars.changeMaterial)
                        {
                            att.GetComponent <Renderer>().material.color = Color.red;
                        }
                        tempRand = UnityEngine.Random.value;

                        tempStrength = attPars.strength;
                        tempDefence  = attPars.defence;

                        // if attack passes target through target defence, cause damage to target

                        if (tempRand > (tempStrength / (tempStrength + tempDefence)))
                        {
                            targPars.health = targPars.health - 2.0f * tempStrength * UnityEngine.Random.value;
                        }
                    }
                }
            }



            // main coroutine wait statement and performance information collection from attack coroutine

            twaiter = twaiter + 1.5f;

            yield return(new WaitForSeconds(1.5f));

            timeEnd = Time.realtimeSinceStartup;


            timeloops[3] = timeEnd - timeBeg - twaiter;
            timeall[3]   = timeEnd - timeBeg;

            performance[3] = (timeEnd - timeBeg - twaiter) * 100.0f / (timeEnd - timeBeg);

            message3 = ("Attacker: " + (noAttackers).ToString() + "; " + (timeEnd - timeBeg - twaiter).ToString() + "; " + (performance[3]).ToString() + "% ");
        }
    }
コード例 #7
0
    public IEnumerator ApproachTargetPhase()
    {
        // this phase starting attackers to move towards their targets

        float timeBeg;
        float timeEnd;
        float t3;
        float twaiter;

        float ax;
        float ay;
        float az;

        float tx;
        float ty;
        float tz;

        float Rtarget;

        float stopDist = 2.0f;
        float stoppDistance;



        while (true)
        {
            timeBeg = Time.realtimeSinceStartup;


            int noApproachers = 0;
            int ii            = 0;



            t3      = Time.realtimeSinceStartup;
            twaiter = 0.0f;

            // checking through main unitss array which units are set to approach (isApproaching)

            for (int i = 0; i < unitss.Count; i++)
            {
                GameObject   appr     = unitss[i];
                DoV_LandUnit apprPars = appr.GetComponent <DoV_LandUnit>();
                ii = ii + 1;

                if (apprPars.isApproaching)
                {
                    GameObject targ = apprPars.target;

                    UnityEngine.AI.NavMeshAgent apprNav = appr.GetComponent <UnityEngine.AI.NavMeshAgent>();
                    UnityEngine.AI.NavMeshAgent targNav = targ.GetComponent <UnityEngine.AI.NavMeshAgent>();

                    if (targ.GetComponent <DoV_LandUnit>().isApproachable == true)
                    {
                        ax = appr.transform.position.x;
                        ay = appr.transform.position.y;
                        az = appr.transform.position.z;

                        tx = targ.transform.position.x;
                        ty = targ.transform.position.y;
                        tz = targ.transform.position.z;


                        // stopping condition for NavMesh

                        apprNav.stoppingDistance = apprNav.radius / (appr.transform.localScale.x) + targNav.radius / (targ.transform.localScale.x);

                        // distance between approacher and target

                        Rtarget = Mathf.Sqrt((tx - ax) * (tx - ax) + (ty - ay) * (ty - ay) + (tz - az) * (tz - az));



                        stoppDistance = (stopDist + appr.transform.localScale.x * targ.transform.localScale.x * apprNav.stoppingDistance);

                        // counting increased distances (failure to approach) between attacker and target;
                        // if counter failedR becomes bigger than critFailedR, preparing for new target search.

                        if (apprPars.prevR < Rtarget)
                        {
                            apprPars.failedR = apprPars.failedR + 1;
                            if (apprPars.failedR > apprPars.critFailedR)
                            {
                                apprPars.isApproaching = false;
                                apprPars.isReady       = true;
                                apprPars.failedR       = 0;

                                if (apprPars.changeMaterial)
                                {
                                    appr.GetComponent <Renderer>().material.color = Color.yellow;
                                }
                            }
                        }

                        else
                        {
                            // if approachers already close to their targets
                            if (Rtarget < stoppDistance)
                            {
                                apprNav.SetDestination(appr.transform.position);

                                // pre-setting for attacking

                                apprPars.isApproaching = false;
                                apprPars.isAttacking   = true;
                            }
                            else
                            {
                                if (apprPars.changeMaterial)
                                {
                                    appr.GetComponent <Renderer>().material.color = Color.green;
                                }


                                // starting to move

                                if (apprPars.isMovable)
                                {
                                    noApproachers = noApproachers + 1;
                                    apprNav.SetDestination(targ.transform.position);
                                    apprNav.speed = 3.5f;
                                }

                                // performance waiter for long approacher lists
                                if (ii > 1500)
                                {
                                    if (Time.realtimeSinceStartup - t3 > 0.005f)
                                    {
                                        twaiter = twaiter + 0.1f * (Time.realtimeSinceStartup - t3) + 0.05f;
                                        yield return(new WaitForSeconds(0.1f * (Time.realtimeSinceStartup - t3) + 0.05f));

                                        t3 = Time.realtimeSinceStartup;
                                        ii = 0;
                                    }
                                }
                            }
                        }
                        // saving previous R
                        apprPars.prevR = Rtarget;
                    }

                    // condition for non approachable targets
                    else
                    {
                        apprPars.target = null;
                        apprNav.SetDestination(appr.transform.position);



                        apprPars.isApproaching = false;
                        apprPars.isReady       = true;

                        if (apprPars.changeMaterial)
                        {
                            appr.GetComponent <Renderer>().material.color = Color.yellow;
                        }
                    }
                }
            }



            // main coroutine wait statement and performance information collection from approach coroutine

            timeEnd = Time.realtimeSinceStartup;



            twaiter = twaiter + 1.0f * (timeEnd - timeBeg) + 1.0f;
            yield return(new WaitForSeconds(1.0f * (timeEnd - timeBeg) + 1.0f));

            float curTime = Time.realtimeSinceStartup;

            timeloops[2] = curTime - timeBeg - twaiter;
            timeall[2]   = curTime - timeBeg;

            performance[2] = (curTime - timeBeg - twaiter) * 100.0f / (curTime - timeBeg);

            message2 = ("Approacher: " + (noApproachers).ToString() + "; " + (curTime - timeBeg - twaiter).ToString() + "; " + (performance[2]).ToString() + "% ");
        }
    }