YMMOG Class Reference

#include <YMMOG.h>

Inheritance diagram for YMMOG:

YMMOGBase List of all members.

Public Member Functions

virtual int numInitStages () const
void initialize ()
virtual void finish ()

Protected Attributes

std::vector< ResponsibleNodeData * > responsible_nodes
std::vector< ResponsibleNodeData
* >::iterator 
i
std::list< BackupNodeDatabackup_nodes
std::list< BackupNodeData
>::iterator 
b
std::list< IntermediateNodeDataintermediate_nodes
std::list< IntermediateNodeData
>::iterator 
in

Private Member Functions

void sendEvent (int subSpaceId, int playerId, Event event)
void sendEventList (int serviceType, int subSpaceId, int timeSlot, std::vector< Event > eventList, IPAddress destip)
void sendRequestIp (OpenRequestIp openRequest)
void sendPlayerList (int action, int subSpaceId)
void sendDelay (int subSpaceId, double lastDelay, IPAddress fromIp, IPAddress destip)
void sendPing (PingMessage *openPing)
void sendStabilize (int subSpaceId, int nodeType, SubSpace subSpace)
void requestIntermediateNode (int subSpaceId)
void processPingTimer ()
void processPlayerPingTimer ()
void processDelayTimer ()
void processResendTimer ()
void processBandwithTimer ()
void processStabilizeTimer ()
void processSelfTimers (cMessage *msg)
void processAppMessages (cMessage *msg)
void processLogin (LoginMessage *loginMsg)
 Message Handling.
void processLogout (LogoutMessage *logoutMsg)
void processCreate (CreateNodeMessage *createMsg)
void processSubscribe (SubscribeMessage *subscribeMsg)
void processUnSubscribe (UnSubscribeMessage *unsubscribeMsg)
void processPublish (PublishMessage *publishMsg)
void processPublishEventList (PublishEventListMessage *publishMsg)
void processRequestIp (RequestIpMessage *requestMsg)
void processDelay (DelayMessage *delayMsg)
void processReplaceIntermediateNode (ReplaceIntermediateNodeMessage *replaceMsg)
void processPlayerList (PlayerListMessage *playerListMsg)
void processRequestNode (RequestNodeMessage *requestMsg)
void processUpdateRespIp (UpdateRespIpMessage *updateMsg)
void processReplacement (ReplacementMessage *replaceMsg)
void processPing (PingMessage *pingMsg)
void processStabilize (StabilizeMessage *smsg)
void subscribe (int subSpaceId, IPAddress destip)
void unsubscribe (int subSpaceId, IPAddress destip)
void unsubscribeAll ()
bool findSubSpace (int id)
SubSpacegetSubSpace (int id)
IPAddress findIpThroughNeighbor (int subSpaceId)
void checkSubscriptions ()
int findNeighborSubSpace (int subSpaceId)
void requestIpFromNeighbor (int neighborId, int requestedId)
void removeSubSpace (int subSpaceId)
void requestIp (int subSpaceId, int nodeType)
void informNeighbors (SubSpace subSpace)
void processTimeSlotEnd ()
void sendTreeMessages (ResponsibleNodeData *respNode, std::list< TreeMessage > msgList)
ResponsibleNodeDatafindResponsibleNodeDataById (int subSpaceId)
BackupNodeDatafindBackupNodeDataById (int subSpaceId)
IntermediateNodeDatafindIntermediateNodeDataById (int subSpaceId)
bool deleteResponsibleNodeData (int id)
bool deleteIntermediateNodeDataById (int subSpaceId)
void deleteBackupNodeDataById (int subSpaceId)

Private Attributes

std::list< NodeLogEntrynodeLog
int logLevel
 global
double timeSlotSize
int maxPlayerLeafs
int treeWidth
bool sending
int player_id
 Player specific.
int xpos
int ypos
int lastCheckedX
int lastCheckedY
int subSpaceSize
int gameSpaceSize
int currentSubSpaceId
double thisNodeBandwith
double thisNodeDelay
IPAddress lobbyIp
std::vector< SubSpacesubscribed_SubSpaces
int subscriptionRange
int unsubscriptionRange
cMessage * timeSlotTimer
cMessage * delayTimer
cMessage * playerPingTimer
int maxFailedPings
double delayDelay
int computedEvents
int maxPlayerOnline
int savedRequests
int passedSubSpaces
SubSpaceTablemagicLog

Friends

std::ostream & operator<< (std::ostream &Stream, const YMMOG y)

Member Function Documentation

virtual int YMMOG::numInitStages ( void   )  const [inline, virtual]

Reimplemented from YMMOGBase.

00033 {return 6;}

void YMMOG::initialize (  )  [virtual]

Reimplemented from YMMOGBase.

00025 {
00026         // Get Parameters
00027         timeSlotSize = par("timeSlotSize");
00028         maxPlayerLeafs = par("maxPlayerLeafs");
00029         treeWidth = par("treeWidth");
00030         subscriptionRange = par("subscriptionRange");
00031         unsubscriptionRange = par("unsubscriptionRange");
00032         logLevel = par("logLevel");
00033         maxFailed = par("maxFailed");
00034         maxFailedPings = par("maxFailedPings");
00035                 
00036         
00037         thisNodeBandwith = (check_and_cast<cBasicChannel *>(parentModule()->parentModule()->gate("out",0)->channel()))->datarate() / (1000);
00038         thisNodeDelay = (check_and_cast<cBasicChannel *>(parentModule()->parentModule()->gate("out",0)->channel()))->delay();
00039         magicLog = check_and_cast<SubSpaceTable*>(simulation.moduleByPath("globalObserver.globalFunctions[0]"));
00040 
00041         //Initiate Timeslot
00042         maxPlayerOnline = 0;
00043         computedEvents = 0;
00044                 
00045         // timers:
00046         timeSlotTimer = new cMessage("timeSlotEnd");
00047         pingTimer = new cMessage("pingTimer");
00048         delayTimer = new cMessage("delayTimer");
00049         playerPingTimer = new cMessage("playerPingTimer");
00050         scheduleAt(simTime() + 30, playerPingTimer);
00051         pingDelay = 0.2;
00052         delayDelay = 1;
00053         scheduleAt(simTime() + timeSlotSize, timeSlotTimer);
00054         sending = true;
00055         
00056         //Player things
00057         player_id = 0;
00058         xpos = 0;
00059         ypos = 0;
00060         currentSubSpaceId =0;
00061         lastCheckedX = 0;
00062         lastCheckedY = 0;
00063         // Watches:
00064         WATCH(player_id);
00065         WATCH(xpos);
00066         WATCH(ypos);
00067         WATCH(currentSubSpaceId);
00068         WATCH_VECTOR(subscribed_SubSpaces);
00069         WATCH( thisNodeBandwith );
00070         WATCH( thisNodeDelay );
00071         
00072         WATCH ( computedEvents );
00073         WATCH ( maxPlayerOnline );
00074         
00075         WATCH_PTRVECTOR ( responsible_nodes );
00076         WATCH_LIST(backup_nodes);
00077         WATCH_LIST(intermediate_nodes);
00078         
00079         //Statistics
00080         savedRequests=0;
00081         passedSubSpaces=0;
00082         WATCH(savedRequests);
00083         WATCH(passedSubSpaces);
00084         
00085         //NodeLog
00086         WATCH_LIST(nodeLog);    
00087 }

void YMMOG::finish (  )  [virtual]

Reimplemented from YMMOGBase.

00090 {       
00091         magicLog->record(-1,8,simTime()-sessionBegin);
00092         finishStats();
00093         globalStatistics->addStdDev("Own Bandwith: ", (thisNodeBandwith*1000 / 8));
00094         globalStatistics->addStdDev("Own Delay: ", thisNodeDelay);
00095         
00096         nodeLog.clear();
00097         subscribed_SubSpaces.clear();
00098         cancelEvent(delayTimer);
00099         delete delayTimer;
00100         for(i = responsible_nodes.begin(); i != responsible_nodes.end(); ++i) {
00101                 delete *i;
00102         }
00103         responsible_nodes.clear();
00104         intermediate_nodes.clear();
00105         backup_nodes.clear();
00106 }

void YMMOG::sendEvent ( int  subSpaceId,
int  playerId,
Event  event 
) [private]

00252                                                                {        
00253         PublishMessage* publishMsg = new PublishMessage("send_Event");
00254         publishMsg->setCommand(PUBLISH);
00255         publishMsg->setServiceType(REQUEST);
00256         publishMsg->setPlayerId( playerId );
00257         publishMsg->setSubSpaceId( subSpaceId );
00258         publishMsg->setPublishedEvent( event );
00259         // Send the Message
00260         sendMsg( publishMsg, getSubSpace(subSpaceId)->getRespIp() );
00261 }

void YMMOG::sendEventList ( int  serviceType,
int  subSpaceId,
int  timeSlot,
std::vector< Event eventList,
IPAddress  destip 
) [private]

00381                                                                                                                      {
00382         PublishEventListMessage* publishMsg = new PublishEventListMessage("EventList");
00383         publishMsg->setCommand(PUBLISHEVENTLIST);
00384         publishMsg->setServiceType( serviceType );
00385         publishMsg->setSubSpaceId( subSpaceId );
00386         publishMsg->setSent( simTime() );
00387         publishMsg->setTimeSlot( timeSlot );
00388         publishMsg->setEventListArraySize( eventList.size() );
00389         publishMsg->setSender( thisNode.ip.get4() );
00390         for( uint i =0; i < eventList.size(); i++) {
00391                 publishMsg->setEventList(i, eventList.at(i));
00392         }
00393         sendMsg(publishMsg, destip);    
00394 }

void YMMOG::sendRequestIp ( OpenRequestIp  openRequest  )  [private]

void YMMOG::sendPlayerList ( int  action,
int  subSpaceId 
) [private]

00397                                                      {
00398         ResponsibleNodeData* respNode = findResponsibleNodeDataById(subSpaceId);
00399         if( respNode != NULL && ( respNode->getSubSpace().getBackupIp() != (IPAddress) "127.0.0.1")  ) {
00400                 int failed = 0;
00401                 std::list<YMMOGMessage*>::iterator i = dupedMessages.begin();
00402                 while( i != dupedMessages.end() ) {
00403                         if( (*i)->getCommand() == PLAYERLIST) {
00404                                 PlayerListMessage* playerListMsg = dynamic_cast<PlayerListMessage*>(*i);
00405                                 if( playerListMsg != NULL && playerListMsg->getSubSpaceId() == subSpaceId ) {
00406                                         playerListMsg->setFailed( playerListMsg->getFailed() + 1);
00407                                         if( playerListMsg->getFailed() > maxFailed ) {
00408                                                 RequestNodeMessage* replaceMsg = new RequestNodeMessage("ReplaceBackupNodeData");
00409                                                 replaceMsg->setCommand(REQUESTNODE);
00410                                                 replaceMsg->setServiceType(REQUEST);
00411                                                 replaceMsg->setNodeType(BACKUPNODE);
00412                                                 replaceMsg->setSubSpaceId( subSpaceId );
00413                                                 sendMsg(replaceMsg, lobbyIp);
00414                                                 if( logLevel > 0 ) {
00415                                                         nodeLog.push_back( NodeLogEntry(simTime(), 22, playerListMsg->getSubSpaceId(), playerListMsg->getDestip() ) );
00416                                                 }
00417                                                 delete (*i);
00418                                                 i = dupedMessages.erase( i );
00419                                                 return;
00420                                         }
00421                                         else {
00422                                                 failed = playerListMsg->getFailed() ;
00423                                                 delete (*i);
00424                                                 i = dupedMessages.erase( i );
00425                                         }
00426                                 }
00427                                 else { ++i; }
00428                         }
00429                         else {
00430                                 ++i;
00431                         }
00432                 }
00433                 PlayerListMessage* playerListMsg = new PlayerListMessage("PlayerListMessage");
00434                 playerListMsg->setCommand(PLAYERLIST);
00435                 playerListMsg->setServiceType(REQUEST);
00436                 playerListMsg->setTimeStamp( simTime() );
00437                 playerListMsg->setFailed( failed );             
00438                 playerListMsg->setSubSpaceId( subSpaceId );
00439                 std::list<TreeNode> tmp = respNode->getPlayerList();
00440                 playerListMsg->setTreeArraySize( tmp.size() );
00441                 int t = 0;
00442                 while ( tmp.size() > 0 ) {
00443                         playerListMsg->setTree( t, tmp.front() );
00444                         tmp.pop_front();
00445                         t++;
00446                 }
00447                 /*
00448                 if( action == COMPLETE ) {
00449                         std::list<PlayerNode> playerList = respNode->getPlayerList();
00450                         std::list<PlayerNode>::iterator pL;
00451                         playerListMsg->setPlayerListArraySize(playerList.size());
00452                         int i=0;
00453                         for(pL=playerList.begin(); pL != playerList.end(); ++pL ) {
00454                                 playerListMsg->setPlayerList(i, *pL);
00455                                 i++;
00456                         }
00457                         playerListMsg->setAction(COMPLETE);
00458                 }*/
00459                 playerListMsg->setAction(COMPLETE);
00460                 sendMsg(playerListMsg, respNode->getBackupIp());
00461         }
00462 }

void YMMOG::sendDelay ( int  subSpaceId,
double  lastDelay,
IPAddress  fromIp,
IPAddress  destip 
) [private]

00670                                                                                           {
00671         DelayMessage* delayMsg = new DelayMessage("delayMsg"); 
00672         delayMsg->setCommand(DELAY);
00673         delayMsg->setDelay( lastDelay );
00674         delayMsg->setSubSpaceId( subSpaceId );
00675         delayMsg->setFromIp( fromIp );
00676         sendMsg(delayMsg, destip);
00677 }

void YMMOG::sendPing ( PingMessage *  openPing  )  [private, virtual]

Reimplemented from YMMOGBase.

00186                                           {
00187         PingMessage* pingMsg = new PingMessage("BACKUPPING");
00188         pingMsg->setCommand(PING);
00189         pingMsg->setServiceType(REQUEST);
00190         pingMsg->setSent(simTime());
00191         sendMsg(pingMsg, openPing->getDestip());
00192 }

void YMMOG::sendStabilize ( int  subSpaceId,
int  nodeType,
SubSpace  subSpace 
) [private]

01718                                                                          {
01719         StabilizeMessage* stabilizeMsg = new StabilizeMessage("Stabilize: Am i?");
01720         stabilizeMsg->setCommand(STABILIZE);
01721         stabilizeMsg->setServiceType(REQUEST);
01722         stabilizeMsg->setNodeType(nodeType);
01723         stabilizeMsg->setSubSpaceId(subSpaceId);
01724         stabilizeMsg->setCorrect(false);
01725         stabilizeMsg->setSubSpace(subSpace);
01726         sendMsg(stabilizeMsg, lobbyIp);
01727 }

void YMMOG::requestIntermediateNode ( int  subSpaceId  )  [private]

01575                                                   {
01576         RequestNodeMessage* requestMsg = new RequestNodeMessage("RequestingIntermediateNodeData");
01577         requestMsg->setCommand(REQUESTNODE);
01578         requestMsg->setServiceType(REQUEST);
01579         requestMsg->setSubSpaceId( subSpaceId);
01580         requestMsg->setNodeType( INTERMEDIATENODE );
01581         sendMsg( requestMsg, lobbyIp );
01582 }

void YMMOG::processPingTimer (  )  [private]

01476                              {
01477         selfMessages++;
01478         cancelEvent(pingTimer);
01479         std::list<PingMessage*>::iterator p= pings.begin();
01480         double next=simTime();
01481         while( p != pings.end() ) {
01482                 if( ( (*p)->getTimeStamp() + pingDelay) < simTime() ) {
01483                         (*p)->setTimeStamp(simTime());
01484                         (*p)->setFailed( (*p)->getFailed() + 1 );
01485                         if( (*p)->getFailed() > maxFailedPings ) {
01486                                 // A Responsible Node failed. Lets replace it
01487                                 b = backup_nodes.begin();
01488                                 while( b != backup_nodes.end() ) {
01489                                         //There could be more then one ResponsibleNodeData with that ip
01490                                         if( b->getSubSpace().getRespIp() == (*p)->getDestip() ) {
01491                                                 // We are the responsible Node now for that subspace
01492                                                 if( logLevel > 0 ) { nodeLog.push_back( NodeLogEntry( simTime(), 27,  b->getSubSpace().getId(), b->getSubSpace().getRespIp(), (*p)->getDestip(), (int) b->getTree().size(), true ) ); }
01493                                                 
01494                                                 b->getSubSpace().setRespIp( thisNode.ip.get4() );
01495                                                 
01496                                                 ResponsibleNodeData* respNode = new ResponsibleNodeData( b->getSubSpace() , maxPlayerLeafs, treeWidth , simTime() - maxFailedPings * pingDelay ,  b->getTree() );
01497                                                 int sendGameState = 1;
01498                                                 std::list<IPAddress> toInform = respNode->getNodeList();
01499                                                 std::list<IPAddress>::iterator tI;
01500                                                 respNode->setBackupIp( (IPAddress) "127.0.0.1" );
01501                                                 int t=0;
01502                                                 for(tI = toInform.begin(); tI != toInform.end(); ++tI) {
01503                                                         // Inform All Players and subscribe them to the new Resp Node   
01504                                                         ReplacementMessage* replaceMsg = new ReplacementMessage("ReplaceResponsibleNodeData");
01505                                                         replaceMsg->setCommand(REPLACEMENT);
01506                                                         replaceMsg->setServiceType(REQUEST);
01507                                                         replaceMsg->setSubSpaceId( b->getSubSpace().getId() );
01508                                                         replaceMsg->setSendGameState( sendGameState );
01509                                                         if( sendGameState == 1) {                       
01510                                                                 sendGameState = 0;
01511                                                         }
01512                                                         sendMsg(replaceMsg, *tI );t++;
01513                                                 }
01514                                                 responsible_nodes.push_back( respNode );
01515                                                 //Inform LobbyServer
01516                                                 ReplacementMessage* replaceMsg = new ReplacementMessage("ReplaceResponsibleNodeData");
01517                                                 replaceMsg->setCommand(REPLACEMENT);
01518                                                 replaceMsg->setServiceType(REQUEST);
01519                                                 replaceMsg->setSubSpaceId( b->getSubSpace().getId() );
01520                                                 replaceMsg->setSendGameState( sendGameState );
01521                                                 sendMsg(replaceMsg, lobbyIp);
01522                                                 //Inform Neighbors
01523                                                 informNeighbors(respNode->getSubSpace() );
01524                                                 // delete BackupNodeData 
01525                                                 b = backup_nodes.erase( b);
01526                                         }
01527                                         else { ++b; }
01528                                 }
01529                                 delete *p;
01530                                 p = pings.erase(p);
01531                         } else {
01532                                 if( next > (*p)->getTimeStamp() ) next = (*p)->getTimeStamp();
01533                                 sendPing( (*p) );
01534                                 ++p;
01535                         }
01536                 }
01537                 else { ++p; }
01538         }
01539         
01540         //resend playerPings if there are some
01541         p = playerPings.begin();
01542         while( p != playerPings.end() ) {
01543                 if( ( (*p)->getTimeStamp() + pingDelay) < simTime() ) {
01544                         (*p)->setTimeStamp(simTime());
01545                         (*p)->setFailed( (*p)->getFailed() + 1 );
01546                         if( (*p)->getFailed() > maxFailedPings ) {
01547                                 IPAddress failedIp = (*p)->getDestip();
01548                                 for( i = responsible_nodes.begin(); i != responsible_nodes.end() ; ++i) {
01549                                         sendTreeMessages( *i, (*i)->unsubscribe( failedIp ) );
01550                                 }
01551                                 delete *p;
01552                                 p = playerPings.erase(p);
01553                         }
01554                         else {
01555                                 PingMessage* cloneMsg = new PingMessage(*(*p));
01556                                 sendMsg(cloneMsg, cloneMsg->getDestip());
01557                                 ++p;
01558                         }
01559                 }
01560                 else {
01561                         ++p;
01562                 }
01563         }
01564         scheduleAt( next + pingDelay, pingTimer);
01565 }

void YMMOG::processPlayerPingTimer (  )  [private]

01430                                    {
01431         if( responsible_nodes.size() > 0 ) {
01432                 // All Pings still in playerPings are failed. So unsubscribe them from all ResponsibleNodeDatas 
01433                 std::list<PingMessage*>::iterator p = playerPings.begin();
01434                 while( playerPings.size() > 0 ) {
01435                         IPAddress failedIp = playerPings.front()->getDestip();
01436                         for( i = responsible_nodes.begin(); i != responsible_nodes.end() ; ++i) {
01437                                 sendTreeMessages( *i, (*i)->unsubscribe( failedIp ) );
01438                         }
01439                         delete playerPings.front();
01440                         playerPings.pop_front();
01441                 }
01442                 // Fill playerPings with new Ips
01443                 for( i = responsible_nodes.begin(); i != responsible_nodes.end(); ++i ) {
01444                         std::list<IPAddress> ipList = (*i)->getNodeList();
01445                         while( ipList.size() > 0 ) {
01446                                 IPAddress toInsert = ipList.front();
01447                                 bool alreadyInserted = false;
01448                                 for( p = playerPings.begin(); p != playerPings.end(); ++p) {
01449                                         if( (*p)->getDestip() == toInsert ) {
01450                                                 alreadyInserted = true;
01451                                                 break;
01452                                         }
01453                                 }
01454                                 if( !alreadyInserted) {
01455                                         PingMessage* pingMsg = new PingMessage("PlayerPing");
01456                                         pingMsg->setCommand(PING);
01457                                         pingMsg->setServiceType(REQUEST);
01458                                         pingMsg->setDestip(toInsert);
01459                                         pingMsg->setFailed(0);
01460                                         pingMsg->setTimeStamp(simTime());
01461                                         playerPings.push_back(pingMsg);
01462                                 }
01463                                 ipList.pop_front();
01464                         }
01465                 }
01466                 //send the pings:
01467                 for( p = playerPings.begin(); p != playerPings.end(); ++p ) {
01468                         PingMessage* cloneMsg = new PingMessage(*(*p));
01469                         sendMsg(cloneMsg, cloneMsg->getDestip() );
01470                 }
01471         }
01472         cancelEvent(playerPingTimer);
01473         scheduleAt(simTime() + 20, playerPingTimer);
01474 }

void YMMOG::processDelayTimer (  )  [private]

01628                                {
01629         cancelEvent(delayTimer);
01630         for( b = backup_nodes.begin(); b != backup_nodes.end(); ++b) {
01631                 Delay delay = b->getMaxDelay();
01632                 if( b->getBackupDelay() < delay.delay ) {
01633                         // Send Responsible Node Replace for delay.ip 
01634                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), 20, b->getSubSpace().getId(), delay.ip, b->getSubSpace().getRespIp(), b->getBackupDelay(),delay.delay) );
01635                         ReplaceIntermediateNodeMessage* replaceMsg = new ReplaceIntermediateNodeMessage("ReplaceIntermediateNodeData");
01636                         replaceMsg->setCommand(REPLACEINT);
01637                         replaceMsg->setServiceType(REQUEST);
01638                         replaceMsg->setSubSpaceId(b->getSubSpace().getId() );
01639                         replaceMsg->setToReplace( delay.ip );
01640                         sendMsg(replaceMsg, b->getSubSpace().getRespIp() ); 
01641                 }
01642         }
01643         scheduleAt(simTime() + delayDelay , delayTimer);
01644 }

void YMMOG::processResendTimer (  )  [private, virtual]

Reimplemented from YMMOGBase.

00263                                {
00264        double min=simTime() + resendDelay;
00265        double now = simTime();
00266        std::list<YMMOGMessage*>::iterator i = dupedMessages.begin();
00267        while( i != dupedMessages.end() ) {
00268        //&& (*i)->getCommand() != PLAYERLIST
00269               if( (*i)->getTimeStamp() + resendDelay < now ) {
00270                      // we have to resend it
00271                      (*i)->setTimeStamp(now);
00272                      (*i)->setFailed((*i)->getFailed() + 1);
00273                      if( (*i)->getFailed() > maxFailed ) {
00274                             if( (*i)->getCommand() == LOGIN ) {
00275                                 YMMOGMessage* tmp = *i;
00276                                 tmp->setFailed(0);
00277                                 i = dupedMessages.erase(i);
00278                                 sendMsg(tmp, tmp->getDestip());
00279                             }
00280                             else if( (*i)->getCommand() == REQUESTIP) {
00281                                 RequestIpMessage* rmsg = dynamic_cast<RequestIpMessage*>(*i);
00282                                 i = dupedMessages.erase(i);
00283                                 if( rmsg != NULL ) {
00284                                         requestIp(rmsg->getSubSpaceId(), rmsg->getNodeType() );
00285                                 }
00286                                 delete rmsg;    
00287                             }
00288                             else {
00289                                   delete (*i);
00290                                   i = dupedMessages.erase(i);
00291                                 droppedMessages++;
00292                             }
00293                      }
00294                      else {
00295                             YMMOGMessage* tmp = *i;
00296                             i = dupedMessages.erase(i);
00297                             sendMsg(tmp, tmp->getDestip());
00298                      }
00299                 }
00300                 else {
00301                         if( ((*i)->getTimeStamp() + resendDelay < min) &&  (*i)->getTimeStamp() + resendDelay > simTime() ) min = (*i)->getTimeStamp() + resendDelay;
00302                         ++i;
00303                 }
00304         }
00305         selfMessages++;
00306         cancelEvent(resendTimer);
00307         scheduleAt(min + 0.05, resendTimer);
00308 }

void YMMOG::processBandwithTimer (  )  [private, virtual]

Reimplemented from YMMOGBase.

01772                                  {
01773         cancelEvent(bandwithTimer);
01774         upstream->record( up / bandwithDelay );
01775         downstream->record( down / bandwithDelay );
01776         if( responsible_nodes.size() == 1 && backup_nodes.size() == 0 && intermediate_nodes.size() == 0) {
01777                 magicLog->record(responsible_nodes.front()->getPlayerListSize(),11, up / bandwithDelay);
01778                 magicLog->record(responsible_nodes.front()->getPlayerListSize(),12, down / bandwithDelay);
01779         }
01780         else if( responsible_nodes.size() == 0 && backup_nodes.size() == 1 && intermediate_nodes.size() == 0) {
01781                 magicLog->record(backup_nodes.front().getSize(),13, up / bandwithDelay);
01782                 magicLog->record(backup_nodes.front().getSize(),14, down / bandwithDelay);
01783         }
01784         else if( responsible_nodes.size() == 0 && backup_nodes.size() == 0 && intermediate_nodes.size() == 1) {
01785                 magicLog->record(intermediate_nodes.front().getSize(),15, up / bandwithDelay);
01786                 magicLog->record(intermediate_nodes.front().getSize(),16, down / bandwithDelay);
01787         }               
01788         up = 0;
01789         down = 0;       
01790         scheduleAt(simTime() + bandwithDelay, bandwithTimer);
01791 }

void YMMOG::processStabilizeTimer (  )  [private, virtual]

Reimplemented from YMMOGBase.

01707                                   {
01708         cancelEvent(stabilizeTimer);
01709         for( i = responsible_nodes.begin(); i != responsible_nodes.end(); ++i ) {
01710                 sendStabilize((*i)->getSubSpace().getId(), RESPONSIBLENODE, (*i)->getSubSpace() );
01711         }
01712         for( b= backup_nodes.begin(); b != backup_nodes.end(); ++b) {
01713                 sendStabilize(b->getSubSpace().getId(), BACKUPNODE, b->getSubSpace() );
01714         }
01715         scheduleAt(simTime() + stabilizeDelay, stabilizeTimer);
01716 }

void YMMOG::processSelfTimers ( cMessage *  msg  )  [private, virtual]

Reimplemented from YMMOGBase.

00109                                            {
00110         if(msg->isName("resendTimer")) {
00111                 processResendTimer();
00112         } else if( msg->isName("timeSlotEnd") ) {
00113                 processTimeSlotEnd();
00114         }
00115         else if( msg->isName("pingTimer") ) {
00116                 processPingTimer();
00117         }
00118         else if( msg->isName("delayTimer")) {
00119                 processDelayTimer();
00120         }
00121         else if( msg->isName("stabilizeTimer") ) {
00122                 processStabilizeTimer();
00123         }
00124         else if( msg->isName("playerPingTimer") ) {
00125                 processPlayerPingTimer();
00126         }
00127         else if(msg->isName("bandwithTimer") ) {
00128                 processBandwithTimer();
00129         }       
00130 }

void YMMOG::processAppMessages ( cMessage *  msg  )  [private, virtual]

Reimplemented from YMMOGBase.

00132                                             {
00133                 YMMOGMessage* ymmog = (YMMOGMessage*) msg;
00134                 if( ymmog->getCommand() == LOGIN ) {
00135                         lobbyIp = bootstrapOracle->getBootstrapNode().ip.get4();
00136                         LoginMessage* loginMsg = new LoginMessage("InitialLogin");
00137                         loginMsg->setCommand(LOGIN);
00138                         loginMsg->setServiceType(REQUEST);
00139                         loginMsg->setBandwith( (int) thisNodeBandwith );
00140                         sendMsg(loginMsg, lobbyIp);
00141                         delete msg;
00142                 }
00143                 else if ( ymmog->getCommand() == PUBLISH ) {
00144                         ClientEvent* clientEvent = (ClientEvent*) msg;
00145                         Event event = clientEvent->getEvent();
00146                         // Compute responsible SubSpace from X/Y coods
00147                         int subSpaceId = (event.ypos/subSpaceSize)*gameSpaceSize + (event.xpos/subSpaceSize);
00148                         if( event.type == PLAYERPOSITION ) {
00149                                 xpos = event.xpos;
00150                                 ypos = event.ypos;
00151                                 // We moved ourself, so lets check if we passed a subspace and need to check our subscriptions
00152                                 if( abs( xpos - lastCheckedX) > subscriptionRange /2  || abs( ypos - lastCheckedY) > subscriptionRange/2 ) {    checkSubscriptions();
00153                                 }
00154                                 if( subSpaceId != currentSubSpaceId ) {
00155                                         passedSubSpaces++;
00156                                         currentSubSpaceId = subSpaceId;
00157                                         checkSubscriptions();
00158                                 }
00159                         }
00160 
00161                         if( findSubSpace(subSpaceId) ) {
00162                                 sendEvent(subSpaceId, player_id, event);
00163                         }
00164                         else  {
00165                                 requestIp(subSpaceId, RESPONSIBLENODE);
00166                                 //checkSubscriptions();
00167                                 //We are not subscribed to SubSpace yet.. enqueue event and subscribe to subspace first.
00169                         }
00170                         delete msg;
00171                 }
00172 }

void YMMOG::processLogin ( LoginMessage *  loginMsg  )  [private, virtual]

Message Handling.

This Function handles the login Messages recieved from the Lobby Server. It extracts the initial position and playerid and forwards it via Message to the GameClient Applikation. It also subscribe to the first subspaces we got in the loginMessage and initiates some Timers.

Forward data to gameclient

Reimplemented from YMMOGBase.

00312                                                {
00318         receivedLogins++;
00319         if( loginMsg->getServiceType() == RESPONSE ) { 
00320                 if( player_id != 0 ) {
00321                         // We're already logged in it seems our confirmation was dropped. Resend it
00322                         loginMsg->setServiceType(CONFIRMATION);
00323                         sendMsg(loginMsg, loginMsg->getSrcip());
00324                         return;
00325                 }
00326                 player_id = loginMsg->getId ();
00327                 xpos = loginMsg->getXpos ();
00328                 ypos = loginMsg->getYpos ();
00329                 subSpaceSize = loginMsg->getSubSpaceSize();
00330                 gameSpaceSize = loginMsg->getGameSpaceSize();
00331                 currentSubSpaceId = (ypos/subSpaceSize)*gameSpaceSize + (xpos/subSpaceSize);
00332                 // Lets Subscribe to the first responsible Nodes we got
00333                 for(unsigned int k=0; k < loginMsg->getResponsibleNodesArraySize(); k++) {
00334                         subscribe( loginMsg->getResponsibleNodes(k).getId(), loginMsg->getResponsibleNodes(k).getRespIp() ); 
00335                 }
00336                 deleteFromDupedMessages(loginMsg);
00337                 loginMsg->setServiceType(CONFIRMATION);
00338                 sendMsg(loginMsg, loginMsg->getSrcip());
00339                 
00341                 ClientLogin* clientLogin = new ClientLogin("Clientlogin");
00342                 clientLogin->setCommand(LOGIN);
00343                 clientLogin->setPlayerId(player_id);
00344                 clientLogin->setXpos(xpos);
00345                 clientLogin->setYpos(ypos);
00346                 clientLogin->setGameSpaceSize(gameSpaceSize*subSpaceSize - 1);
00347                 send(clientLogin, "to_app");
00348         }
00349 }

void YMMOG::processLogout ( LogoutMessage *  logoutMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01037                                                   {
01039 }

void YMMOG::processCreate ( CreateNodeMessage *  createMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00679                                                       {
00684         receivedCreates++;
00685         //Welcher Type von Node soll erstellt werden?
00686         if ( createMsg->getServiceType() == REQUEST ) {
00687                 if( createMsg->getJobType() == DELETENODE) {
00688                         if( createMsg->getNodeType() == RESPONSIBLENODE ) {
00689                                 int subSpaceId = createMsg->getSubSpaceToCreate().getId();
00690                                 createMsg->setServiceType(RESPONSE);
00691                                 createMsg->setServiceType(false);
00692                                 for( i = responsible_nodes.begin(); i != responsible_nodes.end(); ++i ) {
00693                                         if( (*i)->getSubSpace().getId() == subSpaceId ) {
00694                                                 delete *i;
00695                                                 responsible_nodes.erase(i);
00696                                                 createMsg->setCreationSuccessfull(true);
00697                                                 break;
00698                                         }
00699                                 }
00700                                 sendMsg( createMsg, createMsg->getSrcip() );
00701                                 return;
00702                         }
00703                         if( createMsg->getNodeType() == BACKUPNODE ) {
00704                                 int subSpaceId = createMsg->getSubSpaceToCreate().getId();
00705                                 BackupNodeData* backupNode = findBackupNodeDataById( subSpaceId );
00706                                 if ( backupNode != NULL ) {
00707                                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry( simTime(), (char)12, subSpaceId, createMsg->getSrcip(), backupNode->getSubSpace().getRespIp(), backupNode->lastMessage, true) );
00708                                         for( b = backup_nodes.begin(); b != backup_nodes.end(); ++b) {
00709                                                 if( b->getId() == subSpaceId) {
00710                                                         //Clean up OpenPings
00711                                                         std::list<BackupNodeData>::iterator b2;
00712                                                         int count=-1;
00713                                                         //check if we can delete the ping (only this BackupNodeData is pinging this ip)
00714                                                         for( b2= backup_nodes.begin(); b2 != backup_nodes.end(); ++b2) {
00715                                                                 if( b2->getSubSpace().getRespIp() == b->getSubSpace().getRespIp() ) count++;
00716                                                         }
00717                                                         if( count < 1 ) {
00718                                                                 deleteFromOpenPings(b->getSubSpace().getRespIp() );
00719                                                         }
00720                                                         //Delete BackupNodeData
00721                                                         backup_nodes.erase(b);
00722                                                         break;
00723                                                 }
00724                                         }
00725                                         //delete backupNode;
00726                                         createMsg->setServiceType(RESPONSE);
00727                                         sendMsg(createMsg, createMsg->getSrcip());
00728                                         return;
00729                                 } else {
00730                                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), (char)12, subSpaceId, createMsg->getSrcip(), thisNode.ip.get4(), -1, false) );
00731                                         delete createMsg;
00732                                         return;
00733                                 }
00734                         }
00735                         else if ( createMsg->getNodeType() == INTERMEDIATENODE ) {
00736                                 for(in = intermediate_nodes.begin(); in != intermediate_nodes.end(); ++in) {
00737                                         if( in->getSubSpaceId() == createMsg->getSubSpaceToCreate().getId() ) {
00738                                                 intermediate_nodes.erase( in);
00739                                                 break;
00740                                         }
00741                                 }
00742                                 createMsg->setServiceType(RESPONSE);
00743                                 createMsg->setCreationSuccessfull(true);
00744                                 sendMsg(createMsg, lobbyIp);
00745                                 return;
00746                         }
00747                 }
00748                 switch ( createMsg->getNodeType() ) {
00749                         case RESPONSIBLENODE : { // Responsible Node
00750                                 //Create new ResponsibleNodeData
00751                                 if ( findResponsibleNodeDataById( createMsg->getSubSpaceToCreate().getId() ) != NULL ) {
00752                                         //We already have created the SubSpace... our Response seems to be dropped, resend it
00753                                         createMsg->setServiceType(RESPONSE);
00754                                         createMsg->setCreationSuccessfull(true);
00755                                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), (char)1, createMsg->getSubSpaceToCreate().getId(), createMsg->getSrcip(), thisNode.ip.get4(), false) );
00756                                         sendMsg(createMsg, createMsg->getSrcip());
00757                                         break;
00758                                 }
00759                                 SubSpace toCreate = createMsg->getSubSpaceToCreate();
00760                                 toCreate.setRespIp(thisNode.ip.get4() );
00761                                 responsible_nodes.push_back(new ResponsibleNodeData( toCreate , maxPlayerLeafs, treeWidth, (int) simTime() ));
00762                                 ResponsibleNodeData* respNode = findResponsibleNodeDataById(createMsg->getSubSpaceToCreate().getId() );
00763                                 if( respNode != NULL ) {
00764                                         createMsg->setCreationSuccessfull(true);
00765                                 }
00766                                 // Send Response                                
00767                                 createMsg->setServiceType(RESPONSE);
00768                                 sendMsg(createMsg, createMsg->getSrcip());
00769                                 if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry( simTime(), (char)1, createMsg->getSubSpaceToCreate().getId(), createMsg->getSrcip(), thisNode.ip.get4(), true) );
00770                                 break;
00771                         }
00772                         case BACKUPNODE: {
00773                                 int subSpaceId = createMsg->getSubSpaceToCreate().getId();
00774                                 if( findBackupNodeDataById( subSpaceId ) != NULL ) {
00775                                         // we already are the Backup Node for that SubSpace
00776                                         createMsg->setServiceType(RESPONSE);
00777                                         createMsg->setCreationSuccessfull(true);
00778                                         sendMsg( createMsg, createMsg->getSrcip() );
00779                                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), (char)2, createMsg->getSubSpaceToCreate().getId(), createMsg->getSubSpaceToCreate().getRespIp(), thisNode.ip.get4(), false ) );
00780                                         break;
00781                                 }
00782                                 if( backup_nodes.size() == 0) {
00783                                         cancelEvent(delayTimer);
00784                                         scheduleAt(simTime() + delayDelay, delayTimer);
00785                                 }
00786                                 backup_nodes.push_back( BackupNodeData(createMsg->getSubSpaceToCreate() ) );
00787                                 if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry( simTime(), (char)2, createMsg->getSubSpaceToCreate().getId(), createMsg->getSubSpaceToCreate().getRespIp(), thisNode.ip.get4(), true ) );
00788                                 // Request PlayerList from ResponsibleNodeData
00789                                 PlayerListMessage* playerListMsg = new PlayerListMessage("InitialPlayerListMessage");
00790                                 playerListMsg->setCommand(PLAYERLIST);
00791                                 playerListMsg->setServiceType(FORWARD);
00792                                 playerListMsg->setSubSpaceId( subSpaceId );
00793                                 sendMsg(playerListMsg,  createMsg->getSubSpaceToCreate().getRespIp() );
00794                                 // Begin pinging the responsibleNodes
00795                                 createMsg->setServiceType(RESPONSE);
00796                                 createMsg->setCreationSuccessfull(true);
00797                                 sendMsg(createMsg, createMsg->getSrcip());
00798                                 break;  
00799                         }
00800                         case INTERMEDIATENODE: {
00801                                 int subSpaceId = createMsg->getSubSpaceToCreate().getId();
00802                                 if( findIntermediateNodeDataById(subSpaceId) != NULL ) {
00803                                         createMsg->setServiceType(RESPONSE);
00804                                         createMsg->setCreationSuccessfull(false);
00805                                         sendMsg( createMsg, createMsg->getSrcip() );
00806                                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), (char)3, createMsg->getSubSpaceToCreate().getId(), createMsg->getSubSpaceToCreate().getRespIp(), thisNode.ip.get4() , false) );
00807                                         break;
00808                                 }
00809                                 if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), (char)1, createMsg->getSubSpaceToCreate().getId(), createMsg->getSubSpaceToCreate().getRespIp(), thisNode.ip.get4(), true) );
00810                                 intermediate_nodes.push_back( IntermediateNodeData( createMsg->getSubSpaceToCreate() ) );
00811                                 // Tell Responsible Node that we're ready 
00812                                 RequestIpMessage* requestMsg = new RequestIpMessage("FinishIntermediateNodeDataCreation");
00813                                 requestMsg->setCommand(REQUESTIP);
00814                                 requestMsg->setServiceType(REQUEST);
00815                                 requestMsg->setSubSpaceId(subSpaceId);
00816                                 requestMsg->setNodeType(INTERMEDIATENODE);
00817                                 requestMsg->setRequestedIp(thisNode.ip.get4());
00818                                 sendMsg( requestMsg,  createMsg->getSubSpaceToCreate().getRespIp() );
00819                                 
00820                                 // respond to lobby Server
00821                                 createMsg->setServiceType(RESPONSE);
00822                                 createMsg->setCreationSuccessfull(true);
00823                                 sendMsg(createMsg, createMsg->getSrcip());
00824                                 break;
00825                         }
00826                         default: {
00827                                 delete createMsg;
00828                                 break;
00829                         }       
00830                 }
00831         }
00832         else  {
00833                 deleteFromDupedMessages(createMsg);
00834                 delete createMsg;
00835         } 
00836 }

void YMMOG::processSubscribe ( SubscribeMessage *  subscribeMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00466                                                            {
00473         receivedSubscribes++;
00474         if( subscribeMsg->getServiceType() == REQUEST ) {
00475                 // Are we holding the subSpace the player trys to subscribe? 
00476                 int subSpaceId = subscribeMsg->getSubSpaceId();
00477                 ResponsibleNodeData* respNode = findResponsibleNodeDataById( subSpaceId );
00478                 if (respNode != NULL ) {
00479                         //yes we do, so subscribe him and send a response.
00480                         maxPlayerOnline++;
00481                         PlayerNode* player = new PlayerNode( subscribeMsg->getPlayerId(), subscribeMsg->getSrcip(), 0,0);
00482                         // Send eventually intermediateNodes messages 
00483                         sendTreeMessages( respNode, respNode->subscribe( *player ) );
00484                         magicLog->record(subSpaceId, 3, respNode->getPlayerListSize() );
00485                         magicLog->record(subSpaceId, 6, respNode->getAllIntNodes().size() );
00486                         // Respond
00487                         subscribeMsg->setGameState( respNode->getSubSpace().getGameState() );   
00488                         subscribeMsg->setServiceType(RESPONSE);
00489                         sendMsg(subscribeMsg, subscribeMsg->getSrcip());
00490                 }
00491                 else {
00492                         delete subscribeMsg;
00493                 }
00494         }
00495         else if ( subscribeMsg->getServiceType() == RESPONSE ) {
00496                 subscribed_SubSpaces.push_back( SubSpace( subscribeMsg->getSubSpaceId(), subscribeMsg->getSrcip() ) );
00497                 // Delete Subscribe from OpenSubscribes
00498                 deleteFromDupedMessages( subscribeMsg );
00499                 delete subscribeMsg;
00500         }
00501         else if ( subscribeMsg->getServiceType() == FORWARD ) {
00502                 IntermediateNodeData* inode = findIntermediateNodeDataById(subscribeMsg->getSubSpaceId());
00503                 if( inode != NULL ) {
00504                         inode->addIp( subscribeMsg->getPlayerIp() );
00505                 }
00506                 subscribeMsg->setServiceType(CONFIRMATION);
00507                 sendMsg( subscribeMsg, subscribeMsg->getSrcip() );
00508         }
00509         else { // Confirmation
00510                 deleteFromDupedMessages( subscribeMsg );
00511                 delete subscribeMsg;
00512         }
00513         
00514 }

void YMMOG::processUnSubscribe ( UnSubscribeMessage *  unsubscribeMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00516                                                                  {
00521         receivedUnSubscribes++;
00522         if( unsubscribeMsg->getServiceType() == REQUEST) {
00523                 int subSpaceId = unsubscribeMsg->getSubSpaceId();
00524                 ResponsibleNodeData* respNode = findResponsibleNodeDataById( subSpaceId );
00525                 if( respNode != NULL) {
00526                         // delete the player from subspace
00527                         magicLog->record(subSpaceId, 3, respNode->getPlayerListSize() );
00528                         magicLog->record(subSpaceId, 6, respNode->getAllIntNodes().size() );
00529                         // inform Intermediate Nodes
00530                         sendTreeMessages( respNode, respNode->unsubscribe( unsubscribeMsg->getPlayerId() ) );
00531                         // and send a response          
00532                         unsubscribeMsg->setServiceType( RESPONSE );
00533                         sendMsg(unsubscribeMsg, unsubscribeMsg->getSrcip());
00534                 }
00535                 else { 
00536                         delete unsubscribeMsg; 
00537                 }
00538         }
00539         else if ( unsubscribeMsg->getServiceType() == RESPONSE) {
00540                 int subSpaceId = unsubscribeMsg->getSubSpaceId();
00541                 if( findSubSpace( subSpaceId ) ) {
00542                         if( getSubSpace( subSpaceId )->getRespIp() == unsubscribeMsg->getSrcip() ) {
00543                                 // we're successfull unsubscribed from the subspace so delete it
00544                                 removeSubSpace( subSpaceId  );
00545                                 if( debug) std::cout<< " Unsubcribed from SubSpace: " << unsubscribeMsg->getSubSpaceId() << "\n";
00546                                 deleteFromDupedMessages( unsubscribeMsg );
00547                         }
00548                 }
00549                 delete unsubscribeMsg;
00550         }
00551         else if ( unsubscribeMsg->getServiceType() == FORWARD ) {
00552                 IntermediateNodeData* inode = findIntermediateNodeDataById(unsubscribeMsg->getSubSpaceId() );
00553                 if( inode != NULL ){
00554                         inode->removeIp( unsubscribeMsg->getPlayerIp() );
00555                 }
00556                 unsubscribeMsg->setServiceType(CONFIRMATION);
00557                 sendMsg( unsubscribeMsg, unsubscribeMsg->getSrcip() );
00558         }
00559         else { //Confirmation
00560                 deleteFromDupedMessages( unsubscribeMsg );
00561                 delete unsubscribeMsg;
00562         }
00563 }

void YMMOG::processPublish ( PublishMessage *  publishMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00565                                                      {
00569         receivedEvents++;
00570         if ( publishMsg->getServiceType() == REQUEST ) {
00571                 ResponsibleNodeData* responsibleNode = findResponsibleNodeDataById( publishMsg->getSubSpaceId() );
00572                 if( responsibleNode != NULL ) {
00573                         responsibleNode->addEvent( publishMsg->getPublishedEvent() ) ;
00574                         delete publishMsg;
00575                 }
00576                 else { delete publishMsg; } // some error handling missing
00577         }
00578 }

void YMMOG::processPublishEventList ( PublishEventListMessage *  publishMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00582                                                                        {
00594         receivedEventLists++;
00595 
00596         IPAddress backupIp;
00597         int subSpaceId = publishMsg->getSubSpaceId();
00598         int timeSlot = publishMsg->getTimeSlot();
00599         std::vector<Event> eventList;
00600         for(unsigned int i=0; i < publishMsg->getEventListArraySize(); ++i) {
00601                 eventList.push_back( publishMsg->getEventList(i) );
00602         }
00603 
00604         if( findSubSpace( subSpaceId ) ) {
00607                 if( (timeSlot == (getSubSpace(subSpaceId)->getTimeSlot() + 1) || (getSubSpace(subSpaceId)->getTimeSlot() == -1) ) && publishMsg->getSender() == getSubSpace(subSpaceId)->getRespIp() ) {
00608                         // We received the correct next timeStamp
00609                         getSubSpace(subSpaceId)->setTimeSlot( timeSlot );
00610                         ClientEventList* clientEventList = new ClientEventList("ClientEventList");
00611                         clientEventList->setCommand(PUBLISHEVENTLIST);
00612                         clientEventList->setEventListArraySize(publishMsg->getEventListArraySize());
00613                         magicLog->record(subSpaceId,10, simTime() - publishMsg->getTimeStamp() );
00614                         for(unsigned int i=0; i < eventList.size(); ++i) {
00615                                 magicLog->record(-1,9, simTime() - eventList.at(i).getTimeStamp() );
00616                                 clientEventList->setEventList(i, eventList.at(i));
00617                         }
00618                         send(clientEventList, "to_app");
00619                 }
00620                 else if( publishMsg->getTimeSlot() > (getSubSpace(subSpaceId)->getTimeSlot() + 1 )) {
00621                         // We missed at least one TimeSlot request it
00623                 }
00624         }
00625         
00626         IntermediateNodeData* intermediateNode = findIntermediateNodeDataById( subSpaceId );
00627         if( intermediateNode != NULL ) {
00628                 // We seem to have an Intermediate Node and we have to forward the Eventlists
00629                 if( timeSlot > intermediateNode->getTimeSlot() || intermediateNode->getTimeSlot() == -1) {
00630                         intermediateNode->setTimeSlot( timeSlot );
00631                         backupIp = intermediateNode->getBackupIp();
00632                         std::list<IPAddress> ips = intermediateNode->getIps();
00633                         std::list<IPAddress>::iterator forwardTo;
00634                         for( forwardTo = ips.begin() ; forwardTo != ips.end() ; ++forwardTo) {
00635                                 PublishEventListMessage* clone =  new PublishEventListMessage(*publishMsg);
00636                                 clone->setServiceType(FORWARD);
00637                                 sendMsg(clone, *forwardTo);
00638                         }
00639                         if( backupIp != thisNode.ip.get4() && publishMsg->getServiceType() == FORWARD) {
00640                                 // Compute the Delay between the last Node and us [as long lastNode is not ResponsibleNodeData]:
00641                                 if ( intermediateNode->addDelay( simTime() - publishMsg->getSent() ) ) {
00642                                         sendDelay( subSpaceId, intermediateNode->getDelay(), publishMsg->getSrcip(), backupIp);
00643                                 }
00644                         }
00645                 }
00646         }
00647         if( !findSubSpace( subSpaceId ) && intermediateNode == NULL ) {
00648                 if( !findOpenUnSubscribe( subSpaceId, publishMsg->getSender() ) ) {
00649                         UnSubscribeMessage* unsubscribeMsg = new UnSubscribeMessage("Unsubscribe");
00650                         unsubscribeMsg->setCommand(UNSUBSCRIBE);
00651                         unsubscribeMsg->setServiceType(REQUEST);
00652                         unsubscribeMsg->setSubSpaceId( subSpaceId );
00653                         unsubscribeMsg->setPlayerId( player_id) ;
00654                         unsubscribeMsg->setPlayerIp( thisNode.ip.get4() );
00655                         sendMsg(unsubscribeMsg, publishMsg->getSender() );
00656                 }
00657                 if( publishMsg->getSender() != publishMsg->getSrcip() && !findOpenUnSubscribe( subSpaceId, publishMsg->getSrcip() ) ) {
00658                         // Send the intermediate Node one unsubscribe too
00659                         UnSubscribeMessage* unsubscribeMsg2 = new UnSubscribeMessage("Unsubscribe");
00660                         unsubscribeMsg2->setCommand(UNSUBSCRIBE);
00661                         unsubscribeMsg2->setServiceType(FORWARD);
00662                         unsubscribeMsg2->setSubSpaceId( subSpaceId );
00663                         unsubscribeMsg2->setPlayerIp( thisNode.ip.get4() );
00664                         sendMsg(unsubscribeMsg2, publishMsg->getSrcip() );
00665                 }
00666         }
00667                  
00668         delete publishMsg;
00669 }

void YMMOG::processRequestIp ( RequestIpMessage *  requestMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00838                                                            {
00839         receivedRequestIps++;
00840         if (requestIpMsg->getServiceType() == REQUEST ) {
00841                 if( requestIpMsg->getNodeType() == INTERMEDIATENODE ) { 
00842                         ResponsibleNodeData* respNode = findResponsibleNodeDataById(requestIpMsg->getSubSpaceId() );
00843                         if( respNode != NULL ) {
00844                                 sendTreeMessages( respNode, respNode->addIntermediateNode(requestIpMsg->getSrcip() ) );
00845                         }
00846                         requestIpMsg->setServiceType(RESPONSE);
00847                         sendMsg(requestIpMsg, requestIpMsg->getSrcip() );
00848                         if( debug ) std::cout<< "Got a ready Intermediate Node.. IP: " << requestIpMsg->getSrcip() << " \n";
00849                 }
00850                 if ( requestIpMsg->getNodeType() == RESPONSIBLENODE) {
00851                         IPAddress responseIp = findIpThroughNeighbor(requestIpMsg->getSubSpaceId());
00852                         if( responseIp != (IPAddress) "127.0.0.1") {
00853                                 requestIpMsg->setRequestedIp(responseIp);
00854                                 requestIpMsg->setServiceType(RESPONSE);
00855                                 sendMsg(requestIpMsg, requestIpMsg->getSrcip() );
00856                         }
00857                         else {
00858                                 requestIpMsg->setServiceType(RESPONSE);
00859                                 notReadyMessages.push_back(requestIpMsg);
00860                                 bool alreadyWaiting = false;
00861                                 std::list<YMMOGMessage*>::iterator d= dupedMessages.begin();
00862                                 while( d != dupedMessages.end() ) {
00863                                         if( (*d)->getCommand() == REQUESTIP ) {
00864                                                 RequestIpMessage* rmsg = dynamic_cast<RequestIpMessage*>(*d);
00865                                                 if( rmsg != NULL && rmsg->getSubSpaceId() == requestIpMsg->getSubSpaceId() && rmsg->getDestip() == lobbyIp ) {
00866                                                         alreadyWaiting=true;
00867                                                         break;
00868                                                 }
00869                                         }
00870                                         ++d;
00871                                 }
00872                                 if( ! alreadyWaiting ) {
00873                                         requestIp(requestIpMsg->getSubSpaceId(), RESPONSIBLENODE);
00874                                 }
00875                         }
00876                 }
00877         }
00878         else if ( requestIpMsg->getServiceType() == RESPONSE ) {
00879                 if( requestIpMsg->getNodeType() == INTERMEDIATENODE ) {
00880                         deleteFromDupedMessages(requestIpMsg);
00881                         delete requestIpMsg;
00882                         return;
00883                 }
00884                 //check if we was respNode and have to forward it:
00885                 std::list<YMMOGMessage*>::iterator w= notReadyMessages.begin();
00886                 while( w != notReadyMessages.end() ) {
00887                         if( (*w)->getCommand() == REQUESTIP ) { //check if we have requests waiting because we were a responsibleNode
00888                                 RequestIpMessage* rmsg = dynamic_cast<RequestIpMessage*>(*w);
00889                                 if( rmsg != NULL && rmsg->getSubSpaceId() == requestIpMsg->getSubSpaceId() && rmsg->getServiceType() == RESPONSE ) {
00890                                         rmsg->setRequestedIp(requestIpMsg->getRequestedIp());
00891                                         w = notReadyMessages.erase(w);
00892                                         sendMsg(rmsg, rmsg->getSrcip());
00893                                         
00894                                 }
00895                                 else { ++w; }
00896                         }
00897                         else if( (*w)->getCommand() == SUBSCRIBE ) { // check if we have own subscribes waiting
00898                                 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(*w);
00899                                 if( subscribeMsg != NULL && subscribeMsg->getSubSpaceId() == requestIpMsg->getSubSpaceId() ) {
00900                                         w = notReadyMessages.erase(w);
00901                                         sendMsg( subscribeMsg, requestIpMsg->getRequestedIp() );        
00902                                 }
00903                                 else { ++w; }
00904                         }
00905                         else { ++w; }
00906                 }
00907                 deleteFromDupedMessages( requestIpMsg );
00908                 // Check if there are some old Messages
00909                 std::list<YMMOGMessage*>::iterator i = dupedMessages.begin(); 
00910                 while( i != dupedMessages.end() ) {
00911                         if( (*i)->getCommand() == SUBSCRIBE) {
00912                                 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(*i);
00913                                 if( subscribeMsg != NULL && subscribeMsg->getSubSpaceId() == requestIpMsg->getSubSpaceId() && subscribeMsg->getDestip() != requestIpMsg->getRequestedIp() ) {
00914                                         i = dupedMessages.erase(i);
00915                                         sendMsg( subscribeMsg, requestIpMsg->getRequestedIp() );
00916                                 }
00917                                 else { ++i; }
00918                         }
00919                         else if( (*i)->getCommand() == UNSUBSCRIBE) {
00920                                 UnSubscribeMessage* unsubscribeMsg = dynamic_cast<UnSubscribeMessage*>(*i);
00921                                 if( unsubscribeMsg != NULL && unsubscribeMsg->getSubSpaceId() == requestIpMsg->getSubSpaceId() && unsubscribeMsg->getDestip() != requestIpMsg->getRequestedIp() ) {
00922                                         i = dupedMessages.erase(i);
00923                                         sendMsg( unsubscribeMsg, requestIpMsg->getRequestedIp() );
00924                                 }
00925                                 else { ++i; }
00926                         }
00927                         else { ++i; }
00928                 }
00929                 if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - gameSpaceSize - 1) != NULL) {
00930                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - gameSpaceSize - 1)->setNeighbor(0,requestIpMsg->getRequestedIp());
00931                 }
00932                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - gameSpaceSize) != NULL) {
00933                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - gameSpaceSize)->setNeighbor(1,requestIpMsg->getRequestedIp());
00934                 }               
00935                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - gameSpaceSize + 1) != NULL) {
00936                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - gameSpaceSize +1)->setNeighbor(2,requestIpMsg->getRequestedIp());
00937                 }
00938                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - 1) != NULL) {
00939                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() - 1)->setNeighbor(3,requestIpMsg->getRequestedIp());
00940                 }
00941                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + 1) != NULL) {
00942                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + 1)->setNeighbor(4,requestIpMsg->getRequestedIp());
00943                 }
00944                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + gameSpaceSize - 1) != NULL) {
00945                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + gameSpaceSize -1)->setNeighbor(5,requestIpMsg->getRequestedIp());
00946                 }
00947                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + gameSpaceSize ) != NULL) {
00948                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + gameSpaceSize)->setNeighbor(6,requestIpMsg->getRequestedIp());
00949                 }
00950                 else if( findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + gameSpaceSize + 1) != NULL) {
00951                         findResponsibleNodeDataById( requestIpMsg->getSubSpaceId() + gameSpaceSize +1)->setNeighbor(7,requestIpMsg->getRequestedIp());
00952                 }
00953                 delete requestIpMsg;
00954         }
00955 
00956         else { 
00957                 delete requestIpMsg;
00958         }
00959 }

void YMMOG::processDelay ( DelayMessage *  delayMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01646                                                {
01647         BackupNodeData* backupNode = findBackupNodeDataById(delayMsg->getSubSpaceId() );
01648         if( backupNode != NULL ) {
01649                 backupNode->addDelay( delayMsg->getDelay(), delayMsg->getFromIp() );    
01650         }
01651         delete delayMsg;
01652 }

void YMMOG::processReplaceIntermediateNode ( ReplaceIntermediateNodeMessage *  replaceMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01653                                                                                      {
01654         if( replaceMsg->getServiceType() == REQUEST) {
01655                 ResponsibleNodeData* respNode = findResponsibleNodeDataById( replaceMsg->getSubSpaceId() );
01656                 if( respNode != NULL ) {
01657                         
01658                         std::list<IPAddress> ips = respNode->replaceIntermediateNode(replaceMsg->getToReplace(), replaceMsg->getSrcip());
01659                         replaceMsg->setIpListArraySize(ips.size());
01660                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry(simTime(), 25, replaceMsg->getSubSpaceId(), replaceMsg->getToReplace(), replaceMsg->getSrcip(), (double) ips.size() ) );
01661                         // copy Ips to replaceMsg
01662                         for(unsigned int i=0; i < replaceMsg->getIpListArraySize(); i++) {
01663                                 replaceMsg->setIpList( i, ips.front());
01664                                 ips.pop_front();
01665                         }
01666                         magicLog->record(replaceMsg->getSubSpaceId(),5,respNode->getReplacedIntermediateNodeCount());
01667                         replaceMsg->setSubSpace( respNode->getSubSpace() );
01668                         replaceMsg->setServiceType( RESPONSE );
01669                         // Request new Backup Node
01670                         RequestNodeMessage* requestMsg = new RequestNodeMessage("RequestBackupNodeData");
01671                         requestMsg->setCommand(REQUESTNODE);
01672                         requestMsg->setServiceType(REQUEST);
01673                         requestMsg->setNodeType(BACKUPNODE);
01674                         requestMsg->setSubSpaceId(replaceMsg->getSubSpaceId() );
01675                         if( logLevel > 0 ) nodeLog.push_back( NodeLogEntry( simTime(), 22, replaceMsg->getSubSpaceId(), respNode->getBackupIp() ) );
01676                         
01677                         sendMsg(replaceMsg, replaceMsg->getSrcip() );
01678                         sendMsg(requestMsg, lobbyIp);
01679                 }
01680         }
01681         else if ( replaceMsg->getServiceType() == RESPONSE ) {  
01682                 if ( findIntermediateNodeDataById( replaceMsg->getSubSpaceId() ) == NULL ) {
01683                         intermediate_nodes.push_back( IntermediateNodeData(replaceMsg->getSubSpace() ) );
01684                 }
01685                 IntermediateNodeData* intNode = findIntermediateNodeDataById( replaceMsg->getSubSpaceId() );
01686                 if( intNode != NULL ) {
01687                         for(unsigned int i=0; i < replaceMsg->getIpListArraySize() ; ++i ){
01688                                 intNode->addIp( replaceMsg->getIpList(i));
01689                         }
01690                 }
01691                 deleteFromDupedMessages(replaceMsg);
01692                 replaceMsg->setIpListArraySize(0);
01693                 replaceMsg->setServiceType(FORWARD);
01694                 sendMsg(replaceMsg, replaceMsg->getToReplace() );
01695         }
01696         else if( replaceMsg->getServiceType() == FORWARD ) {
01697                 deleteIntermediateNodeDataById( replaceMsg->getSubSpaceId() );
01698                 delete replaceMsg;
01699         }
01700         else {
01701                 delete replaceMsg;
01702         }
01703 }

void YMMOG::processPlayerList ( PlayerListMessage *  playerListMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01305                                                               {
01306         receivedPlayerLists++;
01307         if(playerListMsg->getServiceType() == REQUEST ) {
01308                 BackupNodeData* backupNode = findBackupNodeDataById( playerListMsg->getSubSpaceId() );
01309                 if( backupNode != NULL) {
01310                         backupNode->setBackupDelay( simTime() - playerListMsg->getTimeStamp() );
01311                         
01312                         if( playerListMsg->getAction() == COMPLETE ) {
01313                                 std::list<TreeNode> tmp;
01314                                 uint i = 0;
01315                                 while ( i < playerListMsg->getTreeArraySize() ) {
01316                                         tmp.push_back(  playerListMsg->getTree(i) );
01317                                         i++;
01318                                 }
01319                                 backupNode->setTree( tmp );
01320                         }
01321                         
01322                         if( pings.size() == 0) {
01323                                 cancelEvent(pingTimer);
01324                                 scheduleAt(simTime() + pingDelay, pingTimer);
01325                         }
01326                         if( !findOpenPing( backupNode->getSubSpace().getRespIp()) ) {
01327                                 PingMessage* pingMsg = new PingMessage("BackupNodeDataPing");
01328                                 pingMsg->setCommand(PING);
01329                                 pingMsg->setServiceType(REQUEST);
01330                                 pingMsg->setDestip( backupNode->getSubSpace().getRespIp() );
01331                                 pingMsg->setSrcip(thisNode.ip.get4() );
01332                                 pingMsg->setFailed(0);
01333                                 pingMsg->setTimeStamp(simTime());
01334                                 pings.push_back(pingMsg);
01335                                 sendPing( pingMsg );
01336                         }
01337 
01338                         deleteFromDupedMessages( playerListMsg );
01339                         backupNode->lastMessage=simTime();
01340                         playerListMsg->setServiceType(CONFIRMATION);
01341                         sendMsg(playerListMsg, playerListMsg->getSrcip() );
01342                 }
01343                 else {
01344                         if (debug) {
01345                                 std::cout<< "WARNING! We got a playerList for subSpace: " << playerListMsg->getSubSpaceId() << " from " << playerListMsg->getSrcip() << " but we're not holding the backupNode. I'm " << thisNode.ip.get4() << "\n";
01346                         }
01347                         //delete playerListMsg;
01348                         playerListMsg->setServiceType(CONFIRMATION);
01349                         sendMsg(playerListMsg, playerListMsg->getSrcip() );
01350 
01351                 }
01352         }
01353         else if ( playerListMsg->getServiceType() == CONFIRMATION ) {
01354                 deleteFromDupedMessages( playerListMsg );
01355                 delete playerListMsg;
01356         }
01357         else if ( playerListMsg->getServiceType() == FORWARD ) {
01358                 if( debug) std::cout<< "Received playerListMsg FORWARD from: " << playerListMsg->getSrcip() << " SubSpaceId: " << playerListMsg->getSubSpaceId() << " . I'm " << thisNode.ip.get4() << "\n";
01359                 
01360                 ResponsibleNodeData* respNode = findResponsibleNodeDataById(playerListMsg->getSubSpaceId());
01361                 deleteFromDupedMessages( playerListMsg );
01362                 if( respNode != NULL ) {
01363                         int subSpaceId = playerListMsg->getSubSpaceId();
01364                         respNode->setBackupIp(playerListMsg->getSrcip());
01365                         sendPlayerList(COMPLETE, subSpaceId);                   
01366                         //Inform all IntermediateNodeDatas about the new Backup node
01367                         std::list<IPAddress> playerlist = respNode->getAllIntNodes();
01368                         std::list<IPAddress>::iterator pl;
01369                         for(pl= playerlist.begin(); pl != playerlist.end(); ++pl) {
01370                                 UpdateRespIpMessage* forwardMsg = new UpdateRespIpMessage("Update Resp IP");
01371                                 forwardMsg->setCommand(UPDATERESPIP);
01372                                 forwardMsg->setServiceType(FORWARD);
01373                                 forwardMsg->setSubSpaceId(subSpaceId);
01374                                 forwardMsg->setDirection(-1);
01375                                 forwardMsg->setUpdatedIp(playerListMsg->getSrcip());
01376                                 sendMsg(forwardMsg, *pl);
01377                         }
01378                 }
01379                 else {
01380                         if ( debug) std::cout<< "WARNING! We got request to send PlayerList to backupNode " << playerListMsg->getSrcip() << " but we 're not holding RespNode Id: " << playerListMsg->getSubSpaceId() << " I'm : " << thisNode.ip.get4() << "\n";
01381                 }
01382                 delete playerListMsg;
01383         }
01384 }

void YMMOG::processRequestNode ( RequestNodeMessage *  requestMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01567                                                              {
01568         receivedRequestNodes++;
01569         if( requestMsg->getServiceType() == CONFIRMATION ) {
01570                 deleteFromDupedMessages( requestMsg );
01571                 delete requestMsg;
01572         }
01573 }

void YMMOG::processUpdateRespIp ( UpdateRespIpMessage *  updateMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00961                                                               {
00968         receivedUpdateRespIps++;
00969         if( updateMsg->getServiceType() == REQUEST ) {
00970                 int subspaceid = updateMsg->getSubSpaceId();
00971                 ResponsibleNodeData* respNode = findResponsibleNodeDataById(subspaceid);
00972                 if( respNode != NULL ) {
00973                         IPAddress updatedip = updateMsg->getUpdatedIp();
00974                         int direction = updateMsg->getDirection();
00975                         respNode->setNeighbor(direction, updatedip);
00976                         if( debug) std::cout<< "Updating "<< respNode->getId() <<" "<< subspaceid << " with IPAddress: "<< updatedip << "\n";
00977                         if( direction != -1 ) {
00978                                 /*//Inform all players
00979                                 std::list<PlayerNode> playerlist = respNode->getPlayerList();
00980                                 std::list<PlayerNode>::iterator pl;
00981                                 for(pl= playerlist.begin(); pl != playerlist.end(); ++pl) {
00982                                         if( pl->getIp() != thisNode.ip.get4() ) {
00983                                                 UpdateRespIpMessage* forwardMsg = new UpdateRespIpMessage("Update Resp IP");
00984                                                 forwardMsg->setCommand(UPDATERESPIP);
00985                                                 forwardMsg->setServiceType(FORWARD);
00986                                                 forwardMsg->setSubSpaceId(subspaceid);
00987                                                 forwardMsg->setDirection(direction);
00988                                                 forwardMsg->setUpdatedIp(updatedip);
00989                                                 if(debug) std::cout<< "Sending Updated SubSpace "<< subspaceid << " with new IP: "<< updatedip << " at "<< direction << " to: " << pl->getIp() << "\n";
00990                                                 sendMsg(forwardMsg, pl->getIp());
00991                                         }
00992                                 }*/
00993                         }
00994                         else {
00995                                 // Inform intermediateNodes from new BackupNodeData
00996                                 std::list<IPAddress> ips = respNode->getAllIntNodes();
00997                                 std::list<IPAddress>::iterator i;
00998                                 for(i = ips.begin(); i != ips.end(); ++i ) {
00999                                         UpdateRespIpMessage* forwardMsg = new UpdateRespIpMessage("Update Resp Backup IP");
01000                                         forwardMsg->setCommand(UPDATERESPIP);
01001                                         forwardMsg->setServiceType(FORWARD);
01002                                         forwardMsg->setSubSpaceId(subspaceid);
01003                                         forwardMsg->setDirection(direction);
01004                                         forwardMsg->setUpdatedIp(updatedip);
01005                                         if(debug) std::cout<< "Sending Updated SubSpace "<< subspaceid << " with new Backup IP: "<< updatedip << " at "<< direction << " to: " << (*i) << "\n";
01006                                         sendMsg(forwardMsg, (*i));
01007                                 }
01008                         }
01009                         updateMsg->setServiceType(CONFIRMATION);
01010                         sendMsg(updateMsg, updateMsg->getSrcip() );
01011                 }
01012                 else {
01013                         // we're not holding requestet subspace
01014                         delete updateMsg;
01015                 } 
01016         }
01017         else if( updateMsg->getServiceType() == CONFIRMATION ) {
01018                 deleteFromDupedMessages( updateMsg );
01019                 delete updateMsg;
01020         }
01021         else if( updateMsg->getServiceType() == FORWARD ) {
01022                 SubSpace* subSpace = getSubSpace(updateMsg->getSubSpaceId());
01023                 if( subSpace != NULL ) {
01024                         subSpace->setNeighbor(updateMsg->getDirection(), updateMsg->getUpdatedIp());
01025                 }
01026                 if( updateMsg->getDirection() == -1) {
01027                         IntermediateNodeData* intNode = findIntermediateNodeDataById( updateMsg->getSubSpaceId() );
01028                         if( intNode != NULL ) {
01029                                 intNode->setBackupIp( updateMsg->getUpdatedIp() );
01030                         }
01031                 }
01032                 updateMsg->setServiceType(CONFIRMATION);
01033                 sendMsg(updateMsg, updateMsg->getSrcip());
01034         }
01035 }

void YMMOG::processReplacement ( ReplacementMessage *  replaceMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01388                                                              {
01389         receivedReplacements++;
01390         if( replaceMsg->getServiceType() == REQUEST) {
01391                 SubSpace* subSpace =  getSubSpace(replaceMsg->getSubSpaceId());
01392                 if( subSpace != NULL ) {
01393                         IPAddress newIp = replaceMsg->getSrcip();
01394                         int subSpaceId = replaceMsg->getSubSpaceId();
01395                         IPAddress oldRespIp = subSpace->getRespIp();
01396                         subSpace->setRespIp( newIp );
01397                         //check if there are some openUnsubscribes
01398                         std::list<YMMOGMessage*>::iterator i= dupedMessages.begin();
01399                         while( i != dupedMessages.end() ) {
01400                                 if( (*i)->getCommand() == UNSUBSCRIBE ) {
01401                                         UnSubscribeMessage* unsubscribeMsg = dynamic_cast<UnSubscribeMessage*>(*i);
01402                                         if( unsubscribeMsg != NULL && unsubscribeMsg->getSubSpaceId() == subSpaceId && unsubscribeMsg->getDestip() == oldRespIp && oldRespIp != newIp ) {
01403                                                 unsubscribeMsg->setFailed(0);
01404                                                 i = dupedMessages.erase(i);
01405                                                 sendMsg(unsubscribeMsg, newIp);
01406                                         }
01407                                         else { ++i; }
01408                                 }
01409                                 else { ++i; }
01410                         }
01411                         if( replaceMsg->getSendGameState() == 1) {
01412                                 replaceMsg->setGameState( getSubSpace(replaceMsg->getSubSpaceId() )->getGameState() );
01413                         }
01414                         replaceMsg->setServiceType(CONFIRMATION);
01415                         sendMsg(replaceMsg, replaceMsg->getSrcip() );
01416                 }
01417                 else {
01418                         delete replaceMsg;
01419                 }
01420         }
01421         else { // Confirmation
01422                 if( replaceMsg->getSendGameState() == 1) {
01423                         // Load GameState to responsibleNodes
01425                 }
01426                 delete replaceMsg;
01427         }
01428 }

void YMMOG::processPing ( PingMessage *  pingMsg  )  [private, virtual]

Reimplemented from YMMOGBase.

00174                                             {
00175         receivedPings++;
00176         if( pingMsg->getServiceType() == CONFIRMATION) {
00177                 resetPing( pingMsg->getSrcip() );
00178                 delete pingMsg;
00179         } else {
00180                 pingMsg->setServiceType(CONFIRMATION);
00181                 pingMsg->setSent(simTime());
00182                 sendMsg(pingMsg, pingMsg->getSrcip() );
00183         }
00184 }

void YMMOG::processStabilize ( StabilizeMessage *  smsg  )  [private, virtual]

Reimplemented from YMMOGBase.

01729                                                            {
01730         if( stabilizeMsg->getServiceType() == REQUEST ) {
01731                 if( findResponsibleNodeDataById(stabilizeMsg->getSubSpaceId()) == NULL ) {
01732                         responsible_nodes.push_back(new ResponsibleNodeData( stabilizeMsg->getSubSpace() , maxPlayerLeafs, treeWidth, (int) simTime() ));
01733                 }
01734         }
01735         else if( stabilizeMsg->getServiceType() == RESPONSE ) {
01736                 if ( ! stabilizeMsg->getCorrect() ) {
01737                         if( stabilizeMsg->getNodeType() == RESPONSIBLENODE) {
01738                                 for( i = responsible_nodes.begin(); i != responsible_nodes.end(); ++i) {
01739                                         if( (*i)->getSubSpace().getId() == stabilizeMsg->getSubSpaceId() ) {
01740                                                 responsible_nodes.erase(i);
01741                                                 break;
01742                                         }
01743                                 }
01744                         }
01745                         else if ( stabilizeMsg->getNodeType() == BACKUPNODE) {
01746                                 for( b = backup_nodes.begin(); b != backup_nodes.end(); ++b) {
01747                                         if( b->getSubSpace().getId() == stabilizeMsg->getSubSpaceId() ) {
01748                                                 backup_nodes.erase(b);
01749                                                 break;
01750                                         }
01751                                 }
01752                         }
01753                 }
01754                 else { 
01755                         if( stabilizeMsg->getNodeType() == RESPONSIBLENODE ) {
01756                                 ResponsibleNodeData* respNode = findResponsibleNodeDataById(stabilizeMsg->getSubSpaceId() ) ;
01757                                 if( respNode != NULL ) {
01758                                         respNode->setSubSpace( stabilizeMsg->getSubSpace() );
01759                                 }
01760                         }
01761                         else if( stabilizeMsg->getNodeType() == BACKUPNODE) {
01762                                 BackupNodeData* backupNode = findBackupNodeDataById( stabilizeMsg->getSubSpaceId() );
01763                                 if( backupNode != NULL ) {
01764                                         backupNode->setSubSpace( stabilizeMsg->getSubSpace() );
01765                                 }
01766                         }
01767                 }
01768         }
01769         delete stabilizeMsg;
01770 }

void YMMOG::subscribe ( int  subSpaceId,
IPAddress  destip 
) [private]

01041                                                       {
01046         if( !findOpenSubScribe( subSpaceId, destip) ) {
01047                 SubscribeMessage* subscribeMsg = new SubscribeMessage("SubscribeToSubSpace");
01048                 subscribeMsg->setCommand(SUBSCRIBE);
01049                 subscribeMsg->setServiceType(REQUEST);
01050                 subscribeMsg->setPlayerId( player_id );
01051                 subscribeMsg->setSubSpaceId( subSpaceId );
01052                 sendMsg(subscribeMsg, destip);
01053         }
01054 }

void YMMOG::unsubscribe ( int  subSpaceId,
IPAddress  destip 
) [private]

01057                                                         {
01062         if ( !findOpenUnSubscribe(subSpaceId,destip) ) {
01063                 UnSubscribeMessage* unsubscribeMsg = new UnSubscribeMessage("UnsubscribeFromSubSpace");
01064                 unsubscribeMsg->setCommand(UNSUBSCRIBE);
01065                 unsubscribeMsg->setServiceType(REQUEST);
01066                 unsubscribeMsg->setPlayerId( player_id);
01067                 unsubscribeMsg->setSubSpaceId( subSpaceId );
01068                 sendMsg( unsubscribeMsg, destip );
01069         }
01070 }

void YMMOG::unsubscribeAll (  )  [private]

01072                            {
01076         std::vector<SubSpace>::iterator i;
01077         for(i=subscribed_SubSpaces.begin() ; i != subscribed_SubSpaces.end(); ++i) {
01078                 unsubscribe( (*i).getId() , (*i).getRespIp() );
01079         }
01080 }

bool YMMOG::findSubSpace ( int  id  )  [private]

01092                                {
01093         std::vector<SubSpace>::iterator i;
01094         for(i=subscribed_SubSpaces.begin(); i != subscribed_SubSpaces.end() ; ++i ) {
01095                 if( i->getId() == id ) return true;
01096         }
01097         return false;
01098 }

SubSpace * YMMOG::getSubSpace ( int  id  )  [private]

01100                                    {
01101         std::vector<SubSpace>::iterator i;
01102         for(i=subscribed_SubSpaces.begin(); i != subscribed_SubSpaces.end() ; ++i ) {
01103                 if( i->getId() == id ) return &(*i);
01104         }
01105         return NULL;
01106 }

IPAddress YMMOG::findIpThroughNeighbor ( int  subSpaceId  )  [private]

01124                                                      {
01125         //
01126         IPAddress toSubscribe;
01127         ResponsibleNodeData* respNode = findResponsibleNodeDataById( subSpaceId );
01128         if ( respNode != NULL ) { return respNode->getSubSpace().getRespIp(); }
01129         if ( findSubSpace(subSpaceId - gameSpaceSize -1) ) {
01130                 toSubscribe = getSubSpace(subSpaceId - gameSpaceSize -1)->getNeighbor(SE);
01131                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01132         }
01133         if ( findSubSpace(subSpaceId - gameSpaceSize) ) {
01134                 toSubscribe = getSubSpace(subSpaceId - gameSpaceSize)->getNeighbor(S);
01135                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01136         }
01137         if ( findSubSpace(subSpaceId - gameSpaceSize + 1) ) {
01138                 toSubscribe = getSubSpace(subSpaceId - gameSpaceSize + 1)->getNeighbor(SW);
01139                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01140         }
01141         if ( findSubSpace(subSpaceId - 1) ) {
01142                 toSubscribe = getSubSpace(subSpaceId - 1)->getNeighbor(E);
01143                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01144         }
01145         if ( findSubSpace(subSpaceId + 1) ) {
01146                 toSubscribe = getSubSpace(subSpaceId + 1)->getNeighbor(W);
01147                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01148         }
01149         if ( findSubSpace(subSpaceId + gameSpaceSize - 1) ) {
01150                 toSubscribe = getSubSpace(subSpaceId + gameSpaceSize - 1)->getNeighbor(NE);
01151                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01152         }
01153         if ( findSubSpace(subSpaceId + gameSpaceSize ) ) {
01154                 toSubscribe = getSubSpace(subSpaceId + gameSpaceSize)->getNeighbor(N);
01155                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01156         }
01157         if ( findSubSpace(subSpaceId + gameSpaceSize + 1) ) {
01158                 toSubscribe = getSubSpace(subSpaceId + gameSpaceSize + 1)->getNeighbor(NW);
01159                 if( toSubscribe != (IPAddress) "127.0.0.1" ) return toSubscribe;        
01160         }
01161         // We haven't found the ip in our neighbors so return dummy.
01162         return (IPAddress) "127.0.0.1";
01163 }

void YMMOG::checkSubscriptions (  )  [private]

01218                                {
01219         lastCheckedX = xpos;
01220         lastCheckedY = ypos;
01221         // Find all SubSpaces in Subscription Range that are not subscribed yet and subscribe to them
01222         if ( debug ) {
01223                 std::cout<< "We're subscribed to " << subscribed_SubSpaces.size() << " SubSpaces yet\n";
01224         }
01225         int xbegin = (xpos - subscriptionRange) / subSpaceSize;
01226         if ( xbegin < 0 ) xbegin = 0;
01227         int xend  = (xpos + subscriptionRange) / subSpaceSize;
01228         if ( xend >= gameSpaceSize ) xend = gameSpaceSize - 1;
01229         
01230         int ybegin = (ypos - subscriptionRange) / subSpaceSize;
01231         if ( ybegin < 0 ) ybegin = 0;
01232         int yend = (ypos + subscriptionRange) / subSpaceSize;
01233         if ( yend >= gameSpaceSize ) yend = gameSpaceSize - 1;
01234         for( int i= xbegin; i <= xend; i++) {
01235                 for (int k= ybegin; k <= yend; k++) {
01236                         // Is SubSpace already subscribed?
01237                         if ( ! findSubSpace( k*gameSpaceSize + i ) ) {
01238                                 //No then lets Subscribe..
01239                                 //check if we already have an open Subscribe we're waiting for:
01240                                 bool alreadyWaitingForSubscribe=false;
01241                                 std::list<YMMOGMessage*>::iterator w= notReadyMessages.begin();
01242                                 while( w != notReadyMessages.end() ) {
01243                                         if( (*w)->getCommand() == SUBSCRIBE ) {
01244                                                 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(*w);
01245                                                 if( subscribeMsg != NULL && subscribeMsg->getSubSpaceId() == k*gameSpaceSize + i ) {
01246                                                         alreadyWaitingForSubscribe = true;
01247                                                         break;
01248                                                 }
01249                                         }
01250                                         ++w;
01251                                 }
01252                                 w = dupedMessages.begin();
01253                                 while( w != dupedMessages.end() ) {
01254                                         if( (*w)->getCommand() == SUBSCRIBE ) {
01255                                                 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(*w);
01256                                                 if( subscribeMsg != NULL && subscribeMsg->getSubSpaceId() == k*gameSpaceSize + i ) {
01257                                                         alreadyWaitingForSubscribe = true;
01258                                                         break;
01259                                                 }
01260                                         }
01261                                         ++w;
01262                                 }
01263                                 if( !alreadyWaitingForSubscribe ) {
01264                                         SubscribeMessage* subscribeMsg = new SubscribeMessage("Subscribe");
01265                                         subscribeMsg->setCommand(SUBSCRIBE);
01266                                         subscribeMsg->setServiceType(REQUEST);
01267                                         subscribeMsg->setPlayerId(player_id);
01268                                         subscribeMsg->setPlayerIp(thisNode.ip.get4());
01269                                         subscribeMsg->setSubSpaceId(k*gameSpaceSize + i);
01270                                         if( findResponsibleNodeDataById(k*gameSpaceSize+i) != NULL ) {
01271                                                 sendMsg(subscribeMsg, thisNode.ip.get4() );
01272                                         }
01273                                         else {
01274                                                 notReadyMessages.push_back(subscribeMsg);
01275                                         }
01276                                         int sid = findNeighborSubSpace( k*gameSpaceSize + i );
01277                                         if( sid != -1 ) {
01278                                                 requestIpFromNeighbor(sid, k*gameSpaceSize + i);
01279                                         }
01280                                         else {
01281                                                         requestIp( k*gameSpaceSize + i, RESPONSIBLENODE);
01282                                         }
01283                                 }
01284                         }
01285                 }
01286         }
01287         // Do we have to unsubscribe some?
01288         std::vector<SubSpace>::iterator i;
01289         for(i=subscribed_SubSpaces.begin(); i != subscribed_SubSpaces.end() ; ++i ) {
01290                 if(  i->getId() < ((ypos - unsubscriptionRange) / subSpaceSize)*gameSpaceSize  ) {
01291                         unsubscribe(i->getId(), i->getRespIp() );
01292                 }
01293                 else if ( i->getId() % gameSpaceSize < ((xpos - unsubscriptionRange) / subSpaceSize) ) {
01294                         unsubscribe(i->getId(), i->getRespIp() );
01295                 }
01296                 else if( i->getId() % gameSpaceSize > ((xpos + unsubscriptionRange) / subSpaceSize) ) {
01297                         unsubscribe(i->getId(), i->getRespIp() );
01298                 }
01299                 else if( i->getId() > ( (( (ypos + unsubscriptionRange) / subSpaceSize) +1) )*gameSpaceSize ) {
01300                         unsubscribe(i->getId(), i->getRespIp() );
01301                 }
01302         }
01303 }

int YMMOG::findNeighborSubSpace ( int  subSpaceId  )  [private]

01205                                               {
01206         if( findSubSpace(subSpaceId - gameSpaceSize -1) ) return subSpaceId - gameSpaceSize -1;
01207         if( findSubSpace(subSpaceId - gameSpaceSize ) ) return subSpaceId - gameSpaceSize;
01208         if( findSubSpace(subSpaceId - gameSpaceSize +1) ) return subSpaceId - gameSpaceSize +1;
01209         if( findSubSpace(subSpaceId - 1) ) return subSpaceId -1;
01210         if( findSubSpace(subSpaceId + 1) ) return subSpaceId +1;
01211         if( findSubSpace(subSpaceId + gameSpaceSize -1) ) return subSpaceId + gameSpaceSize -1;
01212         if( findSubSpace(subSpaceId + gameSpaceSize ) ) return subSpaceId + gameSpaceSize;
01213         if( findSubSpace(subSpaceId + gameSpaceSize +1) ) return subSpaceId + gameSpaceSize +1;
01214         return -1;      
01215 }

void YMMOG::requestIpFromNeighbor ( int  neighborId,
int  requestedId 
) [private]

01185                                                                        {
01186         std::list<YMMOGMessage*>::iterator i=dupedMessages.begin();
01187         while( i != dupedMessages.end() ) {
01188                 if( (*i)->getCommand() == REQUESTIP ) {
01189                         RequestIpMessage* rmsg = dynamic_cast<RequestIpMessage*>(*i);
01190                         if( rmsg != NULL && rmsg->getSubSpaceId() == requestedSubSpace && rmsg->getDestip() ==  getSubSpace(neighborId)->getRespIp() ) {
01191                                 return;
01192                         }
01193                         else { ++i; }
01194                 }
01195                 else { ++i; }
01196         }
01197         RequestIpMessage* requestMsg = new RequestIpMessage("RequestIpThroughNeighbor");
01198         requestMsg->setCommand(REQUESTIP);
01199         requestMsg->setServiceType(REQUEST);
01200         requestMsg->setSubSpaceId( requestedSubSpace );
01201         requestMsg->setNodeType( RESPONSIBLENODE );
01202         sendMsg( requestMsg, getSubSpace(neighborId)->getRespIp() );
01203 }

void YMMOG::removeSubSpace ( int  subSpaceId  )  [private]

01082                                            {
01083         std::vector<SubSpace>::iterator i;
01084         for(i=subscribed_SubSpaces.begin() ; i != subscribed_SubSpaces.end(); ++i) {
01085                 if( i->getId() == subSpaceId) { 
01086                         subscribed_SubSpaces.erase(i);
01087                         break;
01088                 }
01089         }
01090 }

void YMMOG::requestIp ( int  subSpaceId,
int  nodeType 
) [private]

01165                                                   {
01166         std::list<YMMOGMessage*>::iterator i=dupedMessages.begin();
01167         while( i != dupedMessages.end() ) {
01168                 if( (*i)->getCommand() == REQUESTIP ) {
01169                         RequestIpMessage* rmsg = dynamic_cast<RequestIpMessage*>(*i);
01170                         if( rmsg != NULL && rmsg->getSubSpaceId() == subSpaceId && rmsg->getDestip() == lobbyIp ) {
01171                                 return;
01172                         }
01173                         else { ++i; }
01174                 }
01175                 else { ++i; }
01176         }       
01177         RequestIpMessage* requestMsg = new RequestIpMessage("RequestIpForNode");
01178         requestMsg->setCommand(REQUESTIP);
01179         requestMsg->setServiceType(REQUEST);
01180         requestMsg->setSubSpaceId( subSpaceId );
01181         requestMsg->setNodeType( nodeType );
01182         sendMsg( requestMsg, lobbyIp );
01183 }

void YMMOG::informNeighbors ( SubSpace  subSpace  )  [private]

01108                                              {
01109         for( int i=0; i < 8; i++) {
01110                 if( subSpace.getNeighbor(i) != (IPAddress) "127.0.0.1" ) {
01111                         UpdateRespIpMessage* updateMsg = new UpdateRespIpMessage("Update Responsible Ip");
01112                         updateMsg->setCommand(UPDATERESPIP);
01113                         updateMsg->setServiceType(REQUEST);
01114                         if( i < 3 ) { updateMsg->setSubSpaceId(subSpace.getId() - gameSpaceSize + i - 1 ); }
01115                         else if( i == 3) { updateMsg->setSubSpaceId(subSpace.getId() - 1 ); }
01116                         else if( i == 4) { updateMsg->setSubSpaceId(subSpace.getId() + 1 ); }
01117                         else if (i >= 5) { updateMsg->setSubSpaceId(subSpace.getId() + gameSpaceSize + i - 6 ); }
01118                         updateMsg->setDirection(7-i);
01119                         updateMsg->setUpdatedIp(subSpace.getRespIp());
01120                         sendMsg(updateMsg, subSpace.getNeighbor(i));
01121                 }
01122         }
01123 }

void YMMOG::processTimeSlotEnd (  )  [private]

00351                                {
00357         if( sending ) {
00358                 std::vector<ResponsibleNodeData*>::iterator i;
00359                 for(i=responsible_nodes.begin(); i != responsible_nodes.end(); ++i) {
00360                         int subSpaceId = (*i)->getId();
00361                         magicLog->record(subSpaceId, 4,(*i)->getDroppedEvents());
00362                         std::vector<Event> eventList = (*i)->endTimeSlot(simTime() );  //creates the ordered Eventlist
00363                         int timeSlot = (*i)->getSubSpace().getTimeSlot();
00364                         computedEvents += eventList.size(); // global statistic
00365                         std::list<IPAddress> playerList = (*i)->getList();
00366                         std::list<IPAddress>::iterator pL;
00367                         for( pL = playerList.begin(); pL != playerList.end() ; ++pL ) {
00368                                 sendEventList(REQUEST, subSpaceId, timeSlot, eventList, *pL);
00369                         }
00370                         sendPlayerList( COMPLETE, subSpaceId);
00371                         eventList.clear();
00372                 }
00373                 sending = false;
00374         }
00375         else { sending = true; }
00376         // set the new timeout
00377         cancelEvent(timeSlotTimer);
00378         scheduleAt(simTime() + timeSlotSize/2, timeSlotTimer);
00379 }

void YMMOG::sendTreeMessages ( ResponsibleNodeData respNode,
std::list< TreeMessage msgList 
) [private]

01585                                                                                               {
01586         std::list<TreeMessage> msgList = treeMessages;
01587         std::list<TreeMessage>::iterator m ;
01588         for ( m = msgList.begin(); m != msgList.end() ; ++m) {
01589                 if( m->type == 0 ) {
01590                         // Forward Subscribe to IntermediateNodeData
01591                         SubscribeMessage* subscribeMsg = new SubscribeMessage("ForwardSubScribeToIntermediateNodeData");
01592                         subscribeMsg->setCommand(SUBSCRIBE);
01593                         subscribeMsg->setServiceType(FORWARD);
01594                         subscribeMsg->setPlayerId(-1);
01595                         subscribeMsg->setPlayerIp( m->playerip );
01596                         subscribeMsg->setSubSpaceId( respNode->getId()  );
01597                         sendMsg( subscribeMsg, m->destip );
01598                 }
01599                 else if( m->type == 1) {
01600                         // Forward UnSubscribe to IntermediateNodeData
01601                         UnSubscribeMessage* unsubscribeMsg = new UnSubscribeMessage("ForwardUnSubscribeToIntermediateNodeData");
01602                         unsubscribeMsg->setCommand(UNSUBSCRIBE);
01603                         unsubscribeMsg->setServiceType(FORWARD);
01604                         unsubscribeMsg->setPlayerId(-1);
01605                         unsubscribeMsg->setPlayerIp( m->playerip );
01606                         unsubscribeMsg->setSubSpaceId( respNode->getId() );
01607                         sendMsg( unsubscribeMsg, m->destip);
01608                 }
01609                 else if ( m->type == 2 ) {
01610                         // request a new IntermediateNode
01611                         requestIntermediateNode(respNode->getId() );
01612                 }
01613                 else if ( m->type == 3) {
01614                         // delete IntermediateNodeData
01615                         CreateNodeMessage* createMsg = new CreateNodeMessage("DeleteIntermediateNodeData");
01616                         createMsg->setCommand(CREATE);
01617                         createMsg->setServiceType(FORWARD);
01618                         createMsg->setNodeType(INTERMEDIATENODE);
01619                         createMsg->setJobType(DELETENODE);
01620                         createMsg->setSubSpaceToCreate( SubSpace(respNode->getId()) );
01621                         sendMsg(createMsg, m->destip);
01622                         if( logLevel > 0 ) { nodeLog.push_back( NodeLogEntry(simTime(),26,respNode->getId(),m->destip) ); }     
01623                 }
01624         }
01625         
01626 }

ResponsibleNodeData * YMMOG::findResponsibleNodeDataById ( int  subSpaceId  )  [private]

00224                                                               {
00225         for(i=responsible_nodes.begin(); i != responsible_nodes.end(); ++i) {   
00226                 if ( (*i)->getId() == id ) {
00227                         return (*i); 
00228                 }
00229         }
00230         return NULL;
00231 }

BackupNodeData * YMMOG::findBackupNodeDataById ( int  subSpaceId  )  [private]

00233                                                             {
00234         for(b=backup_nodes.begin(); b != backup_nodes.end(); ++b)  {
00235                 if( b->getId() == subSpaceId ) {
00236                         return &(*b);
00237                 }
00238         }
00239         return NULL;
00240 }

IntermediateNodeData * YMMOG::findIntermediateNodeDataById ( int  subSpaceId  )  [private]

00242                                                                         {
00243         for( in = intermediate_nodes.begin(); in != intermediate_nodes.end() ; in++) {
00244                 if( in->getSubSpaceId() == subSpaceId) {
00245                         return &(*in);
00246                 }
00247         }
00248         return NULL;
00249 }

bool YMMOG::deleteResponsibleNodeData ( int  id  )  [private]

00195                                             {
00196         for(i=responsible_nodes.begin(); i != responsible_nodes.end(); ++i) {   
00197                 if ( (*i)->getId() == id ) {
00198                         delete *i;
00199                         responsible_nodes.erase(i);
00200                         return true; 
00201                 }
00202         }
00203         return false;
00204 }

bool YMMOG::deleteIntermediateNodeDataById ( int  subSpaceId  )  [private]

00205                                                            {
00206         for(in = intermediate_nodes.begin(); in != intermediate_nodes.end(); ++in) {
00207                 if( in->getSubSpaceId() == subSpaceId) {
00208                         intermediate_nodes.erase(in);
00209                         return true;
00210                 }
00211         }
00212         return false;
00213 }

void YMMOG::deleteBackupNodeDataById ( int  subSpaceId  )  [private]

00215                                                     {
00216         for( b = backup_nodes.begin(); b != backup_nodes.end(); ++b) {
00217                 if( b->getSubSpace().getId() == subSpaceId) {
00218                         backup_nodes.erase(b);
00219                         break;
00220                 }
00221         }
00222 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  Stream,
const YMMOG  y 
) [friend]

01794 {
01795     return Stream << "IP: "  << "Holding "<< y.responsible_nodes.size() << " Responsible Nodes";
01796 }


Member Data Documentation

std::vector<ResponsibleNodeData*> YMMOG::responsible_nodes [protected]

std::vector<ResponsibleNodeData*>::iterator YMMOG::i [protected]

std::list<BackupNodeData> YMMOG::backup_nodes [protected]

std::list<BackupNodeData>::iterator YMMOG::b [protected]

std::list<IntermediateNodeData> YMMOG::intermediate_nodes [protected]

std::list<IntermediateNodeData>::iterator YMMOG::in [protected]

std::list<NodeLogEntry> YMMOG::nodeLog [private]

int YMMOG::logLevel [private]

global

double YMMOG::timeSlotSize [private]

int YMMOG::maxPlayerLeafs [private]

int YMMOG::treeWidth [private]

bool YMMOG::sending [private]

int YMMOG::player_id [private]

Player specific.

int YMMOG::xpos [private]

int YMMOG::ypos [private]

int YMMOG::lastCheckedX [private]

int YMMOG::lastCheckedY [private]

int YMMOG::subSpaceSize [private]

int YMMOG::gameSpaceSize [private]

int YMMOG::currentSubSpaceId [private]

double YMMOG::thisNodeBandwith [private]

double YMMOG::thisNodeDelay [private]

IPAddress YMMOG::lobbyIp [private]

std::vector<SubSpace> YMMOG::subscribed_SubSpaces [private]

int YMMOG::subscriptionRange [private]

int YMMOG::unsubscriptionRange [private]

cMessage* YMMOG::timeSlotTimer [private]

cMessage* YMMOG::delayTimer [private]

cMessage* YMMOG::playerPingTimer [private]

int YMMOG::maxFailedPings [private]

double YMMOG::delayDelay [private]

int YMMOG::computedEvents [private]

int YMMOG::maxPlayerOnline [private]

int YMMOG::savedRequests [private]

int YMMOG::passedSubSpaces [private]

SubSpaceTable* YMMOG::magicLog [private]


The documentation for this class was generated from the following files:
Generated on Tue Jul 24 16:51:19 2007 for ITM OverSim by  doxygen 1.5.1