Copyright (c) 2008 Douglas Hammer
# Vavaldi Decentralized Swarm Coordinates 
@include "Mathtools.tz"
@include "Stationary.tz"
@include "Control.tz"
@include "Mobile.tz"

@define SWARM_SIZE    80.

Controller cCluster.

Control : cCluster {
    + variables:
        birds,sublist (list).
        item (object).
        breveTexture, cloudTexture (object).
        selection (object).
        thetatwo (float).

        # the menu items corresponding to different flocking behaviors

        wackyMenu (object).
        obedientMenu (object).
        normalMenu (object).

    + to click on item (object):
        if selection: selection hide-neighbor-lines.
        if item: item show-neighbor-lines.

        selection = item.

        super click on item.

    + to init:
        floor (object).

        # Set up menus to modify the type of movement allowed.
        self add-menu named "Smoosh The Birdies" for-method "squish".
        self add-menu-separator.
        obedientMenu = (self add-menu named "Flock Obediently" for-method "flock-obediently").
        normalMenu = (self add-menu named "Flock Normally" for-method "flock-normally").
        wackyMenu = (self add-menu named "Flock Wackily" for-method "flock-wackily").

        self enable-lighting.
        #self enable-smooth-drawing.
        self move-light to (0, 20, 20).

        breveTexture = (new Image load from "images/breve.png").
        cloudTexture = (new Image load from "images/clouds.png").

        # Add a huge floor.

        floor = new Floor.
        floor catch-shadows.

        birds = SWARM_SIZE new Birds.

        birds set-bitmap-image to breveTexture.

        # we'll call this method to set up the initial bird behavior.

        self flock-normally.

        self set-background-texture-image to cloudTexture.

        self offset-camera by (5, 1.5, 6).

        self enable-shadows.
        
        
    + to iterate:
        location (vector).
        topDiff (double).
 
        self update-neighbors.

        # get the average location, and point the camera at it.

        foreach item in birds: {
            item fly.
            location += (item get-location).
        }

        location /= | birds |.

        topDiff = 0.0.

        foreach item in birds: {
            if topDiff < |location - (item get-location) |:
                topDiff = | location - (item get-location) |.
        }

        # we'll try to keep the camera aimed at the center of the 
        # flock, and zoom in and out depending on how spread out the 
        # flock is.  it's doesn't work very well :).

        self aim-camera at location.
        self zoom-camera to (.5 * topDiff) + 10.

        # call the superclass iterate method to step the simulation forward.

        super iterate.
        
    + to post-iterate:
        sum,mean(float).
        i,n,j,m (int).
        i=0.
        foreach item in birds: {
            sum+= (item get-phase).
        }
        mean=(1/SWARM_SIZE)*sum.
        n=|birds|.
        for i=0, i<n, i++ : {
             birds{i} set-phase val mean.
             birds{i} set-gain val mean.
             sublist = birds{i} get-neighbors.
             m=|sublist|.
             for j=0, j<m, j++ : {
                 birds{i} update-loc ptr sublist{j}.
            }# m 
        }# n

    # The following methods are the menu items we provide.

    + to squish:
        birds move to (0, 0, 0).
    
    + to flock-normally:
        birds flock-normally.
        normalMenu check.
        obedientMenu uncheck.
        wackyMenu uncheck.

    + to flock-obediently:
        birds flock-obediently.
        normalMenu uncheck.
        obedientMenu check.
        wackyMenu uncheck.

    + to flock-wackily:
        birds flock-wackily.
        normalMenu uncheck.
        obedientMenu uncheck.
        wackyMenu check.
        
     
}

Mobile : Bird (aka Birds) {
    + variables: 
        landed (int).
        phase,w,theta,delta (float).

        # These are all parameters that can change the way the flock
        # behaves.  Look at the flock-normally method for an example.

        cruiseDistance (float).
 
        maxAcceleration (float).
        maxVelocity (float).

        wanderConstant (float).
        worldCenterConstant (float).
        centerConstant (float).
        velocityConstant (float).
        spacingConstant (float).

    + to init:
        # register the object, set the initial location, velocity and color.
        phase = random[2]*3.141592635898. #[0..2pi]T
        delta=0.0.
        self set-shape to (new Sphere init-with radius .25). 
        self move to random[(10, 10, 10)] - (5, -5, 5).
        self set-velocity to random[(20, 20, 20)] - (10, 10, 10).

        # when we hit the ground, we want to land on it using the method "land".
        # it gets called automatically when the collision occurs.

        self handle-collisions with-type "Floor" with-method "land".

        # set the neighborhood radius that we will look in to find neighbors.

        self set-neighborhood-size to 2.0.
        
    + to get-phase:
       return phase.
       
    + to set-phase val delta(float):
        w=1.0. # Cq.
        theta=phase.
        phase=w*sin(theta)+delta.
        
    + to set-gain val x(float):
         w=x.
         
    + to get-gain:
         return w.
         
    + to update-loc ptr item(object):
        dir,newloc,g (vector).
        distance (float).
        dir = (item get-location) - (self get-location).
        if |dir| != 0: dir /= |dir|.
        distance = |sqrt((self get-location)^2 + (item get-gain)^2) - (item get-location)|.
        g=dir*distance.
        delta -= 0.025.
        delta = max(0.05, delta). # stop criteria
        g=g*delta.
        newloc=(self get-location)+g.
        self move to newloc.
        
        
    + to flock-normally:
        wanderConstant = 4.0.
        worldCenterConstant = 5.0.
        centerConstant = 2.0.
        velocityConstant = 2.0.
        spacingConstant = 5.0.

        maxVelocity = 15.
        maxAcceleration = 15.
        cruiseDistance = .4.

    + to flock-obediently:
        # The obedient flocking has a lower maxAcceleration, which means that 
        # the objects don't react as quickly.  This has a calming effect on the 
        # agents.
       
        wanderConstant = 6.0.
        worldCenterConstant = 6.0.
        centerConstant = 2.0.
        velocityConstant = 3.0.
        spacingConstant = 4.0.

        maxVelocity = 16.
        maxAcceleration = 20.
        cruiseDistance = 1.

    + to flock-wackily:
        # The wacky flocking has a high maximum acceleration so that the 
        # agents act heavily on all of their impulses every iteration.
        # This makes them swarm like insects.

        wanderConstant = 8.0.
        worldCenterConstant = 14.0.
        centerConstant = 1.0.
        velocityConstant = 3.0.
        spacingConstant = 4.0.

        maxVelocity = 20.
        maxAcceleration = 30.
        cruiseDistance = .5.

    + to land with ground (object):
        # if we hit the ground, we stop moving and set the landed flag to 1.

        # print "Landing".

        self set-acceleration to (0, 0, 0).
        self set-velocity to (0, 0, 0).

        landed = 1.

        # we don't want to keep colliding with the ground, or else we'll
        # keep on getting stuck again at every iteration--move up just a 
        # tiny bit.

        self offset by (0, 0.01, 0).

    + to check-landed:
        # Ask the object if it has landed...

        return landed.

    + to fly:
        # This is the method which does it all.

        bird (object).
        toNeighbor (vector).
        
        centerUrge (vector).
        worldCenterUrge (vector).
        velocityUrge (vector).
        spacingUrge (vector).
        wanderUrge (vector).

        acceleration (vector).

        newVelocity (vector).

        neighbors (list).

        take-off (int).

        # get a list of neighbors within our neighborhood-size 
        # (set during init), and check to see if they're visible.
        # using get neighbors, we very quickly get a list of 
        # eligible objects and then check them further.  this is
        # *much* faster than checking every bird in the simulation.

        foreach bird in (self get-neighbors):
            if (self check-visibility of bird): push bird onto neighbors.

        # if we're on the ground now, we'll pick a random number to see if we 
        # take off again.  The chances are 1 in 40, which is actually pretty
        # reasonable since this code is called every iteration.

        if landed: {
            take-off = random[40].

            if take-off == 1: {
                # if we decide to take off, pick a random direction,
                # but not towards the ground.

                landed = 0.
                self set-velocity to random[(.1, 1.1, .1)] - (.05, 0, .05).
            } else {
                return. 
            }
        }

        # get the urge towards the center, and velocity matching urge. 

        centerUrge = (self get-center-urge with neighbors).
        velocityUrge = (self get-velocity-urge with neighbors).

        # are we too close to our neighbors?  get a vector which reflects that
        # urge.

        foreach bird in neighbors: {
            toNeighbor = (self get-location) - (bird get-location).
            if |toNeighbor| < cruiseDistance: spacingUrge += toNeighbor.
        }

        # Are we wandering too far from the center of the world?

        if |(self get-location)| > 10: worldCenterUrge = -(self get-location).

        # Add a random component to the accumulation.

        wanderUrge = random[(2, 2, 2)] - (1, 1, 1).

        # normalize all of the vectors to length 1.

        if |spacingUrge|: spacingUrge /= |spacingUrge|.
        if |worldCenterUrge|: worldCenterUrge /= |worldCenterUrge|.
        if |velocityUrge|: velocityUrge /= |velocityUrge|.
        if |centerUrge|: centerUrge /= |centerUrge|.
        if |wanderUrge|: wanderUrge /= |wanderUrge|.

        wanderUrge *= wanderConstant.
        worldCenterUrge *= worldCenterConstant.
        centerUrge *= centerConstant.
        velocityUrge *= velocityConstant.
        spacingUrge *= spacingConstant.

        acceleration = (worldCenterUrge + centerUrge + velocityUrge  + spacingUrge + wanderUrge).

        if |acceleration| != 0: acceleration /= |acceleration|.
        self set-acceleration to maxAcceleration * acceleration.

        newVelocity = (self get-velocity).

        if |newVelocity| > maxVelocity: 
            newVelocity = maxVelocity * newVelocity/|newVelocity|.

        self set-velocity to newVelocity.

    + to get-velocity-urge with flock (list):
        item (object).
        count (float).
        aveVelocity (vector).

        # get the average velocity of all the visible birds in the flock.
        if phase >= 3.141592635898: {         
        foreach item in flock: {
            count += 1.
            aveVelocity += (item get-velocity).
        }
        }

        if count == 0: return (0, 0, 0).

        aveVelocity /= count.

        return aveVelocity - (self get-velocity).

    + to get-center-urge with flock (list):
        item (object).
        count (float).
        center (vector).

        # get the average location of all the visible birds in the flock.
        if phase >= 3.141592635898: { 
        foreach item in flock: {
            count += 1.
            center += (item get-location).
        }
        }

        if count == 0: return (0, 0, 0).

        center /= count.

        return center - (self get-location).

    + to check-visibility of item (object):
        # An item is visible if it is within a certain angle (2.0 radians) 
        # of the direction we're facing (assumed to be a vector in the 
        # direction we're moving).

        if (item == self): return 0.
        if !(item is a "Bird"): return 0.
        if (item check-landed): return 0.
        if (self get-angle to item) > 2.0: return 0.

        return 1. 

    + to get-angle to otherMobile (object):
        tempVector (vector).
        velocity (vector).

        velocity = ( self get-velocity ).

        if | velocity | == 0.0:
            return 0.
        
        tempVector = (otherMobile get-location) - (self get-location).
        return angle( velocity, tempVector).
}