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;
}
}
bool Daemon::processControl( Channel channel ) {
InputMessage message;
channel->peek( message );
auto cleanup = [&] {
channel->receiveHeader( message );
};
Code code = message.tag< Code >();
switch ( code ) {
case Code::Enslave:
enslave( message, std::move( channel ) );
break;
case Code::Disconnect:
cleanup();
release( std::move( channel ) );
return false;
case Code::Peers:
startGrouping( message, std::move( channel ) );
break;
case Code::ConnectTo:
connecting( message, std::move( channel ) );
break;
case Code::Join:
join( message, std::move( channel ) );
break;
case Code::DataLine:
addDataLine( message, std::move( channel ) );
break;
case Code::Grouped:
cleanup();
grouped( std::move( channel ) );
break;
case Code::InitialData:
initData( message, std::move( channel ) );
break;
case Code::Run:
run( message, std::move( channel ) );
break;
case Code::PrepareToLeave:
cleanup();
prepare( std::move( channel ) );
break;
case Code::CutRope:
cleanup();
cutRope( std::move( channel ) );
break;
case Code::Leave:
cleanup();
leave( std::move( channel ) );
break;
case Code::Error:
cleanup();
error( std::move( channel ) );
break;
case Code::Renegade:
renegade( message, std::move( channel ) );
break;
case Code::Status:
cleanup();
status( std::move( channel ) );
break;
case Code::Shutdown:
cleanup();
shutdown( std::move( channel ) );
break;
case Code::ForceShutdown:
cleanup();
forceShutdown();
break;
case Code::ForceReset:
cleanup();
forceReset();
return false;
default:
cleanup();
throw ResponseException( {
Code::Enslave,
Code::Disconnect,
Code::Peers,
Code::ConnectTo,
Code::Join,
Code::DataLine,
Code::Grouped,
Code::InitialData,
Code::Run,
Code::PrepareToLeave,
Code::Leave,
Code::CutRope,
Code::Error,
Code::Renegade,
Code::Shutdown,
Code::ForceShutdown,
Code::ForceReset,
}, code );
break;
}
return true;
}
