// later put this in the custshipheader?
void DDDFrigateDied(Ship *ship)
{
sdword i;
DDDFrigateSpec *spec;
Ship *deleteme;
dbgAssert(ship->shiptype == DDDFrigate);
spec = (DDDFrigateSpec *)ship->ShipSpecifics;
for (i=0;i<MAX_NUM_DRONES;i++)
{
deleteme = spec->DronePtrs[i];
if ((deleteme != NULL) && ((deleteme->flags & SOF_Dead) == 0))
{
if (deleteme->shiplink.belongto != NULL)
{
// ship is outside, so delete it
deleteme->howDidIDie = ship->howDidIDie;
deleteme->whoKilledMe = ship->whoKilledMe;
univDeleteDeadShip(deleteme,EDT_AccumDamage);
listRemoveNode(&deleteme->shiplink);
listRemoveNode(&deleteme->impactablelink);
#if ETG_DISABLEABLE
if (!etgEffectsEnabled)
{
univWipeShipOutOfExistence(deleteme);
}
#endif
}
}
}
}
void MiningBaseDied(Ship *ship)
{
Ship *deleteme;
Node *node;
MiningBaseSpec *spec = (MiningBaseSpec *)ship->ShipSpecifics;
dbgAssert(ship->shiptype == MiningBase);
if (ship->flags & SOF_NISShip)
{
return;
}
if (spec->dontRecurseKill)
{
return;
}
// first pass: Set all other MiningBases to dontRecurseKill so we don't get weird recursion
for (node = universe.ShipList.head; node != NULL; node = node->next)
{
deleteme = (Ship *)listGetStructOfNode(node);
dbgAssert(deleteme->objtype == OBJ_ShipType);
if ((deleteme->shiptype == MiningBase) && (deleteme != ship) && ((deleteme->flags & (SOF_Dead|SOF_NISShip)) == 0))
{
spec = (MiningBaseSpec *)deleteme->ShipSpecifics;
spec->dontRecurseKill = TRUE;
}
}
// delete all other mining bases
for (node = universe.ShipList.head; node != NULL; node = node->next)
{
deleteme = (Ship *)listGetStructOfNode(node);
dbgAssert(deleteme->objtype == OBJ_ShipType);
if ((deleteme->shiptype == MiningBase) && (deleteme != ship) && ((deleteme->flags & (SOF_Dead|SOF_NISShip)) == 0))
{
deleteme->howDidIDie = ship->howDidIDie;
deleteme->whoKilledMe = ship->whoKilledMe;
univDeleteDeadShip(deleteme,EDT_AccumDamage);
listRemoveNode(&deleteme->shiplink);
listRemoveNode(&deleteme->impactablelink);
#if ETG_DISABLEABLE
if (!etgEffectsEnabled)
{
univWipeShipOutOfExistence(deleteme);
}
#endif
}
}
}
xthread * xthread::getJoiner(void) {
xthread * thread = NULL;
lnode * node = NULL;
node = joinqueue.next;
PRDBG("node is %p\n", node);
#if 0
if(node == NULL) {
while(1) ;
}
#endif
assert(node != NULL);
listRemoveNode(node);
// Get corresponding thread for this thread
if(node) {
thread = container_of(node, xthread, toqueue);
PRDBG("node is %p. Get thread %p\n", node, thread);
}
else {
// Should not be here.
assert(0);
}
return thread;
}
void* DLLCALL msgQueueFind(msg_queue_t* q, const void* data, size_t length)
{
link_list_t* list = msgQueueReadList(q);
list_node_t* node;
if((node=listFindNode(list,data,length))==NULL)
return(NULL);
return listRemoveNode(list,node,/* Free Data? */FALSE);
}
void DLLCALL jsrt_Release(JSRuntime *rt)
{
list_node_t *node;
pthread_mutex_lock(&jsrt_mutex);
node = listFindNode(&rt_list, rt, 0);
if(node)
listRemoveNode(&rt_list, node, FALSE);
JS_DestroyRuntime(rt);
pthread_mutex_unlock(&jsrt_mutex);
}
void graphUnlinkVertices(Graph *G, GVertex *source, GVertex *destination)
{
NodeList *pnodo_arco;
if(!source->LAdjacents) return;
pnodo_arco = listSearch(source->LAdjacents, destination,gEdgeCmpxDestination);
if(pnodo_arco){
listRemoveNode(source->LAdjacents, pnodo_arco);
// free(pnodo_arco->cont);
//nodeListDelete(&pnodo_arco);
}
}
NodeList *graphRemoveVertex(Graph *G, GVertex *V, cmpfn cmp)
{
NodeList *pnodovertice;
// listDelete(&V->LAdjacents);
for(pnodovertice = listGetHeader(G); pnodovertice!=NULL;
pnodovertice = nodeListGetNext(pnodovertice)){
graphUnlinkVertices(G, (GVertex*)nodeListGetCont(pnodovertice), V);
}
pnodovertice = listSearch(G, V, cmp);
listRemoveNode(G, pnodovertice);
return pnodovertice;
}
long DLLCALL listRemoveNodes(link_list_t* list, list_node_t* node, long max, BOOL free_data)
{
long count;
if(list==NULL)
return(-1);
listLock(list);
if(node==FIRST_NODE)
node=list->first;
for(count=0; node!=NULL && count<max; node=node->next, count++)
if(listRemoveNode(list, node, free_data)==NULL)
break;
listUnlock(list);
return(count);
}
void univUpdateMineWallFormations()
{
Node *node,*minenode,*tempnode;
//Missile *mine, *mineend = NULL, *minestart, *mineendtemp;
MineFormationInfo *mineformationinfo;
Missile *minestart;
vector tempvec;
node = universe.MineFormationList.head;
while(node != NULL)
{
mineformationinfo = (MineFormationInfo *) listGetStructOfNode(node);
if(mineformationinfo->MineList.num == 9) //use another number other than 0 later..maybe 8? Tunable
{
//no more mines in formation so destroy this here formation
//destroy any effects that are still going
//here re-task mines (make not Force Dropped...)
if(mineformationinfo->FULL)
{
//no more mines are going to be added...
minenode = mineformationinfo->MineList.head;
//set formationinfo to NULL
while(minenode != NULL)
{
minestart = (Missile *) listGetStructOfNode(minenode);
minestart->formationinfo = NULL;
minenode = minenode->next;
}
listRemoveAll(&mineformationinfo->MineList); //removes all mine links
tempnode = node->next;
listDeleteNode(node); //destroys mineformation
node = tempnode;
continue;
}
}
else
{
//mines exist in formation
if(mineformationinfo->FULL)
{
minenode = mineformationinfo->MineList.head;
while(minenode != NULL)
{
minestart = (Missile *) listGetStructOfNode(minenode);
vecSub(tempvec, minestart->posinfo.position, minestart->formation_position);
if(vecMagnitudeSquared(tempvec) > MINE_GONE_TOO_FAR_SQR)
{
tempnode = minenode->next;
minestart->formationinfo = NULL;
listRemoveNode(&minestart->formationLink);
minenode = tempnode;
continue;
}
minenode = minenode->next;
}
}
}
ret:
node = node->next;
}
}
/*-----------------------------------------------------------------------------
Name : rmUpdateResearch
Description : updates all research
Inputs : none
Outputs : none
Return : void
----------------------------------------------------------------------------*/
void rmUpdateResearch(void)
{
sdword index, labindex, i;
ResearchLab *lab;
PlayerResearchInfo *research;
ResearchTopic *topic;
Node *walk;
LinkedList deletelist;
bool shipcanbuild[STD_LAST_SHIP];
listInit(&deletelist);
// search through list of players
for (index=0; index<universe.numPlayers; index++)
{
research = &universe.players[index].researchinfo;
if (research->CanDoResearch)
{
walk = research->listoftopics.head;
// walk through list of topics being researched
while (walk != NULL)
{
topic = (ResearchTopic *)listGetStructOfNode(walk);
topic->timeleft -= labdec[topic->numlabsresearching];
if (topic->timeleft < 0)
{
for (i = 0; i < STD_LAST_SHIP; i++)
{
shipcanbuild[i] = rmCanBuildShip(&(universe.players[index]), i);
}
// Insert sound for technology completed
if (universe.players[index].race == R1)
{
speechEventFleet(STAT_F_Research_R1_Completed, topic->techresearch, index);
}
else if (universe.players[index].race == R2)
{
speechEventFleet(STAT_F_Research_R2_Completed, topic->techresearch, index);
}
topic->timeleft = 0;
research->HasTechnology |= TechToBit(topic->techresearch);
listRemoveNode(&topic->link);
listAddNode(&deletelist,&topic->link,topic);
for (labindex=0; labindex<NUM_RESEARCHLABS; labindex++)
{
lab = &research->researchlabs[labindex];
if (lab->topic==topic)
{
lab->labstatus = LS_NORESEARCHITEM;
lab->topic = NULL;
if (rmGUIActive)
rmClearLab(labindex);
}
}
for (i = 0; i < STD_LAST_SHIP; i++)
{
if (shipcanbuild[i] != rmCanBuildShip(&(universe.players[index]), i))
{
speechEventFleet(STAT_F_Research_CompletedShip, i, index);
if (cmActive)
{
cmUpdateShipsAvailable();
}
}
}
if (singlePlayerGame && (index == 0))
{
tmTechForSale[topic->techresearch] = TM_TECH_IS_ALREADY_OWNED;
}
if (rmGUIActive)
rmUpdateTechList();
}
walk = walk->next;
}
listDeleteAll(&deletelist);
}
}
}
