API tools faq
paste
Advertisement
Guest User

Server

a guest
Oct 19th, 2016
95
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 40.29 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/socket.h>
  5. #include <sys/types.h>
  6. #include <netinet/in.h>
  7. #include <netdb.h>
  8. #include <errno.h>
  9. #include <unistd.h>
  10. #include <sys/un.h>
  11. #include <fcntl.h>
  12. #include <time.h>
  13. #include <pthread.h>
  14. #include <limits.h>
  15.  
  16.  
  17. #define SOCKET_NAME "/tmp/my_first_socket"
  18. #define DIM_MATRICE 10
  19. /*===============================================================================================================================================
  20. Indizi
  21. ===============================================================================================================================================*/
  22. struct indizi{
  23.     int CoordX;
  24.     int CoordY;
  25. };
  26. struct indizi aiuto[10];
  27. /*===============================================================================================================================================
  28. LISTA GIOCATORI ONLINE
  29. ===============================================================================================================================================*/
  30. struct ListaGiocatori{                             
  31.     char NomeGiocatore[25];
  32.     int nIndiziTrovati;
  33.     int FlagUltimoInd;  //Assume il valore di 1 solo se è stato trovato l'ultimo indizio
  34.     struct ListaGiocatori *next;
  35. };
  36. struct ListaGiocatori *players=NULL;
  37.  
  38. int indizitrovati[9];   //Array degli indizi trovati
  39. pthread_mutex_t semaforo1=PTHREAD_MUTEX_INITIALIZER ;
  40. pthread_mutex_t semaforo2=PTHREAD_MUTEX_INITIALIZER ;
  41. time_t Tinizio,Tcorrente;   //Variabili temporali
  42. int sincronizzazioneclient1=0; //Sincronizzazione del client
  43. int tesoro=1;       //assume il valore di 1 se è stato scovato il tesoro
  44. char Mappa[DIM_MATRICE][DIM_MATRICE];//Mappa di gioco
  45. /*===============================================================================================================================================
  46. Prototipi di funzioni
  47. ===============================================================================================================================================*/
  48. struct ListaGiocatori *EliminaGiocatore(struct ListaGiocatori *players, char username[]);
  49. void CreaGiocatore(char username[]);
  50. int UtentiCollegati(struct ListaGiocatori *players);
  51. void IndizioTrovato(struct ListaGiocatori *players,char *username);
  52. void StampaGiocatori(int Socket, struct ListaGiocatori *players);
  53. void StampaMappa(char Mappa [DIM_MATRICE][DIM_MATRICE]);
  54. void * ThreadLogin(void * arg);
  55. void creaMappa(char Mappa[DIM_MATRICE][DIM_MATRICE], struct indizi* aiuto);
  56. void Partenza(int Socket,int *Riga, int *Colonna);
  57. void PosizioneAttuale(char Mappa[DIM_MATRICE][DIM_MATRICE], int Riga, int Colonna);
  58. void FileTesoro(char username[]);
  59. int updateMappa(int Socket,char Mappa[DIM_MATRICE][DIM_MATRICE],int Riga,int Colonna,int oldRiga,int oldColonna,struct indizi* aiuto,char *username);
  60. void MappaClient(int Socket, char Mappa[DIM_MATRICE][DIM_MATRICE], int flag, int Riga,int Colonna,char *username);
  61. void Gioco(int Socket,char username[], char Mappa[DIM_MATRICE][DIM_MATRICE]);
  62. void MenuGioco(int Socket, char username[]);
  63. int ControlloDisponibilita(char username[]);
  64. void SalvaLogin ( char username[] );
  65. void LiberaMappa(int *Riga, int *Colonna);
  66. void login(int Socket);
  67. /*===============================================================================================================================================
  68. Autori: Nunzio Salvato & Salvatore Barbuto
  69. Programma: Caccia al Tesoro
  70. ===============================================================================================================================================*/
  71. int main(int argc, char **argv){
  72.     srand((unsigned)time(NULL));
  73.     if(argc<2){
  74.         perror("Errore parametri\n");
  75.         exit(1);
  76.     }
  77.     int *ThreadSocket, ascoltosocket, connessionesocket, porta=atoi(argv[1]);
  78.     struct sockaddr_in indirizzo, clientAddr;
  79.     pthread_t tid;
  80.     socklen_t clientLen;
  81.     indirizzo.sin_family=AF_INET;
  82.     indirizzo.sin_addr.s_addr=INADDR_ANY;
  83.  
  84.     if((ascoltosocket=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))<0){  //crea un socket e lo assegnamo a ascoltosocket
  85.         perror("socket");
  86.         exit(1);
  87.     }
  88.     unlink(SOCKET_NAME);
  89.     indirizzo.sin_port=htons(porta); // assegno a my address il numero della porta su cui comunnicano client e server
  90.     //Binding
  91.     if(bind(ascoltosocket, (struct sockaddr *)&indirizzo, sizeof(indirizzo))<0){  // bind serve per dare al socket un indirizzo (&my addr)
  92.         perror("bind");
  93.         exit(1);
  94.     }
  95.     if(listen(ascoltosocket, 1)<0) { // setto il socket in modalita' ascolto verso il server (ascolta il server)
  96.         perror("ListaGiocatorien");
  97.         exit(1);
  98.     }
  99.     //Creazione della mappa
  100.     time(&Tinizio);
  101.     Tcorrente=Tinizio;
  102.     creaMappa(Mappa,aiuto);
  103.     while(1){
  104.         clientLen = sizeof(clientAddr);
  105.         if((connessionesocket=accept(ascoltosocket, (struct sockaddr *)&clientAddr, &clientLen))<0){ // con la funzione accept il server accetta i client, fa si che i client si colleghino a lui
  106.             perror("accept");
  107.             exit(1);
  108.         }
  109.         ThreadSocket=(int*)malloc(sizeof(int)); //il serve crea un thread per il client connesso e per gestirlo
  110.         fprintf(stderr, " new connection \n");//
  111.         *ThreadSocket = connessionesocket;//
  112.         printf("server: new connection from %d \n",connessionesocket);//
  113.         pthread_create(&tid, NULL, ThreadLogin, (void *) ThreadSocket); // fine creazione, threadlogin funzione che fa i login dei client, il terzo parametro di queta funzione sarà l'input della funzione managethread
  114.     }
  115.     close(connessionesocket);// chiusura dei 2 socket
  116.     close(ascoltosocket);
  117.     return 0;
  118. }
  119. /*===============================================================================================================================================
  120. Rimuovi Giocatore dalla Lista
  121. ===============================================================================================================================================*/
  122. struct ListaGiocatori *EliminaGiocatore(struct ListaGiocatori *players, char username[]){
  123.     if(players!=NULL){
  124.         if(strcmp(players->NomeGiocatore,username)==0){
  125.             struct ListaGiocatori *PabloEmilioEscobarGaviria=(struct ListaGiocatori *)malloc(sizeof(struct ListaGiocatori));
  126.             PabloEmilioEscobarGaviria=players;
  127.             players=players->next;
  128.             free(PabloEmilioEscobarGaviria); // abbiamo ucciso escobar
  129.         }
  130.         else{
  131.             players->next=EliminaGiocatore(players->next, username);
  132.         }
  133.  
  134.     }
  135.     return players;
  136. }
  137. /*===============================================================================================================================================
  138. Crea Lista giocatori
  139. ===============================================================================================================================================*/
  140. void CreaGiocatore(char username[]){
  141.     if(players==NULL){
  142.         players=(struct ListaGiocatori *)malloc(sizeof(struct ListaGiocatori));
  143.         strcpy(players->NomeGiocatore, username);
  144.         players->nIndiziTrovati=0;
  145.         players->next=NULL;
  146.     }
  147.     else{  //aggiungo in testa il giocatore
  148.         struct ListaGiocatori *NewPlayer=(struct ListaGiocatori *)malloc(sizeof(struct ListaGiocatori));
  149.         strcpy(NewPlayer->NomeGiocatore, username);
  150.         players->nIndiziTrovati=0;
  151.         players->FlagUltimoInd=0;
  152.         NewPlayer->next=players;
  153.         players=NewPlayer;
  154.     }
  155. }
  156. /*===============================================================================================================================================
  157. Restituisci Utenti Online
  158. ===============================================================================================================================================*/
  159. int UtentiCollegati(struct ListaGiocatori *players){
  160.     if(players != NULL){
  161.         return 1+UtentiCollegati(players->next);
  162.     }
  163.     else{
  164.         return 0;
  165.     }
  166. }
  167.  
  168. /*===============================================================================================================================================
  169. Aggiorna Indizi
  170. ===============================================================================================================================================*/
  171. void IndizioTrovato(struct ListaGiocatori *players,char *username){
  172.     if(strcmp(players->NomeGiocatore, username) == 0){
  173.         players->nIndiziTrovati=players->nIndiziTrovati+1;
  174.     }
  175.     else{
  176.         IndizioTrovato(players->next,username);
  177.     }
  178. }
  179.  
  180. /*===============================================================================================================================================
  181. Stampa Lista Giocatori
  182. ===============================================================================================================================================*/
  183. void StampaGiocatori(int Socket, struct ListaGiocatori *players){
  184.     char Messaggio[300]; // messaggio che il server manda al client
  185.     char NumIndizi[3];
  186.     char NomePlayer[20];
  187.     int i;
  188.     bzero(Messaggio,300); //pulisco il Messaggio
  189.     if(players==NULL){
  190.         write(Socket, "0 UTENTI ONLINE",  15);
  191.     }
  192.     else{
  193.         struct ListaGiocatori *tmp=players;
  194.         strcat(Messaggio,"USERNAME   NUMERO INDIZI\n");
  195.         for(;tmp!=NULL;tmp=tmp->next){
  196.             for (i=0; tmp->NomeGiocatore[i] != '\n'; i++){
  197.                NomePlayer[i]=tmp->NomeGiocatore[i];
  198.             }
  199.             NomePlayer[i]='\0';
  200.             strcat(Messaggio, NomePlayer);
  201.             for(i=0;i < (20-strlen(NomePlayer));i++) strcat(Messaggio," ");
  202.             sprintf(NumIndizi,"%d",tmp->nIndiziTrovati);
  203.             strcat(Messaggio,NumIndizi);
  204.             strcat(Messaggio,"\n");
  205.         }
  206.         write(Socket,Messaggio,strlen(Messaggio));
  207.     }
  208. }
  209. /*===============================================================================================================================================
  210. Stampo Mappa di gioco lato server
  211. ===============================================================================================================================================*/
  212. void StampaMappa(char Mappa [DIM_MATRICE][DIM_MATRICE]){
  213.     int i, j;
  214.     char indizio[2];
  215.     printf("\nMAPPA DI GIOCO:\n");
  216.     for(i=0;i<DIM_MATRICE;i++){
  217.         for(j=0;j<DIM_MATRICE;j++){
  218.             if(Mappa [i][j]>='1' && Mappa [i][j]<='9'){
  219.                 indizio[0]=Mappa[i][j];
  220.                 indizio[1]='\0';
  221.                 printf("\t%d" , atoi(indizio));
  222.             }
  223.             else{
  224.                 printf("\t%c", Mappa[i][j]);
  225.             }
  226.         }
  227.         printf ("\n");
  228.     }
  229. }
  230.  
  231. /*===============================================================================================================================================
  232. Gestione Thread iniziale
  233. ===============================================================================================================================================*/
  234. void * ThreadLogin(void * arg){
  235.   int socket=*(int*)arg;
  236.   login(socket);
  237. }
  238.  
  239. /*===============================================================================================================================================
  240. Creazione Mappa
  241. ===============================================================================================================================================*/
  242. void creaMappa(char Mappa[DIM_MATRICE][DIM_MATRICE], struct indizi* aiuto){
  243.     char NumIndizio='1';
  244.     int Coordinate[2], i=0, j=0,num_indizi=8, num_ostacoli=rand()%20+1;
  245.     //Azzero array indizi e matrice
  246.     for(i=0;i<9;i++) indizitrovati[i]=0;
  247.     for(i=0;i<DIM_MATRICE;i++){
  248.         for(j=0;j<DIM_MATRICE;j++){
  249.             Mappa[i][j]='0';
  250.         }
  251.     }
  252.     i=0;
  253.     //Inizio blocco indizi
  254.     aiuto[0].CoordX=rand()%10;
  255.     aiuto[0].CoordY=rand()%10;
  256.     Mappa[aiuto[0].CoordX][aiuto[0].CoordY]=NumIndizio;
  257.     while(atoi(&NumIndizio)!=num_indizi+1){
  258.         Coordinate[0]=rand()%10;
  259.         Coordinate[1]=rand()%10;
  260.         if(Mappa[Coordinate[0]][Coordinate[1]]=='0'){
  261.             Mappa[Coordinate[0]][Coordinate[1]]=NumIndizio+1 ;
  262.             aiuto[atoi(&NumIndizio)].CoordX=Coordinate[0];
  263.             aiuto[atoi(&NumIndizio)].CoordY=Coordinate[1];
  264.             NumIndizio++;
  265.         }
  266.     }
  267.     //Fine blocco indizi
  268.     i=0;
  269.     //Inizio blocco tesoro
  270.     do{
  271.         Coordinate[0]=rand()%10;
  272.         Coordinate[1]=rand()%10;
  273.         if(Mappa[Coordinate[0]][Coordinate[1]]=='0'){
  274.             Mappa[Coordinate[0]][Coordinate[1]]='$';
  275.             i++;
  276.         }
  277.     }while(i!=1);
  278.     //Fine blocco tesoro ed assegno coordinate all'ultimo suggerimento
  279.     aiuto[9].CoordX=Coordinate[0],
  280.     aiuto[9].CoordY=Coordinate[1];
  281.     i=0;
  282.     //Inizio blocco ostacoli
  283.     while(i!=num_ostacoli){
  284.         Coordinate[0]=rand()%10;
  285.         Coordinate[1]=rand()%10;
  286.         if(Mappa[Coordinate[0]][Coordinate[1]]=='0'){
  287.             Mappa[Coordinate[0]][Coordinate[1]]='x';
  288.             i++;
  289.         }
  290.     }
  291.     //Fine blocco ostacoli
  292.     StampaMappa(Mappa);
  293. }
  294.  
  295. /*===============================================================================================================================================
  296. Posiziono Giocatore
  297. ===============================================================================================================================================*/
  298. void Partenza(int Socket,int *Riga, int *Colonna){
  299.     char Messaggio[256], scelta[128];
  300.     bzero(Messaggio, 256);
  301.     pthread_mutex_lock(&semaforo2); // semaforo utilizzato per evitare che 2 client possano iniziare nello stesso punto
  302.     do{
  303.         *Riga=rand()%10;
  304.         *Colonna=rand()%10;
  305.     }
  306.     while(Mappa[*Riga][*Colonna]!='0' && Mappa[*Riga][*Colonna]!='c');
  307.     strcpy(Messaggio, "GIOCATORE PRONTO A GIOCARE...");
  308.     write(Socket, Messaggio, strlen(Messaggio));
  309.     read(Socket,scelta,127);
  310.     pthread_mutex_unlock(&semaforo2); //sblocco semaforo
  311.     bzero(Messaggio, 256);
  312. }
  313.  
  314. /*===============================================================================================================================================
  315. Aggiornamento posizione del giocatore
  316. ===============================================================================================================================================*/
  317. void PosizioneAttuale(char Mappa[DIM_MATRICE][DIM_MATRICE], int Riga, int Colonna){
  318.     Mappa[Riga][Colonna]='?';
  319. }
  320.  
  321. /*===============================================================================================================================================
  322. Salvataggio utente - orario di chi ha trovato il tesoro
  323. ===============================================================================================================================================*/
  324. void FileTesoro(char username[]){
  325.       int fd;
  326.       char messaggio[256], orario[256];
  327.       time_t ora;
  328.       time(&ora);
  329.       bzero(messaggio, 256);
  330.       bzero(orario, 256);
  331.       strcpy(messaggio, "L'UTENTE : " ) ;
  332.       sprintf(orario, "%s", asctime(localtime(&ora)));
  333.       strcat(messaggio, username);
  334.       strcat(messaggio, " HA TROVATO IL TESORO IL ");
  335.       strcat(messaggio, orario);
  336.       strcat(messaggio, "\n");
  337.       pthread_mutex_lock(&semaforo1); // per evitare che più client possano aprire il file di testo in contemporanea
  338.       fd=open("tesoro.txt", O_WRONLY|O_CREAT);
  339.       lseek(fd, 0, SEEK_END);
  340.       write(fd, messaggio, strlen(messaggio));
  341.       close(fd);
  342.       pthread_mutex_unlock(&semaforo1);
  343. }
  344.  
  345. /*===============================================================================================================================================
  346. Aggiorno valori all'interno della mappa di gioco
  347. ===============================================================================================================================================*/
  348. int updateMappa(int Socket,char Mappa[DIM_MATRICE][DIM_MATRICE],int Riga,int Colonna,int oldRiga,int oldColonna,struct indizi* aiuto,char *username){
  349.     struct ListaGiocatori *Gioc1;
  350.     int lastIndizio, flag=0;
  351.     char app[5], buf[2];
  352.     for(Gioc1=players;Gioc1;Gioc1=Gioc1->next){
  353.         if(strcmp(Gioc1->NomeGiocatore,username)==0) lastIndizio=Gioc1->FlagUltimoInd;
  354.     }
  355.     //Blocco ritrovamento tesoro
  356.     if(Mappa[Riga][Colonna]=='$' || Mappa[Riga][Colonna]=='X'){
  357.         Mappa[Riga][Colonna]='X';
  358.         //Tesoro scovato
  359.         if(lastIndizio==1){
  360.             tesoro=0;
  361.             FileTesoro(username);
  362.         }
  363.         if(!(Mappa[oldRiga][oldColonna]>='1' && Mappa[oldRiga][oldColonna]<='9')){
  364.             Mappa[oldRiga][oldColonna]='c';
  365.         }  
  366.         flag=20;
  367.     }
  368.     //Blocco ritrovamento indizio
  369.     else if(Mappa[Riga][Colonna]>='1' && Mappa[Riga][Colonna]<='9'){
  370.              if(!(Mappa[oldRiga][oldColonna]>='1' && Mappa[oldRiga][oldColonna]<='9') ){
  371.                  if (Mappa[oldRiga][oldColonna]!='X'){
  372.                        Mappa[oldRiga][oldColonna]='c';
  373.                  }
  374.              }
  375.              buf[0]=Mappa[Riga][Colonna];
  376.              buf[1]='\0';
  377.              flag=9+atoi(buf);
  378.              indizitrovati[atoi(buf)-1]=1;
  379.              if(Mappa[Riga][Colonna]=='9'){
  380.                 for(Gioc1=players;Gioc1;Gioc1=Gioc1->next){
  381.                     if(strcmp(Gioc1->NomeGiocatore,username)==0){
  382.                         Gioc1->FlagUltimoInd=1;
  383.                      }
  384.                  }
  385.              }
  386.     }
  387.  
  388.     //Blocco ritrovamento ostacolo
  389.     else if(Mappa[Riga][Colonna]=='x'){
  390.         if(oldRiga == Riga && oldColonna != Colonna)    Mappa[Riga][Colonna]='|';
  391.         else Mappa[Riga][Colonna]='_';
  392.         flag=1;
  393.     }
  394.     //Movimento non consentito su ostacolo o utente
  395.     else if(Mappa[Riga][Colonna]=='|' || Mappa[Riga][Colonna]=='_' || Mappa[Riga][Colonna]=='?' || Mappa[Riga][Colonna]=='O'){
  396.         flag=1;
  397.     }
  398.     //Movimento su celle non importanti
  399.     else if (Mappa[Riga][Colonna]=='0' || Mappa[Riga][Colonna]=='c'){
  400.         if(!(Mappa[oldRiga][oldColonna]>='1' && Mappa[oldRiga][oldColonna]<='9')  ){
  401.             if (Mappa[oldRiga][oldColonna]!='X'){
  402.                 Mappa[oldRiga][oldColonna]='c';
  403.             }
  404.         }
  405.         flag=0;
  406.     }
  407.    
  408.     return flag;
  409. }
  410.  
  411. /*===============================================================================================================================================
  412. Stampa della mappa sul client
  413. ===============================================================================================================================================*/
  414. void MappaClient(int Socket, char Mappa[DIM_MATRICE][DIM_MATRICE], int flag, int Riga,int Colonna,char *username){
  415.     int lastIndizio,i, j;
  416.     char buf[2],ColRiga[5],messaggio[1000],app[5];
  417.     bzero(messaggio,1000);
  418.     struct ListaGiocatori* Gioc1;
  419.     //Cerchiamo se l'username è presente all'interno della lista dei giocatori online e ci salviamo l'ultimo indizio
  420.     for(Gioc1=players;Gioc1;Gioc1=Gioc1->next){
  421.         if(strcmp(Gioc1->NomeGiocatore,username)==0){
  422.             lastIndizio=Gioc1->FlagUltimoInd;
  423.         }
  424.     }
  425.     sprintf(app, "%f", difftime(time(&Tcorrente), Tinizio));
  426.     strcat(messaggio, "\t\t\t TEMPO: ");
  427.     strcat(messaggio, app);
  428.     strcat(messaggio, "s \n");
  429.     if(flag==0 || flag==20){
  430.         strcat(messaggio, " MOVIMENTO EFFETTUATO ");
  431.         strcat(messaggio, "\n\n");
  432.     }
  433.     else if(flag==-1){
  434.         strcat(messaggio, "\t\t\t INIZIO GIOCO!");
  435.         strcat(messaggio, ColRiga);
  436.         strcat(messaggio, " \n\n");
  437.         strcat(messaggio, "\t IL PRIMO INDIZIO SI TROVA NELLA COLONNA :  ");
  438.         sprintf(app, "%d", aiuto[0].CoordY + 1);
  439.         strcat(messaggio, app);
  440.         strcat(messaggio, ",");
  441.         strcat(messaggio, " E RIGA :  ");
  442.         sprintf(app, "%d", aiuto[0].CoordX + 1);
  443.         strcat(messaggio, app);
  444.         strcat(messaggio, "     \n");
  445.     }
  446.     else if(flag==3){
  447.         strcat(messaggio, " MOVIMENTO FUORI CAMPO DI GIOCO!");
  448.         strcat(messaggio, ColRiga);
  449.         strcat(messaggio, " \n\n");
  450.     }
  451.     else if (flag==1){
  452.         strcat( messaggio , " MOVIMENTO NON CONCESSO! ");
  453.         strcat(messaggio, ColRiga);
  454.         strcat(messaggio, " \n\n");
  455.     }
  456.     else{
  457.         if(flag!=20){
  458.             if(flag==18) strcat(messaggio, "\tULTIMO INDIZIO SCOVATO, IL TESORO SI TROVA NELLA COLONNA: ");
  459.             else  strcat(messaggio, "\tINDIZIO SCOVATO, IL PROSSIMO INDIZIO SI TROVA NELLA COLONNA: ");
  460.             sprintf(ColRiga, "%d", aiuto[(flag-9)].CoordY + 1);
  461.             strcat(messaggio, ColRiga);
  462.             strcat(messaggio, ",");
  463.             strcat(messaggio, " E RIGA : ");
  464.             sprintf(ColRiga, "%d", aiuto[(flag-9)].CoordX + 1);
  465.             strcat(messaggio, ColRiga);
  466.             strcat(messaggio, "   \n\n");
  467.         }
  468.     }
  469.  
  470.     for(i=0;i<DIM_MATRICE;i++){
  471.         for(j=0;j<DIM_MATRICE;j++){
  472.             //Trovato il tesoro
  473.             if(Mappa[i][j]=='X' ){
  474.                 if(lastIndizio==1) strcat(messaggio, "\a\033[36mX\t\033[0m");
  475.                 else{
  476.                     if(Riga==i && Colonna==j) strcat(messaggio, "\033[31m?\033[0m\t");
  477.                     else  strcat(messaggio, ".\t");
  478.                 }
  479.             }
  480.             //Trovato ostacolo
  481.             else
  482.             {    if(Mappa[i][j]=='|'){
  483.                         strcat ( messaggio , "|\t" ) ;
  484.                  }
  485.                  else{
  486.                         if(Mappa[i][j]=='_'){
  487.                             strcat ( messaggio , "_\t" ) ;
  488.                         }
  489.                         //Trovate celle inesplorate
  490.                         else{
  491.                             if( Mappa[i][j]=='x' || Mappa[i][j]=='X' || Mappa[i][j]=='0'){
  492.                                 strcat(messaggio, "o\t");
  493.                             }  
  494.                             //Trovato indizio
  495.                             else{
  496.                                 if(Mappa[i][j]>='1' && Mappa[i][j]<='9') {
  497.                                     buf[0]=Mappa[i][j];
  498.                                     buf[1]='\0';
  499.                                     if(indizitrovati[atoi(buf)-1]==0) strcat(messaggio, "o\t");
  500.                                     else {
  501.                                         if(Riga==i && Colonna==j){
  502.                                         strcat(messaggio,"\033[31m?\033[0m\t");
  503.                                         }
  504.                                         else{
  505.                                             strcat(messaggio, buf);
  506.                                             strcat(messaggio, "\t");
  507.                                         }
  508.                                     }
  509.                                 }          
  510.                                 //Celle già visitate
  511.                                 else{
  512.                                         if(Mappa[i][j]=='c'){
  513.                                             strcat(messaggio, ".\t");
  514.                                         }
  515.                                         //Posizione utente attuale
  516.                                         else{
  517.                                             if(Mappa[i][j]=='?'){
  518.                                                 strcat(messaggio, "\033[31m?\033[0m\t");
  519.                                             }
  520.                                         }
  521.                                 }
  522.                             }
  523.                         }
  524.                 }
  525.             }
  526.            
  527.         }
  528.         strcat(messaggio, "\n");
  529.     }
  530.     strcat(messaggio, "\n");
  531.     if(tesoro!=0){
  532.         strcat(messaggio, "(4/8/2/6) PER MUOVERTI, (ONLINE) PER STAMPARE GLI UTENTI ONLINE, (EXIT) PER USCIRE ");
  533.     }
  534.     else{
  535.         strcat(messaggio, "(: TROVATO  IL TESORO!!! (INVIO) GENERA UNA NUOVA MAPPA, (EXIT) DISCONNETTI! ;)");
  536.         tesoro=0;
  537.     }
  538.     write(Socket, messaggio, strlen(messaggio));
  539.     bzero(messaggio, 1000);
  540. }
  541.  
  542. /*===============================================================================================================================================
  543. Funzione del Gioco
  544. ===============================================================================================================================================*/
  545. void Gioco(int Socket,char username[], char Mappa[DIM_MATRICE][DIM_MATRICE]){
  546.     int n, flag=0,Vincitori=0,min_indizi=INT_MIN,Riga=0,Colonna=0;
  547.     char rematch[300],messaggio[1000],NomeUser[20],scelta[300];
  548.     struct ListaGiocatori *Gioc1;
  549.     Partenza(Socket, &Riga, &Colonna);
  550.     PosizioneAttuale(Mappa, Riga, Colonna);
  551.     MappaClient(Socket, Mappa,-1,Riga,Colonna,username);
  552.     //Stampa mappa sul server
  553.     while(1) { //fino a quando non viene trovato il tesoro o finisce il tempo:
  554.         bzero(scelta, 300);
  555.         bzero(messaggio, 1000);
  556.         flag=0;
  557.         n=read(Socket, scelta, 299);
  558.         if(n<0){
  559.             perror("Errore lettura da socket scelta\n");
  560.             exit(1);
  561.         }
  562.         //controllo se il gioco è terminato
  563.         if(tesoro==0 || difftime(time(&Tcorrente), Tinizio)>180){
  564.             if ( tesoro==1 && difftime(time(&Tcorrente), Tinizio)>180){  //se è scaduto il tempo
  565.                 for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
  566.                     if(Gioc1->nIndiziTrovati>min_indizi){
  567.                         min_indizi=Gioc1->nIndiziTrovati;
  568.                         strcpy(NomeUser,Gioc1->NomeGiocatore);
  569.                     }
  570.                 }
  571.                 strcat(messaggio, "\nTempo Scaduto!!\n");
  572.                 for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
  573.                     if(Gioc1->nIndiziTrovati==min_indizi){
  574.                         Vincitori++;
  575.                     }
  576.                 }
  577.                 if(Vincitori>1){
  578.                     strcat (messaggio, "Vincono i seguenti Giocatori...\n"); //Pareggio
  579.                     for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
  580.                         if(Gioc1->nIndiziTrovati==min_indizi){
  581.                             strcat(messaggio, Gioc1->NomeGiocatore);
  582.                             strcat(messaggio,"\n");
  583.                         }
  584.                     }
  585.                 }
  586.                 else{
  587.                     strcat(messaggio, "Il vincitore e' l'utente: \n"); //Vince la partita
  588.                     strcat(messaggio, NomeUser);
  589.                 }
  590.                 Vincitori=0;
  591.                 min_indizi=INT_MIN;
  592.             }
  593.             pthread_mutex_lock(&semaforo1);
  594.             sincronizzazioneclient1++;
  595.             if(sincronizzazioneclient1==1){
  596.                 creaMappa(Mappa, aiuto);
  597.             }
  598.             pthread_mutex_unlock(&semaforo1);
  599.             strcat(messaggio, "\nAttendi altri giocatori...");
  600.             write(Socket, messaggio, strlen(messaggio));
  601.             while(sincronizzazioneclient1<UtentiCollegati(players) && sincronizzazioneclient1!=0);
  602.             read(Socket, rematch, 299);
  603.             Partenza(Socket, &Riga, &Colonna);
  604.             PosizioneAttuale(Mappa, Riga, Colonna);
  605.             for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
  606.                 Gioc1->nIndiziTrovati=0;
  607.                 Gioc1->FlagUltimoInd=0;
  608.             }
  609.             tesoro=1;
  610.             sincronizzazioneclient1=0;
  611.             flag=-1;
  612.             time(&Tinizio);
  613.         }
  614.         else{//Blocco spostamento a sx
  615.             if(strcmp(scelta, "4\n")==0 ){//Controllo non superare il limite della matrice
  616.                 if((Colonna-1)>-1){
  617.                     flag=updateMappa(Socket, Mappa, Riga, Colonna-1, Riga, Colonna, aiuto,username);
  618.                    
  619.                     if(flag==0 && tesoro==1){
  620.                         PosizioneAttuale(Mappa, Riga, Colonna-1);
  621.                         Colonna=Colonna-1;
  622.                     }
  623.                     else {
  624.                         if(flag>=10){
  625.                             IndizioTrovato(players,username);
  626.                             Colonna=Colonna-1;
  627.                         }
  628.                     }
  629.                 }
  630.                 else flag=3;    //Avviso che si è usciti fuori dalla matrice
  631.             }
  632.             //Blocco spostamento su
  633.             else{
  634.                 if(strcmp(scelta, "8\n")==0){
  635.                     //Controllo non superare il limite della matrice
  636.                     if((Riga-1)>-1){
  637.                         flag=updateMappa(Socket,Mappa,Riga-1,Colonna,Riga,Colonna,aiuto,username);
  638.                         if (flag==0 && tesoro==1){
  639.                             PosizioneAttuale(Mappa,Riga-1,Colonna);
  640.                             Riga=Riga-1;
  641.                         }
  642.                         else{
  643.                             if(flag>=10){
  644.                                 IndizioTrovato(players,username);
  645.                                 Riga=Riga-1;
  646.                             }
  647.                         }
  648.                     }
  649.                     else flag=3;    //Avviso che si è usciti fuori dalla matrice
  650.                 }
  651.                 //Blocco spostamento giù
  652.                 else{
  653.                     if(strcmp(scelta, "2\n")==0){
  654.                     //Controllo non superare il limite della matrice
  655.                         if((Riga+1)<10){
  656.                             flag=updateMappa(Socket, Mappa, Riga+1, Colonna, Riga, Colonna, aiuto,username);
  657.                             if(flag==0 && tesoro==1){
  658.                                 PosizioneAttuale(Mappa, Riga+1, Colonna);
  659.                                 Riga=Riga+1;
  660.                             }
  661.                             else{
  662.                                 if(flag>=10){
  663.                                     IndizioTrovato(players,username);
  664.                                     Riga=Riga+1;
  665.                                 }
  666.                             }
  667.                         }
  668.                         else flag=3;    //Avviso che si è usciti fuori dalla matrice
  669.                     }
  670.                     //Blocco spostamento a dx
  671.                     else{
  672.                         if(strcmp(scelta, "6\n")==0){
  673.                             //Controllo non superare il limite della matrice
  674.                             if((Colonna+1)<10){
  675.                                     flag=updateMappa(Socket, Mappa, Riga, Colonna+1, Riga, Colonna, aiuto,username);
  676.                                     if(flag==0 && tesoro==1){
  677.                                         PosizioneAttuale(Mappa, Riga, Colonna+1);
  678.                                         Colonna=Colonna+1;
  679.                                     }
  680.                                     else{
  681.                                         if(flag>=10){
  682.                                             IndizioTrovato(players,username);
  683.                                             Colonna=Colonna + 1;
  684.                                         }
  685.                                     }
  686.                             }
  687.                             else{
  688.                                 flag=3; //Avviso che si è usciti fuori dalla matrice
  689.                             }
  690.                         }
  691.                         else{  
  692.                             if(strcmp(scelta, "EXIT\n")==0 || strcmp(scelta, "exit\n")==0){
  693.                                 printf("Mi sto disconnettendo...\n");
  694.                                 players=EliminaGiocatore(players, username);
  695.                                 LiberaMappa(&Riga, &Colonna);
  696.                                 printf("Disconnesso..\n");
  697.                                 pthread_exit(NULL);
  698.                             }
  699.                             else{
  700.                                     if(strcmp(scelta, "ONLINE\n")==0 || strcmp(scelta, "online\n")==0){
  701.                                             StampaGiocatori(Socket,players);   
  702.                                     }
  703.                             }
  704.                         }
  705.                     }
  706.                 }
  707.              }
  708.         }
  709.         MappaClient(Socket, Mappa, flag,Riga,Colonna,username);
  710.     }
  711. }
  712.  
  713. /*===============================================================================================================================================
  714. MENU UTENTE
  715. ===============================================================================================================================================*/
  716. void MenuGioco(int Socket, char username[]){
  717.     char scelta[300], messaggio[300],app[300];
  718.     int n, opzione=0;
  719.     do{
  720.         bzero(messaggio, 300);
  721.         strcpy(messaggio, "\033[0m\n\t\t\t\t\t M    E    N    U \033[0m");
  722.         strcat(messaggio, "\n");
  723.         strcat(messaggio, "\033[32m\nOPZIONI POSSIBILI:\033[0m ");
  724.         strcat(messaggio, "\n");
  725.         strcat(messaggio, "\033[33m\n\t( 1 ) I N I Z I A M O   A   G I O C A R E !\033[0m ");
  726.         strcat(messaggio, "\n\n");
  727.         strcat(messaggio, "\033[33m\t( 2 ) V I S U A L I Z Z A  UTENTI  CONNESSI   A L   S E R V E R \033[0m");
  728.         strcat(messaggio, "\n\n");
  729.         strcat(messaggio, "\033[33m\t( 3 ) D I S C O N N E T T I T I   D A L L'  A C C O U N T\033[0m");
  730.         strcat(messaggio, "\n\n\n");
  731.         strcat(messaggio, "\t\t\033[36mS C E L T A :\033[0m  ");
  732.         n=write(Socket, messaggio, strlen(messaggio)); //Invio del menu al client
  733.         if(n<0){
  734.             perror("Errore scrittura sul socket\n");
  735.             exit(1);
  736.         }
  737.         bzero(scelta, 300);
  738.         n=read(Socket ,scelta ,299);
  739.         opzione=atoi(scelta);
  740.         if(n<0){
  741.             perror("Errore lettura da socket\n");
  742.             exit(1);
  743.         }
  744.         if(strcmp(scelta, "1\n")==0){
  745.             printf("FUNZIONE GIOCO:\n");
  746.             Gioco(Socket, username, Mappa);
  747.             break;
  748.         }
  749.         else if(strcmp(scelta, "2\n")==0){
  750.             printf("UTENTI ONLINE:\n");
  751.             StampaGiocatori(Socket, players);
  752.             read(Socket ,app ,299);
  753.             }
  754.             else if(strcmp(scelta, "3\n")==0) break;
  755.                  else{
  756.                      strcpy(messaggio, "Operazione non valida. Premere  INVIO per continuare.");
  757.                      write(Socket, messaggio, strlen(messaggio));
  758.                      bzero(messaggio, 300);
  759.                      read(Socket, messaggio, 300);
  760.                 }
  761.     }
  762.     while(opzione<=0 || opzione==2 || opzione>3);
  763.    
  764.     bzero(messaggio, 300);
  765.     players=EliminaGiocatore(players, username);
  766.     strcpy(messaggio, "\nAccount disconnesso. Premere INVIO per continuare.." );
  767.     write(Socket, messaggio, strlen(messaggio));
  768.     bzero(messaggio, 300);
  769.     read(Socket, messaggio, 300);
  770. }
  771.  
  772. /*===============================================================================================================================================
  773. CONTROLLO DISPONIBILITA' USERNAME
  774. ===============================================================================================================================================*/
  775. int ControlloDisponibilita(char username[]){
  776.     char c,NomeUtente[20];
  777.     int Pf,i=0;
  778.      Pf=open("accesso.txt", O_RDONLY);
  779.      if(Pf){
  780.         while (read(Pf,&NomeUtente[i],1)>0)
  781.         {    if(NomeUtente[i]==' ')
  782.              {     NomeUtente[i]='\0';
  783.                    if(strcmp(NomeUtente,username)==0) return 1;
  784.                    bzero(NomeUtente,20);
  785.                    while(read(Pf,&c,1)>0)
  786.                    {   if(c == ' ') break;
  787.                    }
  788.                    i=0;
  789.              }
  790.              else i++;
  791.         }
  792.         close(Pf);
  793.         return 0 ;
  794.      }
  795.      else return -1;
  796. }
  797. /*===============================================================================================================================================
  798. MEMORIZZA GLI ACCESSI DEGLI UTENTI
  799. ===============================================================================================================================================*/
  800. void SalvaLogin ( char username[] ){
  801.     int Pf;
  802.     char messaggio[300], orario[300];
  803.     time_t ora;
  804.     time(&ora);
  805.     bzero(messaggio, 300);
  806.     bzero(orario, 300);
  807.     strcpy(messaggio, "L'utente: ");
  808.     sprintf(orario, "%s", asctime(localtime(&ora)));
  809.     strcat(messaggio, username);
  810.     strcat(messaggio, " ha effettuato l'accesso il giorno: ");
  811.     strcat(messaggio, orario);
  812.     strcat(messaggio, "  ");
  813.     pthread_mutex_lock(&semaforo1);
  814.     Pf=open("salvalogin.txt", O_WRONLY|O_CREAT) ;
  815.     lseek(Pf, 0, SEEK_END);
  816.     write(Pf, messaggio, strlen(messaggio));
  817.     close(Pf);
  818.     pthread_mutex_unlock(&semaforo1);
  819. }
  820.  
  821. /*===============================================================================================================================================
  822. AGGIORNO MAPPA IN CASO DI ABBANDONO DI UN UTENTE
  823. ===============================================================================================================================================*/
  824. void LiberaMappa(int *Riga, int *Colonna){
  825.     if(Mappa[*Riga][*Colonna]=='?'){
  826.         Mappa[*Riga][*Colonna]='0';
  827.     }
  828.     else {
  829.         *Riga=-1;
  830.         *Colonna=-1;
  831.     }
  832.    
  833. }
  834. /*===============================================================================================================================================
  835. ACCESSO E REGISTRAZIONE
  836. ===============================================================================================================================================*/
  837. void login(int Socket){
  838.     int PuntFile,n,trovato,accesso=0; // utilizzo accesso per sapere se l'accesso è avvenuto correttamente (caso in cui accesso=1), ci sono stati problemi di tipo credenziali non valide (accesso=0) oppure accesso con dati di un giocatore gia' connesso (accesso=2)
  839.     struct ListaGiocatori *TrovoPlayer; // utilizzo questo puntatore per scoprire se l'username inserito dall'utente non sia gia' presente nella lista dei giocatori online
  840.     char messaggio[300], username[300], password[300], confronta_passwd[300], confronta_user[300];
  841.     do{
  842.         write(Socket, "\n PREMERE: \n\t\t(1) Se vuoi registrarti;\n\t\t(2) Se vuoi accedere;\n\t\t(3) per uscire\n", 92);
  843.         bzero(messaggio, 300);
  844.         n=read(Socket, messaggio, 299); // leggo risposta del client e salvo il messaggio nell'array messaggio
  845.         if(n<0){
  846.             perror("Errore lettura da socket\n");
  847.             exit(1);
  848.         }
  849.         if(strcmp(messaggio, "3\n")==0){
  850.             printf("Mi disconnetto..\n");
  851.             pthread_exit(NULL);
  852.          }
  853.         //Registrazione
  854.         else {
  855.             if ( strcmp ( messaggio , "1\n" ) == 0 ){
  856.                 pthread_mutex_lock(&semaforo1); // semaforo1 rosso
  857.                 PuntFile=open("accesso.txt", O_RDWR | O_CREAT); // per tenere traccia degli utenti registrati salvo su file nome utente e pass
  858.                 lseek(PuntFile, 0, SEEK_END);
  859.                 //Username
  860.                 do{
  861.                     write(Socket, "\n\t\t Inserire Username:\t\tPREMERE i per tornare indietro..", 61);
  862.                     bzero(username, 300);
  863.                     n=read(Socket, username, 299);
  864.                     if(strcmp(username,"i\n")==0) break;
  865.                     if(n<0){
  866.                         perror ("Errore lettura socket\n");
  867.                         exit(1);
  868.                       }
  869.                     trovato=ControlloDisponibilita(username) ; //Username già in uso?
  870.                     if(trovato < 0){
  871.                         bzero(messaggio,300);
  872.                         strcpy(messaggio, "\nERRORE NELLA CREAZIONE DEL FILE!");
  873.                         write(Socket, messaggio, strlen(messaggio));
  874.                         read(Socket, messaggio, 300);
  875.                     }
  876.                     if(trovato==1){
  877.                         bzero(messaggio,300);
  878.                         strcpy(messaggio, "\nUsername gia' in uso. Premi INVIO per provarne un altro!");
  879.                         write(Socket, messaggio, strlen(messaggio));
  880.                         read(Socket, messaggio, 300);
  881.                     }
  882.                 }
  883.                 while(trovato==1);
  884.                 if(strcmp(username,"i\n")!=0){
  885.                     n=write(PuntFile, username, strlen(username));
  886.                     n=write(PuntFile, " ", 1);
  887.                     //Password
  888.                     write(Socket, "\n\t\t Inserire Password:\n\t\t", 31);
  889.                     bzero(password, 300);
  890.                     n=read(Socket, password, 299);
  891.                     if(n<0){
  892.                         perror("Errore lettura socket\n");
  893.                         exit(1);
  894.                     }
  895.                     n=write(PuntFile, password, strlen(password));
  896.                     n=write(PuntFile, " ", 1);
  897.                     bzero(messaggio, 300);
  898.                     strcpy(messaggio, " Registrazione effettuata con SUCCESSO! \nPremere INVIO per continuare...");
  899.                     write(Socket, messaggio, strlen(messaggio));
  900.                     bzero(messaggio, 300);
  901.                     read(Socket, messaggio, 300);
  902.                 }
  903.                 close(PuntFile);
  904.                 pthread_mutex_unlock(&semaforo1);   //Sblocco semaforo
  905.              }
  906.        
  907.               else{
  908.                 if(strcmp(messaggio, "2\n")==0){
  909.                     n = write ( Socket, "\n\t\t Inserire Username:\t\tPREMERE i per tornare indietro..", 61 ) ;
  910.                     if ( n < 0 ){
  911.                         perror ("Errore scrittura socket");
  912.                         exit (1);
  913.                     }
  914.  
  915.                       bzero ( username , 300 );
  916.                       n=read(Socket, username, 299);
  917.                       if(strcmp(username,"i\n")!=0){
  918.                          if(n< 0){
  919.                                 perror ( "Errore lettura socket\n");
  920.                                 exit (1);
  921.                          }
  922.                          for(TrovoPlayer=players;TrovoPlayer;TrovoPlayer=TrovoPlayer->next){
  923.                                 if(strcmp(TrovoPlayer->NomeGiocatore,username)==0) break;  
  924.                          }
  925.                          if(TrovoPlayer)accesso=2;
  926.                          else{ 
  927.                                n=write(Socket, "\n\t\t Inserire Password:\n\t\t", 31);
  928.                                if(n<0){
  929.                                     perror("Errore scrittura socket");
  930.                                     exit(1);
  931.                                }
  932.                                bzero(password, 300);
  933.                                n=read(Socket, password, 299);
  934.                                if(n<0){
  935.                                     perror("Errore lettura socket\n");
  936.                                     exit(1);
  937.                                }
  938.                                pthread_mutex_lock(&semaforo1);
  939.                                PuntFile=open("accesso.txt", O_RDWR | O_CREAT);
  940.                                lseek(PuntFile, 0, SEEK_SET);
  941.                                int i=0, j=0;
  942.                                bzero(confronta_user, 300);
  943.                                bzero(confronta_passwd, 300);
  944.                                while(read(PuntFile, &confronta_user[i], 1)>0) {
  945.                                     if(confronta_user[i]==' '){     // Acquisisco username da file
  946.                                         j=0;
  947.                                         confronta_user[i] = '\0';
  948.                                         if(strcmp(username,confronta_user)==0){
  949.                                             while(read(PuntFile,&confronta_passwd[j],1)>0){
  950.                                                 if(confronta_passwd[j]==' '){
  951.                                                     confronta_passwd[j]='\0';
  952.                                                     break;
  953.                                                 }
  954.                                                 else j++;  
  955.                                             }
  956.                                             if(strcmp(confronta_passwd,password)!=0){//Password non coincide
  957.                                                 break;
  958.                                             }  
  959.                                             else {
  960.                                                 if(strcmp(confronta_passwd, password)==0){
  961.                                                     CreaGiocatore(username);
  962.                                                     accesso = 1 ;
  963.                                                     break;
  964.                                                 }
  965.                                             }
  966.                                         }
  967.                                         else{
  968.                                             bzero(confronta_user,i);
  969.                                             i=0;
  970.                                         }
  971.                                     }
  972.                                     else i++;
  973.                                 }
  974.                                 close ( PuntFile ) ;
  975.                                 pthread_mutex_unlock (&semaforo1);
  976.                            }
  977.                            if(accesso==0){
  978.                            // Credenziali non valide
  979.                                 n=write(Socket, "Credenziali invalide! Premere INVIO per continuare", 53);
  980.                                 if(n<0){
  981.                                     perror("Errore scrittura socket");
  982.                                     exit(1);
  983.                                 }
  984.                                 bzero(messaggio, 300);
  985.                                 n=read(Socket, messaggio, 299);
  986.                                 if(n<0){
  987.                                     perror("Errore lettura da socket");
  988.                                     exit(1);
  989.                                 }
  990.                             }
  991.                             else{
  992.                                 if(accesso==2){
  993.                                 // Utente già collegato in partita
  994.                                     n=write(Socket, "Utente gia' in gioco con questo Username! Premere INVIO per continuare", 72);
  995.                                     if(n<0){
  996.                                             perror("Errore scrittura sul socket");
  997.                                             exit(1);
  998.                                     }
  999.                                     bzero(messaggio, 300);
  1000.                                     n=read(Socket, messaggio, 299);
  1001.                                     if(n<0){
  1002.                                             perror("Errore lettura da socket");
  1003.                                             exit(1);
  1004.                                     }  
  1005.                                 }
  1006.                                 else{ //Credenziali Valide
  1007.                                     n=write(Socket, "Login effettuato con successo!\nPremere INVIO  per continuare..", 65);
  1008.                                     if(n<0){
  1009.                                             perror("Errore scrittura sul socket");
  1010.                                             exit(1);
  1011.                                     }
  1012.                                     bzero(messaggio, 300);
  1013.                                     n=read(Socket, messaggio, 299);
  1014.                                     if(n<0){
  1015.                                             perror("Errore lettura da socket");
  1016.                                             exit(1);
  1017.                                     }
  1018.                                     SalvaLogin(username);
  1019.                                     printf("\n %s \n",username);
  1020.                                     // dopo aver fatto correttamente il log in del client chiamo la funzione MenuGioco
  1021.                                     MenuGioco(Socket, username ) ;
  1022.                                 }
  1023.                             }
  1024.                       }
  1025.                 }
  1026.               }
  1027.         }
  1028.     }while(n!=3);
  1029. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!