void studrenClearBuffers(S_Renderer *pRenderer)
{
S_StudentRenderer * renderer;
int minus = -1;
IZG_ASSERT(pRenderer);
/* ukazatel na studentsky renderer */
renderer = (S_StudentRenderer *)pRenderer;
/* vymazeme a inicializujeme buffery */
/* ??? */
for (int i = 0; i < renderer->base.frame_h * renderer->base.frame_w; i++)
{
vecSet(renderer->vecHeadBuff, i, &minus);
}
renderer->vecNodeBuff = fragvecCreateEmpty();
/* zavolame take puvodni funkci */
renClearBuffers(pRenderer);
}
void readText(char * filename, corpus * data)
// read in text data from filename
{
FILE * file = fopen(filename,"r");
int val;
int d, n, c;
int totNumWords = 0;
int docNumWords = 0;
for (d = 0; d < data->numDocs; d++)
{
n = 0;
fscanf(file, "%d", &val); // remove first term (not of interest)
while (n < data->docs[d].numUnique)
{
fscanf(file, "%d", &val);
vecSet(data->docs[d].wordIdx,n,val);
c = getc(file);
fscanf(file, "%d", &val);
vecSet(data->docs[d].wordCnt,n,val);
docNumWords = docNumWords + val;
totNumWords = totNumWords + val;
n++;
}
data->docs[d].numWords = docNumWords;
docNumWords = 0;
}
data->numWords = totNumWords;
fclose(file);
int maxval = 0;
for (d = 0; d < data->numDocs; d++)
{
for (n = 0; n < data->docs[d].numUnique; n++)
{
if (vecGet(data->docs[d].wordIdx,n) > maxval)
maxval = vecGet(data->docs[d].wordIdx,n);
}
}
maxval++;
data->vocabSize = maxval;
}
//fires the bursts for the ship
bool doBurstFire(Ship *ship)
{
HeavyCorvetteSpec *spec = (HeavyCorvetteSpec *)ship->ShipSpecifics;
GunInfo *gunInfo = ship->gunInfo;
sdword numGuns = gunInfo->numGuns;
//Gun *gun;
sdword done;
vector trajectory,heading;
real32 range,one_over_range;
SpaceObjRotImpTarg dummyTarg;
vecSub(trajectory,spec->burstFireVector,ship->posinfo.position);
range = vecMagnitudeSquared(trajectory);
range = fsqrt(range);
one_over_range = 1.0f/range;
vecScalarMultiply(trajectory,trajectory,one_over_range);
dummyTarg.objtype = OBJ_ShipType;
dummyTarg.posinfo.position = spec->burstFireVector;
dummyTarg.collInfo.collPosition = spec->burstFireVector;
dummyTarg.currentLOD = ship->currentLOD;
dummyTarg.collMyBlob = ship->collMyBlob;
vecSet(dummyTarg.posinfo.velocity,0.0f,0.0f,0.0f);
//track target even more precisely
vecSub(heading,spec->burstFireVector,ship->posinfo.position);
vecNormalize(&heading);
aitrackHeadingWithFlags(ship,&heading,0.9999f,AITRACKHEADING_IGNOREUPVEC);
//set special information that needs to be 'transmitted'
//to the code in gunshoot.
//fix later
spec->bulletLifeTime = range*oneOverburstSpeed;
bitSet(ship->specialFlags,SPECIAL_BurstFiring);
done = gunShootGunsAtTarget(ship,&dummyTarg,0.0f,&trajectory);
bitClear(ship->specialFlags,SPECIAL_BurstFiring);
if(done == TRUE)
{
spec->cooldown = TRUE;
spec->burstChargeState2 = burstCoolDownTime;
}
return done;
}
/**
* Do all necessary initializations
* @param settings Pointer to the global settings
*/
void TaskCoreFFTW::prepare(swspect_settings_t* settings)
{
/* get settings and prepare buffers */
this->cfg = settings;
this->windowfct = (fftw_real*)memalign(128, sizeof(fftw_real)*cfg->fft_points);
this->unpacked_re = (fftw_real*)memalign(128, sizeof(fftw_real)*cfg->fft_points);
this->fft_result_reim = new fftw_real*[cfg->num_sources];
this->fft_accu_reim = new fftw_real*[cfg->num_sources];
this->num_ffts_accumulated = 0;
this->num_spectra_calculated = 0;
for (int s=0; s<cfg->num_sources; s++) {
this->fft_result_reim[s] = (fftw_real*)memalign(128, sizeof(fftw_real)*cfg->fft_points); // 4*fft_points*2 if c2c dft
this->fft_accu_reim[s] = (fftw_real*)memalign(128, sizeof(fftw_real)*cfg->fft_points);
}
this->fft_result_reim_conj = (fftw_real*)memalign(128, sizeof(fftw_real)*cfg->fft_points); // 4*fft_points*2 if c2c dft
this->spectrum_scalevector = (fftw_real*)memalign(128, sizeof(fftw_real)*cfg->fft_points);
this->processing_stage = STAGE_NONE;
this->total_runtime = 0.0;
this->total_ffts = 0;
reset_spectrum();
/* windowing function */
for (int i=0; i<(cfg->fft_points); i++) {
fftw_real w = sin(fftw_real(i) * M_PI/(cfg->fft_points - 1.0));
windowfct[i] = w*w;
}
/* FFT setup */
// fftwPlan = fftw_create_plan(cfg->fft_points, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE); // IPP_FFT_DIV_INV_BY_N, ippAlgHintFast
fftwPlans = new fftwf_plan[cfg->num_sources];
for (int s=0; s<cfg->num_sources; s++) {
fftwPlans[s] = fftwf_plan_r2r_1d(cfg->fft_points, this->unpacked_re, this->fft_result_reim[s], FFTW_R2HC, FFTW_ESTIMATE);
}
/* prepare fixed scale/normalization factor */
vecSet(fftw_real(1.0/cfg->integrated_ffts), spectrum_scalevector, cfg->fft_points);
/* init mutexeds and start the worker thread */
terminate_worker = false;
pthread_mutex_init(&mmutex, NULL);
pthread_mutex_lock(&mmutex);
pthread_create(&wthread, NULL, taskcorefft_worker, (void*)this);
return;
}
void DefenseFighterHouseKeep(Ship *ship)
{
DefenseFighterSpec *spec = (DefenseFighterSpec *)ship->ShipSpecifics;
DefenseFighterStatics *defensefighterstatics;
Node *bulletnode;
Node *tempnode;
DefenseStruct *defensestruct;
vector seperationvector;
vector tempvec,rot_vector;
GunStatic *gunstatic;
Gun *gun;
vector positionInWorldCoordSys;
gun = &ship->gunInfo->guns[0];
gunstatic = gun->gunstatic;
defensefighterstatics = (DefenseFighterStatics *) ((ShipStaticInfo *)(ship->staticinfo))->custstatinfo;
bulletnode = spec->DefenseList.head;
while (bulletnode != NULL)
{ //as long as theres a bullet to deal with
defensestruct = (DefenseStruct *)listGetStructOfNode(bulletnode);
/* if (defensestruct->bullet)
dbgMessagef("DS: %d %f %d %f %d %d",
universe.univUpdateCounter,
defensestruct->bullet->collOptimizeDist,
defensestruct->laser ? 1:0,
defensestruct->CoolDownTime,
defensestruct->CoolDown ? 1:0,
defensestruct->LaserDead ? 1:0);
else
dbgMessagef("DS: %d N %d %f %d %d",
universe.univUpdateCounter,
defensestruct->laser ? 1:0,
defensestruct->CoolDownTime,
defensestruct->CoolDown ? 1:0,
defensestruct->LaserDead ? 1:0);*/
if(!defensestruct->CoolDown)
{ //laser cannon isn't cooling down, so continue tracking
if (defensestruct->bullet == NULL || defensestruct->bullet->damage <= 0)
{ //bullet is already dead...don't kill it again
defensestruct->bullet = NULL; //destroy pointer...
if (defensestruct->laser != NULL)
{
defensestruct->laser->timelived =10000.0f; //kill laser
}
defensestruct->LaserDead = TRUE; //set killed flag
defensestruct->laser=NULL;
defensestruct->CoolDown = TRUE; //begin laser cooldown
defensestruct->CoolDownTime = 0.0f; //reset to 0 for cooldown count
bulletnode=bulletnode->next;
continue;
}
if((universe.univUpdateCounter & defensefighterstatics->DamageRate) == 0)
{
// Time to do damage...
//Do damage to bullet
defensestruct->bullet->damage = (defensestruct->bullet->damage - frandombetween(defensefighterstatics->DamageReductionLow,defensefighterstatics->DamageReductionHigh));
if(defensestruct->bullet->damage <= 0)
{
//bullet is destroyed
DefenseFighterDestroyedABullet(ship, defensestruct->bullet, defensestruct->laser);
defensestruct->bullet->damage = 0; //cap at 0;
defensestruct->bullet = NULL; //destroy pointer...
//dbgMessagef("Defense Fighter Destroyed A Bullet.");
if (defensestruct->laser != NULL)
{
defensestruct->laser->timelived =10000.0f; //kill laser
}
defensestruct->LaserDead = TRUE; //set killed flag
if(defensestruct->laser->effect != NULL)
{
univRemoveObjFromRenderList((SpaceObj *) defensestruct->laser->effect);
}
defensestruct->laser=NULL;
defensestruct->CoolDown = TRUE; //begin laser cooldown
defensestruct->CoolDownTime = 0.0f; //reset to 0 for cooldown count
}
}
if(defensestruct->laser != NULL)
{
//check if bullet is still in range and infront...
if((universe.univUpdateCounter & defensefighterstatics->RangeCheckRate) == 0)
{
//time to check if in front
vecSub(seperationvector, ship->posinfo.position, defensestruct->bullet->posinfo.position);
if(vecMagnitudeSquared(seperationvector) > ship->staticinfo->bulletRangeSquared[ship->tacticstype])
{
//bullet is out of range
defensestruct->laser->timelived =10000.0f; //kill laser
defensestruct->LaserDead = TRUE; //set killed flag
if(defensestruct->laser->effect != NULL)
{
univRemoveObjFromRenderList((SpaceObj *) defensestruct->laser->effect);
}
defensestruct->laser=NULL;
//dbgMessagef("Bullet out of range.");
bitClear(defensestruct->bullet->SpecialEffectFlag,0x0002);
defensestruct->CoolDown = TRUE; //begin laser cooldown
defensestruct->bullet = NULL; //set target to NULL so it isn't referenced again!
defensestruct->CoolDownTime = 0.0f; //reset to 0 for cooldown count
}
else if(!defensefighterCheckInFront(ship, defensestruct->bullet))
{
//if bullet ISN'T in front
defensestruct->laser->timelived =10000.0f; //kill laser
defensestruct->LaserDead = TRUE; //set killed flag
if(defensestruct->laser->effect != NULL)
{
univRemoveObjFromRenderList((SpaceObj *) defensestruct->laser->effect);
}
defensestruct->laser=NULL;
//dbgMessagef("Bullet Not infront anymore...stop tracking.");
if(defensefighterstatics->MultipleTargettingofSingleBullet)
{
bitClear(defensestruct->bullet->SpecialEffectFlag,0x0002);
}
defensestruct->CoolDown = TRUE; //begin laser cooldown
defensestruct->bullet = NULL; //set target to NULL so it isn't referenced again!
defensestruct->CoolDownTime = 0.0f; //reset to 0 for cooldown count
}
}
}
//This code is for the sake of the visual effect which STILL won't work
//properly!!! So it is temperary only!
if(defensestruct->laser != NULL)
{ //update bullent info...for visual effect
dbgAssertOrIgnore(defensestruct->bullet != NULL);
matMultiplyMatByVec(&positionInWorldCoordSys,&ship->rotinfo.coordsys,&gunstatic->position);
vecAdd(defensestruct->laser->posinfo.position,positionInWorldCoordSys,ship->posinfo.position);
vecSub(defensestruct->laser->lengthvec, defensestruct->bullet->posinfo.position, defensestruct->laser->posinfo.position);
// heading
tempvec = defensestruct->laser->lengthvec;
vecNormalize(&tempvec);
//matMultiplyMatByVec(&gunheadingInWorldCoordSys, &ship->rotinfo.coordsys, &tempvec);
//laser->bulletheading = gunheadingInWorldCoordSys;
defensestruct->laser->bulletheading = tempvec;
matCreateCoordSysFromHeading(&defensestruct->laser->rotinfo.coordsys,&tempvec);
if(defensestruct->laser->effect != NULL)
{ //adjust length
((real32 *)defensestruct->laser->effect->variable)[ETG_LengthVariable] =
fsqrt(vecMagnitudeSquared(defensestruct->laser->lengthvec));
}
}
}
else
{ //this laser cannon is cooling, so cool it
defensestruct->CoolDownTime += universe.phystimeelapsed;
if(defensestruct->CoolDownTime > defensefighterstatics->CoolDownTimePerLaser)
{ //Laser Terminal has cooled down...so free it up
tempnode = bulletnode->next;
listDeleteNode(bulletnode);
//dbgMessagef("Deleting defense node in CoolDown.");
bulletnode = tempnode;
continue;
}
}
bulletnode = bulletnode->next;
}
if (spec->DefenseList.num == 0)
{
soundEventBurstStop(ship, gun);
}
//do special rotation if neccessary
if(bitTest(ship->dontrotateever,1))
{
//matGetVectFromMatrixCol3(rot_vector,ship->rotinfo.coordsys);
vecSet(rot_vector,100.0f,0.0f,0.0f);
vecAddTo(ship->rotinfo.torque, rot_vector);
vecCapVectorSloppy(&ship->rotinfo.rotspeed, defensefighterstatics->max_rot_speed );
spec->rotate_time_counter -= universe.phystimeelapsed;
if(spec->rotate_time_counter <= 0.0f)
{
bitClear(ship->dontrotateever,1);
spec->DefenseFighterCanNowRotate = FALSE;
}
}
else if (spec->DefenseFighterCanNowRotate == FALSE)
{
spec->rotate_time_counter += universe.phystimeelapsed;
if(spec->rotate_time_counter >= defensefighterstatics->rotate_recover_time)
{
spec->DefenseFighterCanNowRotate = TRUE;
spec->rotate_time_counter = defensefighterstatics->rotate_time;
}
}
}
void ResearchShipHouseKeep(Ship *ship)
{
ResearchShipSpec *spec = (ResearchShipSpec *)ship->ShipSpecifics;
SelectCommand selection;
vector up,destination,desiredheading,newup;
vector univup = {0.0f,0.0f,1.0f};
bool InParadeandMoving = FALSE;
matrix rot_matrix,tmpmat,rotmat;
real32 radangle;
ResearchShipStatics *researchshipstatics;
researchshipstatics = (ResearchShipStatics *) ((ShipStaticInfo *)(ship->staticinfo))->custstatinfo;
if(bitTest(ship->specialFlags,SPECIAL_StopForResearchDocking))
{
vecScalarMultiply(ship->posinfo.velocity,ship->posinfo.velocity,0.94);
vecScalarMultiply(ship->rotinfo.rotspeed,ship->rotinfo.rotspeed,0.94);
bitSet(ship->dontapplyforceever,1);
bitSet(ship->dontrotateever,1);
}
else
{
bitClear(ship->dontapplyforceever,1);
bitClear(ship->dontrotateever,1);
}
if(ship->flags & SOF_Slaveable)
{
if(ship->slaveinfo->flags & SF_MASTER)
{
CommandToDo *command = getShipAndItsCommand(&universe.mainCommandLayer,ship);
if(command != NULL)
{
//ship may be in parade...
if(command->ordertype.order == COMMAND_MILITARY_PARADE)
{
//ship is in parade
CommandToDo *ashipCom = getShipAndItsCommand(&universe.mainCommandLayer,command->militaryParade->aroundShip);
if(ashipCom != NULL)
{
//probably shouldn't be null regardless..should be equal to command..but ohwell
if(ashipCom->ordertype.order == COMMAND_MOVE ||
ashipCom->ordertype.order == COMMAND_ATTACK ||
ashipCom->ordertype.order == COMMAND_SPECIAL ||
ashipCom->ordertype.order == COMMAND_MP_HYPERSPACING)
{
InParadeandMoving = TRUE;
spec->rotate_state = ROTATE_WAIT;
}
}
//in parade
if(!InParadeandMoving)
{
if(bitTest(ship->specialFlags,SPECIAL_ParadeNeedTomoveCloser))
{
InParadeandMoving = TRUE;
spec->rotate_state = ROTATE_WAIT;
}
}
}
}
}
}
if(ship->flags & SOF_Slaveable)
{ //ship is slaveable
bitSet(ship->flags,SOF_DontDrawTrails);
ship->autostabilizeship = FALSE; // never have univupdate autostabilize research ships
if(ship->slaveinfo->flags & SF_MASTER)
{ //ship is a master
if(!InParadeandMoving)
{
if(ship->shiprace == R1)
{ //ship is a race 1 MASTER research ship...
//i.e. it controls the motion
switch(spec->rotate_state)
{
case ANGLE_ESTABLISH: //establishes the angle at which the station is supposed to rotate at
break;
case ROTATE_WAIT: //wait to rotate
if(ship->slaveinfo->slaves.num >= 5)
{ //correct # of ships...
if(!ship_is_moving(ship))
{
if(!spec->prepshipforanother)
{ //no ships are coming to dock
//do up vector tracking!
//Later Calculate this vector ONCE at code start up...Let Daly do it
//and get as a static value
radangle = DEG_TO_RAD(researchshipstatics->RotationAngle);
matMakeRotAboutX(&rotmat,(real32) cos(radangle),(real32) sin(radangle));
matMultiplyMatByVec(&newup, &rotmat, &univup);
//matGetVectFromMatrixCol3(desiredHeading,ship->rotinfo.coordsys);
if(aitrackHeadingWithFlags(ship,&newup,0.96f,AITRACKHEADING_IGNOREUPVEC))
{
spec->rotate_state = ROTATE_DO;
getRotatePoint(ship, &spec->rotate_point,&spec->rotate_distance);
}
}
}
if(!spec->have_removed_from_parade)
{
spec->have_removed_from_parade = TRUE;
selection.numShips = 1;
selection.ShipPtr[0] = ship;
//RemoveShipsFromDoingStuff(&universe.mainCommandLayer,&selection);
//clHalt(&universe.mainCommandLayer,&selection);
}
}
break;
case ROTATE_STOP:
case ROTATE_STOP_QUICK:
case ROTATE_DO:
ship->posinfo.isMoving = ISMOVING_MOVING | ISMOVING_ROTATING;
make_all_slaves_moving(ship);
if(ship->slaveinfo->slaves.num < 5)
{
//don't rotate anymore because slaves dropped below threhold for whatever reasons!
spec->rotate_state = ROTATE_STOP;
break;
}
if(spec->prepshipforanother)
{ //need to prep ship for a docking ship..
spec->rotate_state = ROTATE_STOP;
}
else if(ship_is_moving(ship))
{ //ship is being moved
spec->rotate_state = ROTATE_STOP_QUICK;
}
else
{
spec->rotate_state = ROTATE_DO;
}
//matGetVectFromMatrixCol3(heading,ship->rotinfo.coordsys);
matGetVectFromMatrixCol1(up,ship->rotinfo.coordsys);
//vecScalarMultiply(rotate_point, heading, -250.0f);
//vecAdd(rotate_point,rotate_point, ship->posinfo.position);
switch(spec->rotate_state)
{
case ROTATE_DO:
if(spec->theta >= researchshipstatics->max_rotate)
spec->theta = researchshipstatics->max_rotate;
else
spec->theta += researchshipstatics->rotate_acelleration;
break;
case ROTATE_STOP_QUICK:
spec->theta *= researchshipstatics->rotate_slow;
spec->theta *= researchshipstatics->rotate_slow;
case ROTATE_STOP:
if(spec->theta <= 0.00001f)
{
spec->theta = 0.0f;
spec->rotate_state = ROTATE_WAIT;
break;
}
else
spec->theta *= researchshipstatics->rotate_slow;
break;
default:
dbgAssertOrIgnore(FALSE);
break;
}
matMakeRotAboutX(&rot_matrix,(real32) cos(spec->theta),(real32) sin(spec->theta));
//matMultiplyMatByMat(&tmpmat, &rot_matrix, &ship->rotinfo.coordsys);
matMultiplyMatByMat(&tmpmat, &ship->rotinfo.coordsys, &rot_matrix);
//vecSub(tmpvec, ship->posinfo.position, spec->rotate_point);
//dist = vecMagnitudeSquared(tmpvec);
//dist = fsqrt(dist);
matGetVectFromMatrixCol3(desiredheading,tmpmat);
vecScalarMultiply(destination, desiredheading, spec->rotate_distance); //old was dist
vecAdd(destination,destination,spec->rotate_point);
ship->posinfo.position = destination;
ship->rotinfo.coordsys = tmpmat;
univUpdateObjRotInfo((SpaceObjRot *)ship);
break;
default:
dbgMessagef("Shouldn't Get Here...unknown Research Ship Rotate State");
dbgAssertOrIgnore(FALSE);
break;
}
}
else
{ //Ship is an R2 Master...so rotate differently
switch(spec->rotate_state)
{
case ANGLE_ESTABLISH:
break;
case ROTATE_WAIT: //wait to rotate
if(ship->slaveinfo->slaves.num >= 3)
{ //correct # of ships...
if(!spec->prepshipforanother && !ship_is_moving(ship))
{ //no ships are coming to dock
radangle = DEG_TO_RAD(researchshipstatics->RotationAngle);
matMakeRotAboutX(&rotmat,(real32) cos(radangle),(real32) sin(radangle));
matMultiplyMatByVec(&newup, &rotmat, &univup);
if(aitrackHeadingWithFlags(ship,&newup,0.96f,AITRACKHEADING_IGNOREUPVEC))
{
spec->rotate_state = ROTATE_DO;
}
}
else
{
vecSet(ship->rotinfo.rotspeed,0.0f,0.0f,0.0f);
vecSet(ship->rotinfo.torque,0.0f,0.0f,0.0f);
}
}
if(ship->slaveinfo->slaves.num >= 1)
{ //correct # of ships...
if(!spec->have_removed_from_parade)
{
spec->have_removed_from_parade = TRUE;
selection.numShips = 1;
selection.ShipPtr[0] = ship;
//RemoveShipsFromDoingStuff(&universe.mainCommandLayer,&selection);
//clHalt(&universe.mainCommandLayer,&selection);
}
}
break;
case ROTATE_STOP:
case ROTATE_STOP_QUICK:
case ROTATE_DO:
ship->posinfo.isMoving = ISMOVING_MOVING | ISMOVING_ROTATING;
make_all_slaves_moving(ship);
if(ship->slaveinfo->slaves.num < 3)
{
//don't rotate anymore because slaves dropped below threhold for whatever reasons!
spec->rotate_state = ROTATE_STOP;
break;
}
if(spec->prepshipforanother)
{ //need to prep ship for a docking ship..
spec->rotate_state = ROTATE_STOP;
}
if(ship_is_moving(ship))
{ //ship is being moved
spec->rotate_state = ROTATE_STOP_QUICK;
}
switch(spec->rotate_state)
{
case ROTATE_DO:
if(spec->theta >= researchshipstatics->max_rotate)
spec->theta = researchshipstatics->max_rotate;
else
spec->theta += researchshipstatics->rotate_acelleration;
break;
case ROTATE_STOP_QUICK:
spec->theta *= researchshipstatics->rotate_slow;
spec->theta *= researchshipstatics->rotate_slow;
case ROTATE_STOP:
if(spec->theta <= 0.00001f)
{
spec->theta = 0.0f;
spec->rotate_state = ROTATE_WAIT;
break;
}
else
spec->theta *= researchshipstatics->rotate_slow;
break;
default:
dbgAssertOrIgnore(FALSE);
break;
}
matMakeRotAboutZ(&rot_matrix,(real32) cos(spec->theta),(real32) sin(spec->theta));
tmpmat = ship->rotinfo.coordsys;
matMultiplyMatByMat(&ship->rotinfo.coordsys,&tmpmat,&rot_matrix);
univUpdateObjRotInfo((SpaceObjRot *)ship);
break;
default:
dbgMessagef("Shouldn't Get Here...unknown Research Ship Rotate State");
dbgAssertOrIgnore(FALSE);
break;
}
}
}
}
else
{
vecScalarMultiply(ship->posinfo.velocity,ship->posinfo.velocity, 0.0f);
}
}
}
bool HeavyCorvetteSpecialTarget(Ship *ship, void *custom)
{
HeavyCorvetteSpec *spec = (HeavyCorvetteSpec *)ship->ShipSpecifics;
SelectAnyCommand *targets = (SelectAnyCommand *)custom;
real32 tempreal;
vector Av;
sdword i,flag;
if(spec->cooldown)
{
aitrackSteadyShip(ship);
return FALSE;
}
if (targets->numTargets == 0)
{
return TRUE;
}
switch(spec->burstState)
{
case BURST_Begin:
//get average position of targets
vecSet(Av,0.0f,0.0f,0.0f);
for(i=0;i<targets->numTargets;i++)
{
vecAddTo(Av,targets->TargetPtr[i]->collInfo.collPosition);
}
tempreal = 1.0f/((real32)i);
vecScalarMultiply(spec->burstFireVector,Av,tempreal);
///////////////////////////////
/////burst attack speech event!
//event num: COMM_HVette_BurstAttack
//use battle chatter
if(ship->playerowner->playerIndex ==
universe.curPlayerIndex)
{
if(ship->playerowner->playerIndex == universe.curPlayerIndex)
{
if (battleCanChatterAtThisTime(BCE_COMM_HVette_BurstAttack, ship))
{
battleChatterAttempt(SOUND_EVENT_DEFAULT, BCE_COMM_HVette_BurstAttack, ship, SOUND_EVENT_DEFAULT);
}
}
}
///////////////////////////////
spec->burstState=BURST_FlyToFirePoint;
break;
case BURST_FlyToFirePoint:
flag = 0;
if(doBurstCharging(ship))
{
//ship is fully charged
flag = 1;
}
if(flytoBurstPosition(ship))
{
//ship is in position fire
if(flag == 1)
{
spec->burstState=BURST_Fire;
}
}
break;
case BURST_Fire:
if(doBurstFire(ship))
{
spec->burstState = BURST_Begin;
dbgMessagef("Firing Burst Fire.");
}
break;
default:
dbgFatalf(DBG_Loc,"\nUnknown BurstState %d for shiptype %d.",spec->burstState,ship->shiptype);
}
//perform burst attack AI here...
return FALSE;
}
