GameClient Class Reference

#include <GameClient.h>

List of all members.

Public Member Functions

virtual int numInitStages () const
virtual void initialize (int stage)
virtual void handleMessage (cMessage *msg)
virtual void finish ()

Protected Attributes

bool debugOutput

Private Member Functions

void sendMsg (cMessage *msg)

Private Attributes

int playerId
int xpos
int ypos
int gameSpaceSize
std::list
< PlayerPosition
playerMap
std::list
< PlayerPosition >
::iterator 
pM
Movementmovement
cMessage * loginTimer
cMessage * moveTimer
cMessage * eventCreationTimer
double initialDelay
double eventCreationDelay
double moveDelay
int sentMessages
int receivedMessages
int sentEvents
int receivedEvents
int reachedWaypoints


Member Function Documentation

virtual int GameClient::numInitStages (  )  const [inline, virtual]

00043                 {
00044                         return 6;
00045                 }

void GameClient::initialize ( int  stage  )  [virtual]

00028 {
00029 // because of IPAddressResolver, we need to wait until interfaces are registered,
00030 // address auto-assignment takes place etc.
00031         
00032         if (stage != 5)
00033                 return;
00034 
00035         // fetch parameters
00036         eventCreationDelay = par("eventCreationDelay"); // create a random Event every eventCreationDelay s
00037         
00038         // some initialization  
00039         movement = NULL;                
00040         playerId = 0;
00041         xpos = 0;
00042         ypos = 0;
00043                 
00044         // timers:
00045         loginTimer = new cMessage("login");
00046         moveTimer = new cMessage("move");
00047         eventCreationTimer = new cMessage("event_creation");
00048                         
00049         // Delays
00050         initialDelay= 1;
00051         moveDelay = 0.2; // Move every moveDelay
00052         
00053         // Statistics
00054         sentMessages = 0;
00055         receivedMessages = 0;
00056         sentEvents = 0;
00057         receivedEvents = 0;
00058         reachedWaypoints = 0;
00059         
00060         // Watches for gui
00061         WATCH(playerId);
00062         WATCH(xpos);
00063         WATCH(ypos);
00064         WATCH_LIST(playerMap);
00065         WATCH(receivedMessages);
00066         WATCH(sentMessages);
00067         WATCH(reachedWaypoints);
00068         WATCH(receivedEvents);
00069         WATCH(sentEvents);
00070         
00071         // begin
00072         scheduleAt(simTime() + initialDelay, loginTimer );
00073 
00074 }

void GameClient::handleMessage ( cMessage *  msg  )  [virtual]

Berechne die Events....

00077 {
00078         if( msg->isName("login") ) {
00079                 if(debug) ev << "Initiate Login\n";
00080                 ClientLogin* clientLogin = new ClientLogin("Clientlogin");
00081                 clientLogin->setCommand(LOGIN);
00082                 sendMsg( clientLogin );
00083                 cancelEvent(loginTimer);
00084                 scheduleAt(simTime() + 60, loginTimer );
00085         }
00086         
00087         else if ( msg->isName("move") ) {
00088                 Point p = movement->move(xpos, ypos);
00089                 xpos = p.x;
00090                 ypos = p.y;
00091                 if( p.reached ) reachedWaypoints++;
00092                 cancelEvent(moveTimer);
00093                 scheduleAt(simTime() + moveDelay, moveTimer);
00094         }
00095         
00096         else if ( msg->isName("event_creation") ) {
00097                 // Send our actual position to the rest of the world.
00098                 ClientEvent* clientEvent = new ClientEvent("publishEvent");
00099                 clientEvent->setEvent(Event(simTime(), playerId, PLAYERPOSITION, xpos, ypos));
00100                 sentEvents++;
00101                 clientEvent->setCommand(PUBLISH);
00102                 sendMsg(clientEvent);
00103                 // Schedule for next Event creation     
00104                 cancelEvent(eventCreationTimer);
00105                 scheduleAt(simTime() + eventCreationDelay, eventCreationTimer);
00106         }
00107         
00108         else if (msg->arrivedOn ("from_lowerTier"))
00109         {
00110                 receivedMessages++;
00111                 YMMOGMessage *ymmog = (YMMOGMessage *) (msg);
00112                 if (ymmog != NULL)
00113                 {
00114                         if( ymmog->getCommand() == LOGIN ) {
00115                                 ClientLogin* clientLogin = (ClientLogin*) ymmog;
00116                                 playerId = clientLogin->getPlayerId();
00117                                 xpos = clientLogin->getXpos();
00118                                 ypos = clientLogin->getYpos();
00119                                 gameSpaceSize = clientLogin->getGameSpaceSize();
00120                                 movement = new Movement(gameSpaceSize);
00121                                 cancelEvent(moveTimer);
00122                                 scheduleAt(simTime()+0.1, moveTimer);
00123                                 cancelEvent(eventCreationTimer);
00124                                 scheduleAt(simTime(), eventCreationTimer);
00125                                 cancelEvent(loginTimer);
00126                                 delete msg;
00127                         }
00128                         else if (ymmog->getCommand() == PUBLISHEVENTLIST ) {
00129                                 ClientEventList* clientEventList = (ClientEventList*) ymmog;
00131                                 receivedEvents += clientEventList->getEventListArraySize();
00132                                 for(unsigned int i=0; i < clientEventList->getEventListArraySize(); ++i) {
00133                                         Event event = clientEventList->getEventList(i);
00134                                         if( event.type == PLAYERPOSITION ) {
00135                                                 for(pM=playerMap.begin(); pM != playerMap.end(); ++pM) {
00136                                                         if(pM->playerId == event.playerId) {
00137                                                                 pM->xpos = event.xpos;
00138                                                                 pM->ypos = event.ypos;
00139                                                                 pM->timeStamp = event.timestamp;
00140                                                                 break;
00141                                                         }
00142                                                 }
00143                                                 if( pM == playerMap.end() ) {
00144                                                         PlayerPosition player;
00145                                                         player.playerId = event.playerId;
00146                                                         player.xpos = event.xpos;
00147                                                         player.ypos = event.ypos;
00148                                                         player.timeStamp = event.timestamp;
00149                                                         playerMap.push_back(player);
00150                                                 }
00151                                         }
00152                                 }
00153                                 pM=playerMap.begin();
00154                                 // Delete too old positions
00155                                 while(pM != playerMap.end()) {
00156                                         if ( pM->timeStamp < simTime() - 10) {
00157                                                 pM = playerMap.erase(pM);
00158                                         }
00159                                         else { ++pM; }
00160                                 }
00161                                 delete msg;
00162                         }
00163                         else {
00164                                 delete msg;
00165                         }
00166                 }
00167                 else {
00168                         delete msg;
00169                 }
00170         }
00171 }

void GameClient::finish (  )  [virtual]

00175 {
00176         //CleanUp       
00177         playerMap.clear();
00178         delete movement;
00179         
00180         cancelEvent( loginTimer );
00181         cancelEvent( moveTimer );
00182         cancelEvent( eventCreationTimer );
00183         delete loginTimer;
00184         delete moveTimer;
00185         delete eventCreationTimer;
00186         
00187 }

void GameClient::sendMsg ( cMessage *  msg  )  [private]

00189                                       {
00190         send( msg, "to_lowerTier");
00191         sentMessages++;
00192 }


Member Data Documentation

bool GameClient::debugOutput [protected]

int GameClient::playerId [private]

int GameClient::xpos [private]

int GameClient::ypos [private]

int GameClient::gameSpaceSize [private]

std::list<PlayerPosition> GameClient::playerMap [private]

std::list<PlayerPosition>::iterator GameClient::pM [private]

Movement* GameClient::movement [private]

cMessage* GameClient::loginTimer [private]

cMessage* GameClient::moveTimer [private]

cMessage* GameClient::eventCreationTimer [private]

double GameClient::initialDelay [private]

double GameClient::eventCreationDelay [private]

double GameClient::moveDelay [private]

int GameClient::sentMessages [private]

int GameClient::receivedMessages [private]

int GameClient::sentEvents [private]

int GameClient::receivedEvents [private]

int GameClient::reachedWaypoints [private]


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