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->setSrcPort(thisNode.port);
00499         msg->setControlInfo(udpControlInfo);
00500         send(msg,"to_udp");
00501         sentMessages++;
00502         overheadBytes = sentOverheadBytes + receivedOverheadBytes;
00503         messageBytes = sentBytes + receivedBytes;
00504         sentSum = sentLogins + sentLogouts + sentSubscribes + sentUnSubscribes + sentEvents + sentCreates + sentRequestIps + sentUpdateRespIps + sentEventLists + sentPings + sentPlayerLists +sentRequestNodes + sentReplacements + sentDelays + sentReplaceInt;
00505 }

void YMMOGBase::setLength ( YMMOGMessage *  msg  ) 

00509                                            {
00510         static const uint INT_SIZE = sizeof(int);
00511         static const uint SUBSPACE_SIZE = sizeof(SubSpace);
00512         static const uint IPADDRESS_SIZE = sizeof(IPAddress);
00513         static const uint BOOL_SIZE = sizeof(bool);
00514         static const uint DOUBLE_SIZE = sizeof(double);
00515         static const uint EVENT_SIZE = sizeof(Event);
00516         int base= 2*INT_SIZE + 2*IPADDRESS_SIZE;
00517 
00518         switch ( msg->getCommand() ) {
00519                 case LOGIN: {
00520                         LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(msg);
00521                         msg->setLength( base + 7* INT_SIZE + loginMsg->getResponsibleNodesArraySize() * SUBSPACE_SIZE);
00522                         break;
00523                 }
00524                 case LOGOUT: { msg->setLength( base + INT_SIZE + BOOL_SIZE);  break; }
00525                 case SUBSCRIBE: {
00526                         SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(msg);
00527                         msg->setLength( base + INT_SIZE + IPADDRESS_SIZE + SUBSPACE_SIZE + sizeof( subscribeMsg->getGameState() ) );
00528                         break;
00529                 }
00530                 case UNSUBSCRIBE: { msg->setLength( base + 2*INT_SIZE + IPADDRESS_SIZE); break; }
00531                 case PUBLISH: { msg->setLength( base + 2*INT_SIZE + EVENT_SIZE); break; }
00532                 case CREATE: { msg->setLength( base + 2*INT_SIZE + SUBSPACE_SIZE + BOOL_SIZE); break; }
00533                 case REQUESTIP: { msg->setLength( base + 2*INT_SIZE + IPADDRESS_SIZE); break; }
00534                 case UPDATERESPIP: {  msg->setLength( base + 2*INT_SIZE + IPADDRESS_SIZE); break; }
00535                 case PUBLISHEVENTLIST: {
00536                         PublishEventListMessage* publishMsg = dynamic_cast<PublishEventListMessage*>(msg);
00537                         msg->setLength( base + 2*INT_SIZE + DOUBLE_SIZE + publishMsg->getEventListArraySize() * EVENT_SIZE);
00538                         break;
00539                 }
00540                 case PING: { msg->setLength( base + DOUBLE_SIZE);  break; }
00541                 case PLAYERLIST: {
00542                         PlayerListMessage* playerListMsg = dynamic_cast<PlayerListMessage*>(msg);
00543                         msg->setLength( base +  2*INT_SIZE + DOUBLE_SIZE + IPADDRESS_SIZE*playerListMsg->getTreeArraySize() );
00544                         break;
00545                 }
00546                 case REQUESTNODE: { msg->setLength(base + 2*INT_SIZE); break; }
00547                 case REPLACEMENT: {
00548                         ReplacementMessage* replaceMsg = dynamic_cast<ReplacementMessage*>(msg);
00549                         msg->setLength( base + 2*INT_SIZE + sizeof( replaceMsg->getGameState() ) );
00550                         break;
00551                 }
00552                 case DELAY: { msg->setLength( base + INT_SIZE + DOUBLE_SIZE + IPADDRESS_SIZE);  break; }
00553                 case REPLACEINT: {
00554                         ReplaceIntermediateNodeMessage* replaceMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(msg);
00555                         msg->setLength( base + INT_SIZE + SUBSPACE_SIZE + IPADDRESS_SIZE + replaceMsg->getIpListArraySize()*IPADDRESS_SIZE);
00556                         break;
00557                 }
00558         }
00559 }

void YMMOGBase::deleteFromDupedMessages ( YMMOGMessage *  ymmog  ) 

00561                                                            {
00562         std::list<YMMOGMessage*>::iterator i = dupedMessages.begin();
00563         int command = ymmog->getCommand();
00564         while( i != dupedMessages.end() ) {
00565                 if( (*i)->getCommand() == command) {
00566                         switch( command ) {
00567                                 case LOGIN: {
00568                                         LoginMessage* storedMsg = dynamic_cast<LoginMessage*>(*i);
00569                                         if( storedMsg != NULL ) {
00570                                                 delete *i;
00571                                                 dupedMessages.erase(i);
00572                                                 return;
00573                                         }
00574                                         break;
00575                                 }
00576                                 case LOGOUT: {
00577                                         LogoutMessage* receivedMsg = dynamic_cast<LogoutMessage*>(ymmog);
00578                                         LogoutMessage* storedMsg = dynamic_cast<LogoutMessage*>(*i);
00579                                         if( storedMsg != NULL && receivedMsg != NULL) {
00580                                                 if( storedMsg->getId() == receivedMsg->getId() ) {
00581                                                         delete *i;
00582                                                         dupedMessages.erase(i);
00583                                                         return;
00584                                                 }
00585                                         }
00586                                         break;
00587                                 }
00588                                 case CREATE: {
00589                                         CreateNodeMessage* receivedMsg = dynamic_cast<CreateNodeMessage*>(ymmog);
00590                                         CreateNodeMessage* storedMsg = dynamic_cast<CreateNodeMessage*>(*i);
00591                                         if( storedMsg != NULL && receivedMsg != NULL) {
00592                                                 if( storedMsg->getNodeType() == receivedMsg->getNodeType() && storedMsg->getJobType() == receivedMsg->getJobType() && storedMsg->getSubSpaceToCreate().getId() == receivedMsg->getSubSpaceToCreate().getId() ) {
00593                                                         delete *i;
00594                                                         dupedMessages.erase(i);
00595                                                         return;
00596                                                 }
00597                                         }
00598                                         break;
00599                                 }
00600                                 case SUBSCRIBE: {
00601                                         SubscribeMessage* receivedMsg = dynamic_cast<SubscribeMessage*>(ymmog);
00602                                         SubscribeMessage* storedMsg = dynamic_cast<SubscribeMessage*>(*i);
00603                                         if( storedMsg != NULL && receivedMsg != NULL) {
00604                                                 if( ( storedMsg->getPlayerId() == receivedMsg->getPlayerId() || storedMsg->getPlayerIp() == receivedMsg->getPlayerIp() ) && storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() ) {
00605                                                         delete *i;
00606                                                         dupedMessages.erase(i);
00607                                                         return;
00608                                                 }
00609                                         }
00610                                         break;
00611                                 }
00612                                 case UNSUBSCRIBE: {
00613                                         UnSubscribeMessage* receivedMsg = dynamic_cast<UnSubscribeMessage*>(ymmog);
00614                                         UnSubscribeMessage* storedMsg = dynamic_cast<UnSubscribeMessage*>(*i);
00615                                         if( storedMsg != NULL && receivedMsg != NULL) {
00616                                                 if( (storedMsg->getPlayerId() == receivedMsg->getPlayerId() || storedMsg->getPlayerIp() == receivedMsg->getPlayerIp() ) && storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() ) {
00617                                                         delete *i;
00618                                                         dupedMessages.erase(i);
00619                                                         return;
00620                                                 }
00621                                         }
00622                                         break;
00623                                 }
00624                                 case PUBLISH: {
00626                                         break;
00627                                 }
00628                                 case PUBLISHEVENTLIST: {
00630                                         break;
00631                                 }
00632                                 case REQUESTIP: {
00633                                         RequestIpMessage* receivedMsg = dynamic_cast<RequestIpMessage*>(ymmog);
00634                                         RequestIpMessage* storedMsg = dynamic_cast<RequestIpMessage*>(*i);
00635                                         if( storedMsg != NULL && receivedMsg != NULL) {
00636                                                 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() ) {
00637                                                         delete *i;
00638                                                         dupedMessages.erase(i);
00639                                                         return;
00640                                                 }
00641                                         }
00642                                         break;
00643                                 }
00644                                 case UPDATERESPIP: {
00645                                         UpdateRespIpMessage* receivedMsg = dynamic_cast<UpdateRespIpMessage*>(ymmog);
00646                                         UpdateRespIpMessage* storedMsg = dynamic_cast<UpdateRespIpMessage*>(*i);
00647                                         if( storedMsg != NULL && receivedMsg != NULL) {
00648                                                 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getDirection() == receivedMsg->getDirection() && storedMsg->getDestip() == receivedMsg->getSrcip() ) {
00649                                                         delete *i;
00650                                                         dupedMessages.erase(i);
00651                                                         return;
00652                                                 }
00653                                         }
00654                                         break;
00655                                 }
00656                                 case PING: {
00658                                         break;
00659                                 }
00660                                 case PLAYERLIST: {
00661                                         PlayerListMessage* receivedMsg = dynamic_cast<PlayerListMessage*>(ymmog);
00662                                         PlayerListMessage* storedMsg = dynamic_cast<PlayerListMessage*>(*i);
00663                                         if( storedMsg != NULL && receivedMsg != NULL) {
00664                                                 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getAction() == receivedMsg->getAction() ) {
00665                                                         delete *i;
00666                                                         dupedMessages.erase(i);
00667                                                         return;
00668                                                 }
00669                                         }
00670                                         break;
00671                                 }
00672                                 case REQUESTNODE: {
00673                                         RequestNodeMessage* receivedMsg = dynamic_cast<RequestNodeMessage*>(ymmog);
00674                                         RequestNodeMessage* storedMsg = dynamic_cast<RequestNodeMessage*>(*i);
00675                                         if( storedMsg != NULL && receivedMsg != NULL) {
00676                                                 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getNodeType() == receivedMsg->getNodeType() ) {
00677                                                         delete *i;
00678                                                         dupedMessages.erase(i);
00679                                                         return;
00680                                                 }
00681                                         }
00682                                         break;
00683                                 }
00684                                 case REPLACEMENT: {
00685                                         ReplacementMessage* receivedMsg = dynamic_cast<ReplacementMessage*>(ymmog);
00686                                         ReplacementMessage* storedMsg = dynamic_cast<ReplacementMessage*>(*i);
00687                                         if( storedMsg != NULL && receivedMsg != NULL) {
00688                                                 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getDestip() == receivedMsg->getSrcip() ) {
00689                                                         delete *i;
00690                                                         dupedMessages.erase(i);
00691                                                         return;
00692                                                 }
00693                                         }
00694                                         break;
00695                                 }
00696                                 case DELAY: {
00698                                         break;
00699                                 }
00700                                 case REPLACEINT: {
00701                                         ReplaceIntermediateNodeMessage* receivedMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(ymmog);
00702                                         ReplaceIntermediateNodeMessage* storedMsg = dynamic_cast<ReplaceIntermediateNodeMessage*>(*i);
00703                                         if( storedMsg != NULL && receivedMsg != NULL) {
00704                                                 if( storedMsg->getSubSpaceId() == receivedMsg->getSubSpaceId() && storedMsg->getToReplace() == receivedMsg->getToReplace() ) {
00705                                                         delete *i;
00706                                                         dupedMessages.erase(i);
00707                                                         return;
00708                                                 }
00709                                         }
00710                                         break;
00711                                 }
00712                                 default: {
00713                                         return;
00714                                 }
00715                         }
00716                 }
00717                 ++i;
00718         }
00719 }

bool YMMOGBase::findOpenSubScribe ( int  subSpaceId,
IPAddress  destip 
)

00772                                                                   {
00773         std::list<YMMOGMessage*>::iterator i=dupedMessages.begin();
00774         while( i != dupedMessages.end() ) {
00775                 if( (*i)->getCommand() == SUBSCRIBE ) {
00776                         SubscribeMessage* subscribeMsg = dynamic_cast<SubscribeMessage*>(*i);
00777                         if( subscribeMsg != NULL && subscribeMsg->getSubSpaceId() == subSpaceId && subscribeMsg->getDestip() == destip)
00778                                 return true;
00779                 }
00780                 ++i;
00781         }
00782         return false;
00783 }

bool YMMOGBase::findOpenUnSubscribe ( int  subSpaceId,
IPAddress  destip 
)

00805                                                                     {
00806         std::list<YMMOGMessage*>::iterator i=dupedMessages.begin();
00807         while( i != dupedMessages.end() ) {
00808                 if( (*i)->getCommand() == UNSUBSCRIBE ) {
00809                         UnSubscribeMessage* unSubscribeMsg = dynamic_cast<UnSubscribeMessage*>(*i);
00810                         if( unSubscribeMsg != NULL && unSubscribeMsg->getSubSpaceId() == subSpaceId && unSubscribeMsg->getDestip() == destip)
00811                                 return true;
00812                 }
00813                 ++i;
00814         }
00815         return false;
00816 }

bool YMMOGBase::findOpenPing ( IPAddress  destip  ) 

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

bool YMMOGBase::findOpenPlayerList ( int  subSpaceId  ) 

bool YMMOGBase::findOpenRequestNode ( int  subSpaceId,
int  nodeType 
)

00817                                                                 {
00818         std::list<YMMOGMessage*>::iterator i= dupedMessages.begin();
00819         while( i != dupedMessages.end() ) {
00820                 if( (*i)->getCommand() == REQUESTNODE ) {
00821                         RequestNodeMessage* requestMsg = dynamic_cast<RequestNodeMessage*>(*i);
00822                         if( requestMsg != NULL && requestMsg->getSubSpaceId() == subSpaceId && requestMsg->getNodeType() == nodeType)
00823                                 return true;
00824                 }
00825                 ++i;
00826         }
00827         return false;
00828 }

bool YMMOGBase::findOpenCreate ( int  subSpaceId,
int  nodeType 
)

00761                                                             {
00762         std::list<YMMOGMessage*>::iterator i = dupedMessages.begin();
00763         while( i != dupedMessages.end() ) {
00764                 if( (*i)->getCommand() == CREATE ) {
00765                         CreateNodeMessage* tmp = dynamic_cast<CreateNodeMessage*>(*i);
00766                         if( tmp != NULL && tmp->getSubSpaceToCreate().getId() == subSpaceId && tmp->getNodeType() ) return true;
00767                 }
00768                 ++i;
00769         }
00770         return false;
00771 }

bool YMMOGBase::findOpenLogin ( IPAddress  playerip  ) 

00784                                                  {
00785         std::list<YMMOGMessage*>::iterator i= notReadyMessages.begin();
00786         while( i != notReadyMessages.end() ) {
00787                 if( (*i)->getCommand() == LOGIN) {
00788                         LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(*i);
00789                         if( loginMsg != NULL && loginMsg->getSrcip() == playerip)
00790                                 return true;
00791                 }
00792                 ++i;
00793         }
00794         i= dupedMessages.begin();
00795         while( i != dupedMessages.end() ) {
00796                 if( (*i)->getCommand() == LOGIN) {
00797                         LoginMessage* loginMsg = dynamic_cast<LoginMessage*>(*i);
00798                         if( loginMsg != NULL && loginMsg->getSrcip() == playerip)
00799                                 return true;
00800                 }
00801                 ++i;
00802         }
00803         return false;
00804 }

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]

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.

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

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

Reimplemented in YMMOG.

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

void YMMOGBase::processResendTimer (  )  [virtual]

Reimplemented in YMMOG.

00721                                    {
00722        double min=simTime() + resendDelay;
00723        double now = simTime();
00724        std::list<YMMOGMessage*>::iterator i = dupedMessages.begin();
00725        while( i != dupedMessages.end() ) {
00726               if( (*i)->getTimeStamp() + resendDelay < now) {
00727                      // we have to resend it
00728                      (*i)->setTimeStamp(now);
00729                      (*i)->setFailed((*i)->getFailed() + 1);
00730                      if( (*i)->getFailed() > maxFailed ) {
00731                             delete (*i);
00732                             i = dupedMessages.erase(i);
00733                             droppedMessages++;
00734                      }
00735                      else {
00736                             YMMOGMessage* tmp = *i;
00737                             i = dupedMessages.erase(i);
00738                             sendMsg(tmp, tmp->getDestip());
00739                      }
00740                 }
00741                 else {
00742                         if( ((*i)->getTimeStamp() + resendDelay < min) &&  (*i)->getTimeStamp() + resendDelay > simTime() ) min = (*i)->getTimeStamp() + resendDelay;
00743                         ++i;
00744                 }
00745         }
00746         selfMessages++;
00747         cancelEvent(resendTimer);
00748         scheduleAt(min + 0.05, resendTimer);
00749 }

void YMMOGBase::processBandwithTimer (  )  [virtual]

Reimplemented in YMMOG.

00871                                      {
00872         cancelEvent(bandwithTimer);
00873         upstream->record( up / bandwithDelay );
00874         downstream->record( down / bandwithDelay );
00875         up = 0;
00876         down = 0;
00877         scheduleAt(simTime() + bandwithDelay, bandwithTimer);
00878 }

void YMMOGBase::processStabilizeTimer (  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

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

void YMMOGBase::processLogin ( LoginMessage *  loginMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00889                                                    {
00890         ev << "Warning this is a Dummy Function! processLogin(LoginMessage* loginMsg)";
00891 }

void YMMOGBase::processLogout ( LogoutMessage *  logoutMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00892                                                       {
00893         ev << "Warning this is a Dummy Function! processLogout(LogoutMessage* logoutMsg)";
00894 }

void YMMOGBase::processCreate ( CreateNodeMessage *  createMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00882                                                           {
00883         // No default handling
00884         ev << "Warning this is a Dummy Function! processCreate";
00885 }

void YMMOGBase::processSubscribe ( SubscribeMessage *  subscribeMsg  )  [virtual]

Reimplemented in YMMOG.

00922                                                                {
00923         ev << "Warning this is a Dummy Function! processSubscribe(SubscribeMessage* subscribeMsg)";
00924 }

void YMMOGBase::processUnSubscribe ( UnSubscribeMessage *  unsubscribeMsg  )  [virtual]

Reimplemented in YMMOG.

00925                                                                      {
00926         ev << "Warning this is a Dummy Function! processUnSubscribe(UnSubscribeMessage* unsubscribeMsg)";
00927 }

void YMMOGBase::processPublish ( PublishMessage *  publishMsg  )  [virtual]

Reimplemented in YMMOG.

00901                                                          {
00902         ev << "Warning this is a Dummy Function! processPublish(PublishMessage* publishMsg";
00903 }

void YMMOGBase::processPublishEventList ( PublishEventListMessage *  publishMsg  )  [virtual]

Reimplemented in YMMOG.

00904                                                                            {
00905         ev << "Warning this is a Dummy Function! processPublishEventList(PublishEventListMessage* publishMsg)";
00906 }

void YMMOGBase::processRequestIp ( RequestIpMessage *  requestMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00913                                                              {
00914         ev << "Warning this is a Dummy Function! processRequestIp(RequestIpMessage* requestMsg)";
00915 }

void YMMOGBase::processDelay ( DelayMessage *  delayMsg  )  [virtual]

Reimplemented in YMMOG.

00886                                                    {
00887         ev << "Warning this is a Dummy Function! processDelay(DelayMessage* delayMsg)";
00888 }

void YMMOGBase::processReplaceIntermediateNode ( ReplaceIntermediateNodeMessage *  replaceMsg  )  [virtual]

Reimplemented in YMMOG.

00907                                                                                          {
00908         ev << "Warning this is a Dummy Function! processReplaceIntermediateNode(ReplaceIntermediateNodeMessage* replaceMsg)";
00909 }

void YMMOGBase::processPlayerList ( PlayerListMessage *  playerListMsg  )  [virtual]

Reimplemented in YMMOG.

00898                                                                   {
00899         ev << "Warning this is a Dummy Function! processPlayerList(PlayerListMessage* playerListMsg)";
00900 }

void YMMOGBase::processRequestNode ( RequestNodeMessage *  requestMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00916                                                                  {
00917         ev << "Warning this is a Dummy Function! processRequestNode(RequestNodeMessage* requestMsg)";
00918 }

void YMMOGBase::processUpdateRespIp ( UpdateRespIpMessage *  updateMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00928                                                                   {
00929         ev << "Warning this is a Dummy Function! processUpdateRespIp(UpdateRespIpMessage* updateMsg)";
00930 }

void YMMOGBase::processReplacement ( ReplacementMessage *  replaceMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00910                                                                  {
00911         ev << "Warning this is a Dummy Function! processReplacement(ReplacementMessage* replaceMsg)";
00912 }

void YMMOGBase::processPing ( PingMessage *  pingMsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

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

void YMMOGBase::processStabilize ( StabilizeMessage *  smsg  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

00919                                                       {
00920         ev << "Warning this is a Dummy Function! processStabilize(StabilizeMessage* smsg)";
00921 }

void YMMOGBase::sendPing ( PingMessage *  openPing  )  [virtual]

Reimplemented in LobbyServer, and YMMOG.

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

void YMMOGBase::deleteFromOpenPings ( IPAddress  destip  ) 

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

void YMMOGBase::resetPing ( IPAddress  destip  ) 

00830                                           {
00831         std::list<PingMessage*>::iterator i= pings.begin();
00832         while( i != pings.end() ) {
00833                 if( (*i)->getDestip() == destip ) {
00834                         (*i)->setTimeStamp(simTime());
00835                         (*i)->setFailed(0);
00836                         break;
00837                 }
00838                 ++i;
00839         }
00840         i =  playerPings.begin();
00841         while( i != playerPings.end() ) {
00842                 if( (*i)->getDestip() == destip ) {
00843                         delete *i;
00844                         i = playerPings.erase(i);
00845                 }
00846                 else { ++i; }
00847         }
00848         return;
00849 }


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 Tue Jul 24 16:51:19 2007 for ITM OverSim by  doxygen 1.5.1