#include <YMMOG.h>
Inheritance diagram for YMMOG:
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< BackupNodeData > | backup_nodes |
std::list< BackupNodeData >::iterator | b |
std::list< IntermediateNodeData > | intermediate_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) |
SubSpace * | getSubSpace (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) |
ResponsibleNodeData * | findResponsibleNodeDataById (int subSpaceId) |
BackupNodeData * | findBackupNodeDataById (int subSpaceId) |
IntermediateNodeData * | findIntermediateNodeDataById (int subSpaceId) |
bool | deleteResponsibleNodeData (int id) |
bool | deleteIntermediateNodeDataById (int subSpaceId) |
void | deleteBackupNodeDataById (int subSpaceId) |
Private Attributes | |
std::list< NodeLogEntry > | nodeLog |
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< SubSpace > | subscribed_SubSpaces |
int | subscriptionRange |
int | unsubscriptionRange |
cMessage * | timeSlotTimer |
cMessage * | delayTimer |
cMessage * | playerPingTimer |
int | maxFailedPings |
double | delayDelay |
int | computedEvents |
int | maxPlayerOnline |
int | savedRequests |
int | passedSubSpaces |
SubSpaceTable * | magicLog |
Friends | |
std::ostream & | operator<< (std::ostream &Stream, const YMMOG y) |
virtual int YMMOG::numInitStages | ( | void | ) | const [inline, virtual] |
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] |
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] |
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 }
std::ostream& operator<< | ( | std::ostream & | Stream, | |
const YMMOG | y | |||
) | [friend] |
01794 { 01795 return Stream << "IP: " << "Holding "<< y.responsible_nodes.size() << " Responsible Nodes"; 01796 }
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] |