static thread_func_t tcp_register_server_thread(void* s)
{
char buffer[NL_BUFFER_SIZE+1];
server_game* g = (server_game*)s;
lock_w(&game_server_array);
rAdd(&game_server_array, (void*)g);
lock_uw(&game_server_array);
LOG("New server added: %s.", g->name);
/* Let every client aware of the new server. */
broadcast_new_server(g);
/* We do not have anything to share with the server.
* So we do a tcp_rcv, and we know that is unlocks only when
* the server leaves. */
nl_tcp_rcv(buffer, g->socket);
/* Close the server socket */
close(g->socket);
/* Let every client aware of the gone server. */
broadcast_delete_server(g);
lock_w(&game_server_array);
rDelete(&game_server_array, (void*)g, NULL);
lock_uw(&game_server_array);
delete_game_server((void*)g);
LOG("Server thread terminated.");
thread_exit();
}
void BstClass<ItemType>::Delete(/* in */KeyType key) //item to be deleted
{
if(!IsEmpty())
rDelete(key, root);
else
throw DelOnEmpty("List Is Empty, Cannot Delete");
}//end Delete
void updateParticles(
ParticleSystem* system,
mFloat dt)
{
Particle* p;
rList* particles = &system->particles;
void* remember = NULL;
if((p = (Particle*)rGet(particles, FIRST, &remember)) != NULL)
{
do
{
mFloat dpx = p->vx * dt;
mFloat dpy = p->vy * dt;
p->px += dpx;
p->py += dpy;
p->ttl -= dt;
if(p->ttl <= (mFloat)0.0)
{
rDelete(particles, NULL, &remember);
mfree(p);
}
}
while((p = (Particle*)rGet(particles, NEXT, &remember)) != NULL);
}
}
void rDelete(LLNode *phere) {
/* recursive deletion of all the data items */
if(phere) {
deleteADT(phere->data); /*delete its data */
rDelete(phere->next); /* delete the children */
free(phere);
}
}
static thread_func_t tcp_register_client_thread(void* s)
{
char buffer[NL_BUFFER_SIZE+1];
server_game* g;
client* c = (client*)s;
void* remember = NULL;
/* Then, we add the client to the array, such that he will
* be informed whenever a new server arrives or leaves. */
lock_w(&client_array);
rAdd(&client_array, (void*)c);
lock_uw(&client_array);
/* We now give him the preliminary information, list all the
* servers already present. */
lock_r(&game_server_array);
nl_tcp_sndInt(game_server_array.length, c->socket);
if((g = (server_game*)rGet(&game_server_array, FIRST, &remember)) != NULL)
{
do
{
nl_tcp_snd(g->name, c->socket); /* Send the server's name */
nl_snd_addr(g->addr, c->socket); /* And now it's address. */
}
while((g = (server_game*)rGet(&game_server_array, NEXT, &remember)) != NULL);
}
lock_ur(&game_server_array);
/*
* Done. We can now communicate.
* Actually we do not have much to say to each other.
* This is just a little trick to just wait, and then the
* client leaves, this will exit.
*/
nl_tcp_rcv(buffer, c->socket);
/* Close the client socket
* If it has been closed from extern, don't try to close it again! */
close(c->socket);
lock_w(&client_array);
rDelete(&client_array, (void*)c, NULL);
delete_client((void*)c);
lock_uw(&client_array);
LOG("Client thread terminated.");
thread_exit();
}
void BstClass<ItemType>::rDelete(/* in */KeyType key, //item to be deleted
/* in */node<ItemType>* & trav) //location to test for key
{
//where key should be
if(trav == nullptr)
throw NotFound("Key not in list, Cannot Delete");
//given whether the key is greater than or less than current node
//recurse left or right
else if(trav -> data.key < key)
rDelete(key, trav -> right); //recurse right
else if(trav -> data.key > key)
rDelete(key, trav -> left); //recurse left
else //==
{
node<ItemType> * prev;
//no children
if(trav -> left == nullptr && trav -> right == nullptr)
{
delete trav;
trav = nullptr;
}//end if
//one child
else if(trav -> left != nullptr && trav -> right == nullptr ||
trav -> left == nullptr && trav -> right != nullptr)
{
node<ItemType> * temp = trav;
//left occupied
if(trav -> left != nullptr)
{
prev = GetPrev(trav->data.key, root);
if(prev == nullptr)//at root
{
trav = trav -> left;
delete temp;
}//end if
else
{
//connect tree past trav
if(prev -> left == trav)
prev -> left = trav -> left;
else
prev -> right = trav -> left;
delete trav;
trav = nullptr;
}//end else
}//end if
else
{
//get parent node
prev = GetPrev(trav->data.key, root);
if(prev == nullptr)//at root
{
trav = trav -> right;
delete temp;
}//end if
else
{
//connect tree past trav
if(prev -> left == trav)
prev -> left = trav -> right;
else
prev -> right = trav -> right;
delete trav;
}//end else
}//end else
}//end else if
//two children
else
{
//Find InOrder Recurser(highest value left of trav)
node<ItemType>* delThis = trav;
node<ItemType>* temp = RightToNull(trav -> left);
prev = GetPrev(temp -> data.key, root);
if(prev != nullptr)//not at root
{
//disconnect from tree
if(prev -> left == temp)
prev -> left = nullptr;
else
prev -> right = nullptr;
//get the parent node
prev = GetPrev(trav -> data.key, root);
if(prev == nullptr)//at root
{
temp -> right = trav -> right;
while(temp -> left != nullptr)
temp = temp -> left;
temp -> left = trav -> left;
trav = temp;
delete delThis;
}//end if
else //at root
{
if(prev -> left == trav)
prev -> left = temp;
else
prev -> right = temp;
temp -> right = trav -> right;
while(temp -> left != nullptr)
temp = temp -> left;
temp -> left = trav -> left;
delete trav;
}//end else
}//end if
}//end else
}//end else
}//end rDelete
