#include <YMMOGBase.h>
Public Member Functions | |
virtual int | numInitStages () const |
void | initialize (int stage) |
virtual void | initialize () |
virtual void | finish () |
void | handleMessage (cMessage *msg) |
void | sendMsg (YMMOGMessage *msg, IPAddress destip) |
void | setLength (YMMOGMessage *msg) |
void | deleteFromDupedMessages (YMMOGMessage *ymmog) |
bool | findOpenSubScribe (int subSpaceId, IPAddress destip) |
bool | findOpenUnSubscribe (int subSpaceId, IPAddress destip) |
bool | findOpenPing (IPAddress destip) |
bool | findOpenPlayerList (int subSpaceId) |
bool | findOpenRequestNode (int subSpaceId, int nodeType) |
bool | findOpenCreate (int subSpaceId, int nodeType) |
bool | findOpenLogin (IPAddress playerip) |
virtual void | initializeStats () |
virtual void | finishStats () |
virtual void | processSelfTimers (cMessage *msg) |
virtual void | processAppMessages (cMessage *msg) |
virtual void | processResendTimer () |
virtual void | processBandwithTimer () |
virtual void | processStabilizeTimer () |
virtual void | processLogin (LoginMessage *loginMsg) |
virtual void | processLogout (LogoutMessage *logoutMsg) |
virtual void | processCreate (CreateNodeMessage *createMsg) |
virtual void | processSubscribe (SubscribeMessage *subscribeMsg) |
virtual void | processUnSubscribe (UnSubscribeMessage *unsubscribeMsg) |
virtual void | processPublish (PublishMessage *publishMsg) |
virtual void | processPublishEventList (PublishEventListMessage *publishMsg) |
virtual void | processRequestIp (RequestIpMessage *requestMsg) |
virtual void | processDelay (DelayMessage *delayMsg) |
virtual void | processReplaceIntermediateNode (ReplaceIntermediateNodeMessage *replaceMsg) |
virtual void | processPlayerList (PlayerListMessage *playerListMsg) |
virtual void | processRequestNode (RequestNodeMessage *requestMsg) |
virtual void | processUpdateRespIp (UpdateRespIpMessage *updateMsg) |
virtual void | processReplacement (ReplacementMessage *replaceMsg) |
virtual void | processPing (PingMessage *pingMsg) |
virtual void | processStabilize (StabilizeMessage *smsg) |
virtual void | sendPing (PingMessage *openPing) |
void | deleteFromOpenPings (IPAddress destip) |
void | resetPing (IPAddress destip) |
Public Attributes | |
std::list < YMMOGMessage * > | notReadyMessages |
std::list < YMMOGMessage * > | dupedMessages |
std::list < PingMessage * > | pings |
std::list < PingMessage * > | playerPings |
double | stabilizeDelay |
double | bandwithDelay |
double | resendDelay |
double | pingDelay |
cMessage * | resendTimer |
cMessage * | pingTimer |
cMessage * | stabilizeTimer |
cMessage * | bandwithTimer |
int | selfMessages |
int | maxFailed |
int | droppedMessages |
bool | debug |
int | localPort |
double | sessionBegin |
int | sentMessages |
int | receivedMessages |
cOutVector * | upstream |
cOutVector * | downstream |
unsigned int | up |
unsigned int | down |
int | sentSum |
int | receivedSum |
unsigned int | overheadBytes |
unsigned int | messageBytes |
unsigned int | sentOverheadBytes |
unsigned int | receivedOverheadBytes |
unsigned int | receivedBytes |
unsigned int | sentBytes |
int | sentLogins |
int | sentLogouts |
int | sentSubscribes |
int | sentUnSubscribes |
int | sentEvents |
int | sentCreates |
int | sentRequestIps |
int | sentUpdateRespIps |
int | sentEventLists |
int | sentPings |
int | sentPlayerLists |
int | sentRequestNodes |
int | sentReplacements |
int | sentDelays |
int | sentReplaceInt |
int | sentUndefined |
int | receivedLogins |
int | receivedLogouts |
int | receivedSubscribes |
int | receivedUnSubscribes |
int | receivedEvents |
int | receivedCreates |
int | receivedRequestIps |
int | receivedUpdateRespIps |
int | receivedEventLists |
int | receivedPings |
int | receivedPlayerLists |
int | receivedRequestNodes |
int | receivedReplacements |
int | receivedDelays |
int | receivedReplaceInt |
BootstrapOracle * | bootstrapOracle |
NodeHandle | thisNode |
GlobalStatistics * | globalStatistics |
virtual int YMMOGBase::numInitStages | ( | void | ) | const [inline, virtual] |
void YMMOGBase::initialize | ( | int | stage | ) |
00003 { 00004 if ( stage != 5 ) 00005 return; 00006 00007 debug = par("debug"); 00008 localPort = par("localPort"); 00009 00010 thisNode.ip = IPAddressResolver().addressOf(parentModule()->parentModule()).get4(); 00011 thisNode.port = localPort; 00012 bootstrapOracle = BootstrapOracleAccess().get(); 00013 globalStatistics = GlobalStatisticsAccess().get(); 00014 // set up UDP 00015 cMessage* msg = new cMessage("UDP_C_BIND", UDP_C_BIND); 00016 UDPControlInfo* ctrl = new UDPControlInfo(); 00017 ctrl->setSrcPort(localPort); 00018 ctrl->setSockId(UDPSocket::generateSocketId()); 00019 msg->setControlInfo(ctrl); 00020 send(msg, "to_udp"); 00021 00022 resendTimer = new cMessage("resendTimer"); 00023 stabilizeTimer = new cMessage("stabilizeTimer"); 00024 bandwithTimer = new cMessage("bandwithTimer"); 00025 stabilizeDelay = 30; 00026 resendDelay = 1.5; 00027 selfMessages = 0; 00028 bandwithDelay = 60; 00029 scheduleAt(simTime() + resendDelay, resendTimer); 00030 scheduleAt(simTime() + stabilizeDelay, stabilizeTimer); 00031 scheduleAt(simTime() + bandwithDelay, bandwithTimer); 00032 initializeStats(); 00033 initialize(); 00034 }
void YMMOGBase::initialize | ( | ) | [virtual] |
void YMMOGBase::finish | ( | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00137 { 00138 finishStats(); 00139 ev << "You should add your own finish()"; 00140 }
void YMMOGBase::handleMessage | ( | cMessage * | msg | ) |
00220 { 00221 processSelfTimers(msg); 00222 if ( msg->arrivedOn("from_udp") ) 00223 { 00224 receivedMessages++; 00225 receivedBytes += msg->byteLength(); 00226 down += msg->byteLength(); 00227 // remove udp interface control information 00228 UDPControlInfo* udpControlInfo = check_and_cast<UDPControlInfo*>(msg->removeControlInfo()); 00229 delete udpControlInfo; 00230 YMMOGMessage* ymmog = dynamic_cast<YMMOGMessage*>(msg); 00231 if ( ymmog != NULL ) 00232 { 00233 if( ymmog->getTimeStamp() < simTime() - 3 ) { 00234 delete msg; 00235 return; 00236 } 00237 // Here we will process the diffrent messages 00238 switch ( ymmog->getCommand() ) { 00239 case LOGIN: { // Login Response 00240 LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(ymmog); 00241 if( loginMsg != NULL ) { 00242 processLogin(loginMsg); 00243 } 00244 break; 00245 } 00246 case LOGOUT: { // Logout Response 00247 LogoutMessage *logoutMsg = dynamic_cast<LogoutMessage*>(ymmog); 00248 if (logoutMsg != NULL) 00249 { 00250 processLogout(logoutMsg); 00251 } 00252 break; 00253 } 00254 case SUBSCRIBE: { // Subscribe 00255 receivedOverheadBytes += msg->byteLength(); 00256 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(ymmog); 00257 if(subscribeMsg != NULL ) { 00258 processSubscribe(subscribeMsg); 00259 } 00260 break; 00261 } 00262 case UNSUBSCRIBE: { // Unsubscribe 00263 receivedOverheadBytes += msg->byteLength(); 00264 UnSubscribeMessage* unsubscribeMsg = dynamic_cast<UnSubscribeMessage*>(ymmog); 00265 if ( unsubscribeMsg != NULL ) { 00266 processUnSubscribe(unsubscribeMsg); 00267 } 00268 break; 00269 } 00270 case PUBLISH: { // Publish 00271 PublishMessage* publishMsg = dynamic_cast<PublishMessage*>(ymmog); 00272 if( publishMsg != NULL) { 00273 processPublish(publishMsg); 00274 } 00275 break; 00276 } 00277 case PUBLISHEVENTLIST: { 00278 PublishEventListMessage* publishMsg = dynamic_cast<PublishEventListMessage*>(ymmog); 00279 if( publishMsg != NULL) { 00280 processPublishEventList(publishMsg); 00281 } 00282 break; 00283 } 00284 case CREATE: { // Create 00285 receivedOverheadBytes += msg->byteLength(); 00286 CreateNodeMessage* createMsg = dynamic_cast<CreateNodeMessage*>(ymmog); 00287 if( createMsg != NULL ) { 00288 processCreate(createMsg); 00289 } 00290 break; 00291 } 00292 case REQUESTIP: { 00293 receivedOverheadBytes += msg->byteLength(); 00294 RequestIpMessage *requestIpMsg = dynamic_cast<RequestIpMessage*>(ymmog); 00295 if (requestIpMsg != NULL ) { 00296 processRequestIp(requestIpMsg); 00297 } 00298 break; 00299 } 00300 case UPDATERESPIP: { 00301 receivedOverheadBytes += msg->byteLength(); 00302 UpdateRespIpMessage* updateMsg = dynamic_cast<UpdateRespIpMessage*>(ymmog); 00303 if( updateMsg != NULL ) { 00304 processUpdateRespIp(updateMsg); 00305 } 00306 break; 00307 } 00308 case PING: { 00309 receivedOverheadBytes += msg->byteLength(); 00310 PingMessage* pingMsg = dynamic_cast<PingMessage*>(ymmog); 00311 if( pingMsg != NULL ) { 00312 processPing(pingMsg); 00313 } 00314 break; 00315 } 00316 case PLAYERLIST: { 00317 receivedOverheadBytes += msg->byteLength(); 00318 PlayerListMessage* playerListMsg = dynamic_cast<PlayerListMessage*>(ymmog); 00319 if( playerListMsg != NULL ) { 00320 processPlayerList(playerListMsg); 00321 } 00322 break; 00323 } 00324 case REQUESTNODE: { 00325 receivedOverheadBytes += msg->byteLength(); 00326 RequestNodeMessage* requestMsg = dynamic_cast<RequestNodeMessage*>(ymmog); 00327 if( requestMsg != NULL ) { 00328 processRequestNode(requestMsg); 00329 } 00330 break; 00331 } 00332 case REPLACEMENT: { 00333 receivedOverheadBytes += msg->byteLength(); 00334 ReplacementMessage* replaceMsg = dynamic_cast<ReplacementMessage*>(ymmog); 00335 if( replaceMsg != NULL ) { 00336 processReplacement(replaceMsg); 00337 } 00338 break; 00339 } 00340 case DELAY: { 00341 receivedOverheadBytes += msg->byteLength(); 00342 DelayMessage* delayMsg = dynamic_cast<DelayMessage*>(ymmog); 00343 if( delayMsg != NULL ) { 00344 processDelay(delayMsg); 00345 } 00346 break; 00347 } 00348 case REPLACEINT: { 00349 receivedOverheadBytes += msg->byteLength(); 00350 ReplaceIntermediateNodeMessage* replaceMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(ymmog); 00351 if ( replaceMsg != NULL ) { 00352 processReplaceIntermediateNode(replaceMsg); 00353 } 00354 break; 00355 } 00356 case STABILIZE: { 00357 StabilizeMessage* stabilizeMsg = dynamic_cast<StabilizeMessage*>(ymmog); 00358 if( stabilizeMsg != NULL ) { 00359 processStabilize(stabilizeMsg); 00360 } 00361 break; 00362 } 00363 default: { 00364 delete msg; 00365 break; 00366 } 00367 } 00368 overheadBytes = receivedOverheadBytes + sentOverheadBytes; 00369 receivedSum = receivedLogins + receivedLogouts + receivedSubscribes + receivedUnSubscribes + receivedEvents + receivedCreates + receivedRequestIps + receivedUpdateRespIps + receivedEventLists + receivedPings +receivedPlayerLists + receivedRequestNodes + receivedReplacements + receivedDelays + receivedReplaceInt; 00370 } 00371 else { 00372 delete msg; 00373 } 00374 } 00375 else if(msg->arrivedOn("from_app")) 00376 { 00377 processAppMessages(msg); 00378 } 00379 }
void YMMOGBase::sendMsg | ( | YMMOGMessage * | msg, | |
IPAddress | destip | |||
) |
00381 { 00382 msg->setSrcip(thisNode.ip.get4()); 00383 msg->setDestip(destip); 00384 setLength(msg); 00385 msg->setTimeStamp(simTime()); 00386 if( msg->getFailed() < 0 || msg->getFailed() > maxFailed) { 00387 msg->setFailed(0); 00388 } 00389 switch ( msg->getCommand() ) { 00390 case LOGIN: { 00391 sentLogins++; 00392 LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(msg); 00393 if(loginMsg != NULL && loginMsg->getServiceType() == REQUEST) { 00394 dupedMessages.push_back( new LoginMessage(*loginMsg) ); 00395 } 00396 break; 00397 } 00398 case LOGOUT: { 00399 sentLogouts++; 00400 LogoutMessage* logoutMsg = dynamic_cast<LogoutMessage*>(msg); 00401 if(logoutMsg != NULL && logoutMsg->getServiceType() == REQUEST) { 00402 dupedMessages.push_back( new LogoutMessage(*logoutMsg) ); 00403 } 00404 break; 00405 } 00406 case SUBSCRIBE: { 00407 sentSubscribes++; 00408 sentOverheadBytes += msg->byteLength(); 00409 SubscribeMessage* orginalMsg = dynamic_cast<SubscribeMessage*>(msg); 00410 if(orginalMsg != NULL && ( orginalMsg->getServiceType() == REQUEST || orginalMsg->getServiceType() == FORWARD) ) { 00411 dupedMessages.push_back( new SubscribeMessage(*orginalMsg) ); 00412 } 00413 break; 00414 } 00415 case UNSUBSCRIBE: { 00416 sentUnSubscribes++; 00417 sentOverheadBytes += msg->byteLength(); 00418 UnSubscribeMessage* orginalMsg = dynamic_cast<UnSubscribeMessage*>(msg); 00419 if(orginalMsg != NULL && ( orginalMsg->getServiceType() == REQUEST || orginalMsg->getServiceType() == FORWARD) ) { 00420 dupedMessages.push_back( new UnSubscribeMessage(*orginalMsg) ); 00421 } 00422 break; 00423 } 00424 case PUBLISH: { sentEvents++; break; } 00425 case CREATE: { 00426 sentCreates++; 00427 sentOverheadBytes += msg->byteLength(); 00428 CreateNodeMessage* createMsg = dynamic_cast<CreateNodeMessage*>(msg); 00429 if(createMsg != NULL && createMsg->getServiceType() == REQUEST ) { 00430 dupedMessages.push_back( new CreateNodeMessage(*createMsg) ); 00431 } 00432 break; 00433 } 00434 case REQUESTIP: { 00435 sentRequestIps++; 00436 sentOverheadBytes += msg->byteLength(); 00437 RequestIpMessage* orginalMsg = dynamic_cast<RequestIpMessage*>(msg); 00438 if( orginalMsg != NULL && orginalMsg->getServiceType() == REQUEST ) { 00439 dupedMessages.push_back( new RequestIpMessage(*orginalMsg)); 00440 } 00441 break; 00442 } 00443 case UPDATERESPIP: { 00444 sentUpdateRespIps++; 00445 sentOverheadBytes += msg->byteLength(); 00446 UpdateRespIpMessage* orginalMsg = dynamic_cast<UpdateRespIpMessage*>(msg); 00447 if(orginalMsg != NULL && orginalMsg->getServiceType() == REQUEST ) { 00448 dupedMessages.push_back( new UpdateRespIpMessage(*orginalMsg) ); 00449 } 00450 break; 00451 } 00452 case PUBLISHEVENTLIST: { sentEventLists++; sentOverheadBytes += msg->byteLength(); break; } 00453 case PING: { sentPings++; sentOverheadBytes += msg->byteLength(); break; } 00454 case PLAYERLIST: { 00455 sentPlayerLists++; 00456 sentOverheadBytes += msg->byteLength(); 00457 PlayerListMessage* orginalMsg = dynamic_cast<PlayerListMessage*>(msg); 00458 if(orginalMsg != NULL && ( orginalMsg->getServiceType() == REQUEST ) ) {// || orginalMsg->getServiceType() == FORWARD) ) { 00459 dupedMessages.push_back( new PlayerListMessage(*orginalMsg) ); 00460 } 00461 break; 00462 } 00463 case REQUESTNODE: { 00464 sentRequestNodes++; 00465 sentOverheadBytes += msg->byteLength(); 00466 RequestNodeMessage* orginalMsg = dynamic_cast<RequestNodeMessage*>(msg); 00467 if(orginalMsg != NULL && orginalMsg->getServiceType() == REQUEST) { 00468 dupedMessages.push_back( new RequestNodeMessage(*orginalMsg) ); 00469 } 00470 break; 00471 } 00472 case REPLACEMENT: { 00473 sentReplacements++; 00474 sentOverheadBytes += msg->byteLength(); 00475 ReplacementMessage* orginalMsg = dynamic_cast<ReplacementMessage*>(msg); 00476 if(orginalMsg != NULL && orginalMsg->getServiceType() == REQUEST) { 00477 dupedMessages.push_back( new ReplacementMessage(*orginalMsg) ); 00478 } 00479 break; 00480 } 00481 case DELAY: { sentDelays++; sentOverheadBytes += msg->byteLength(); break; } 00482 case REPLACEINT: { 00483 sentReplaceInt++; 00484 sentOverheadBytes += msg->byteLength(); 00485 ReplaceIntermediateNodeMessage* orginalMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(msg); 00486 if(orginalMsg != NULL && orginalMsg->getServiceType() == REQUEST) { 00487 dupedMessages.push_back( new ReplaceIntermediateNodeMessage(*orginalMsg) ); 00488 } 00489 break; 00490 } 00491 default: { sentUndefined++; break; } 00492 } 00493 sentBytes += msg->byteLength(); 00494 up +=msg->byteLength(); 00495 UDPControlInfo* udpControlInfo = new UDPControlInfo(); 00496 udpControlInfo->setDestAddr(destip); 00497 udpControlInfo->setDestPort(thisNode.port); 00498 udpControlInfo->setSrcAddr(thisNode.ip); 00499 udpControlInfo->setSrcPort(thisNode.port); 00500 msg->setControlInfo(udpControlInfo); 00501 send(msg,"to_udp"); 00502 sentMessages++; 00503 overheadBytes = sentOverheadBytes + receivedOverheadBytes; 00504 messageBytes = sentBytes + receivedBytes; 00505 sentSum = sentLogins + sentLogouts + sentSubscribes + sentUnSubscribes + sentEvents + sentCreates + sentRequestIps + sentUpdateRespIps + sentEventLists + sentPings + sentPlayerLists +sentRequestNodes + sentReplacements + sentDelays + sentReplaceInt; 00506 }
void YMMOGBase::setLength | ( | YMMOGMessage * | msg | ) |
00510 { 00511 static const uint INT_SIZE = sizeof(int); 00512 static const uint SUBSPACE_SIZE = sizeof(SubSpace); 00513 static const uint IPADDRESS_SIZE = sizeof(IPAddress); 00514 static const uint BOOL_SIZE = sizeof(bool); 00515 static const uint DOUBLE_SIZE = sizeof(double); 00516 static const uint EVENT_SIZE = sizeof(Event); 00517 int base= 2*INT_SIZE + 2*IPADDRESS_SIZE; 00518 00519 switch ( msg->getCommand() ) { 00520 case LOGIN: { 00521 LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(msg); 00522 msg->setLength( base + 7* INT_SIZE + loginMsg->getResponsibleNodesArraySize() * SUBSPACE_SIZE); 00523 break; 00524 } 00525 case LOGOUT: { msg->setLength( base + INT_SIZE + BOOL_SIZE); break; } 00526 case SUBSCRIBE: { 00527 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(msg); 00528 msg->setLength( base + INT_SIZE + IPADDRESS_SIZE + SUBSPACE_SIZE + sizeof( subscribeMsg->getGameState() ) ); 00529 break; 00530 } 00531 case UNSUBSCRIBE: { msg->setLength( base + 2*INT_SIZE + IPADDRESS_SIZE); break; } 00532 case PUBLISH: { msg->setLength( base + 2*INT_SIZE + EVENT_SIZE); break; } 00533 case CREATE: { msg->setLength( base + 2*INT_SIZE + SUBSPACE_SIZE + BOOL_SIZE); break; } 00534 case REQUESTIP: { msg->setLength( base + 2*INT_SIZE + IPADDRESS_SIZE); break; } 00535 case UPDATERESPIP: { msg->setLength( base + 2*INT_SIZE + IPADDRESS_SIZE); break; } 00536 case PUBLISHEVENTLIST: { 00537 PublishEventListMessage* publishMsg = dynamic_cast<PublishEventListMessage*>(msg); 00538 msg->setLength( base + 2*INT_SIZE + DOUBLE_SIZE + publishMsg->getEventListArraySize() * EVENT_SIZE); 00539 break; 00540 } 00541 case PING: { msg->setLength( base + DOUBLE_SIZE); break; } 00542 case PLAYERLIST: { 00543 PlayerListMessage* playerListMsg = dynamic_cast<PlayerListMessage*>(msg); 00544 msg->setLength( base + 2*INT_SIZE + DOUBLE_SIZE + IPADDRESS_SIZE*playerListMsg->getTreeArraySize() ); 00545 break; 00546 } 00547 case REQUESTNODE: { msg->setLength(base + 2*INT_SIZE); break; } 00548 case REPLACEMENT: { 00549 ReplacementMessage* replaceMsg = dynamic_cast<ReplacementMessage*>(msg); 00550 msg->setLength( base + 2*INT_SIZE + sizeof( replaceMsg->getGameState() ) ); 00551 break; 00552 } 00553 case DELAY: { msg->setLength( base + INT_SIZE + DOUBLE_SIZE + IPADDRESS_SIZE); break; } 00554 case REPLACEINT: { 00555 ReplaceIntermediateNodeMessage* replaceMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(msg); 00556 msg->setLength( base + INT_SIZE + SUBSPACE_SIZE + IPADDRESS_SIZE + replaceMsg->getIpListArraySize()*IPADDRESS_SIZE); 00557 break; 00558 } 00559 } 00560 }
void YMMOGBase::deleteFromDupedMessages | ( | YMMOGMessage * | ymmog | ) |
There should be no publishMsg's enqueued
There should be no PublishEventListMessage enqueued
handeld seperate
There should be no DelayMessages enqueued
00562 { 00563 std::list<YMMOGMessage*>::iterator i = dupedMessages.begin(); 00564 int command = ymmog->getCommand(); 00565 while( i != dupedMessages.end() ) { 00566 if( (*i)->getCommand() == command) { 00567 switch( command ) { 00568 case LOGIN: { 00569 LoginMessage* storedMsg = dynamic_cast<LoginMessage*>(*i); 00570 if( storedMsg != NULL ) { 00571 delete *i; 00572 dupedMessages.erase(i); 00573 return; 00574 } 00575 break; 00576 } 00577 case LOGOUT: { 00578 LogoutMessage* receivedMsg = dynamic_cast<LogoutMessage*>(ymmog); 00579 LogoutMessage* storedMsg = dynamic_cast<LogoutMessage*>(*i); 00580 if( storedMsg != NULL && receivedMsg != NULL) { 00581 if( storedMsg->getId() == receivedMsg->getId() ) { 00582 delete *i; 00583 dupedMessages.erase(i); 00584 return; 00585 } 00586 } 00587 break; 00588 } 00589 case CREATE: { 00590 CreateNodeMessage* receivedMsg = dynamic_cast<CreateNodeMessage*>(ymmog); 00591 CreateNodeMessage* storedMsg = dynamic_cast<CreateNodeMessage*>(*i); 00592 if( storedMsg != NULL && receivedMsg != NULL) { 00593 if( storedMsg->getNodeType() == receivedMsg->getNodeType() && storedMsg->getJobType() == receivedMsg->getJobType() && storedMsg->getSubSpaceToCreate().getId() == receivedMsg->getSubSpaceToCreate().getId() ) { 00594 delete *i; 00595 dupedMessages.erase(i); 00596 return; 00597 } 00598 } 00599 break; 00600 } 00601 case SUBSCRIBE: { 00602 SubscribeMessage* receivedMsg = dynamic_cast<SubscribeMessage*>(ymmog); 00603 SubscribeMessage* storedMsg = dynamic_cast<SubscribeMessage*>(*i); 00604 if( storedMsg != NULL && receivedMsg != NULL) { 00605 if( ( storedMsg->getPlayerId() == receivedMsg->getPlayerId() || storedMsg->getPlayerIp() == receivedMsg->getPlayerIp() ) && storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() ) { 00606 delete *i; 00607 dupedMessages.erase(i); 00608 return; 00609 } 00610 } 00611 break; 00612 } 00613 case UNSUBSCRIBE: { 00614 UnSubscribeMessage* receivedMsg = dynamic_cast<UnSubscribeMessage*>(ymmog); 00615 UnSubscribeMessage* storedMsg = dynamic_cast<UnSubscribeMessage*>(*i); 00616 if( storedMsg != NULL && receivedMsg != NULL) { 00617 if( (storedMsg->getPlayerId() == receivedMsg->getPlayerId() || storedMsg->getPlayerIp() == receivedMsg->getPlayerIp() ) && storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() ) { 00618 delete *i; 00619 dupedMessages.erase(i); 00620 return; 00621 } 00622 } 00623 break; 00624 } 00625 case PUBLISH: { 00627 break; 00628 } 00629 case PUBLISHEVENTLIST: { 00631 break; 00632 } 00633 case REQUESTIP: { 00634 RequestIpMessage* receivedMsg = dynamic_cast<RequestIpMessage*>(ymmog); 00635 RequestIpMessage* storedMsg = dynamic_cast<RequestIpMessage*>(*i); 00636 if( storedMsg != NULL && receivedMsg != NULL) { 00637 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() ) { 00638 delete *i; 00639 dupedMessages.erase(i); 00640 return; 00641 } 00642 } 00643 break; 00644 } 00645 case UPDATERESPIP: { 00646 UpdateRespIpMessage* receivedMsg = dynamic_cast<UpdateRespIpMessage*>(ymmog); 00647 UpdateRespIpMessage* storedMsg = dynamic_cast<UpdateRespIpMessage*>(*i); 00648 if( storedMsg != NULL && receivedMsg != NULL) { 00649 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getDirection() == receivedMsg->getDirection() && storedMsg->getDestip() == receivedMsg->getSrcip() ) { 00650 delete *i; 00651 dupedMessages.erase(i); 00652 return; 00653 } 00654 } 00655 break; 00656 } 00657 case PING: { 00659 break; 00660 } 00661 case PLAYERLIST: { 00662 PlayerListMessage* receivedMsg = dynamic_cast<PlayerListMessage*>(ymmog); 00663 PlayerListMessage* storedMsg = dynamic_cast<PlayerListMessage*>(*i); 00664 if( storedMsg != NULL && receivedMsg != NULL) { 00665 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getAction() == receivedMsg->getAction() ) { 00666 delete *i; 00667 dupedMessages.erase(i); 00668 return; 00669 } 00670 } 00671 break; 00672 } 00673 case REQUESTNODE: { 00674 RequestNodeMessage* receivedMsg = dynamic_cast<RequestNodeMessage*>(ymmog); 00675 RequestNodeMessage* storedMsg = dynamic_cast<RequestNodeMessage*>(*i); 00676 if( storedMsg != NULL && receivedMsg != NULL) { 00677 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getNodeType() == receivedMsg->getNodeType() ) { 00678 delete *i; 00679 dupedMessages.erase(i); 00680 return; 00681 } 00682 } 00683 break; 00684 } 00685 case REPLACEMENT: { 00686 ReplacementMessage* receivedMsg = dynamic_cast<ReplacementMessage*>(ymmog); 00687 ReplacementMessage* storedMsg = dynamic_cast<ReplacementMessage*>(*i); 00688 if( storedMsg != NULL && receivedMsg != NULL) { 00689 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getDestip() == receivedMsg->getSrcip() ) { 00690 delete *i; 00691 dupedMessages.erase(i); 00692 return; 00693 } 00694 } 00695 break; 00696 } 00697 case DELAY: { 00699 break; 00700 } 00701 case REPLACEINT: { 00702 ReplaceIntermediateNodeMessage* receivedMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(ymmog); 00703 ReplaceIntermediateNodeMessage* storedMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(*i); 00704 if( storedMsg != NULL && receivedMsg != NULL) { 00705 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getToReplace() == receivedMsg->getToReplace() ) { 00706 delete *i; 00707 dupedMessages.erase(i); 00708 return; 00709 } 00710 } 00711 break; 00712 } 00713 default: { 00714 return; 00715 } 00716 } 00717 } 00718 ++i; 00719 } 00720 }
bool YMMOGBase::findOpenSubScribe | ( | int | subSpaceId, | |
IPAddress | destip | |||
) |
00773 { 00774 std::list<YMMOGMessage*>::iterator i=dupedMessages.begin(); 00775 while( i != dupedMessages.end() ) { 00776 if( (*i)->getCommand() == SUBSCRIBE ) { 00777 SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(*i); 00778 if( subscribeMsg != NULL && subscribeMsg->getSubSpaceId() == subSpaceId && subscribeMsg->getDestip() == destip) 00779 return true; 00780 } 00781 ++i; 00782 } 00783 return false; 00784 }
bool YMMOGBase::findOpenUnSubscribe | ( | int | subSpaceId, | |
IPAddress | destip | |||
) |
00806 { 00807 std::list<YMMOGMessage*>::iterator i=dupedMessages.begin(); 00808 while( i != dupedMessages.end() ) { 00809 if( (*i)->getCommand() == UNSUBSCRIBE ) { 00810 UnSubscribeMessage* unSubscribeMsg = dynamic_cast<UnSubscribeMessage*>(*i); 00811 if( unSubscribeMsg != NULL && unSubscribeMsg->getSubSpaceId() == subSpaceId && unSubscribeMsg->getDestip() == destip) 00812 return true; 00813 } 00814 ++i; 00815 } 00816 return false; 00817 }
bool YMMOGBase::findOpenPing | ( | IPAddress | destip | ) |
bool YMMOGBase::findOpenPlayerList | ( | int | subSpaceId | ) |
bool YMMOGBase::findOpenRequestNode | ( | int | subSpaceId, | |
int | nodeType | |||
) |
00818 { 00819 std::list<YMMOGMessage*>::iterator i= dupedMessages.begin(); 00820 while( i != dupedMessages.end() ) { 00821 if( (*i)->getCommand() == REQUESTNODE ) { 00822 RequestNodeMessage* requestMsg = dynamic_cast<RequestNodeMessage*>(*i); 00823 if( requestMsg != NULL && requestMsg->getSubSpaceId() == subSpaceId && requestMsg->getNodeType() == nodeType) 00824 return true; 00825 } 00826 ++i; 00827 } 00828 return false; 00829 }
bool YMMOGBase::findOpenCreate | ( | int | subSpaceId, | |
int | nodeType | |||
) |
00762 { 00763 std::list<YMMOGMessage*>::iterator i = dupedMessages.begin(); 00764 while( i != dupedMessages.end() ) { 00765 if( (*i)->getCommand() == CREATE ) { 00766 CreateNodeMessage* tmp = dynamic_cast<CreateNodeMessage*>(*i); 00767 if( tmp != NULL && tmp->getSubSpaceToCreate().getId() == subSpaceId && tmp->getNodeType() ) return true; 00768 } 00769 ++i; 00770 } 00771 return false; 00772 }
bool YMMOGBase::findOpenLogin | ( | IPAddress | playerip | ) |
00785 { 00786 std::list<YMMOGMessage*>::iterator i= notReadyMessages.begin(); 00787 while( i != notReadyMessages.end() ) { 00788 if( (*i)->getCommand() == LOGIN) { 00789 LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(*i); 00790 if( loginMsg != NULL && loginMsg->getSrcip() == playerip) 00791 return true; 00792 } 00793 ++i; 00794 } 00795 i= dupedMessages.begin(); 00796 while( i != dupedMessages.end() ) { 00797 if( (*i)->getCommand() == LOGIN) { 00798 LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(*i); 00799 if( loginMsg != NULL && loginMsg->getSrcip() == playerip) 00800 return true; 00801 } 00802 ++i; 00803 } 00804 return false; 00805 }
void YMMOGBase::initializeStats | ( | ) | [virtual] |
00039 { 00040 WATCH_PTRLIST( dupedMessages ); 00041 WATCH_PTRLIST(notReadyMessages); 00042 WATCH(selfMessages); 00043 WATCH_PTRLIST(pings); 00044 00045 droppedMessages=0; 00046 sentMessages=0; 00047 receivedMessages=0; 00048 WATCH(sentMessages); 00049 WATCH(receivedMessages); 00050 WATCH(droppedMessages); 00051 00052 sentSum = 0; 00053 receivedSum = 0; 00054 WATCH(sentSum); 00055 WATCH(receivedSum); 00056 00057 upstream = new cOutVector("Used Upstream"); 00058 downstream = new cOutVector("Used Downstream"); 00059 up=0; 00060 down=0; 00061 sessionBegin = simTime(); 00062 00063 00064 messageBytes = 0; 00065 overheadBytes = 0; 00066 sentOverheadBytes = 0; 00067 receivedOverheadBytes = 0; 00068 sentBytes = 0; 00069 receivedBytes = 0; 00070 00071 // Sent Variables: 00072 sentLogins = 0; 00073 sentLogouts = 0; 00074 sentSubscribes = 0; 00075 sentUnSubscribes = 0; 00076 sentEvents = 0; 00077 sentCreates = 0; 00078 sentRequestIps = 0; 00079 sentUpdateRespIps = 0; 00080 sentEventLists = 0; 00081 sentPings = 0; 00082 sentPlayerLists = 0; 00083 sentRequestNodes = 0; 00084 sentReplacements = 0; 00085 sentDelays = 0; 00086 sentReplaceInt = 0; 00087 sentUndefined = 0; 00088 00089 WATCH( sentLogins ); 00090 WATCH( sentLogouts ); 00091 WATCH( sentSubscribes ); 00092 WATCH( sentUnSubscribes ); 00093 WATCH( sentEvents ); 00094 WATCH( sentCreates ); 00095 WATCH( sentRequestIps ); 00096 WATCH( sentUpdateRespIps ); 00097 WATCH( sentEventLists ); 00098 WATCH( sentPings ); 00099 WATCH( sentPlayerLists ); 00100 WATCH( sentRequestNodes ); 00101 WATCH( sentReplacements ); 00102 WATCH( sentDelays ); 00103 WATCH( sentReplaceInt ); 00104 WATCH( sentUndefined ); 00105 00106 // Received Variables: 00107 receivedLogins = 0; 00108 receivedLogouts = 0; 00109 receivedSubscribes = 0; 00110 receivedUnSubscribes = 0; 00111 receivedEvents = 0; 00112 receivedCreates = 0; 00113 receivedRequestIps = 0; 00114 receivedUpdateRespIps = 0; 00115 receivedEventLists = 0; 00116 receivedPings = 0; 00117 receivedPlayerLists = 0; 00118 receivedRequestNodes = 0; 00119 receivedReplacements = 0; 00120 receivedDelays = 0; 00121 receivedReplaceInt = 0; 00122 00123 WATCH( receivedLogins ); 00124 WATCH( receivedLogouts ); 00125 WATCH( receivedSubscribes ); 00126 WATCH( receivedUnSubscribes ); 00127 WATCH( receivedEvents ); 00128 WATCH( receivedCreates ); 00129 WATCH( receivedRequestIps ); 00130 WATCH( receivedUpdateRespIps ); 00131 WATCH( receivedEventLists ); 00132 WATCH( receivedRequestNodes ); 00133 WATCH( receivedReplacements ); 00134 WATCH( receivedDelays ); 00135 WATCH( receivedReplaceInt ); 00136 }
void YMMOGBase::finishStats | ( | ) | [virtual] |
Sents
Received
00141 { 00142 00143 globalStatistics->addStdDev("Total Overhead:", overheadBytes); 00144 globalStatistics->addStdDev("sentOverhead:", sentOverheadBytes); 00145 globalStatistics->addStdDev("receivedOverhead:", receivedOverheadBytes); 00146 globalStatistics->addStdDev("Total Bytes:", messageBytes); 00147 globalStatistics->addStdDev("Total sent Bytes:", sentBytes); 00148 globalStatistics->addStdDev("Total received Bytes:", receivedBytes); 00149 if( sentOverheadBytes > 0) globalStatistics->addStdDev("Sent Overhead in %", (double) sentOverheadBytes / sentBytes); 00150 if( receivedOverheadBytes > 0) globalStatistics->addStdDev("Received Overhead in %", (double) receivedOverheadBytes / receivedBytes); 00151 globalStatistics->addStdDev("Avg Bandwith Usage:", (double) messageBytes / (simTime() - sessionBegin) ); 00152 globalStatistics->addStdDev("DroppedMessages:", droppedMessages); 00153 00154 00157 globalStatistics->addStdDev("SentLogins: ", sentLogins ); 00158 globalStatistics->addStdDev("SentLogouts: ", sentLogouts ); 00159 globalStatistics->addStdDev("SentSubscribes: ", sentSubscribes ); 00160 globalStatistics->addStdDev("SentUnSubscribes: ", sentUnSubscribes ); 00161 globalStatistics->addStdDev("SentEvents: ", sentEvents ); 00162 globalStatistics->addStdDev("SentCreates: ", sentCreates ); 00163 globalStatistics->addStdDev("SentRequestIps: ", sentRequestIps ); 00164 globalStatistics->addStdDev("SentUpdates: ", sentUpdateRespIps ); 00165 globalStatistics->addStdDev("SentEventLists: ", sentEventLists ); 00166 globalStatistics->addStdDev("SentPings: ", sentPings ); 00167 globalStatistics->addStdDev("SentPlayerLists: ", sentPlayerLists ); 00168 globalStatistics->addStdDev("SentRequestNodes: ", sentRequestNodes ); 00169 globalStatistics->addStdDev("SentReplacements: ", sentReplacements ); 00170 globalStatistics->addStdDev("SentDelays: ", sentDelays ); 00171 globalStatistics->addStdDev("SentReplaceInt: ", sentReplaceInt ); 00172 globalStatistics->addStdDev("SentUndefined: ", sentUndefined ); 00173 00176 globalStatistics->addStdDev("ReceivedLogins: ", receivedLogins ); 00177 globalStatistics->addStdDev("ReceivedLogouts: ", receivedLogouts ); 00178 globalStatistics->addStdDev("ReceivedSubScribes: ", receivedSubscribes ); 00179 globalStatistics->addStdDev("ReceivedUnSubscribes: ", receivedUnSubscribes ); 00180 globalStatistics->addStdDev("ReceivedEvents: ", receivedEvents ); 00181 globalStatistics->addStdDev("ReceivedCreates: ", receivedCreates ); 00182 globalStatistics->addStdDev("ReceivedRequestIps: ", receivedRequestIps ); 00183 globalStatistics->addStdDev("ReceivedUpdateRespIps: ", receivedUpdateRespIps ); 00184 globalStatistics->addStdDev("ReceivedEventLists: ", receivedEventLists ); 00185 globalStatistics->addStdDev("ReceivedRequestNodes: ", receivedRequestNodes ); 00186 globalStatistics->addStdDev("ReceivedReplacements: ", receivedReplacements ); 00187 globalStatistics->addStdDev("ReceivedDelays: ", receivedDelays ); 00188 globalStatistics->addStdDev("ReceivedReplaceInt: ", receivedReplaceInt ); 00189 00190 00191 // cleanup 00192 while( notReadyMessages.size() > 0) { 00193 delete notReadyMessages.front(); 00194 notReadyMessages.pop_front(); 00195 } 00196 notReadyMessages.clear(); 00197 while( dupedMessages.size() > 0 ) { 00198 delete dupedMessages.front(); 00199 dupedMessages.pop_front(); 00200 } 00201 dupedMessages.clear(); 00202 while (pings.size() > 0 ) { 00203 delete pings.front(); 00204 pings.pop_front(); 00205 } 00206 00207 if( pingTimer != NULL ) { 00208 cancelEvent(pingTimer); 00209 delete pingTimer; 00210 pingTimer = NULL; 00211 cancelEvent(resendTimer); 00212 delete resendTimer; 00213 cancelEvent(bandwithTimer); 00214 delete bandwithTimer; 00215 delete upstream; 00216 delete downstream; 00217 } 00218 }
void YMMOGBase::processSelfTimers | ( | cMessage * | msg | ) | [virtual] |
void YMMOGBase::processAppMessages | ( | cMessage * | msg | ) | [virtual] |
void YMMOGBase::processResendTimer | ( | ) | [virtual] |
Reimplemented in YMMOG.
00722 { 00723 double min=simTime() + resendDelay; 00724 double now = simTime(); 00725 std::list<YMMOGMessage*>::iterator i = dupedMessages.begin(); 00726 while( i != dupedMessages.end() ) { 00727 if( (*i)->getTimeStamp() + resendDelay < now) { 00728 // we have to resend it 00729 (*i)->setTimeStamp(now); 00730 (*i)->setFailed((*i)->getFailed() + 1); 00731 if( (*i)->getFailed() > maxFailed ) { 00732 delete (*i); 00733 i = dupedMessages.erase(i); 00734 droppedMessages++; 00735 } 00736 else { 00737 YMMOGMessage* tmp = *i; 00738 i = dupedMessages.erase(i); 00739 sendMsg(tmp, tmp->getDestip()); 00740 } 00741 } 00742 else { 00743 if( ((*i)->getTimeStamp() + resendDelay < min) && (*i)->getTimeStamp() + resendDelay > simTime() ) min = (*i)->getTimeStamp() + resendDelay; 00744 ++i; 00745 } 00746 } 00747 selfMessages++; 00748 cancelEvent(resendTimer); 00749 scheduleAt(min + 0.05, resendTimer); 00750 }
void YMMOGBase::processBandwithTimer | ( | ) | [virtual] |
Reimplemented in YMMOG.
00872 { 00873 cancelEvent(bandwithTimer); 00874 upstream->record( up / bandwithDelay ); 00875 downstream->record( down / bandwithDelay ); 00876 up = 0; 00877 down = 0; 00878 scheduleAt(simTime() + bandwithDelay, bandwithTimer); 00879 }
void YMMOGBase::processStabilizeTimer | ( | ) | [virtual] |
void YMMOGBase::processLogin | ( | LoginMessage * | loginMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00890 { 00891 ev << "Warning this is a Dummy Function! processLogin(LoginMessage* loginMsg)"; 00892 }
void YMMOGBase::processLogout | ( | LogoutMessage * | logoutMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00893 { 00894 ev << "Warning this is a Dummy Function! processLogout(LogoutMessage* logoutMsg)"; 00895 }
void YMMOGBase::processCreate | ( | CreateNodeMessage * | createMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00883 { 00884 // No default handling 00885 ev << "Warning this is a Dummy Function! processCreate"; 00886 }
void YMMOGBase::processSubscribe | ( | SubscribeMessage * | subscribeMsg | ) | [virtual] |
Reimplemented in YMMOG.
00923 { 00924 ev << "Warning this is a Dummy Function! processSubscribe(SubscribeMessage* subscribeMsg)"; 00925 }
void YMMOGBase::processUnSubscribe | ( | UnSubscribeMessage * | unsubscribeMsg | ) | [virtual] |
Reimplemented in YMMOG.
00926 { 00927 ev << "Warning this is a Dummy Function! processUnSubscribe(UnSubscribeMessage* unsubscribeMsg)"; 00928 }
void YMMOGBase::processPublish | ( | PublishMessage * | publishMsg | ) | [virtual] |
Reimplemented in YMMOG.
00902 { 00903 ev << "Warning this is a Dummy Function! processPublish(PublishMessage* publishMsg"; 00904 }
void YMMOGBase::processPublishEventList | ( | PublishEventListMessage * | publishMsg | ) | [virtual] |
Reimplemented in YMMOG.
00905 { 00906 ev << "Warning this is a Dummy Function! processPublishEventList(PublishEventListMessage* publishMsg)"; 00907 }
void YMMOGBase::processRequestIp | ( | RequestIpMessage * | requestMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00914 { 00915 ev << "Warning this is a Dummy Function! processRequestIp(RequestIpMessage* requestMsg)"; 00916 }
void YMMOGBase::processDelay | ( | DelayMessage * | delayMsg | ) | [virtual] |
Reimplemented in YMMOG.
00887 { 00888 ev << "Warning this is a Dummy Function! processDelay(DelayMessage* delayMsg)"; 00889 }
void YMMOGBase::processReplaceIntermediateNode | ( | ReplaceIntermediateNodeMessage * | replaceMsg | ) | [virtual] |
Reimplemented in YMMOG.
00908 { 00909 ev << "Warning this is a Dummy Function! processReplaceIntermediateNode(ReplaceIntermediateNodeMessage* replaceMsg)"; 00910 }
void YMMOGBase::processPlayerList | ( | PlayerListMessage * | playerListMsg | ) | [virtual] |
Reimplemented in YMMOG.
00899 { 00900 ev << "Warning this is a Dummy Function! processPlayerList(PlayerListMessage* playerListMsg)"; 00901 }
void YMMOGBase::processRequestNode | ( | RequestNodeMessage * | requestMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00917 { 00918 ev << "Warning this is a Dummy Function! processRequestNode(RequestNodeMessage* requestMsg)"; 00919 }
void YMMOGBase::processUpdateRespIp | ( | UpdateRespIpMessage * | updateMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00929 { 00930 ev << "Warning this is a Dummy Function! processUpdateRespIp(UpdateRespIpMessage* updateMsg)"; 00931 }
void YMMOGBase::processReplacement | ( | ReplacementMessage * | replaceMsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00911 { 00912 ev << "Warning this is a Dummy Function! processReplacement(ReplacementMessage* replaceMsg)"; 00913 }
void YMMOGBase::processPing | ( | PingMessage * | pingMsg | ) | [virtual] |
void YMMOGBase::processStabilize | ( | StabilizeMessage * | smsg | ) | [virtual] |
Reimplemented in LobbyServer, and YMMOG.
00920 { 00921 ev << "Warning this is a Dummy Function! processStabilize(StabilizeMessage* smsg)"; 00922 }
void YMMOGBase::sendPing | ( | PingMessage * | openPing | ) | [virtual] |
void YMMOGBase::deleteFromOpenPings | ( | IPAddress | destip | ) |
void YMMOGBase::resetPing | ( | IPAddress | destip | ) |
00831 { 00832 std::list<PingMessage*>::iterator i= pings.begin(); 00833 while( i != pings.end() ) { 00834 if( (*i)->getDestip() == destip ) { 00835 (*i)->setTimeStamp(simTime()); 00836 (*i)->setFailed(0); 00837 break; 00838 } 00839 ++i; 00840 } 00841 i = playerPings.begin(); 00842 while( i != playerPings.end() ) { 00843 if( (*i)->getDestip() == destip ) { 00844 delete *i; 00845 i = playerPings.erase(i); 00846 } 00847 else { ++i; } 00848 } 00849 return; 00850 }
std::list<YMMOGMessage*> YMMOGBase::notReadyMessages |
std::list<YMMOGMessage*> YMMOGBase::dupedMessages |
std::list<PingMessage*> YMMOGBase::pings |
std::list<PingMessage*> YMMOGBase::playerPings |
double YMMOGBase::stabilizeDelay |
double YMMOGBase::bandwithDelay |
double YMMOGBase::resendDelay |
double YMMOGBase::pingDelay |
cMessage* YMMOGBase::resendTimer |
cMessage* YMMOGBase::pingTimer |
cMessage* YMMOGBase::stabilizeTimer |
cMessage* YMMOGBase::bandwithTimer |
bool YMMOGBase::debug |
double YMMOGBase::sessionBegin |
cOutVector* YMMOGBase::upstream |
cOutVector* YMMOGBase::downstream |
unsigned int YMMOGBase::up |
unsigned int YMMOGBase::down |
unsigned int YMMOGBase::overheadBytes |
unsigned int YMMOGBase::messageBytes |
unsigned int YMMOGBase::sentOverheadBytes |
unsigned int YMMOGBase::receivedOverheadBytes |
unsigned int YMMOGBase::receivedBytes |
unsigned int YMMOGBase::sentBytes |