---

/home/rdbrown/doxygen/cse125g1/src/modules/arrows/Arrows.cpp

#include <stdlib.h>
#include <iostream>
#include <list>
#include "Arrows.h"
#include "net/NetArrow.h"
#include "audio/audio.h"

#define GRAVITY -25.8

extern MMAudio::Source *arrowSources;
extern std::list<int> freeArrowSources;
static unsigned int soundname;
static MMNet::Game *game;

using namespace std;

void ArrowSystem::DrawTarget(Vector3 pos, const Vector3 &vel, TNL::U32 chargeTime) {
        MMNet::NetArrow na;
        Vector3 lastPos;
        na.Init(pos, vel, chargeTime, NULL);

        GroundY = 0 ;
        float deltaTime = .01f;

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        float opacity = 0.9f;

        glLineStipple(1, 0xAAAA);
        glEnable(GL_LINE_STIPPLE);
        glBegin(GL_LINES);
        while (pos.y > GroundY)
        {
                glColor4f(1.0, 1.0, 1.0, opacity);
                if (opacity > .1)
                        opacity -= deltaTime/2.0;
                
                na.Update(deltaTime);

                pos = na.getPos();
                lastPos = na.getLastPos();
                glVertex3f(lastPos.x, lastPos.y, lastPos.z);
                glVertex3f(pos.x, pos.y, pos.z);
                
        }
        glEnd();
        glDisable(GL_LINE_STIPPLE);
        glDisable(GL_BLEND);
}





/************************
 *  ARROW CLASS
 ************************/
static const Vector3 gravity(0.0, -9.8, 0.0);

void Arrow::Init(MMNet::Game *gm, MMNet::NetArrow *na, float r, float g, float b) {
        game = gm;
        netArrow = na;
        Position = netArrow->getPos();
        LastPosition.Set(Position.x-.01,Position.y-.01,Position.z-.01);
        Color.Set(r,g,b);
        immuneToForces = true;

        Velocity = netArrow->getVel();
        Force.Zero();

        Mass = netArrow->getMass();;
}


void Arrow::draw() {
        Vector3 normalVelocity;
        glColor3f( 139/255.0f, 69/255.0f,19/255.0f);
        Vector3 pos = netArrow->getPos();
        glVertex3f(pos.x, pos.y, pos.z);
        //if (immuneToForces)
        //      glColor3f( 0.0, 1.0, 0.0);//, P[i].Color.y, P[i].Color.z);
        //else
                glColor3f(      205/255.0f, 133/255.0f, 63/255.0f);
        normalVelocity = netArrow->getVel();
        normalVelocity.Normalize();
        normalVelocity.Scale(5.0);
        glVertex3f(pos.x-normalVelocity.x, 
    pos.y-normalVelocity.y, 
    pos.z-normalVelocity.z);
}

void Arrow::ReverseUpdate(float deltaTime) {
        // Compute acceleration (Newton’s second law)
        Vector3 Accel= Vector3( (1.0/Mass) * Force.x,
                                                        (1.0/Mass) * Force.y,
                                                        (1.0/Mass) * Force.z);

        Position.x -= Velocity.x * deltaTime;
        Position.y -= Velocity.y * deltaTime;
        Position.z -= Velocity.z * deltaTime;

        // Compute new position & velocity
        Velocity.x -= Accel.x * deltaTime;
        Velocity.y -= Accel.y * deltaTime;
        Velocity.z -= Accel.z * deltaTime;
        Force.Zero();
}

float Arrow::getSquaredDistanceFromPlayer(void) const {
        const Vector3 &playerpos = game->myPlayer->world.d;
        const Vector3 &mypos = netArrow->getPos();
        float t = 0;
        float c = mypos.x - playerpos.x;
        t += c*c;
        c = mypos.y - playerpos.y;
        t += c*c;
        c = mypos.z - playerpos.z;
        t += c*c;
        return c;
}

void Arrow::update(float deltaTime) {
        try {
        if (sourceno >= 0) {
                if (netArrow->getImmuneToForces()) {// || getSquaredDistanceFromPlayer() > 3.0) {
                        arrowSources[sourceno].stop();
                        if (netArrow->getImmuneToForces()) {
                                arrowSources[sourceno].setGain(10);
                                arrowSources[sourceno].setRolloff(.5);
                                arrowSources[sourceno].playSound(1);
                                freeArrowSources.push_back(sourceno);
                        }
                        /*
                        for (std::list<int>::iterator i = freeArrowSources.begin();
                                 i != freeArrowSources.end(); i++)
                        */
                        sourceno = -1;
                } else {
                        arrowSources[sourceno].setPosition(netArrow->getPos());
                }
        } else if (!netArrow->getImmuneToForces()) {
                if (!freeArrowSources.empty()) {
                        if (immuneToForces) { // just fired
                                sourceno = freeArrowSources.front();
                                freeArrowSources.pop_front();
                                freeArrowSources.push_back(sourceno);
                                arrowSources[sourceno].setGain(1);
                                arrowSources[sourceno].setRolloff(2);
                                arrowSources[sourceno].setPosition(netArrow->getPos());
                                arrowSources[sourceno].playSound(2);
                                sourceno = -1;
                        }
                        if (getSquaredDistanceFromPlayer() < 9.0) {
                                sourceno = freeArrowSources.front();
                                freeArrowSources.pop_front();;
                                arrowSources[sourceno].setGain(0.6);
                                arrowSources[sourceno].setRolloff(4);
                                arrowSources[sourceno].setPosition(netArrow->getPos());
                                arrowSources[sourceno].loopSound(soundname);
                                /*
                                for (std::list<int>::iterator i = freeArrowSources.begin();
                                         i != freeArrowSources.end(); i++)
                                */
                        }
                }
        }
        } catch (AudioException ex) { }
        immuneToForces = netArrow->getImmuneToForces();
        return;
}


// These functions are provided for compatibility w/ base class
const float 
Arrow::getTop() const {
        return -1.0;
}

const float 
Arrow::getBottom() const {
        return -1.0;
}

const float 
Arrow::getRadius() const {
        return -1.0;
}


void setFlyingArrowSound(unsigned int sname) {
        soundname = sname;
}

---