static struct ssBundle *gfClumpsToBundles(struct gfClump *clumpList,
boolean isRc, struct dnaSeq *seq, int minScore,
struct gfRange **retRangeList)
/* Convert gfClumps to an actual alignments (ssBundles) */
{
struct ssBundle *bun, *bunList = NULL;
struct gfRange *rangeList = NULL, *range;
struct dnaSeq *targetSeq;
rangeList = seqClumpToRangeList(clumpList, 0);
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, 2000);
for (range = rangeList; range != NULL; range = range->next)
{
targetSeq = range->tSeq;
gfiExpandRange(range, seq->size, targetSeq->size, FALSE, isRc,
usualExpansion);
range->tStart = 0;
range->tEnd = targetSeq->size;
AllocVar(bun);
bun->qSeq = seq;
bun->genoSeq = targetSeq;
alignComponents(range, bun, ffCdna);
ssStitch(bun, ffCdna, minScore, ssAliCount);
slAddHead(&bunList, bun);
}
slReverse(&bunList);
*retRangeList = rangeList;
return bunList;
}
void gfAlignStrand(int *pConn, char *tSeqDir, struct dnaSeq *seq,
boolean isRc, int minMatch, struct hash *tFileCache, struct gfOutput *out)
/* Search genome on server with one strand of other sequence to find homology.
* Then load homologous bits of genome locally and do detailed alignment.
* Call 'outFunction' with each alignment that is found. */
{
struct ssBundle *bun;
struct gfRange *rangeList = NULL, *range;
struct dnaSeq *targetSeq;
char targetName[PATH_LEN];
rangeList = gfQuerySeq(*pConn, seq);
close(*pConn);
*pConn = -1;
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, ffIntronMax);
for (range = rangeList; range != NULL; range = range->next)
{
getTargetName(range->tName, out->includeTargetFile, targetName);
targetSeq = gfiExpandAndLoadCached(range, tFileCache, tSeqDir,
seq->size, &range->tTotalSize, FALSE, FALSE, usualExpansion);
AllocVar(bun);
bun->qSeq = seq;
bun->genoSeq = targetSeq;
alignComponents(range, bun, ffCdna);
ssStitch(bun, ffCdna, minMatch, ssAliCount);
saveAlignments(targetName, range->tTotalSize, range->tStart,
bun, NULL, isRc, FALSE, ffCdna, minMatch, out);
ssBundleFree(&bun);
freeDnaSeq(&targetSeq);
}
gfRangeFreeList(&rangeList);
}
void doEntities(void)
{
int numAllies, numEnemies;
int numActiveAllies, numActiveEnemies;
int numSpawnedEnemies;
Entity *e, *prev;
prev = &battle.entityHead;
numAllies = numEnemies = numActiveAllies = numActiveEnemies = 0;
if (dev.playerImmortal)
{
player->health = player->maxHealth;
player->shield = player->maxShield;
}
for (e = battle.entityHead.next ; e != NULL ; e = e->next)
{
removeFromQuadtree(e, &battle.quadtree);
if (dev.allImmortal)
{
e->health = e->maxHealth;
e->shield = e->maxShield;
}
if (e->active)
{
self = e;
e->reload = MAX(e->reload - 1, 0);
if (e->shieldRechargeRate)
{
if (e->shield >= 0)
{
if (--e->shieldRecharge <= 0)
{
e->shield = MIN(e->shield + 1, e->maxShield);
e->shieldRecharge = e->shieldRechargeRate;
}
}
else
{
e->shield++;
}
}
e->armourHit = MAX(e->armourHit - 25, 0);
e->shieldHit = MAX(e->shieldHit - 5, 0);
e->systemHit = MAX(e->systemHit - 25, 0);
e->aiDamageTimer = MAX(e->aiDamageTimer - 1, 0);
if (!e->aiDamageTimer)
{
e->aiDamagePerSec = 0;
e->aiFlags &= ~AIF_EVADE;
}
switch (e->type)
{
case ET_FIGHTER:
doFighter();
break;
case ET_CAPITAL_SHIP:
doCapitalShip();
break;
default:
doEntity();
break;
}
if (e->alive == ALIVE_ALIVE || e->alive == ALIVE_DYING)
{
if (e->action != NULL)
{
if (dev.noEntityActions)
{
e->thinkTime = 2;
}
if (--e->thinkTime <= 0)
{
e->thinkTime = 0;
e->action();
}
}
doRope(e);
restrictToBattleArea(e);
if (!e->speed)
{
e->dx = e->dy = 0;
}
e->x += e->dx;
e->y += e->dy;
addToQuadtree(e, &battle.quadtree);
}
else
{
if (e == battle.entityTail)
{
battle.entityTail = prev;
}
if (e == battle.missionTarget)
{
battle.missionTarget = NULL;
}
if (e == player)
{
player = NULL;
battle.playerSelect = battle.isEpic;
}
cutRope(e);
prev->next = e->next;
/* move to dead list */
e->next = NULL;
deadTail->next = e;
deadTail = e;
e = prev;
}
}
if (e->type == ET_FIGHTER || e->type == ET_CAPITAL_SHIP)
{
if (e->side == SIDE_ALLIES)
{
numAllies++;
if (e->health > 0 && e->active)
{
numActiveAllies++;
}
}
else
{
numEnemies++;
if (e->health > 0 && e->active)
{
numActiveEnemies++;
if (e->spawned)
{
numSpawnedEnemies++;
}
}
}
}
prev = e;
}
battle.numAllies = (battle.isEpic) ? numAllies : numActiveAllies;
battle.numEnemies = (battle.isEpic) ? numEnemies : numActiveEnemies;
if (battle.isEpic && battle.stats[STAT_TIME] % FPS == 0)
{
numActiveEnemies -= numSpawnedEnemies;
if (numAllies > battle.epicFighterLimit)
{
activateEpicFighters(battle.epicFighterLimit - numActiveAllies, SIDE_ALLIES);
}
if (numEnemies > battle.epicFighterLimit)
{
activateEpicFighters(battle.epicFighterLimit - numActiveEnemies, SIDE_NONE);
}
}
alignComponents();
disabledGlow = MAX(DISABLED_GLOW_MIN, MIN(disabledGlow + disabledGlowDir, DISABLED_GLOW_MAX));
if (disabledGlow <= DISABLED_GLOW_MIN)
{
disabledGlowDir = DISABLED_GLOW_SPEED;
}
else if (disabledGlow >= DISABLED_GLOW_MAX)
{
disabledGlowDir = -DISABLED_GLOW_SPEED;
}
}
