API tools faq
paste
Advertisement
patryk

SOP Server ver2.0

patryk
Feb 18th, 2015
537
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 27.57 KB | None | 0 0
raw download clone embed print report
  1. #include <ctype.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <ctype.h>
  5. #include <stdbool.h>
  6. #include <sys/ipc.h>
  7. #include <sys/msg.h>
  8. #include <sys/types.h>
  9. #include <sys/sem.h>
  10. #include <string.h>
  11. #include <signal.h>
  12. #include <unistd.h>
  13.  
  14. //----PAMIEC WSPOLDZIELONA----
  15. char *C1_LekkaPiechota;
  16. char *C1_CiezkaPiechota;
  17. char *C1_Jazda;
  18. char *C1_Robotnicy;
  19. char *C1_Surowce;
  20. char *C1_Punkty;
  21.  
  22. char *C2_LekkaPiechota;
  23. char *C2_CiezkaPiechota;
  24. char *C2_Jazda;
  25. char *C2_Robotnicy;
  26. char *C2_Surowce;
  27. char *C2_Punkty;
  28.  
  29. int C1_LekkaPiechotaAdr;
  30. int C1_CiezkaPiechotaAdr;
  31. int C1_JazdaAdr;
  32. int C1_RobotnicyAdr;
  33. int C1_SurowceAdr;
  34. int C1_PunktyAdr;
  35.  
  36. int C2_LekkaPiechotaAdr;
  37. int C2_CiezkaPiechotaAdr;
  38. int C2_JazdaAdr;
  39. int C2_RobotnicyAdr;
  40. int C2_SurowceAdr;
  41. int C2_PunktyAdr;
  42.  
  43.  
  44.  
  45. //----STRUKTURY----
  46. struct clientStatus {
  47.     long mtype;
  48.     int surowce;
  49.     int lekka_piechota;
  50.     int ciezka_piechota;
  51.     int jazda;
  52.     int robotnicy;
  53.     int punkty;
  54. };
  55.  
  56. struct prepareClient {
  57.     long mtype;
  58.     int CSQueueNumber;
  59.     int SCQueueNumber;
  60. };
  61.  
  62. struct message {
  63.     long mtype;
  64.     int value;
  65. };
  66.  
  67. struct atak {
  68.     long mtype;
  69.     int lekka_p;
  70.     int ciezka_p;
  71.     int jazda;
  72. };
  73.  
  74.  
  75. //----SEMAFORY----
  76. int clientReadySID, serverReadySID, memoryMutexSID, c1RecruitingSID, c2RecruitingSID;
  77. struct sembuf clientReady;
  78. struct sembuf serverReady;
  79. struct sembuf memoryMutex;
  80. struct sembuf c1Recruiting;
  81. struct sembuf c2Recruiting;
  82.  
  83.  
  84. //----KOLEJKI----
  85. struct prepareClient pC;   
  86. int pC_ID;
  87.  
  88.  
  89. void removeMQueues() {
  90.     int queueID = msgget(1000, 0606);
  91.     msgctl(queueID, IPC_RMID, 0);
  92. }
  93.  
  94. void listenForFight() {
  95.     if (fork()) {
  96.         while (1) {
  97. // Klient 1 - Walka
  98.             struct atak attack;
  99.             int attack_ID = msgget(2001, 0606 | IPC_CREAT);
  100.            
  101.             msgrcv(attack_ID, &attack, 30, 10, 0);
  102.             printf("Gracz 1 - ATAKUJE");
  103.             fflush(stdout);
  104.             int P1_wojsko_lp = attack.lekka_p;
  105.             int P1_wojsko_cp = attack.ciezka_p;
  106.             int P1_wojsko_j = attack.jazda;
  107.  
  108.             memoryMutex.sem_num = 0;
  109.             memoryMutex.sem_flg = 0;
  110.             memoryMutex.sem_op = -1;
  111.             semop(memoryMutexSID, &memoryMutex, 1);
  112.  
  113.             if (P1_wojsko_lp > atoi(C1_LekkaPiechota))         
  114.                 P1_wojsko_lp = atoi(C1_LekkaPiechota);
  115.    
  116.             int stayInBase = atoi(C1_LekkaPiechota) - P1_wojsko_lp;
  117.             char W_Text[10];
  118.             sprintf(W_Text, "%d", stayInBase);
  119.             strcpy(C1_LekkaPiechota, W_Text);
  120.  
  121.  
  122.             if (P1_wojsko_cp > atoi(C1_CiezkaPiechota))    
  123.                 P1_wojsko_cp = atoi(C1_CiezkaPiechota);
  124.            
  125.             stayInBase = atoi(C1_CiezkaPiechota) - P1_wojsko_cp;
  126.             sprintf(W_Text, "%d", stayInBase);
  127.             strcpy(C1_CiezkaPiechota, W_Text);
  128.  
  129.  
  130.             if (P1_wojsko_j > atoi(C1_Jazda))          
  131.                 P1_wojsko_j = atoi(C1_Jazda);
  132.            
  133.             stayInBase = atoi(C1_Jazda) - P1_wojsko_j;
  134.             sprintf(W_Text, "%d", stayInBase);
  135.             strcpy(C1_Jazda, W_Text);
  136.  
  137.             int P2_wojsko_lp = atoi(C2_LekkaPiechota);
  138.             int P2_wojsko_cp = atoi(C2_CiezkaPiechota);
  139.             int P2_wojsko_j = atoi(C2_Jazda);
  140.  
  141.             memoryMutex.sem_num = 0;
  142.             memoryMutex.sem_flg = 0;
  143.             memoryMutex.sem_op = 1;
  144.             semop(memoryMutexSID, &memoryMutex, 1);
  145.  
  146.             int P1_attack = (P1_wojsko_lp * 1) + (P1_wojsko_cp * 1.5) + (P1_wojsko_j * 3.5);  
  147.             int P1_defense = (P1_wojsko_lp * 1.2) + (P1_wojsko_cp * 3) + (P1_wojsko_j * 1.2);
  148.  
  149.             int P2_attack = (P2_wojsko_lp * 1) + (P2_wojsko_cp * 1.5) + (P2_wojsko_j * 3.5);
  150.             int P2_defense = (P2_wojsko_lp * 1.2) + (P2_wojsko_cp * 3) + (P2_wojsko_j * 1.2);
  151.    
  152.             memoryMutex.sem_num = 0;
  153.             memoryMutex.sem_flg = 0;
  154.             memoryMutex.sem_op = -1;
  155.             semop(memoryMutexSID, &memoryMutex, 1);
  156.  
  157.             if (P1_attack > P2_defense) {
  158.                 strcpy(C2_LekkaPiechota, "0");
  159.                 strcpy(C2_CiezkaPiechota, "0");
  160.                 strcpy(C2_Jazda, "0");
  161.                 int P1_Points = atoi(C1_Punkty);
  162.                 P1_Points += 1;
  163.  
  164.                 char P_Text[10];
  165.                 sprintf(P_Text, "%d", P1_Points);
  166.                 strcpy(C1_Punkty, P_Text);
  167.             } else {
  168.                 printf(" %d, %d, %d, %d\n", P2_wojsko_lp, P2_wojsko_cp, P2_wojsko_j, P1_attack/P2_defense);
  169.                 int LP_Straty = (double)((double)P2_wojsko_lp * (double)((double)P1_attack / (double)P2_defense));
  170.                 int CP_Straty = (double)((double)P2_wojsko_cp * (double)((double)P1_attack / (double)P2_defense));
  171.                 int J_Straty = (double)((double)P2_wojsko_j * (double)((double)P1_attack / (double)P2_defense));
  172.                 printf("%d, %d, %d\n", LP_Straty, CP_Straty, J_Straty);
  173.                 fflush(stdout);
  174.    
  175.                 if (P2_wojsko_lp - LP_Straty < 0)
  176.                     P2_wojsko_lp = 0;
  177.                 else
  178.                     P2_wojsko_lp = P2_wojsko_lp - LP_Straty;
  179.  
  180.                 if (P2_wojsko_cp - CP_Straty < 0)
  181.                     P2_wojsko_cp = 0;
  182.                 else
  183.                     P2_wojsko_cp = P2_wojsko_cp - CP_Straty;
  184.  
  185.                 if (P2_wojsko_j - J_Straty < 0)
  186.                     P2_wojsko_j = 0;
  187.                 else
  188.                     P2_wojsko_j = P2_wojsko_j - J_Straty;
  189.  
  190.                 int LP_AfterFight = P2_wojsko_lp;
  191.                 int CP_AfterFight = P2_wojsko_cp;
  192.                 int J_AfterFight = P2_wojsko_j;
  193.  
  194.                 char LPAF_Text[10], CPAF_Text[10], JAF_Text[10];
  195.                 sprintf(LPAF_Text, "%d", LP_AfterFight);
  196.                 sprintf(CPAF_Text, "%d", CP_AfterFight);
  197.                 sprintf(JAF_Text, "%d", J_AfterFight);
  198.  
  199.                 strcpy(C2_LekkaPiechota, LPAF_Text);
  200.                 strcpy(C2_CiezkaPiechota, CPAF_Text);
  201.                 strcpy(C2_Jazda, JAF_Text);
  202.             }
  203.  
  204.             int LP_Straty = (double)((double)P1_wojsko_lp * (double)((double)P2_attack / (double)P1_defense));
  205.             int CP_Straty = (double)((double)P1_wojsko_cp * (double)((double)P2_attack / (double)P1_defense));
  206.             int J_Straty = (double)((double)P1_wojsko_j * (double)((double)P2_attack / (double)P1_defense));
  207.  
  208.             if (P1_wojsko_lp - LP_Straty < 0)
  209.                 P1_wojsko_lp = 0;
  210.             else
  211.                 P1_wojsko_lp = P1_wojsko_lp - LP_Straty;
  212.  
  213.             if (P1_wojsko_cp - CP_Straty < 0)
  214.                 P1_wojsko_cp = 0;
  215.             else
  216.                 P1_wojsko_cp = P1_wojsko_cp - CP_Straty;
  217.  
  218.             if (P1_wojsko_j - J_Straty < 0)
  219.                 P1_wojsko_j = 0;
  220.             else
  221.                 P1_wojsko_j = P1_wojsko_j - J_Straty;
  222.  
  223.             int LP_AfterFight = P1_wojsko_lp + atoi(C1_LekkaPiechota);
  224.             int CP_AfterFight = P1_wojsko_cp + atoi(C1_CiezkaPiechota);
  225.             int J_AfterFight = P1_wojsko_j  + atoi(C1_Jazda);
  226.  
  227.             char LPAF_Text[10], CPAF_Text[10], JAF_Text[10];
  228.             sprintf(LPAF_Text, "%d", LP_AfterFight);
  229.             sprintf(CPAF_Text, "%d", CP_AfterFight);
  230.             sprintf(JAF_Text, "%d", J_AfterFight);
  231.  
  232.             strcpy(C1_LekkaPiechota, LPAF_Text);
  233.             strcpy(C1_CiezkaPiechota, CPAF_Text);
  234.             strcpy(C1_Jazda, JAF_Text);
  235.            
  236.             memoryMutex.sem_num = 0;
  237.             memoryMutex.sem_flg = 0;
  238.             memoryMutex.sem_op = 1;
  239.             semop(memoryMutexSID, &memoryMutex, 1);
  240.         }
  241.     } else {
  242.         while (1) {
  243. // Klient 2 - Walka
  244.             struct atak attack;
  245.             int attack_ID = msgget(2002, 0606 | IPC_CREAT);
  246.            
  247.             msgrcv(attack_ID, &attack, 30, 10, 0);
  248.             printf("Gracz 2 - ATAKUJE");
  249.             fflush(stdout);
  250.         }
  251.     }
  252. }
  253.  
  254. /**
  255.      Nasłuchuje czy klient nie chce rekrutować jednostki
  256. */
  257. void listenForRecruitment() {
  258.  
  259. // Klient 1 - Przychodzące
  260.  
  261.     if (fork()) {
  262.         while (1) {            
  263.  
  264.             struct message recruit;
  265.             struct message informClient;
  266.             int recruit_ID = msgget(2001, 0606 | IPC_CREAT);
  267.             int informClient_ID = msgget(3001, 0606 | IPC_CREAT);
  268.             int sendForward_ID = msgget(6001, 0606 | IPC_CREAT);            // Dodatkowa kolejka do obsługi rekrutacji
  269.  
  270.             msgrcv(recruit_ID, &recruit, 20, -6, 0);
  271.  
  272.             int unitCost;
  273.             int unitsClientBehest;
  274.             int totalCost;
  275.  
  276.             switch (recruit.mtype) {
  277.  
  278.     // Lekka Piechota
  279.                 case 3:
  280.                     unitCost = 100;
  281.                     unitsClientBehest = recruit.value;
  282.                     totalCost = unitCost * unitsClientBehest;
  283.  
  284.                     memoryMutex.sem_num = 0;
  285.                     memoryMutex.sem_flg = 0;
  286.                     memoryMutex.sem_op = -1;
  287.                     semop(memoryMutexSID, &memoryMutex, 1);    
  288.  
  289.                     if (totalCost > atoi(C1_Surowce)) {
  290.                         informClient.mtype = 8;
  291.                         informClient.value = 0;
  292.                         msgsnd(informClient_ID, &informClient, 20, 0);
  293.                     } else {
  294.  
  295.                         int materialsTogether = atoi(C1_Surowce);
  296.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  297.                         char M_Text[10];
  298.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  299.                         strcpy(C1_Surowce, M_Text);
  300.  
  301.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  302.  
  303.                         informClient.mtype = 8;
  304.                         informClient.value = 1;
  305.                         msgsnd(informClient_ID, &informClient, 20, 0);
  306.                     }
  307.  
  308.                     memoryMutex.sem_num = 0;
  309.                     memoryMutex.sem_flg = 0;
  310.                     memoryMutex.sem_op = 1;
  311.                     semop(memoryMutexSID, &memoryMutex, 1);    
  312.                     break;
  313.  
  314.     // Ciężka Piechota
  315.                 case 4:
  316.                     unitCost = 250;
  317.                     unitsClientBehest = recruit.value;
  318.                     totalCost = unitCost * unitsClientBehest;
  319.  
  320.                     memoryMutex.sem_num = 0;
  321.                     memoryMutex.sem_flg = 0;
  322.                     memoryMutex.sem_op = -1;
  323.                     semop(memoryMutexSID, &memoryMutex, 1);    
  324.  
  325.                     if (totalCost > atoi(C1_Surowce)) {
  326.                         informClient.mtype = 8;
  327.                         informClient.value = 0;
  328.                         msgsnd(informClient_ID, &informClient, 20, 0);
  329.                     } else {
  330.  
  331.                         int materialsTogether = atoi(C1_Surowce);
  332.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  333.                         char M_Text[10];
  334.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  335.                         strcpy(C1_Surowce, M_Text);
  336.  
  337.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  338.  
  339.                         informClient.mtype = 8;
  340.                         informClient.value = 1;
  341.                         msgsnd(informClient_ID, &informClient, 20, 0);
  342.                     }
  343.  
  344.                     memoryMutex.sem_num = 0;
  345.                     memoryMutex.sem_flg = 0;
  346.                     memoryMutex.sem_op = 1;
  347.                     semop(memoryMutexSID, &memoryMutex, 1);    
  348.                     break;
  349.    
  350.     // Jazda
  351.                 case 5:
  352.                     unitCost = 550;
  353.                     unitsClientBehest = recruit.value;
  354.                     totalCost = unitCost * unitsClientBehest;
  355.  
  356.                     memoryMutex.sem_num = 0;
  357.                     memoryMutex.sem_flg = 0;
  358.                     memoryMutex.sem_op = -1;
  359.                     semop(memoryMutexSID, &memoryMutex, 1);    
  360.  
  361.                     if (totalCost > atoi(C1_Surowce)) {
  362.                         informClient.mtype = 8;
  363.                         informClient.value = 0;
  364.                         msgsnd(informClient_ID, &informClient, 20, 0);
  365.                     } else {
  366.  
  367.                         int materialsTogether = atoi(C1_Surowce);
  368.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  369.                         char M_Text[10];
  370.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  371.                         strcpy(C1_Surowce, M_Text);
  372.  
  373.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  374.  
  375.                         informClient.mtype = 8;
  376.                         informClient.value = 1;
  377.                         msgsnd(informClient_ID, &informClient, 20, 0);
  378.                     }
  379.  
  380.                     memoryMutex.sem_num = 0;
  381.                     memoryMutex.sem_flg = 0;
  382.                     memoryMutex.sem_op = 1;
  383.                     semop(memoryMutexSID, &memoryMutex, 1);    
  384.                     break;
  385.            
  386.     // Robotnicy
  387.                 case 6:
  388.                     unitCost = 100;
  389.                     unitsClientBehest = recruit.value;
  390.                     totalCost = unitCost * unitsClientBehest;
  391.  
  392.                     memoryMutex.sem_num = 0;
  393.                     memoryMutex.sem_flg = 0;
  394.                     memoryMutex.sem_op = -1;
  395.                     semop(memoryMutexSID, &memoryMutex, 1);    
  396.  
  397.                     if (totalCost > atoi(C1_Surowce)) {
  398.                         informClient.mtype = 8;
  399.                         informClient.value = 0;
  400.                         msgsnd(informClient_ID, &informClient, 20, 0);
  401.                     } else {
  402.  
  403.                         int materialsTogether = atoi(C1_Surowce);
  404.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  405.                         char M_Text[10];
  406.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  407.                         strcpy(C1_Surowce, M_Text);
  408.  
  409.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  410.  
  411.                         informClient.mtype = 8;
  412.                         informClient.value = 1;
  413.                         msgsnd(informClient_ID, &informClient, 20, 0);
  414.                     }
  415.  
  416.                     memoryMutex.sem_num = 0;
  417.                     memoryMutex.sem_flg = 0;
  418.                     memoryMutex.sem_op = 1;
  419.                     semop(memoryMutexSID, &memoryMutex, 1);    
  420.                     break;
  421.             }      
  422.         }
  423. // Klienta 2 - Przychodzące
  424.  
  425.     } else if (fork()) {
  426.         while (1) {
  427.  
  428.             struct message recruit;
  429.             struct message informClient;
  430.             int recruit_ID = msgget(2002, 0606 | IPC_CREAT);
  431.             int sendForward_ID = msgget(6002, 0606 | IPC_CREAT);            // Dodatkowa kolejka do obsługi rekrutacji
  432.             int informClient_ID = msgget(3002, 0606 | IPC_CREAT);
  433.  
  434.             msgrcv(recruit_ID, &recruit, 20, -6, 0);
  435.  
  436.             int unitCost;
  437.             int unitsClientBehest;
  438.             int totalCost;
  439.  
  440.             switch (recruit.mtype) {
  441.  
  442.     // Lekka Piechota
  443.                 case 3:
  444.                     unitCost = 100;
  445.                     unitsClientBehest = recruit.value;
  446.                     totalCost = unitCost * unitsClientBehest;
  447.  
  448.                     memoryMutex.sem_num = 0;
  449.                     memoryMutex.sem_flg = 0;
  450.                     memoryMutex.sem_op = -1;
  451.                     semop(memoryMutexSID, &memoryMutex, 1);    
  452.  
  453.                     if (totalCost > atoi(C2_Surowce)) {
  454.                         informClient.mtype = 8;
  455.                         informClient.value = 0;
  456.                         msgsnd(informClient_ID, &informClient, 20, 0);
  457.                     } else {
  458.  
  459.                         int materialsTogether = atoi(C2_Surowce);
  460.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  461.                         char M_Text[10];
  462.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  463.                         strcpy(C2_Surowce, M_Text);
  464.  
  465.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  466.  
  467.                         informClient.mtype = 8;
  468.                         informClient.value = 1;
  469.                         msgsnd(informClient_ID, &informClient, 20, 0);
  470.                     }
  471.  
  472.                     memoryMutex.sem_num = 0;
  473.                     memoryMutex.sem_flg = 0;
  474.                     memoryMutex.sem_op = 1;
  475.                     semop(memoryMutexSID, &memoryMutex, 1);    
  476.                     break;
  477.  
  478.     // Ciężka Piechota
  479.                 case 4:
  480.                     unitCost = 250;
  481.                     unitsClientBehest = recruit.value;
  482.                     totalCost = unitCost * unitsClientBehest;
  483.  
  484.                     memoryMutex.sem_num = 0;
  485.                     memoryMutex.sem_flg = 0;
  486.                     memoryMutex.sem_op = -1;
  487.                     semop(memoryMutexSID, &memoryMutex, 1);    
  488.  
  489.                     if (totalCost > atoi(C2_Surowce)) {
  490.                         informClient.mtype = 8;
  491.                         informClient.value = 0;
  492.                         msgsnd(informClient_ID, &informClient, 20, 0);
  493.                     } else {
  494.  
  495.                         int materialsTogether = atoi(C2_Surowce);
  496.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  497.                         char M_Text[10];
  498.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  499.                         strcpy(C2_Surowce, M_Text);
  500.  
  501.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  502.  
  503.                         informClient.mtype = 8;
  504.                         informClient.value = 1;
  505.                         msgsnd(informClient_ID, &informClient, 20, 0);
  506.                     }
  507.  
  508.                     memoryMutex.sem_num = 0;
  509.                     memoryMutex.sem_flg = 0;
  510.                     memoryMutex.sem_op = 1;
  511.                     semop(memoryMutexSID, &memoryMutex, 1);    
  512.                     break;
  513.    
  514.     // Jazda
  515.                 case 5:
  516.                     unitCost = 550;
  517.                     unitsClientBehest = recruit.value;
  518.                   totalCost = unitCost * unitsClientBehest;
  519.  
  520.                     memoryMutex.sem_num = 0;
  521.                     memoryMutex.sem_flg = 0;
  522.                     memoryMutex.sem_op = -1;
  523.                     semop(memoryMutexSID, &memoryMutex, 1);    
  524.  
  525.                     if (totalCost > atoi(C2_Surowce)) {
  526.                         informClient.mtype = 8;
  527.                         informClient.value = 0;
  528.                         msgsnd(informClient_ID, &informClient, 20, 0);
  529.                     } else {
  530.  
  531.                         int materialsTogether = atoi(C2_Surowce);
  532.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  533.                         char M_Text[10];
  534.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  535.                         strcpy(C2_Surowce, M_Text);
  536.  
  537.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  538.  
  539.                         informClient.mtype = 8;
  540.                         informClient.value = 1;
  541.                         msgsnd(informClient_ID, &informClient, 20, 0);
  542.                     }
  543.  
  544.                     memoryMutex.sem_num = 0;
  545.                     memoryMutex.sem_flg = 0;
  546.                     memoryMutex.sem_op = 1;
  547.                     semop(memoryMutexSID, &memoryMutex, 1);    
  548.                     break;
  549.            
  550.     // Robotnicy
  551.                 case 6:
  552.                     unitCost = 100;
  553.                     unitsClientBehest = recruit.value;
  554.                   totalCost = unitCost * unitsClientBehest;
  555.  
  556.                     memoryMutex.sem_num = 0;
  557.                     memoryMutex.sem_flg = 0;
  558.                     memoryMutex.sem_op = -1;
  559.                     semop(memoryMutexSID, &memoryMutex, 1);    
  560.  
  561.                     if (totalCost > atoi(C2_Surowce)) {
  562.                         informClient.mtype = 8;
  563.                         informClient.value = 0;
  564.                         msgsnd(informClient_ID, &informClient, 20, 0);
  565.                     } else {
  566.  
  567.                         int materialsTogether = atoi(C2_Surowce);
  568.                         int materialsAfterRecruitment = materialsTogether - totalCost;         
  569.                         char M_Text[10];
  570.                         sprintf(M_Text, "%d", materialsAfterRecruitment);
  571.                         strcpy(C2_Surowce, M_Text);
  572.  
  573.                         msgsnd(sendForward_ID, &recruit, 20, 0);
  574.  
  575.                         informClient.mtype = 8;
  576.                         informClient.value = 1;
  577.                         msgsnd(informClient_ID, &informClient, 20, 0);
  578.                     }
  579.  
  580.                     memoryMutex.sem_num = 0;
  581.                     memoryMutex.sem_flg = 0;
  582.                     memoryMutex.sem_op = 1;
  583.                     semop(memoryMutexSID, &memoryMutex, 1);    
  584.                     break;
  585.             }      
  586.         }
  587. // REKRUTACJA GRACZ 1
  588.     } else if (fork()) {
  589.         while (1) {
  590.  
  591.             struct message recruit;
  592.             int recruit_ID = msgget(6001, 0606 | IPC_CREAT);
  593.    
  594.             msgrcv(recruit_ID, &recruit, 20, -6, 0);
  595.  
  596.             int unitProductionTime;
  597.             int i;
  598.  
  599.             c1Recruiting.sem_num = 0;
  600.             c1Recruiting.sem_flg = 0;
  601.             c1Recruiting.sem_op = -1;
  602.             semop(c1RecruitingSID, &c1Recruiting, 1);  
  603.  
  604.             switch (recruit.mtype) {
  605.  
  606.     // Lekka piechota - rekrutacja
  607.                 case 3:    
  608.                                        
  609.                     unitProductionTime = 2;
  610.                     for(i = 0; i < recruit.value; i++) {
  611.                         sleep(unitProductionTime);
  612.  
  613.                         memoryMutex.sem_num = 0;
  614.                         memoryMutex.sem_flg = 0;
  615.                         memoryMutex.sem_op = -1;
  616.                         semop(memoryMutexSID, &memoryMutex, 1);
  617.  
  618.                         int afterRecruitment = atoi(C1_LekkaPiechota) + 1;
  619.                         char AR_Text[10];
  620.                         sprintf(AR_Text, "%d", afterRecruitment);
  621.                         strcpy(C1_LekkaPiechota, AR_Text);
  622.  
  623.                         memoryMutex.sem_num = 0;
  624.                         memoryMutex.sem_flg = 0;
  625.                         memoryMutex.sem_op = 1;
  626.                         semop(memoryMutexSID, &memoryMutex, 1);
  627.                     }
  628.                     break;
  629.  
  630.     // Ciezka piechota - rekrutacja
  631.                 case 4:
  632.  
  633.                     unitProductionTime = 3;
  634.                     for(i = 0; i < recruit.value; i++) {
  635.                         sleep(unitProductionTime);
  636.  
  637.                         memoryMutex.sem_num = 0;
  638.                         memoryMutex.sem_flg = 0;
  639.                         memoryMutex.sem_op = -1;
  640.                         semop(memoryMutexSID, &memoryMutex, 1);
  641.  
  642.                         int afterRecruitment = atoi(C1_CiezkaPiechota) + 1;
  643.                         char AR_Text[10];
  644.                         sprintf(AR_Text, "%d", afterRecruitment);
  645.                         strcpy(C1_CiezkaPiechota, AR_Text);
  646.  
  647.                         memoryMutex.sem_num = 0;
  648.                         memoryMutex.sem_flg = 0;
  649.                         memoryMutex.sem_op = 1;
  650.                         semop(memoryMutexSID, &memoryMutex, 1);
  651.                     }
  652.                     break;
  653.  
  654.     // Jazda - rekrutacja
  655.                 case 5:
  656.  
  657.                     unitProductionTime = 5;
  658.                     for(i = 0; i < recruit.value; i++) {
  659.                         sleep(unitProductionTime);
  660.  
  661.                         memoryMutex.sem_num = 0;
  662.                         memoryMutex.sem_flg = 0;
  663.                         memoryMutex.sem_op = -1;
  664.                         semop(memoryMutexSID, &memoryMutex, 1);
  665.  
  666.                         int afterRecruitment = atoi(C1_Jazda) + 1;
  667.                         char AR_Text[10];
  668.                         sprintf(AR_Text, "%d", afterRecruitment);
  669.                         strcpy(C1_Jazda, AR_Text);
  670.  
  671.                         memoryMutex.sem_num = 0;
  672.                         memoryMutex.sem_flg = 0;
  673.                         memoryMutex.sem_op = 1;
  674.                         semop(memoryMutexSID, &memoryMutex, 1);
  675.                     }
  676.                     break;
  677.  
  678.     // Robotnicy - rekrutacja
  679.                 case 6:
  680.  
  681.                     unitProductionTime = 2;
  682.                     for(i = 0; i < recruit.value; i++) {
  683.                         sleep(unitProductionTime);
  684.  
  685.                         memoryMutex.sem_num = 0;
  686.                         memoryMutex.sem_flg = 0;
  687.                         memoryMutex.sem_op = -1;
  688.                         semop(memoryMutexSID, &memoryMutex, 1);
  689.  
  690.                         int afterRecruitment = atoi(C1_Robotnicy) + 1;
  691.                         char AR_Text[10];
  692.                         sprintf(AR_Text, "%d", afterRecruitment);
  693.                         strcpy(C1_Robotnicy, AR_Text);
  694.  
  695.                         memoryMutex.sem_num = 0;
  696.                         memoryMutex.sem_flg = 0;
  697.                         memoryMutex.sem_op = 1;
  698.                         semop(memoryMutexSID, &memoryMutex, 1);
  699.                     }
  700.                     break;
  701.             }
  702.  
  703.             c1Recruiting.sem_num = 0;
  704.             c1Recruiting.sem_flg = 0;
  705.             c1Recruiting.sem_op = 1;
  706.             semop(c1RecruitingSID, &c1Recruiting, 1);  
  707.         }
  708. // REKRUTACJA GRACZ 2
  709.     } else {
  710.         while (1) {
  711.        
  712.             struct message recruit;
  713.             int recruit_ID = msgget(6002, 0606 | IPC_CREAT);
  714.    
  715.             msgrcv(recruit_ID, &recruit, 20, -6, 0);
  716.  
  717.             c2Recruiting.sem_num = 0;
  718.             c2Recruiting.sem_flg = 0;
  719.             c2Recruiting.sem_op = -1;
  720.             semop(c2RecruitingSID, &c2Recruiting, 1);  
  721.  
  722.             int unitCost;
  723.             int unitProductionTime;
  724.             int unitsClientBehest ;
  725.             int totalCost;
  726.             int i;
  727.  
  728.             switch (recruit.mtype) {
  729.  
  730.     // Lekka piechota - rekrutacja
  731.                 case 3:    
  732.                                        
  733.                     unitProductionTime = 2;
  734.                     for(i = 0; i < recruit.value; i++) {
  735.                         sleep(unitProductionTime);
  736.  
  737.                         memoryMutex.sem_num = 0;
  738.                         memoryMutex.sem_flg = 0;
  739.                         memoryMutex.sem_op = -1;
  740.                         semop(memoryMutexSID, &memoryMutex, 1);
  741.  
  742.                         int afterRecruitment = atoi(C2_LekkaPiechota) + 1;
  743.                         char AR_Text[10];
  744.                         sprintf(AR_Text, "%d", afterRecruitment);
  745.                         strcpy(C2_LekkaPiechota, AR_Text);
  746.  
  747.                         memoryMutex.sem_num = 0;
  748.                         memoryMutex.sem_flg = 0;
  749.                         memoryMutex.sem_op = 1;
  750.                         semop(memoryMutexSID, &memoryMutex, 1);
  751.                     }
  752.                     break;
  753.  
  754.     // Ciezka piechota - rekrutacja
  755.                 case 4:
  756.  
  757.                     unitProductionTime = 3;
  758.                     for(i = 0; i < recruit.value; i++) {
  759.                         sleep(unitProductionTime);
  760.  
  761.                         memoryMutex.sem_num = 0;
  762.                         memoryMutex.sem_flg = 0;
  763.                         memoryMutex.sem_op = -1;
  764.                         semop(memoryMutexSID, &memoryMutex, 1);
  765.  
  766.                         int afterRecruitment = atoi(C2_CiezkaPiechota) + 1;
  767.                         char AR_Text[10];
  768.                         sprintf(AR_Text, "%d", afterRecruitment);
  769.                         strcpy(C2_CiezkaPiechota, AR_Text);
  770.  
  771.                         memoryMutex.sem_num = 0;
  772.                         memoryMutex.sem_flg = 0;
  773.                         memoryMutex.sem_op = 1;
  774.                         semop(memoryMutexSID, &memoryMutex, 1);
  775.                     }
  776.                     break;
  777.  
  778.     // Jazda - rekrutacja
  779.                 case 5:
  780.  
  781.                     unitProductionTime = 5;
  782.                     for(i = 0; i < recruit.value; i++) {
  783.                         sleep(unitProductionTime);
  784.  
  785.                         memoryMutex.sem_num = 0;
  786.                         memoryMutex.sem_flg = 0;
  787.                         memoryMutex.sem_op = -1;
  788.                         semop(memoryMutexSID, &memoryMutex, 1);
  789.  
  790.                         int afterRecruitment = atoi(C2_Jazda) + 1;
  791.                         char AR_Text[10];
  792.                         sprintf(AR_Text, "%d", afterRecruitment);
  793.                         strcpy(C2_Jazda, AR_Text);
  794.  
  795.                         memoryMutex.sem_num = 0;
  796.                         memoryMutex.sem_flg = 0;
  797.                         memoryMutex.sem_op = 1;
  798.                         semop(memoryMutexSID, &memoryMutex, 1);
  799.                     }
  800.                     break;
  801.  
  802.     // Robotnicy - rekrutacja
  803.                 case 6:
  804.  
  805.                     unitProductionTime = 2;
  806.                     for(i = 0; i < recruit.value; i++) {
  807.                         sleep(unitProductionTime);
  808.  
  809.                         memoryMutex.sem_num = 0;
  810.                         memoryMutex.sem_flg = 0;
  811.                         memoryMutex.sem_op = -1;
  812.                         semop(memoryMutexSID, &memoryMutex, 1);
  813.  
  814.                         int afterRecruitment = atoi(C2_Robotnicy) + 1;
  815.                         char AR_Text[10];
  816.                         sprintf(AR_Text, "%d", afterRecruitment);
  817.                         strcpy(C2_Robotnicy, AR_Text);
  818.  
  819.                         memoryMutex.sem_num = 0;
  820.                         memoryMutex.sem_flg = 0;
  821.                         memoryMutex.sem_op = 1;
  822.                         semop(memoryMutexSID, &memoryMutex, 1);
  823.                     }
  824.                     break;
  825.             }
  826.             c2Recruiting.sem_num = 0;
  827.             c2Recruiting.sem_flg = 0;
  828.             c2Recruiting.sem_op = 1;
  829.             semop(c2RecruitingSID, &c2Recruiting, 1);  
  830.         }
  831.     }
  832. }
  833.  
  834. /**
  835.      Zwiększa co jedną sekundę ilość posiadanych surowców
  836. */
  837. void increaseMaterials() {
  838.     while (1) {
  839.         int materialsIncome = 50 + ( 5 * atoi(C1_Robotnicy) );
  840.         int materialsOverall = atoi(C1_Surowce);
  841.         int materialsAfterIncrease = materialsOverall + materialsIncome;
  842.  
  843.         char MAI_Text[10];
  844.         sprintf(MAI_Text, "%d", materialsAfterIncrease);
  845.  
  846.         memoryMutex.sem_num = 0;
  847.         memoryMutex.sem_flg = 0;
  848.         memoryMutex.sem_op = 1;
  849.         semop(memoryMutexSID, &memoryMutex, -1);   
  850.  
  851.         strcpy(C1_Surowce, MAI_Text);
  852.                        
  853.         memoryMutex.sem_num = 0;
  854.         memoryMutex.sem_flg = 0;
  855.         memoryMutex.sem_op = 1;
  856.         semop(memoryMutexSID, &memoryMutex, 1);
  857.  
  858.         materialsIncome = 50 + ( 5 * atoi(C2_Robotnicy) );
  859.         materialsOverall = atoi(C2_Surowce);
  860.         materialsAfterIncrease = materialsOverall + materialsIncome;
  861.  
  862.         MAI_Text[10];
  863.         sprintf(MAI_Text, "%d", materialsAfterIncrease);
  864.  
  865.         memoryMutex.sem_num = 0;
  866.         memoryMutex.sem_flg = 0;
  867.         memoryMutex.sem_op = 1;
  868.         semop(memoryMutexSID, &memoryMutex, -1);   
  869.  
  870.         strcpy(C2_Surowce, MAI_Text);
  871.  
  872.         memoryMutex.sem_num = 0;
  873.         memoryMutex.sem_flg = 0;
  874.         memoryMutex.sem_op = 1;
  875.         semop(memoryMutexSID, &memoryMutex, 1);
  876.  
  877.  
  878.         sleep(1);
  879.     }
  880. }
  881.  
  882.  
  883. /**
  884.      Wysyła do klienta informacje o stanie jego wojsk i surowców co 200 ms
  885. */
  886. void clientStatus() {
  887.     while (1) {
  888.    
  889.         memoryMutex.sem_num = 0;
  890.         memoryMutex.sem_flg = 0;
  891.         memoryMutex.sem_op = -1;
  892.         semop(memoryMutexSID, &memoryMutex, 1);    
  893.  
  894.         struct clientStatus cS;
  895.         int cS_ID = msgget(3001, 0606 | IPC_CREAT);
  896.         cS.mtype = 1;
  897.         cS.surowce = atoi(C1_Surowce);
  898.         cS.lekka_piechota = atoi(C1_LekkaPiechota);
  899.         cS.ciezka_piechota = atoi(C1_CiezkaPiechota);
  900.         cS.jazda = atoi(C1_Jazda);
  901.         cS.robotnicy = atoi(C1_Robotnicy);
  902.         cS.punkty = atoi(C1_Punkty);
  903.  
  904.         msgsnd(cS_ID, &cS, 50, 0); 
  905.  
  906.         cS_ID = msgget(3002, 0606 | IPC_CREAT);
  907.         cS.mtype = 1;
  908.         cS.surowce = atoi(C2_Surowce);
  909.         cS.lekka_piechota = atoi(C2_LekkaPiechota);
  910.         cS.ciezka_piechota = atoi(C2_CiezkaPiechota);
  911.         cS.jazda = atoi(C2_Jazda);
  912.         cS.robotnicy = atoi(C2_Robotnicy);
  913.         cS.punkty = atoi(C2_Punkty);
  914.         msgsnd(cS_ID, &cS, 50, 0); 
  915.  
  916.         memoryMutex.sem_num = 0;
  917.         memoryMutex.sem_flg = 0;
  918.         memoryMutex.sem_op = 1;
  919.         semop(memoryMutexSID, &memoryMutex, 1);    
  920.  
  921.         usleep(200 * 1000);
  922.  
  923.     }
  924. }
  925.  
  926.  
  927. /**
  928.      Przygotowuje serwer do pracy
  929. */
  930. void prepareServer() {
  931. // SEMAFORY
  932.     clientReadySID = semget(7001, 1, 0600 | IPC_CREAT);
  933.     serverReadySID = semget(7002, 1, 0600 | IPC_CREAT);
  934.     memoryMutexSID = semget(8000, 1, 0600 | IPC_CREAT);
  935.     c1RecruitingSID = semget(8001, 1, 0600 | IPC_CREAT);
  936.     c2RecruitingSID = semget(8002, 1, 0600 | IPC_CREAT);
  937.  
  938.     if(clientReadySID == -1 || serverReadySID == -1 || memoryMutexSID == -1 || c1RecruitingSID == -1 || c2RecruitingSID == -1) {
  939.         exit(1);
  940.     }
  941.  
  942.     semctl(clientReadySID, 0, SETVAL, 0);
  943.     semctl(serverReadySID, 0, SETVAL, 0);
  944.     semctl(memoryMutexSID, 0, SETVAL, 1);
  945.     semctl(c1RecruitingSID, 0, SETVAL, 1);
  946.     semctl(c2RecruitingSID, 0, SETVAL, 1);
  947.  
  948. // KOLEJKI
  949.     pC_ID = msgget(1000, 0606 | IPC_CREAT);
  950.  
  951. // PAMIEC
  952.     C1_LekkaPiechotaAdr = shmget(401, 20, 0606 | IPC_CREAT);
  953.     C1_CiezkaPiechotaAdr = shmget(402, 20, 0606 | IPC_CREAT);
  954.     C1_JazdaAdr = shmget(403, 20, 0606 | IPC_CREAT);
  955.     C1_RobotnicyAdr = shmget(404, 20, 0606 | IPC_CREAT);
  956.     C1_SurowceAdr = shmget(405, 20, 0606 | IPC_CREAT);
  957.     C1_PunktyAdr = shmget(406, 20, 0606 | IPC_CREAT);
  958.  
  959.     C2_LekkaPiechotaAdr = shmget(501, 20, 0606 | IPC_CREAT);
  960.     C2_CiezkaPiechotaAdr = shmget(502, 20, 0606 | IPC_CREAT);
  961.     C2_JazdaAdr = shmget(503, 20, 0606 | IPC_CREAT);
  962.     C2_RobotnicyAdr = shmget(504, 20, 0606 | IPC_CREAT);
  963.     C2_SurowceAdr = shmget(505, 20, 0606 | IPC_CREAT);
  964.     C2_PunktyAdr = shmget(506, 20, 0606 | IPC_CREAT);
  965.  
  966.  
  967.     C1_LekkaPiechota = (char*)shmat(C1_LekkaPiechotaAdr, NULL, 0);
  968.     C1_CiezkaPiechota = (char*)shmat(C1_CiezkaPiechotaAdr, NULL, 0);
  969.     C1_Jazda = (char*)shmat(C1_JazdaAdr, NULL, 0);
  970.     C1_Robotnicy = (char*)shmat(C1_RobotnicyAdr, NULL, 0);
  971.     C1_Surowce = (char*)shmat(C1_SurowceAdr, NULL, 0);
  972.     C1_Punkty = (char*)shmat(C1_PunktyAdr, NULL, 0);
  973.  
  974.     C2_LekkaPiechota = (char*)shmat(C2_LekkaPiechotaAdr, NULL, 0);
  975.     C2_CiezkaPiechota = (char*)shmat(C2_CiezkaPiechotaAdr, NULL, 0);
  976.     C2_Jazda = (char*)shmat(C2_JazdaAdr, NULL, 0);
  977.     C2_Robotnicy = (char*)shmat(C2_RobotnicyAdr, NULL, 0);
  978.     C2_Surowce = (char*)shmat(C2_SurowceAdr, NULL, 0);
  979.     C2_Punkty = (char*)shmat(C2_PunktyAdr, NULL, 0);
  980.  
  981.  
  982.     strcpy(C1_LekkaPiechota, "0");
  983.     strcpy(C1_CiezkaPiechota, "0");
  984.     strcpy(C1_Jazda, "0");
  985.     strcpy(C1_Robotnicy, "0");
  986.     strcpy(C1_Surowce, "300");
  987.     strcpy(C1_Punkty, "0");
  988.  
  989.  
  990.     strcpy(C2_LekkaPiechota, "0");
  991.     strcpy(C2_CiezkaPiechota, "0");
  992.     strcpy(C2_Jazda, "0");
  993.     strcpy(C2_Robotnicy, "0");
  994.     strcpy(C2_Surowce, "300");
  995.     strcpy(C2_Punkty, "0");
  996. }
  997.  
  998.  
  999. int main() {
  1000.     #define client1_server 2001
  1001.     #define client2_server 2002
  1002.     #define server_client1 3001
  1003.     #define server_client2 3002
  1004.  
  1005.     prepareServer();
  1006.  
  1007.     clientReady.sem_num = 0;
  1008.     clientReady.sem_flg = 0;
  1009.     clientReady.sem_op = -1;
  1010.  
  1011.     semop(clientReadySID, &clientReady, 1);     // POŁĄCZENIE PIERWSZEGO KLIENTA
  1012.     pC.mtype = 1;
  1013.     pC.CSQueueNumber = client1_server;
  1014.     pC.SCQueueNumber = server_client1;
  1015.     msgsnd(pC_ID, &pC, 10, 0);
  1016.  
  1017.     semop(clientReadySID, &clientReady, 1);     // POŁĄCZENIE DRUGIEGO KLIENTA
  1018.     pC.CSQueueNumber = client2_server;
  1019.     pC.SCQueueNumber = server_client2;
  1020.     msgsnd(pC_ID, &pC, 10, 0);
  1021.  
  1022.     serverReady.sem_num = 0;
  1023.     serverReady.sem_flg = 0;
  1024.     serverReady.sem_op = 2;
  1025.     semop(serverReadySID, &serverReady, 1);
  1026.  
  1027.     semctl(clientReadySID, 0, SETVAL, 0);
  1028.  
  1029.     if (fork())
  1030.         clientStatus();
  1031.     else if (fork())
  1032.         increaseMaterials();
  1033.     else if (fork())
  1034.         listenForRecruitment();
  1035.     else if (fork())
  1036.         listenForFight();
  1037.     else {
  1038.         clientReady.sem_op = -2;
  1039.         semop(clientReadySID, &clientReady, 1);
  1040.         removeMQueues();
  1041.         kill(0, SIGKILL);
  1042.     }
  1043.  
  1044. }
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!