YMMOGBase Class Reference

#include <YMMOGBase.h>

Inheritance diagram for YMMOGBase:

LobbyServer YMMOG

List of all members.

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
BootstrapOraclebootstrapOracle
NodeHandle thisNode
GlobalStatisticsglobalStatistics


Member Function Documentation

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

Reimplemented in LobbyServer, and YMMOG.

00024 {return 6;}

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]

Reimplemented in LobbyServer, and YMMOG.

00035                            {
00036         ev << "You should add your own initialize()";
00037 }

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  ) 

00752                                              {
00753         std::list<PingMessage*>::iterator i =pings.begin();
00754         while( i != pings.end() ) {
00755                 if( (*i)->getDestip() == destip ) {
00756                         return true;
00757                 }
00758                 ++i;
00759         }
00760         return false;
00761 }

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]

Reimplemented in LobbyServer, and YMMOG.

00866                                                {
00867         ev << "Warning this is a Dummy Function! processSelfTimers";
00868 }

void YMMOGBase::processAppMessages ( cMessage *  msg  )  [virtual]

Reimplemented in YMMOG.

00869                                                 {
00870         ev << "Warning this is a Dummy Function! processAppMessages";
00871 }

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]

Reimplemented in LobbyServer, and YMMOG.

00880                                       {
00881         ev << "Warning this is a Dummy Function! processStabilizeTimer()";
00882 }

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]

Reimplemented in LobbyServer, and YMMOG.

00896                                                 {
00897         ev << "Warning this is a Dummy Function! processPing(PingMessage* pingMsg)";
00898 }

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]

Reimplemented in LobbyServer, and YMMOG.

00863                                                {
00864         ev << "Warning this is a Dummy Function! sendPing";
00865 }

void YMMOGBase::deleteFromOpenPings ( IPAddress  destip  ) 

00852                                                     {
00853         std::list<PingMessage*>::iterator i= pings.begin();
00854         while( i != pings.end() ) {
00855                 if( (*i)->getDestip() == destip ) {
00856                         delete *i;
00857                         i = pings.erase(i);
00858                         return;
00859                 }
00860                 ++i;
00861         }
00862 }

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 }


Member Data Documentation

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

int YMMOGBase::selfMessages

int YMMOGBase::maxFailed

int YMMOGBase::droppedMessages

bool YMMOGBase::debug

int YMMOGBase::localPort

double YMMOGBase::sessionBegin

int YMMOGBase::sentMessages

int YMMOGBase::receivedMessages

cOutVector* YMMOGBase::upstream

cOutVector* YMMOGBase::downstream

unsigned int YMMOGBase::up

unsigned int YMMOGBase::down

int YMMOGBase::sentSum

int YMMOGBase::receivedSum

unsigned int YMMOGBase::overheadBytes

unsigned int YMMOGBase::messageBytes

unsigned int YMMOGBase::sentOverheadBytes

unsigned int YMMOGBase::receivedOverheadBytes

unsigned int YMMOGBase::receivedBytes

unsigned int YMMOGBase::sentBytes

int YMMOGBase::sentLogins

int YMMOGBase::sentLogouts

int YMMOGBase::sentSubscribes

int YMMOGBase::sentUnSubscribes

int YMMOGBase::sentEvents

int YMMOGBase::sentCreates

int YMMOGBase::sentRequestIps

int YMMOGBase::sentUpdateRespIps

int YMMOGBase::sentEventLists

int YMMOGBase::sentPings

int YMMOGBase::sentPlayerLists

int YMMOGBase::sentRequestNodes

int YMMOGBase::sentReplacements

int YMMOGBase::sentDelays

int YMMOGBase::sentReplaceInt

int YMMOGBase::sentUndefined

int YMMOGBase::receivedLogins

int YMMOGBase::receivedLogouts

int YMMOGBase::receivedSubscribes

int YMMOGBase::receivedUnSubscribes

int YMMOGBase::receivedEvents

int YMMOGBase::receivedCreates

int YMMOGBase::receivedRequestIps

int YMMOGBase::receivedUpdateRespIps

int YMMOGBase::receivedEventLists

int YMMOGBase::receivedPings

int YMMOGBase::receivedPlayerLists

int YMMOGBase::receivedRequestNodes

int YMMOGBase::receivedReplacements

int YMMOGBase::receivedDelays

int YMMOGBase::receivedReplaceInt

BootstrapOracle* YMMOGBase::bootstrapOracle

NodeHandle YMMOGBase::thisNode

GlobalStatistics* YMMOGBase::globalStatistics


The documentation for this class was generated from the following files:
Generated on Thu Apr 17 13:19:30 2008 for ITM OverSim by  doxygen 1.5.3