API tools faq
paste
Advertisement
Geralt1001

Untitled

Geralt1001
Feb 6th, 2016
59
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.34 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <time.h>
  10. #include <arpa/inet.h>
  11. #include <sys/wait.h>
  12. #include <signal.h>
  13. #include <fcntl.h>
  14. #include <sys/poll.h>
  15.  
  16. #define MYPORT 6666
  17.  
  18. #define BACKLOG 5
  19.  
  20. void deadChildHandler(int s);
  21. void showTrueLabyrinth(char** lab,int n);
  22. void showInvisibleDungeon(char** lab, int n);
  23. int generatePosition(int n);
  24. void move(int sockfd,char** true_labyrinth,int minions[][2],char c,int number,int steps,int size);
  25. char** generateInvisibleLabyrinth(int n);
  26. char** createLab(int size_lab,int clients);
  27. void freeMemory(char** lab,int n);
  28.  
  29. int main(int argc,char* argv[])
  30. {
  31.    
  32.     printf("\n\tDUNGEON and cakes and mushroms v.1.4\n\n");
  33.     char *end;
  34.     char *end1;
  35.    
  36.     if(argc!=3)
  37.     {
  38.         printf("usage: ilosc_klientow rozmiar_lab\n\n");
  39.         exit(1);
  40.     }
  41.     else if(strtol(argv[1],&end,10)<=0)
  42.     {
  43.         printf("Niepoprawny 1 parametr - ilosc klientow!\nLiczba ma byc nieujemna i wieksza od 0\n");
  44.         exit(1);
  45.     }
  46.     else if(strtol(argv[2],&end1,10)<=0)
  47.     {
  48.         printf("Niepoprawny 2 parametr - rozmiar labiryntu!\nLiczba ma byc nieujemna i wieksza od 0\n");
  49.         exit(1);
  50.     }
  51.    
  52.     int clients_count,size_lab,size;
  53.    
  54.  
  55.     size_lab= strtol(argv[2],&end1,10);
  56.     printf("size_lab = %d\n",size_lab);
  57.     clients_count = strtol(argv[1],&end,10);
  58.     printf("clients_count = %d\n",clients_count);
  59.     int minions[clients_count][2];
  60.    
  61.     int steps=size_lab*10;
  62.    
  63.     srand(time(NULL));
  64.     char **true_labyrinth=NULL;
  65.    
  66.     size=(2*size_lab)+(size_lab/3)+1;
  67.    
  68.     true_labyrinth=createLab(size_lab,clients_count);
  69.     showTrueLabyrinth(true_labyrinth,size);
  70.    
  71.     char minionsChar[5] = {'-','^','V','!','+'};
  72.     int xx,yy;
  73.     printf("Generuje pozycje pionkow:");
  74.     for(int i=0;i<clients_count;i++)
  75.     {
  76.         xx=0;
  77.         yy=0;
  78.         while(true_labyrinth[xx][yy]!='0')
  79.         {
  80.             xx=generatePosition(size);
  81.             yy=generatePosition(size);
  82.            
  83.         }
  84.         true_labyrinth[xx][yy]=minionsChar[i];
  85.         minions[i][0] = xx;
  86.         minions[i][1] = yy;
  87.     }
  88.    
  89.     printf("\nWygenerowalem:\n");
  90.     showTrueLabyrinth(true_labyrinth,size);
  91.     showInvisibleDungeon(true_labyrinth,size);
  92.    
  93.    
  94.     int sockfd,sin_size;
  95.     int tru = 1;
  96.    
  97.    
  98.     struct sockaddr_in my_addr;
  99.     struct sockaddr_in their_addr;
  100.    
  101.     struct sigaction sa;
  102.    
  103.     if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
  104.     {
  105.         perror("Error - socket");
  106.         exit(1);
  107.     }
  108.    
  109.     if(fcntl(sockfd,F_SETFL,O_NONBLOCK)==-1)
  110.     {
  111.         perror( "Error - fcntl - nie nastawilem nieblokowania" );
  112.         exit(1);
  113.     }
  114.    
  115.     if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&tru,sizeof(int))==-1)
  116.     {
  117.         perror("Error - setsockopt");
  118.         exit(1);
  119.     }
  120.    
  121.     my_addr.sin_family = AF_INET;
  122.     my_addr.sin_port = htons(MYPORT);
  123.     my_addr.sin_addr.s_addr = INADDR_ANY;
  124.     memset(&(my_addr.sin_zero), '\0', 8 );
  125.    
  126.    
  127.     if(bind(sockfd,(struct sockaddr *) &my_addr,sizeof(struct sockaddr))==-1)
  128.     {
  129.         perror("Error - bind\n");
  130.         exit(1);
  131.     }
  132.    
  133.     if(listen(sockfd,BACKLOG)==-1)
  134.     {
  135.         perror("Error - listen\n");
  136.         exit(1);
  137.     }
  138.    
  139.     sa.sa_handler = deadChildHandler;
  140.     sigemptyset( & sa.sa_mask );
  141.     sa.sa_flags = SA_RESTART;
  142.    
  143.     if(sigaction(SIGCHLD,& sa,NULL)==-1)
  144.     {
  145.         perror("Error - sigaction");
  146.         exit(1);
  147.     }
  148.    
  149.     int fdTab[10];
  150.    
  151.     sin_size = sizeof( struct sockaddr_in );
  152.     int rc, socket_number = 0, max_socket = 5;
  153.     fd_set fds, readfds;
  154.     FD_ZERO(&fds);
  155.     FD_SET(sockfd, &fds);
  156.    
  157.     while(1)
  158.     {
  159.         readfds = fds;
  160.         rc = select(FD_SETSIZE, &readfds, NULL, NULL, NULL);
  161.         if (rc == -1)
  162.         {
  163.                 perror("Error - select\n");
  164.                 break;
  165.         }
  166.  
  167.         int i=0;
  168.  
  169.         while(i<FD_SETSIZE)
  170.         {
  171.             if (FD_ISSET(i, &readfds))
  172.             {
  173.                 if (i == sockfd)
  174.                 {
  175.                     if (socket_number < max_socket)
  176.                     {
  177.                         if((fdTab[socket_number] = accept(sockfd,( struct sockaddr *) &their_addr,(socklen_t *) &sin_size))==-1)
  178.                         {
  179.                             //printf( "Error - accept" );                               //wylaczona notyfikacja, poniewaz polaczenia nie sa blokujace i bylby niezly span na ekranie
  180.                             continue;
  181.                         }
  182.                         printf("And we have a client from:  %s\n",inet_ntoa(their_addr.sin_addr));
  183.  
  184.                         printf("_____%d  %d______\n",i,socket_number);
  185.                         move(fdTab[socket_number],true_labyrinth,minions,minionsChar[socket_number],socket_number,steps,size);
  186.                         FD_SET(fdTab[socket_number], &fds);
  187.                         socket_number++;
  188.                     }
  189.                 }
  190.             }
  191.             i++;
  192.         }
  193.         shutdown( fdTab[i], SHUT_RDWR );
  194.     }
  195.     freeMemory(true_labyrinth,size);
  196.     close(sockfd);
  197.     return 0;
  198. }
  199.  
  200. void deadChildHandler(int s)
  201. {
  202.     while( wait( NULL ) > 0 );
  203. }
  204.  
  205. int generatePosition(int n)
  206. {
  207.     int x;
  208.     srand(time(NULL));
  209.     x = rand()%(n-2)+1;
  210.     return x;
  211. }
  212.  
  213. void showTrueLabyrinth(char** lab,int n)
  214. {
  215.     for(int i=0;i<n;i++)
  216.     {
  217.         for(int j=0;j<n;j++)
  218.         {
  219.             printf("%c",lab[j][i]);
  220.         }
  221.         printf("\n");
  222.     }
  223.     printf("\n");
  224. }
  225.  
  226. void freeMemory(char** lab,int n)
  227. {
  228.     for(int i=0;i<n;i++)
  229.     {
  230.         free(lab[i]);
  231.     }
  232.     free (lab);
  233. }
  234.  
  235. void showInvisibleDungeon(char** lab, int n)
  236. {
  237.     for(int i=0;i<n;i++)
  238.     {
  239.         for(int j=0;j<n;j++)
  240.         {
  241.             if (lab[j][i]=='0')
  242.                 printf(" ");
  243.             else if (lab[j][i]=='1')
  244.                 printf("X");
  245.             else
  246.                 printf("%c",lab[j][i]);
  247.         }
  248.         printf("\n");
  249.     }
  250. }
  251.  
  252. char** createLab(int size_lab,int clients)
  253. {
  254.     struct room
  255.     {
  256.         bool left_wall;
  257.         bool top_wall;
  258.         bool visited;
  259.     };
  260.     //int size_lab=n;
  261.     bool rand_start=0;
  262.    
  263.    
  264.     room labyrinth[size_lab][size_lab];
  265.  
  266.     int i,j;
  267.    
  268.     for(i=0;i<size_lab;i++)
  269.     {
  270.         for(j=0;j<size_lab;j++)
  271.         {
  272.             labyrinth[i][j].left_wall=1;
  273.             labyrinth[i][j].top_wall=1;
  274.             labyrinth[i][j].visited=0;
  275.         }
  276.     }
  277.    
  278.     int x_hall,y_hall,hall_size,max_hall_size;
  279.  
  280.     int x_start=0;
  281.     int y_start=0;
  282.     if (!rand_start)
  283.     {
  284.         x_start=(rand() % size_lab)+0;
  285.         y_start=(rand() % size_lab)+0;
  286.         rand_start=1;
  287.     }
  288.     int direction=0;
  289.     bool koniec=1;
  290.     while(koniec==1)
  291.     {
  292.         if(labyrinth[x_start][y_start].visited==0)
  293.             labyrinth[x_start][y_start].visited=1;
  294.        
  295.         direction=(rand()%4)+0;
  296.         if (direction==0)
  297.         {
  298.             if (y_start<size_lab-1){
  299.                 if (labyrinth[x_start][y_start+1].visited==0)
  300.                     labyrinth[x_start][y_start+1].top_wall=0;
  301.                 y_start++;
  302.             }  
  303.         }
  304.         else if (direction==1)
  305.         {
  306.             if (y_start>0)
  307.             {
  308.                 if (labyrinth[x_start][y_start-1].visited==0)
  309.                     labyrinth[x_start][y_start].top_wall=0;
  310.                 y_start--;
  311.             }
  312.         }
  313.         else if (direction==2)
  314.         {
  315.             if (x_start>0)
  316.             {
  317.                 if (labyrinth[x_start-1][y_start].visited==0)
  318.                     labyrinth[x_start][y_start].left_wall=0;
  319.                 x_start--;
  320.             }
  321.         }
  322.         else if(direction==3)
  323.         {
  324.             if (x_start<size_lab-1)
  325.             {
  326.                 if (labyrinth[x_start+1][y_start].visited==0)
  327.                     labyrinth[x_start+1][y_start].left_wall=0;
  328.                 x_start++;
  329.             }
  330.         }
  331.    
  332.         for(int i=0;i<size_lab;i++)
  333.         {
  334.             for(int j=0;j<size_lab;j++)
  335.             {
  336.                 if (labyrinth[i][j].visited==0)
  337.                 {
  338.                     koniec=1;
  339.                     break;
  340.                 }
  341.                 else
  342.                     koniec=0;
  343.             }
  344.             if(koniec==1)
  345.                 break;
  346.         }
  347.     }
  348.    
  349.     char perfect [2*size_lab+1][2*size_lab+1];
  350.    
  351.     for(int i=0;i<2*size_lab+1;i++)
  352.     {
  353.         for(int j=0;j<2*size_lab+1;j++)
  354.         {
  355.             if ((i==2*size_lab))
  356.                 perfect[j][i]='1';
  357.             else if ((j==2*size_lab))
  358.                 perfect[j][i]='1';
  359.             else if ((i%2==1)&&(j%2==1))
  360.                 perfect[j][i]='0';
  361.             else if ((i%2==0)&&(j%2==1))
  362.             {
  363.                 if (labyrinth[j/2][i/2].top_wall==0)
  364.                     perfect[j][i]='0';
  365.                 else
  366.                     perfect[j][i]='1';
  367.             }
  368.             else if ((i%2==1)&&(j%2==0))
  369.             {
  370.                 if (labyrinth[j/2][i/2].left_wall==0)
  371.                     perfect[j][i]='0';
  372.                 else
  373.                     perfect[j][i]='1';
  374.             }
  375.             else if ((i%2==0)&&(j%2==0))
  376.                 perfect[j][i]='1';
  377.         }
  378.     }
  379.    
  380.     max_hall_size=size_lab/3;
  381.     int copies_count=size_lab/3;
  382.     for (int k=0;k<copies_count;k++)
  383.     {
  384.         x_hall=(rand() % (2*size_lab-max_hall_size)) + (max_hall_size/2+1);
  385.         y_hall=(rand() % (2*size_lab-max_hall_size)) + (max_hall_size/2+1);
  386.         hall_size=(rand() % (max_hall_size-1)) + 2;
  387.  
  388.         for( i=(x_hall-(hall_size/2));i<(x_hall+hall_size/2+1);i++)
  389.         {
  390.             for(j=(y_hall-(hall_size/2));j<(y_hall+hall_size/2+1);j++)
  391.                 perfect[i][j]='0';
  392.         }
  393.     }
  394.                
  395.     int row[copies_count];
  396.     int column[copies_count];
  397.     for(int k=0;k<copies_count;k++)
  398.     {
  399.         row[k]=(rand() % (2*size_lab-1)) + 1;
  400.         column[k]=(rand() % (2*size_lab-1)) + 1;
  401.     }
  402.     char perfect_with_halls [2*size_lab+1][2*size_lab+1+copies_count];
  403.     int displacement=0;
  404.     int copies;
  405.     for(int j=0;j<2*size_lab+1;j++)
  406.     {
  407.         copies=1;
  408.         for(int k=0;k<copies_count;k++)
  409.             if (column[k]==j)
  410.                 copies++;
  411.            
  412.         for(int l=0;l<copies;l++)
  413.         {
  414.             if (l>0)
  415.                 displacement++;
  416.             for(int i=0;i<2*size_lab+1;i++)
  417.                 perfect_with_halls[i][j+displacement]=perfect[i][j];
  418.         }
  419.     }  
  420.                    
  421.     displacement=0;
  422.     copies=1;
  423.     char ** true_labyrinth = NULL;
  424.    
  425.     true_labyrinth=(char**)calloc(2*size_lab+1+(size_lab/3),sizeof(char*));
  426.    
  427.     for(int i=0;i<2*size_lab+1+(size_lab/3);i++)
  428.     {
  429.         true_labyrinth[i]=(char*)calloc(2*size_lab+1+(size_lab/3),sizeof(char));
  430.     }
  431.  
  432.    
  433.     for(int i=0;i<2*size_lab+1+copies_count;i++)
  434.     {
  435.         copies=1;
  436.             for(int k=0;k<copies_count;k++)
  437.             {
  438.                 if (row[k]==i)
  439.                     copies++;
  440.             }
  441.             for(int l=0;l<copies;l++)
  442.             {
  443.                 if (l>0)
  444.                     displacement++;
  445.                
  446.                 for(int j=0;j<2*size_lab+1+copies_count;j++)
  447.                     true_labyrinth[i+displacement][j]=perfect_with_halls[i][j];
  448.  
  449.             }
  450.     }
  451.                
  452.     for(int i=0;i<2*size_lab+1+copies_count;i++)
  453.     {
  454.         for(int j=0;j<2*size_lab+1+copies_count;j++)
  455.         {
  456.             if (true_labyrinth[j][i]=='0')
  457.                 printf(" ");
  458.             if (true_labyrinth[j][i]=='1')
  459.                 printf("X");
  460.         }
  461.         printf("\n");
  462.     }
  463.     printf("\n");
  464.    
  465.     return true_labyrinth;
  466. }
  467.  
  468. void move(int sockfd,char** true_labyrinth,int minions[][2],char c,int number,int steps,int size)
  469. {
  470.     char znak;
  471.     int xn = minions[number][0];
  472.     int yn = minions[number][1];
  473.     int i;
  474.    
  475.     for(i=0;i<steps;i++)
  476.     {
  477.         char buf[1];
  478.        
  479.         if((recv(sockfd,buf,sizeof(buf),0))==-1)
  480.             sleep(1);
  481.  
  482.         znak = buf[0];
  483.        
  484.         if(znak=='w' || znak=='s' || znak=='a' || znak=='d')
  485.         {
  486.             printf("%c\n",znak);
  487.             switch(znak)
  488.             {
  489.                 case 'w':
  490.                     switch(true_labyrinth[xn][yn-1])
  491.                     {
  492.                         case '1':
  493.                             if(send( sockfd,"Wall",14,MSG_DONTWAIT)==-1)
  494.                                 printf("Error - send\n");
  495.                             break;
  496.                         case '0':
  497.                             if(send( sockfd,"Hall",14,MSG_DONTWAIT)==-1)
  498.                                 printf("Error - send\n");
  499.                             true_labyrinth[xn][yn-1]=true_labyrinth[xn][yn];
  500.                             true_labyrinth[xn][yn]='0';
  501.                             minions[number][1]=yn-1;                           
  502.                             break;
  503.                         default:
  504.                             if(send( sockfd,"Pion",14,MSG_DONTWAIT)==-1)
  505.                                 printf("Error - send\n");
  506.                             break;
  507.                     }
  508.                     showInvisibleDungeon(true_labyrinth,size);
  509.                     break;
  510.  
  511.                 case 's':
  512.                     switch(true_labyrinth[xn][yn+1])
  513.                     {
  514.                         case '1':
  515.                             if(send( sockfd,"Wall",14,MSG_DONTWAIT)==-1)
  516.                                 printf("Error - send\n");
  517.                             break;
  518.                         case '0':
  519.                             if(send( sockfd,"Hall",14,MSG_DONTWAIT)==-1)
  520.                                 printf("Error - send\n");
  521.                             true_labyrinth[xn][yn+1]=true_labyrinth[xn][yn];
  522.                             true_labyrinth[xn][yn]='0';
  523.                             minions[number][1]=yn+1;
  524.                             break;
  525.                         default:
  526.                             if(send( sockfd,"Pion",14,MSG_DONTWAIT)==-1)
  527.                                 printf("Error - send\n");
  528.                             break;
  529.                     }
  530.                     showInvisibleDungeon(true_labyrinth,size);
  531.                     break;
  532.  
  533.                 case 'a':
  534.                     switch(true_labyrinth[xn-1][yn])
  535.                     {
  536.                         case '1':
  537.                             if(send( sockfd,"Wall",14,MSG_DONTWAIT)==-1)
  538.                                 printf("Error - send\n");
  539.                             break;
  540.                         case '0':
  541.                             if(send( sockfd,"Hall",14,MSG_DONTWAIT)==-1)
  542.                                 printf("Error - send\n");
  543.                             true_labyrinth[xn-1][yn]=true_labyrinth[xn][yn];
  544.                             true_labyrinth[xn][yn]='0';
  545.                             minions[number][0]=xn-1;
  546.                             break;
  547.                         default:
  548.                             if(send( sockfd,"Pion",14,MSG_DONTWAIT)==-1)
  549.                                 printf("Error - send\n");
  550.                             break;
  551.                     }
  552.                     showInvisibleDungeon(true_labyrinth,size);
  553.                     break;
  554.  
  555.                 case 'd':
  556.                     switch(true_labyrinth[xn+1][yn])
  557.                     {
  558.                         case '1':
  559.                             if(send( sockfd,"Wall",14,MSG_DONTWAIT)==-1)
  560.                                 printf("Error - send\n");
  561.  
  562.                             break;
  563.                         case '0':
  564.                             if(send( sockfd,"Hall",14,MSG_DONTWAIT)==-1)
  565.                                 printf("Error - send\n");
  566.                             true_labyrinth[xn+1][yn]=true_labyrinth[xn][yn];
  567.                             true_labyrinth[xn][yn]='0';
  568.                             minions[number][0]=xn+1;
  569.                             break;
  570.                         default:
  571.                             if(send( sockfd,"Pion",14,MSG_DONTWAIT)==-1)
  572.                                 printf("Error - send\n");
  573.                             break;
  574.                     }
  575.                     showInvisibleDungeon(true_labyrinth,size);
  576.                     break;
  577.             }
  578.         }
  579.     }
  580. }
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!