Question

I have 3 Classes.

One is a Global class that has my function:

public static function getDistance(ObjOne, ObjTwo)
{
    var distance = Math.sqrt( ( ObjOne.x - ObjTwo.x ) * ( ObjOne.x - ObjTwo.x ) + ( ObjOne.y - ObjTwo.y ) * ( ObjOne.y - ObjTwo.y ) );
    return distance;
}

Then I have a MovieClip that is the class: Minion and another called: Turret

In the Minion class I am calling: Global.getDistance

And setting the args to: Global.getDistance(this, ?????)

How can I get the Turret Object from the Turret class for the final param?

Answer 1

If each minion has a single turret that it is targeting, then you should hold a reference to the turret inside of your Minion class. There should be no need for a static function to get distance (unless it’s used for other things besides the minion/turret relation).

For your turrets to be aware of ALL minions (to decide which minion to attack), a good way to do this is to store them all in a statically assessable vector (array).

Here would be a sample of your Minion class:

public class Minion {
    public static var allMinions:Vector<Minion> = new Vector<Minion>(); //create a static array to store all your minions


    public var turret:Turret;

    public function Minion(targetTurret:Turret):void {
        turret = targetTurret;
        this.addEventListener(Event.ADDED_TO_STAGE,addedToStage,false,0,true);
        this.removeEventListener(Event.REMOVED_FROM_STAGE,removedFromStage,false,0,true);
    }

    private function addedToStage(e:Event):void {
        allMinions.push(this); //add this minion instance to the array when it's added to the display list
    }

    private function removedFromStage(e:Event):void {
        //remove this minion instance from the array of all minions when it's removed from the display list
        var index:int = allMinions.indexOf(this);
        if(index >= 0){
            allMinions.splice(index,1);
        }
    }

    private function move():void { //whatever function you use to move the minion along
       //get distance here, using your local turret var
       getDistance(this,turret); //this could be a local function, or some static function somewhere - local is faster, especially if being called everyframe or in a loop.
    }

    //a function to take damage, returns true if still alive after the damage
    public function takeDamage(amount:Number):Boolean {
        this.health -= amount * armor;  //armor could be a value between 1 (no armor) and 0 (invincible)
        if(health <= 0){ 
             //die
             return false;
        }
        return true;
    }
}

This passes in the appropriate turret when you create a new Minion – new Minion(turretInstance), and has a statically accessible array that holds all the minions that are on the display list at any given time. It also adds a function to take damage

---

For the turrets to attack, you’d want to scan the array of all minions, and determine which are close enough to attack, either attack all (if that’s the type of turret) or pick one (the closest one usually) to attack.

Turret class:

public var range:Number = 200; //how close to the turret a minion needs to be before it can attack
public var attackPower:Number = 10; //how much damage does this turret cause

public function attack():void {

    //this for loop goes through all the minions and finds the closest one
    var closestMinion:Minion;
    var tmpDistance:Number; //
    var distance:Number;
    for each(var minion:Minion in Minion.allMinions){
        distance = Math.sqrt( ( minion.x - this.x ) * ( minion.x - this.x ) + ( minion.y - this.y ) * ( minion.y - this.y ) ); //find the distance between the current minion in the loop and this turret
        if(distance < range && isNaN(tmpDistance) || distance < tmpDistance){  //if the distance of this minion is less than the current closest, make the current closest this one
            closestMinion = minion;
            tmpDistance = distance;
        }

    }

    //attack the closest one
    if(closestMinion){
        closestMinion.takeDamage(attackPower);
    }
}