/Desktop/MGS-MultithreadedGameServer/ConnectionHandler.cc

Vai alla documentazione di questo file.

//
// File: ConnectionHandler.cc
// Created by: <Detro /> aka Ivan De Marino 
// <detro@mandolinux.org, demarino@studenti.unina.it, demarino@na.astro.it>
// Created on: Sun Oct 24 13:52:38 2004
//

#include "ConnectionHandler.h"

Mutex ConnectionHandler::mutex;

/**
 * Costruttore della Classe ConnectionHandler.
 *
 * @param server Server (<code>TCPSocket</code) da cui 
 *    prende la Connessione da Gestire
 * @param activeG Vettore dei Giochi in esecuzione su MGS */
ConnectionHandler::ConnectionHandler(TCPSocket &server, 
   vector <Game *> &activeG,
   vector < pair< string, TFactory<Game*> *> *> &availableG) : 
TCPSession(server), activeGames(activeG), availableGames(availableG) {
   cout << "<ConnHand msg> Creating New ConnectionHandler." << endl;
   cout << "<ConnHand msg> " << getIPV4Local() << " is now Handled." << endl;
}

/** Distruttore ConnectionHandler. */
ConnectionHandler::~ConnectionHandler(void) { exit(); }

/**
 * Attivazione del ConnectionHandler.
 * Questo metodo, overlodato rispetto alla Classe <code>Thread</code>,
 * e' il corpo principale del flusso di controllo di questa Classe.
 * Qui' avviene tutta l'interazione con l'utente (<code>Player</code>). */
void ConnectionHandler::run(void) {
   char *buffer;
   buffer = new char[NAME_MAX_LENGTH];
   char selection;
   char gameSelection;
   
   InetAddress address = getIPV4Local();
   /* "tcp()" e' ereditato dalla classe TCPStream;
    * e' importante perche' attraverso il puntatore che ritorna
    * avviene tutta la comunicazione con l'utente/giocatore */
   *tcp() << ">>> MGS - Multithreaded Game Server <<<" << endl;
   *tcp() << "<ConnHand msg> Welcome to MGS on " 
      << address.getHostname() << " from socket " 
      << so << endl << endl;
   
   *tcp() << "<ConnHand msg> Please, Insert your nick (only one word): ";
   TCPStream::sync();

   if( isPending(Socket::pendingInput, 30000) ) {
      *tcp() >> buffer;
      /* Creazione giocatore */
      player = new Player (buffer , *this, this);
   
      do {
         /* Stampa del Menu per l'utente */
         *tcp() << "\n\n\n\n\n";
         *tcp() << "--- --- --- --- ---" << endl;
         *tcp() << "(n)\t- Create New Game" << endl;
         *tcp() << "(j)\t- Join Active Game" << endl;
         *tcp() << "(q)\t- Quit from MGS" << endl;
         *tcp() << "--- --- --- --- ---" << endl;
         *tcp() << "--- "<< player->getName() << 
            ", please make your selection (case sensitive): ";
         TCPStream::sync();
         *tcp() >> selection;
         /* Elimina dallo stream il carattere "\n" */
         tcp()->ignore(256,'\n');
      
         switch (selection) {
            case 'n':
               /* Menu Creazione Nuovo Game */
               *tcp() << "\n\n\n\n\n";
               printAvailableGameList();
               *tcp() << "--- "<< player->getName() << 
                  ", please make your selection: ";
               TCPStream::sync();
               *tcp() >> gameSelection;
               tcp()->ignore(256,'\n');
               if ( joinPlayerToAvailableGame(player, gameSelection) )
                  player->suspendConnHandler();
               else
                  *tcp() << "--- ERROR: Game not found!" << endl;
               break;
            case 'j':
               /* Menu Join Game attivo */
               *tcp() << "\n\n\n\n\n";
               printActiveGameList();
               *tcp() << "--- "<< player->getName() << 
                  ", please make your selection: ";
               TCPStream::sync();
               *tcp() >> gameSelection;
               tcp()->ignore(256,'\n');
               if ( joinPlayerToActiveGame(player, gameSelection) )
                  player->suspendConnHandler();
               else
                  *tcp() << "--- ERROR: Game not found!" << endl;
               break;
            case 'q':
               /* Quit */
               break;
            default:
               /* Errore di selezione */
               *tcp() << "\n\n\n\n\n";
               *tcp() << "Input error!" << endl;
               break;
         }
      }while ( selection != 'q' );
   }
   else {
      *tcp() << "\n<ConnHand msg> 30 Seconds without type your name." << endl;
      *tcp() << "<ConnHand msg> Connection TimeOut!" << endl;
   }
   *tcp() << "<ConnHand msg> Bye bye, from MGS" << endl;
}

/**
 * Chiusura del ConnectionHandler.
 * Questo metodo viene richiamato automaticamente
 * al termine del metodo <code>run()</code>.
 * Permette di gestire al meglio la chiusura del <code>Thread</code>. 
 * Ha il compito di deallocare il Player creato. */
void ConnectionHandler::final(void) {
   delete player;
   delete this;
}

/** Stampa la lista dei Game attivi verso lo stream dell'utente connesso */
void ConnectionHandler::printActiveGameList(void) {
   int activeGamesNumber;
   mutex.enterMutex();
   
   activeGamesNumber = activeGames.size();
   *tcp() << "\n------------------------" << endl;
   *tcp() << "--> Active Game List <--" << endl;
   *tcp() << "------------------------\n" << endl;
   *tcp() << "Active Games: " << activeGamesNumber << endl;
   *tcp() << "(<num>)\t- [<game name>]" << endl;
   
   for ( int i = 0; i < activeGamesNumber; i++ ) {
      *tcp() << "( " << (i+1) 
         << " )\t- [" << activeGames[i]->getName() << "]" << endl;
      activeGames[i]->printPlayersList(tcp());
   }

   mutex.leaveMutex();
}

/**
 * Inserisci un @c Player in un @c Game attivo.
 * Viene controllato se il @c Game scelto esiste (dato che e'
 * l'utente a digitare i comandi, quindi gli errori sono possibili).
 *
 * @param toJoin Puntatore al Player da Aggiungere
 * @param gameNum Carattere contenente il numero relativo al Game selezionato
 * @return @c true se il Player viene aggiunto al Game, @c false altrimenti */
bool ConnectionHandler::joinPlayerToActiveGame(Player *toJoin, const char gameNum) {
   int game = atoi(&gameNum);
   int activeGamesNumber;
   mutex.enterMutex();
   
   activeGamesNumber = activeGames.size();
   if ( game > 0 && game <= activeGamesNumber ) {
      activeGames[game-1]->addPlayer(toJoin);
   
      mutex.leaveMutex();
      return true;
   }
   
   mutex.leaveMutex();
   return false;
}

/** 
 * Stampa la lista dei Game disponibili su MGS, verso lo stream dell'utente.
 * Sfrutta le peculiarita' della variabile privata @c availableGames. */
void ConnectionHandler::printAvailableGameList(void) {
   *tcp() << "\n---------------------------" << endl;
   *tcp() << "--> Available Game List <--" << endl;
   *tcp() << "---------------------------" << endl;
   *tcp() << "(<num>)\t- [<game name>]" << endl;
   for ( int i = 0; i < availableGames.size(); i++ ) {
         *tcp() << "( " << (i+1) << " )\t- [" <<
            availableGames[i]->first << "]" << endl;
   }
}

/**
 * Inserisci un @c Player in un nuovo @c Game.
 * Viene controllato se il @c Game scelto esiste (dato che e'
 * l'utente a digitare i comandi, quindi gli errori sono possibili). <br>
 * I Game vengono istanziati usando Classi Plug-In (Vedere @c TFactory)
 * le cui Factory sono conservate in @c availableGames.
 *
 * @param toJoin Puntatore al Player da Aggiungere
 * @param gameNum Carattere contenente il numero relativo al Game selezionato 
 * @return @c true se il Player viene aggiunto al Game, @c false altrimenti */
bool ConnectionHandler::joinPlayerToAvailableGame(Player *toJoin, const char gameNum) {
   int game = atoi(&gameNum);
   int availableGamesNumber;
   mutex.enterMutex();
   
   availableGamesNumber = availableGames.size();
   if ( game > 0 && game <= availableGamesNumber ) {
      /* Crea il nuovo Game usando la TFactory */
      Game *newGame = availableGames[game-1]->second->build();
   
      cout << "<ConnHand msg> Created new Game: " << 
         newGame->getName() << endl;
   
      /* Unisce il nuovo Player al Game */
      newGame->addPlayer(toJoin);
      /* Inserisce il nuovo Game tra quelli Attivi */
      activeGames.push_back(newGame);
      mutex.leaveMutex();
      return true;
   }
   
   mutex.leaveMutex();
   return false;
}

---