API tools faq
paste
Advertisement
Guest User

klient

a guest
Apr 24th, 2019
108
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.11 KB | None | 0 0
raw download clone embed print report
  1. /****************************************************
  2.     Virtual Collaborative Teams - The base program
  3.     The main module
  4.     ****************************************************/
  5.  
  6. #include <windows.h>
  7. #include <math.h>
  8. #include <time.h>
  9. #include <vector>
  10. #include <iostream>
  11. #include <gl\gl.h>
  12. #include <gl\glu.h>
  13. #include <iterator>
  14. #include <map>
  15.  
  16. #include "objects.h"
  17. #include "graphics.h"
  18. #include "net.h"
  19. using namespace std;
  20.  
  21. FILE *f = fopen("vct_log.txt", "w"); // plik do zapisu informacji testowych
  22.  
  23.  
  24. MovableObject *my_car;               // obiekt przypisany do tej aplikacji
  25. Environment env;
  26.  
  27. map<int, MovableObject*> other_cars;
  28.  
  29. float avg_cycle_time;                // sredni czas pomiedzy dwoma kolejnymi cyklami symulacji i wyswietlania
  30. long time_of_cycle, number_of_cyc;   // zmienne pomocnicze potrzebne do obliczania avg_cycle_time
  31. long time_start = clock();
  32.  
  33. unicast_net *uni_reciv;          // wsk do obiektu zajmujacego sie odbiorem komunikatow
  34. unicast_net *uni_send;           //   -||-  wysylaniem komunikatow
  35.  
  36. HANDLE threadReciv;                  // uchwyt wątku odbioru komunikatów
  37. HANDLE serverStuff;
  38. HWND main_window;                    // uchwyt do głównego okna programu
  39. CRITICAL_SECTION m_cs;               // do synchronizacji wątków
  40.  
  41. bool if_SHIFT_pressed = false;
  42. bool if_ID_visible = true;           // czy rysowac nr ID przy każdym obiekcie
  43. bool if_mouse_control = false;       // sterowanie za pomocą klawisza myszki
  44. int mouse_cursor_x = 0, mouse_cursor_y = 0;     // położenie kursora myszy
  45.  
  46. extern ViewParams viewpar;           // ustawienia widoku zdefiniowane w grafice
  47.  
  48. long duration_of_day = 800;         // czas trwania dnia w [s]
  49.  
  50. unsigned long ipAdress; // IP SERWERA
  51. char* serverIp = "192.168.123.20";
  52. bool changeServ = false;
  53. bool iAmServer = false;
  54.  
  55. struct Frame                                      // główna struktura służąca do przesyłania informacji
  56. {
  57.     int iID;                                      // identyfikator obiektu, którego
  58.     int type;                                     // typ ramki: informacja o stateie, informacja o zamknięciu, komunikat tekstowy, ...
  59.     ObjectState state;                            // położenie, prędkość: środka masy + kątowe, ...
  60.  
  61.     long sending_time;                            // tzw. znacznik czasu potrzebny np. do obliczenia opóźnienia
  62.     int iID_receiver;                             // nr ID odbiorcy wiadomości, jeśli skierowana jest tylko do niego
  63.     char* ip;
  64. };
  65.  
  66. //// parametry serwera
  67. char* serwerIP;
  68. bool newserwer = false;
  69.  
  70. struct Klient {
  71.     unsigned long ipAdress;
  72.     bool active;
  73.     int packet_last;
  74.  
  75.     Klient(unsigned long ip, int p, bool act, int pack)
  76.     {
  77.         ipAdress = ip;
  78.         active = act;
  79.         packet_last = pack;
  80.     }
  81. };
  82. ////
  83.  
  84. //******************************************
  85. // Funkcja obsługi wątku odbioru komunikatów
  86. // UWAGA!  Odbierane są też komunikaty z własnej aplikacji by porównać obraz ekstrapolowany do rzeczywistego.
  87. DWORD WINAPI ReceiveThreadFun(void *ptr)
  88. {
  89.     unicast_net *pmt_net = (unicast_net*)ptr;  // wskaźnik do obiektu klasy unicast_net
  90.     Frame frame;
  91.  
  92.     std::vector<Klient> clients;
  93.     unicast_net *uni_recivS;          // wsk do obiektu zajmujacego sie odbiorem komunikatow
  94.     unicast_net *uni_sendS;
  95.  
  96.     uni_recivS = new unicast_net(10006);      // obiekt do odbioru ramek sieciowych
  97.     uni_sendS = new unicast_net(10005);
  98.  
  99.     while (1)
  100.     {
  101.         int frame_size = pmt_net->reciv((char*)&frame, &ipAdress, sizeof(Frame));   // oczekiwanie na nadejście ramki
  102.         ObjectState state = frame.state;
  103.  
  104.         //fprintf(f, "odebrano stan iID = %d, ID dla mojego obiektu = %d\n", frame.iID, my_car->iID);
  105.         if (frame.type == 500) //czy to ramka zmiana serwera
  106.         {
  107.             if (changeServ)
  108.             {
  109.                 iAmServer = true;
  110.             }
  111.  
  112.             serverIp = frame.ip;
  113.         }
  114.  
  115.         // Lock the Critical section
  116.         EnterCriticalSection(&m_cs);               // wejście na ścieżkę krytyczną - by inne wątki (np. główny) nie współdzielił
  117.                                                    // tablicy other_cars
  118.         if (frame.iID != my_car->iID)          // jeśli to nie mój własny obiekt
  119.         {
  120.  
  121.             if (other_cars[frame.iID] == NULL)        // nie ma jeszcze takiego obiektu w tablicy -> trzeba go
  122.                 // stworzyć
  123.             {
  124.                 MovableObject *ob = new MovableObject();
  125.                 ob->iID = frame.iID;
  126.                 other_cars[frame.iID] = ob;
  127.                 //fprintf(f, "zarejestrowano %d obcy obiekt o ID = %d\n", iLiczbaCudzychOb - 1, CudzeObiekty[iLiczbaCudzychOb]->iID);
  128.             }
  129.             other_cars[frame.iID]->ChangeState(state);   // aktualizacja stateu obiektu obcego  
  130.  
  131.             if (frame.type == 0) //ramka usun klienta
  132.             {
  133.                 other_cars.erase(frame.iID);
  134.             }
  135.         }
  136.         //Release the Critical section
  137.         LeaveCriticalSection(&m_cs);               // wyjście ze ścieżki krytycznej
  138.  
  139.         if (iAmServer) {
  140.             bool registered = false;
  141.             struct sockaddr_in dest;
  142.  
  143.             dest.sin_addr.S_un.S_addr = ipAdress;
  144.             printf("Package received from %s \n", inet_ntoa(dest.sin_addr));
  145.  
  146.             for (auto &klient : clients)
  147.             {
  148.                 if (klient.ipAdress == ipAdress)
  149.                 {
  150.                     registered = true;
  151.                 }
  152.             }
  153.  
  154.             if (!registered)
  155.             {
  156.                 bool isactive = true;
  157.  
  158.                 if (frame.type == 0)
  159.                 {
  160.                     isactive = false;
  161.                 }
  162.  
  163.                 clients.emplace_back(ipAdress, 10006, isactive, 30);
  164.                 printf("Client %s created \n", inet_ntoa(dest.sin_addr));
  165.             }
  166.  
  167.             if (frame.type == 505)
  168.             {
  169.                 Frame f;
  170.                 f.type = 500; //zmiana serwera
  171.                 f.ip = inet_ntoa(dest.sin_addr);
  172.                 serwerIP = f.ip;
  173.                 //zmien serwer i rozeslj do wszystkich info kto jest serwerem
  174.                 for (auto klient : clients)
  175.                 {
  176.                     uni_send->send((char *)&f, klient.ipAdress, sizeof(Frame));
  177.                 }
  178.  
  179.                 iAmServer = false;
  180.             }
  181.  
  182.             for (int i = 0; i < clients.size(); i++)
  183.             {
  184.                 Klient klient = clients[i];
  185.  
  186.                 if (klient.ipAdress == ipAdress)
  187.                 {
  188.                     if (frame.type == 0)
  189.                     {
  190.                         klient.active = false;
  191.                     }
  192.                     else
  193.                     {
  194.                         klient.active = true;
  195.                         klient.packet_last = 30;
  196.                     }
  197.                 }
  198.                 else
  199.                 {
  200.                     klient.packet_last--;
  201.                 }
  202.  
  203.                 if (klient.packet_last < 1)
  204.                 {
  205.                     klient.active = false;
  206.                 }
  207.  
  208.                 dest.sin_addr.S_un.S_addr = klient.ipAdress;
  209.                 if (klient.active)
  210.                 {
  211.                     uni_send->send((char *)&frame, klient.ipAdress, sizeof(Frame));
  212.                     printf("%s is active \n", inet_ntoa(dest.sin_addr));
  213.                 }
  214.                 else
  215.                 {
  216.                     printf("%s is inactive \n", inet_ntoa(dest.sin_addr));
  217.                     clients.erase(clients.begin() + i);
  218.                 }
  219.             }
  220.         }
  221.     }  // while(1)
  222.     return 1;
  223. }
  224.  
  225.  
  226.  
  227. // *****************************************************************
  228. // ****    Wszystko co trzeba zrobić podczas uruchamiania aplikacji
  229. // ****    poza grafiką  
  230. void InteractionInitialisation()
  231. {
  232.     DWORD dwThreadId, dwThreadId2;
  233.  
  234.     my_car = new MovableObject();    // tworzenie wlasnego obiektu
  235.  
  236.     time_of_cycle = clock();             // pomiar aktualnego czasu
  237.  
  238.     // obiekty sieciowe typu unicast (z podaniem numeru portu)
  239.     uni_reciv = new unicast_net(10005);      // obiekt do odbioru ramek sieciowych
  240.     uni_send = new unicast_net(10006);       // obiekt do wysyłania ramek
  241.  
  242.  
  243.     // uruchomienie wątku obsługującego odbiór komunikatów:
  244.     threadReciv = CreateThread(
  245.         NULL,                        // no security attributes
  246.         0,                           // use default stack size
  247.         ReceiveThreadFun,                // thread function
  248.         (void *)uni_reciv,               // argument to thread function
  249.         NULL,                        // use default creation flags
  250.         &dwThreadId);                // returns the thread identifier
  251.     SetThreadPriority(threadReciv, THREAD_PRIORITY_HIGHEST);
  252.  
  253.  
  254.     printf("start interakcji\n");
  255. }
  256.  
  257.  
  258. // *****************************************************************
  259. // ****    Wszystko co trzeba zrobić w każdym cyklu działania
  260. // ****    aplikacji poza grafiką
  261. void VirtualWorldCycle()
  262. {
  263.     number_of_cyc++;
  264.  
  265.     if (number_of_cyc % 50 == 0)          // jeśli licznik cykli przekroczył pewną wartość, to
  266.     {                              // należy na nowo obliczyć średni czas cyklu avg_cycle_time
  267.         char text[256];
  268.         long prev_time = time_of_cycle;
  269.         time_of_cycle = clock();
  270.         float fFps = (50 * CLOCKS_PER_SEC) / (float)(time_of_cycle - prev_time);
  271.         if (fFps != 0) avg_cycle_time = 1.0 / fFps; else avg_cycle_time = 1;
  272.  
  273.         sprintf(text, "WWC-lab 2018/19 temat 1, wersja i (%0.0f fps  %0.2fms) ", fFps, 1000.0 / fFps);
  274.  
  275.         SetWindowText(main_window, text); // wyświetlenie aktualnej ilości klatek/s w pasku okna         
  276.     }
  277.  
  278.     my_car->Simulation(avg_cycle_time);                    // symulacja własnego obiektu
  279.  
  280.     Frame frame;
  281.     if (changeServ && !iAmServer)
  282.     {
  283.         frame.type = 505; // wyslij ramke zmiana serwera
  284.     }
  285.     else
  286.     {
  287.         frame.type = 1; // wyslij zwykla ramke
  288.     }
  289.  
  290.     frame.state = my_car->State();               // state własnego obiektu
  291.     frame.iID = my_car->iID;
  292.  
  293.     uni_send->send((char*)&frame, serverIp, sizeof(Frame));  // wysłanie komunikatu do pozostałych aplikacji
  294.  
  295. }
  296.  
  297. // *****************************************************************
  298. // ****    Wszystko co trzeba zrobić podczas zamykania aplikacji
  299. // ****    poza grafiką
  300. void EndOfInteraction()
  301. {
  302.     fprintf(f, "Koniec interakcji\n");
  303.     Frame frame;
  304.     frame.state = my_car->State();
  305.     frame.iID = my_car->iID;
  306.     frame.type = 0; // wyslij ramke usun klienta
  307.     uni_send->send((char*)&frame, serverIp, sizeof(Frame));
  308.  
  309.     fclose(f);
  310. }
  311.  
  312. //deklaracja funkcji obslugi okna
  313. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  314.  
  315. HDC g_context = NULL;        // uchwyt contextu graficznego
  316.  
  317.  
  318.  
  319. //funkcja Main - dla Windows
  320. int WINAPI WinMain(HINSTANCE hInstance,
  321.     HINSTANCE hPrevInstance,
  322.     LPSTR     lpCmdLine,
  323.     int       nCmdShow)
  324. {
  325.  
  326.     //Initilize the critical section
  327.     InitializeCriticalSection(&m_cs);
  328.  
  329.     MSG message;          //innymi slowy "komunikat"
  330.     WNDCLASS main_class; //klasa głównego okna aplikacji
  331.  
  332.     static char class_name[] = "Klasa_Podstawowa";
  333.  
  334.     //Definiujemy klase głównego okna aplikacji
  335.     //Okreslamy tu wlasciwosci okna, szczegoly wygladu oraz
  336.     //adres funkcji przetwarzajacej komunikaty
  337.     main_class.style = CS_HREDRAW | CS_VREDRAW;
  338.     main_class.lpfnWndProc = WndProc; //adres funkcji realizującej przetwarzanie meldunków
  339.     main_class.cbClsExtra = 0;
  340.     main_class.cbWndExtra = 0;
  341.     main_class.hInstance = hInstance; //identyfikator procesu przekazany przez MS Windows podczas uruchamiania programu
  342.     main_class.hIcon = 0;
  343.     main_class.hCursor = LoadCursor(0, IDC_ARROW);
  344.     main_class.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
  345.     main_class.lpszMenuName = "Menu";
  346.     main_class.lpszClassName = class_name;
  347.  
  348.     //teraz rejestrujemy klasę okna głównego
  349.     RegisterClass(&main_class);
  350.  
  351.     main_window = CreateWindow(class_name, "WWC-lab 2018/19 temat 1 - Architektury sieciowe, wersja i", WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
  352.         100, 50, 950, 650, NULL, NULL, hInstance, NULL);
  353.  
  354.  
  355.  
  356.     ShowWindow(main_window, nCmdShow);
  357.  
  358.     //odswiezamy zawartosc okna
  359.     UpdateWindow(main_window);
  360.  
  361.     // pobranie komunikatu z kolejki jeśli funkcja PeekMessage zwraca wartość inną niż FALSE,
  362.     // w przeciwnym wypadku symulacja wirtualnego świata wraz z wizualizacją
  363.     ZeroMemory(&message, sizeof(message));
  364.     while (message.message != WM_QUIT)
  365.     {
  366.         if (PeekMessage(&message, NULL, 0U, 0U, PM_REMOVE))
  367.         {
  368.             TranslateMessage(&message);
  369.             DispatchMessage(&message);
  370.         }
  371.         else
  372.         {
  373.             VirtualWorldCycle();    // Cykl wirtualnego świata
  374.             InvalidateRect(main_window, NULL, FALSE);
  375.         }
  376.     }
  377.  
  378.     return (int)message.wParam;
  379. }
  380.  
  381. /********************************************************************
  382. FUNKCJA OKNA realizujaca przetwarzanie meldunków kierowanych do okna aplikacji*/
  383. LRESULT CALLBACK WndProc(HWND main_window, UINT message_code, WPARAM wParam, LPARAM lParam)
  384. {
  385.  
  386.     switch (message_code)
  387.     {
  388.     case WM_CREATE:  //message wysyłany w momencie tworzenia okna
  389.     {
  390.  
  391.         g_context = GetDC(main_window);
  392.  
  393.         srand((unsigned)time(NULL));
  394.         int result = GraphicsInitialisation(g_context);
  395.         if (result == 0)
  396.         {
  397.             printf("nie udalo sie otworzyc okna graficznego\n");
  398.             //exit(1);
  399.         }
  400.  
  401.         InteractionInitialisation();
  402.  
  403.         SetTimer(main_window, 1, 10, NULL);
  404.  
  405.         return 0;
  406.     }
  407.  
  408.  
  409.     case WM_PAINT:
  410.     {
  411.         PAINTSTRUCT paint;
  412.         HDC context;
  413.         context = BeginPaint(main_window, &paint);
  414.  
  415.         DrawScene();
  416.         SwapBuffers(context);
  417.  
  418.         EndPaint(main_window, &paint);
  419.  
  420.         return 0;
  421.     }
  422.  
  423.     case WM_TIMER:
  424.  
  425.         return 0;
  426.  
  427.     case WM_SIZE:
  428.     {
  429.         int cx = LOWORD(lParam);
  430.         int cy = HIWORD(lParam);
  431.  
  432.         WindowResize(cx, cy);
  433.  
  434.         return 0;
  435.     }
  436.  
  437.     case WM_DESTROY: //obowiązkowa obsługa meldunku o zamknięciu okna
  438.  
  439.         EndOfInteraction();
  440.         EndOfGraphics();
  441.  
  442.         ReleaseDC(main_window, g_context);
  443.         KillTimer(main_window, 1);
  444.  
  445.         //LPDWORD lpExitCode;
  446.         DWORD ExitCode;
  447.         GetExitCodeThread(threadReciv, &ExitCode);
  448.         TerminateThread(threadReciv, ExitCode);
  449.         //ExitThread(ExitCode);
  450.  
  451.         //Sleep(1000);
  452.  
  453.         other_cars.clear();
  454.  
  455.  
  456.         PostQuitMessage(0);
  457.         return 0;
  458.  
  459.     case WM_LBUTTONDOWN: //reakcja na lewy przycisk myszki
  460.     {
  461.         int x = LOWORD(lParam);
  462.         int y = HIWORD(lParam);
  463.         if (if_mouse_control)
  464.             my_car->F = 30.0;        // siła pchająca do przodu
  465.         break;
  466.     }
  467.     case WM_RBUTTONDOWN: //reakcja na prawy przycisk myszki
  468.     {
  469.         int x = LOWORD(lParam);
  470.         int y = HIWORD(lParam);
  471.         if (if_mouse_control)
  472.             my_car->F = -5.0;        // siła pchająca do tylu
  473.         break;
  474.     }
  475.     case WM_MBUTTONDOWN: //reakcja na środkowy przycisk myszki : uaktywnienie/dezaktywacja sterwania myszkowego
  476.     {
  477.         if_mouse_control = 1 - if_mouse_control;
  478.         if (if_mouse_control) my_car->if_keep_steer_wheel = true;
  479.         else my_car->if_keep_steer_wheel = false;
  480.  
  481.         mouse_cursor_x = LOWORD(lParam);
  482.         mouse_cursor_y = HIWORD(lParam);
  483.         break;
  484.     }
  485.     case WM_LBUTTONUP: //reakcja na puszczenie lewego przycisku myszki
  486.     {
  487.         if (if_mouse_control)
  488.             my_car->F = 0.0;        // siła pchająca do przodu
  489.         break;
  490.     }
  491.     case WM_RBUTTONUP: //reakcja na puszczenie lewy przycisk myszki
  492.     {
  493.         if (if_mouse_control)
  494.             my_car->F = 0.0;        // siła pchająca do przodu
  495.         break;
  496.     }
  497.     case WM_MOUSEMOVE:
  498.     {
  499.         int x = LOWORD(lParam);
  500.         int y = HIWORD(lParam);
  501.         if (if_mouse_control)
  502.         {
  503.             float wheel_angle = (float)(mouse_cursor_x - x) / 20;
  504.             if (wheel_angle > 60) wheel_angle = 60;
  505.             if (wheel_angle < -60) wheel_angle = -60;
  506.             my_car->state.steering_angle = PI * wheel_angle / 180;
  507.             //my_car->steer_wheel_speed = (float)(mouse_cursor_x - x) / 20;
  508.         }
  509.         break;
  510.     }
  511.     case WM_KEYDOWN:
  512.     {
  513.  
  514.         switch (LOWORD(wParam))
  515.         {
  516.         case VK_SHIFT:
  517.         {
  518.             if_SHIFT_pressed = 1;
  519.             break;
  520.         }
  521.         case VK_SPACE:
  522.         {
  523.             my_car->breaking_factor = 1.0;       // stopień hamowania (reszta zależy od siły docisku i wsp. tarcia)
  524.             break;                       // 1.0 to maksymalny stopień (np. zablokowanie kół)
  525.         }
  526.         case VK_UP:
  527.         {
  528.             my_car->F = 100.0;        // siła pchająca do przodu
  529.             break;
  530.         }
  531.         case VK_DOWN:
  532.         {
  533.             my_car->F = -70.0;
  534.             break;
  535.         }
  536.         case VK_LEFT:
  537.         {
  538.             if (my_car->steer_wheel_speed < 0) {
  539.                 my_car->steer_wheel_speed = 0;
  540.                 my_car->if_keep_steer_wheel = true;
  541.             }
  542.             else {
  543.                 if (if_SHIFT_pressed) my_car->steer_wheel_speed = 0.5;
  544.                 else my_car->steer_wheel_speed = 0.25 / 8;
  545.             }
  546.  
  547.             break;
  548.         }
  549.         case VK_RIGHT:
  550.         {
  551.             if (my_car->steer_wheel_speed > 0) {
  552.                 my_car->steer_wheel_speed = 0;
  553.                 my_car->if_keep_steer_wheel = true;
  554.             }
  555.             else {
  556.                 if (if_SHIFT_pressed) my_car->steer_wheel_speed = -0.5;
  557.                 else my_car->steer_wheel_speed = -0.25 / 8;
  558.             }
  559.             break;
  560.         }
  561.         case 'I':   // wypisywanie nr ID
  562.         {
  563.             if_ID_visible = 1 - if_ID_visible;
  564.             break;
  565.         }
  566.         case 'W':   // cam_distance widoku
  567.         {
  568.             //cam_pos = cam_pos - cam_direct*0.3;
  569.             if (viewpar.cam_distance > 0.5) viewpar.cam_distance /= 1.2;
  570.             else viewpar.cam_distance = 0;
  571.             break;
  572.         }
  573.         case 'S':   // przybliżenie widoku
  574.         {
  575.             //cam_pos = cam_pos + cam_direct*0.3;
  576.             if (viewpar.cam_distance > 0) viewpar.cam_distance *= 1.2;
  577.             else viewpar.cam_distance = 0.5;
  578.             break;
  579.         }
  580.         case 'Q':   // widok z góry
  581.         {
  582.             if (viewpar.tracking) break;
  583.             viewpar.top_view = 1 - viewpar.top_view;
  584.             if (viewpar.top_view)
  585.             {
  586.                 viewpar.cam_pos_1 = viewpar.cam_pos; viewpar.cam_direct_1 = viewpar.cam_direct; viewpar.cam_vertical_1 = viewpar.cam_vertical;
  587.                 viewpar.cam_distance_1 = viewpar.cam_distance; viewpar.cam_angle_1 = viewpar.cam_angle;
  588.                 viewpar.cam_pos = viewpar.cam_pos_2; viewpar.cam_direct = viewpar.cam_direct_2; viewpar.cam_vertical = viewpar.cam_vertical_2;
  589.                 viewpar.cam_distance = viewpar.cam_distance_2; viewpar.cam_angle = viewpar.cam_angle_2;
  590.             }
  591.             else
  592.             {
  593.                 viewpar.cam_pos_2 = viewpar.cam_pos; viewpar.cam_direct_2 = viewpar.cam_direct; viewpar.cam_vertical_2 = viewpar.cam_vertical;
  594.                 viewpar.cam_distance_2 = viewpar.cam_distance; viewpar.cam_angle_2 = viewpar.cam_angle;
  595.                 viewpar.cam_pos = viewpar.cam_pos_1; viewpar.cam_direct = viewpar.cam_direct_1; viewpar.cam_vertical = viewpar.cam_vertical_1;
  596.                 viewpar.cam_distance = viewpar.cam_distance_1; viewpar.cam_angle = viewpar.cam_angle_1;
  597.             }
  598.             break;
  599.         }
  600.         case 'E':   // obrót kamery ku górze (względem lokalnej osi z)
  601.         {
  602.             viewpar.cam_angle += PI * 5 / 180;
  603.             break;
  604.         }
  605.         case 'D':   // obrót kamery ku dołowi (względem lokalnej osi z)
  606.         {
  607.             viewpar.cam_angle -= PI * 5 / 180;
  608.             break;
  609.         }
  610.         case 'A':   // włączanie, wyłączanie trybu śledzenia obiektu
  611.         {
  612.             viewpar.tracking = 1 - viewpar.tracking;
  613.             if (viewpar.tracking)
  614.             {
  615.                 viewpar.cam_distance = viewpar.cam_distance_3; viewpar.cam_angle = viewpar.cam_angle_3;
  616.             }
  617.             else
  618.             {
  619.                 viewpar.cam_distance_3 = viewpar.cam_distance; viewpar.cam_angle_3 = viewpar.cam_angle;
  620.                 viewpar.top_view = 0;
  621.                 viewpar.cam_pos = viewpar.cam_pos_1; viewpar.cam_direct = viewpar.cam_direct_1; viewpar.cam_vertical = viewpar.cam_vertical_1;
  622.                 viewpar.cam_distance = viewpar.cam_distance_1; viewpar.cam_angle = viewpar.cam_angle_1;
  623.             }
  624.             break;
  625.         }
  626.         case 'Z':   // zoom - zmniejszenie kąta widzenia
  627.         {
  628.             viewpar.zoom /= 1.1;
  629.             RECT rc;
  630.             GetClientRect(main_window, &rc);
  631.             WindowResize(rc.right - rc.left, rc.bottom - rc.top);
  632.             break;
  633.         }
  634.         case 'X':   // zoom - zwiększenie kąta widzenia
  635.         {
  636.             viewpar.zoom *= 1.1;
  637.             RECT rc;
  638.             GetClientRect(main_window, &rc);
  639.             WindowResize(rc.right - rc.left, rc.bottom - rc.top);
  640.             break;
  641.         }
  642.         case 'K':   //zmiana serwera
  643.         {
  644.             changeServ = true;
  645.             break;
  646.         }
  647.         case VK_F1:  // wywolanie systemu pomocy
  648.         {
  649.             char lan[1024], lan_bie[1024];
  650.             //GetSystemDirectory(lan_sys,1024);
  651.             GetCurrentDirectory(1024, lan_bie);
  652.             strcpy(lan, "C:\\Program Files\\Internet Explorer\\iexplore ");
  653.             strcat(lan, lan_bie);
  654.             strcat(lan, "\\pomoc.htm");
  655.             int wyni = WinExec(lan, SW_NORMAL);
  656.             if (wyni < 32)  // proba uruchominia pomocy nie powiodla sie
  657.             {
  658.                 strcpy(lan, "C:\\Program Files\\Mozilla Firefox\\firefox ");
  659.                 strcat(lan, lan_bie);
  660.                 strcat(lan, "\\pomoc.htm");
  661.                 wyni = WinExec(lan, SW_NORMAL);
  662.                 if (wyni < 32)
  663.                 {
  664.                     char lan_win[1024];
  665.                     GetWindowsDirectory(lan_win, 1024);
  666.                     strcat(lan_win, "\\notepad pomoc.txt ");
  667.                     wyni = WinExec(lan_win, SW_NORMAL);
  668.                 }
  669.             }
  670.             break;
  671.         }
  672.         case VK_ESCAPE:
  673.         {
  674.             SendMessage(main_window, WM_DESTROY, 0, 0);
  675.             break;
  676.         }
  677.         } // switch po klawiszach
  678.  
  679.         break;
  680.     }
  681.     case WM_KEYUP:
  682.     {
  683.         switch (LOWORD(wParam))
  684.         {
  685.         case VK_SHIFT:
  686.         {
  687.             if_SHIFT_pressed = 0;
  688.             break;
  689.         }
  690.         case VK_SPACE:
  691.         {
  692.             my_car->breaking_factor = 0.0;
  693.             break;
  694.         }
  695.         case VK_UP:
  696.         {
  697.             my_car->F = 0.0;
  698.             break;
  699.         }
  700.         case VK_DOWN:
  701.         {
  702.             my_car->F = 0.0;
  703.             break;
  704.         }
  705.         case VK_LEFT:
  706.         {
  707.             my_car->Fb = 0.00;
  708.             //my_car->state.steering_angle = 0;
  709.             if (my_car->if_keep_steer_wheel) my_car->steer_wheel_speed = -0.25 / 8;
  710.             else my_car->steer_wheel_speed = 0;
  711.             my_car->if_keep_steer_wheel = false;
  712.             break;
  713.         }
  714.         case VK_RIGHT:
  715.         {
  716.             my_car->Fb = 0.00;
  717.             //my_car->state.steering_angle = 0;
  718.             if (my_car->if_keep_steer_wheel) my_car->steer_wheel_speed = 0.25 / 8;
  719.             else my_car->steer_wheel_speed = 0;
  720.             my_car->if_keep_steer_wheel = false;
  721.             break;
  722.         }
  723.  
  724.         }
  725.  
  726.         break;
  727.     }
  728.  
  729.     default: //statedardowa obsługa pozostałych meldunków
  730.         return DefWindowProc(main_window, message_code, wParam, lParam);
  731.     }
  732.  
  733.  
  734. }
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!