/Desktop/MGS-MultithreadedGameServer/Plugins/Games/ChatRoom.cc

Vai alla documentazione di questo file.

//
// File: ChatRoom.cc
// Created by: <Detro /> aka Ivan De Marino 
// <detro@mandolinux.org, demarino@studenti.unina.it, demarino@na.astro.it>
// Created on: Wed Oct 27 15:37:00 2004
//

#include "ChatRoom.h"

/** Costruttore di default della Classe ChatRoom */
ChatRoom::ChatRoom(void) {}

/** 
 * Costruttore overlodato della Classe ChatRoom.
 *
 * @param firstPlayer Primo giocatore della nuova ChatRoom */
ChatRoom::ChatRoom(Player *firstPlayer) {
   addPlayer(firstPlayer);
}

/** Distruttore della Classe ChatRoom. */
ChatRoom::~ChatRoom(void) {exit();}

/** 
 * Inizializzazione della ChatRoom. 
 * Metodo vuoto ereditato da <code>Game</code>. */
void ChatRoom::init(void) {}

/**
 * Flusso di Controllo di ChatRoom.
 * Questo metodo rappresenta il Flusso di Controllo principale
 * del @c Thread. <br>
 * Qui' e' concentrato il funzionamento della ChatRoom. */
void ChatRoom::run(void) {
   string message;
   string completeMessage;
   
   list<Player *>::iterator pli;
   char time_buffer[64];
   int last;
   time_t t;
   tm *tbp;
   string now;

   while (true) {
      if ( playerList.size() == 0 ) {
         cout << "<ChatRoom msg> ChatRoom Empty: Suspended." << endl;
         suspend();
         cout << "<ChatRoom msg> ChatRoom Resumed." << endl;
      }
      pli = playerList.begin();
         
      while ( pli != playerList.end() ) {
         /* Recupera eventuale messaggio digitato dall'utente:
          * attende 5 decimi di secondo */
         message = (*pli)->hear(500);
      
         /* Calcola l'ora e la data corrente. */
         t = std::time(NULL);
         tbp = std::localtime(&t);
         last = std::strftime(time_buffer, 64, "%Y-%m-%d %H:%M:%S", tbp);
         time_buffer[last] = '\0';
         now = time_buffer;
         
         /* Costruisce il Messaggio */ 
         completeMessage = "[" + now + "] ";
         completeMessage += (*pli)->getName();
         completeMessage += " >>> " + message + "\n";
            
         if ( !message.empty() ) {
            if ( !strcmp(message.data(), "\\quit") ) {
               delPlayer(*pli);
               break;
            }
            else {
               /* Invia il messaggio a tutti, tranne che
                * al Player "pli" */
               sayToAll(completeMessage, *pli);
            }
         }
         pli++;
      
         /* e' necessario ripulire la stringa del messaggio dell'utente */
         message.clear();
      }
      /* Attendiamo 2 decimi di second prima di ricominciare
       * a trasmettere messaggi. */
      sleep(200);
   }
   
}

/** 
 * Chiusura della ChatRoom.
 * Metodo ereditato da <code>Thread</code>,
 * richiamato (automaticamente dalla Librerie) 
 * alla fine del metodo <code>run()</code>. <br>
 * Gestisce la corretta chiusura della <code>ChatRoom</code>: 
 * viene richiamato al termine del metodo 
 * @c "run()" o del metodo @c "exit()". */
void ChatRoom::final(void) {
   if ( playerList.size() > 0 ) {
      list<Player *>::iterator pli;
      Player *temp;
      mutex.enterMutex();
      
      while ( pli != playerList.end() ) {
         /* Se il player e' presente:
          * 1) riceve un messaggio di arrivederci
          * 2) Viene riattivato il suo ConnectionHandler
          * 3) Viene eliminato dalla lista */
         (*pli)->say("<ChatRoom msg> ChatRoom Terminated. Now exit.\n");
         (*pli)->resumeConnHandler();
         temp = *pli;
         pli++;
         playerList.remove(temp);
      }
      
      mutex.leaveMutex();
   }
}


/**
 * Aggiungi un <code>Player</code> alla ChatRoom.
 * Un messaggio di Benvenuto viene inviato all'utente e
 * gli altri partecipanti alla ChatRoom vengono avvertiti
 * dell'arrivo del nuovo Player.
 *
 * @param newPlayer Nuovo giocatore. */
void ChatRoom::addPlayer (Player *newPlayer) {
   mutex.enterMutex();
   
   playerList.push_back(newPlayer);
   /* Messaggi di Benvenuto */
   /* ...per il nuovo utente... */
   newPlayer->say("\n<----------------------------------------->\n");
   newPlayer->say(">>>>>     Hello at MGS's ChatRoom     <<<<<\n");
   newPlayer->say("<----------------------------------------->\n\n");
   newPlayer->say("[Users On-Line: ");
   newPlayer->say((int)(playerList.size() -1));
   newPlayer->say("]\n");

   /* ...per i restanti... */
   sayToAll("<ChatRoom msg> " + newPlayer->getName() + " has joined at this ChatRoom\n",
      newPlayer);
   cout << "<ChatRoom msg> " << newPlayer->getName() << " has joined at this ChatRoom\n";

   /* Riattiva o Avvia il Thread se l'utente appena inserito e'
    * l'unico */
   if ( playerList.size() == 1 ) {
      if ( isRunning() )
         resume();
      else
         start();
   }

   mutex.leaveMutex();
}

/**
 * Rimuovi un <code>Player</code> dalla ChatRoom (overloaded).
 * Un messaggio di Arrivederci viene inviato all'utente e
 * gli altri partecipanti alla ChatRoom vengono avvertiti.
 *
 * @param toDelete Nome del Player da eliminare. 
 * @return @c true se il Player viene trovato e rimosso, 
 *    @c false altrimenti */
bool ChatRoom::delPlayer (const string &toDelete) {
   list<Player *>::iterator pli;
   mutex.enterMutex();

   pli = playerList.begin();
   while ( pli != playerList.end() ) {
      if ( (*pli)->getName() == toDelete) {
         /* Se il player é presente:
          * 1) riceve un messaggio di arrivederci
          * 2) Viene riattivato il suo ConnectionHandler
          * 3) Viene eliminato dalla lista */
         (*pli)->say("<ChatRoom msg> GoodBye. ;-)\n");
         sayToAll("<ChatRoom msg> " + (*pli)->getName() + " has leaved this ChatRoom\n", *pli);
         (*pli)->resumeConnHandler();
         playerList.remove(*pli);
         mutex.leaveMutex();
         return true;
      }
      pli++;
   }
   
   mutex.leaveMutex();
   return false;
}

/**
 * Rimuovi un <code>Player</code> dalla ChatRoom (overloaded).
 * Un messaggio di Arrivederci viene inviato all'utente e
 * gli altri partecipanti alla ChatRoom vengono avvertiti.
 *
 * @param toDelete Puntatore al Player da eliminare. */
void ChatRoom::delPlayer (Player *toDelete) {
   mutex.enterMutex();

   toDelete->say("<ChatRoom msg> GoodBye. ;-)\n");
   sayToAll("<ChatRoom msg> " + toDelete->getName() + " has leaved this ChatRoom\n", toDelete);
   toDelete->resumeConnHandler();
   playerList.remove(toDelete);
   
   mutex.leaveMutex();
}

/** 
 * Ritorna il numero di <code>Player</code> presenti nella ChatRoom. 
 * @return Ritorna il numero di Player presenti nella ChatRoom */
int ChatRoom::getNumPlayers (void) const {
   return playerList.size();
}

/** Stampa la lista dei <code>Player</code> presenti nella ChatRoom. */
void ChatRoom::printPlayersList(iostream *streamWherePrint) {
   list<Player *>::iterator pli;
   mutex.enterMutex();

   pli = playerList.begin();
   while ( pli != playerList.end() ) {
      *streamWherePrint << "\t* " << (*pli)->getName() << endl;
      pli++;
   }
   
   mutex.leaveMutex();
}

string ChatRoom::getName(void) const {return "ChatRoom - Simple Chat for MGS";}

/**
 * Invia un messaggio a tutti i <code>Player</code> della ChatRoom.
 * Questo metodo e' utilizzato per "girare" i messaggi digitati
 * da un <code>Player</code> a tutti gli altri 
 * <code>Player</code> presenti nella ChatRoom.
 * 
 * @param message Stringa del messaggio da Inviare
 * @param notSay Puntato del <code>Player</code> a cui NON INVIARE 
 *    il messaggio (probabilmente e' colui che l'ha scritto). */
void ChatRoom::sayToAll(const string &message, Player *notSay) {
   list<Player *>::iterator pli;

   pli = playerList.begin();
   while ( pli != playerList.end() ) {
      if ( notSay == NULL || (notSay != NULL && *pli != notSay) )
         (*pli)->say(message);
      pli++;
   }
}

/** 
 * Ritorna un nuovo oggetto "ChatRoom".
 * E' necessario per poter utilizzare la Classe come Plug-In 
 * e quindi essere istanziata a Run-Time */
extern "C"
ChatRoom *buildObject(void) { return new ChatRoom; }

---