/************************************************************
Interakcja:
Wysyłanie, odbiór komunikatów, interakcja z innymi
uczestnikami WZR, sterowanie wirtualnymi obiektami
*************************************************************/

#include <windows.h>
#include <time.h>
#include <stdio.h>
#include "interakcja.h"
#include "obiekty.h"
#include "grafika.h"

#include "siec.h"

FILE *f = fopen("wwc_log.txt","w");     // plik do zapisu informacji testowych

ObiektRuchomy *pMojObiekt;               // obiekt przypisany do tej aplikacji

Teren teren;
int iLiczbaCudzychOb = 0;
ObiektRuchomy *CudzeObiekty[1000];  // obiekty z innych aplikacji lub inne obiekty niz pCraft
int IndeksyOb[1000];                // tablica indeksow innych obiektow ulatwiajaca wyszukiwanie

float fDt;                          // sredni czas pomiedzy dwoma kolejnymi cyklami symulacji i wyswietlania
long czas_cyklu_WS,licznik_sym;     // zmienne pomocnicze potrzebne do obliczania fDt
float sr_czestosc;                  // srednia czestosc wysylania ramek w [ramkach/s]
long czas_start = clock();          // czas od poczatku dzialania aplikacji

multicast_net *multi_reciv;         // wsk do obiektu zajmujacego sie odbiorem komunikatow
multicast_net *multi_send;          //   -||-  wysylaniem komunikatow

HANDLE threadReciv;                 // uchwyt wątku odbioru komunikatów
extern HWND okno;
int SHIFTwcisniety = 0;


// Parametry widoku:
Wektor3 kierunek_kamery = Wektor3(10,-3,-11);   // kierunek patrzenia
Wektor3 pol_kamery = Wektor3(-5,3,10);          // położenie kamery
Wektor3 pion_kamery = Wektor3(0,1,0);           // kierunek pionu kamery
bool sledzenie = 0;                             // tryb śledzenia obiektu przez kamerę
float oddalenie = 1.0;                          // oddalenie lub przybliżenie kamery
float zoom = 1.0;                               // zmiana kąta widzenia
float kat_kam_z = 0;                            // obrót kamery góra-dół
bool sterowanie_myszkowe = 0;                   // sterowanie pojazdem za pomocą myszki
int kursor_x, kursor_y;                         // polożenie kursora myszki w chwili włączenia sterowania
char napis1[200], napis2[200];                  // napisy wyświetlane w trybie graficznym

int opoznienia = 0;
bool podnoszenie_przedm = 1;        // czy mozna podnosic przedmioty
bool rejestracja_uczestnikow = 1;   // rejestracja trwa do momentu wzięcia przedmiotu przez któregokolwiek uczestnika,
                                    // w przeciwnym razie trzeba by przesyłać cały stan środowiska nowicjuszowi
float czas_odnowy_przedm = 90;      // czas w [s] po którym wzięte przedmioty odnawiają się
bool czy_umiejetnosci = 1;          // czy zróżnicowanie umiejętności (dla każdego pojazdu losowane są umiejętności
                                    // zbierania gotówki i paliwa)

extern float WyslaniePrzekazu(int ID_adresata, int typ_przekazu, float wartosc_przekazu);

enum typy_ramek {STAN_OBIEKTU, WZIECIE_PRZEDMIOTU, ODNOWIENIE_SIE_PRZEDMIOTU, KOLIZJA, PRZEKAZ,
	PROSBA_O_ZAMKNIECIE, NEGOCJACJE_HANDLOWE, TEKST, ZAPROSZENIE, ODPOWIEDZ, ZGODA, START_LICYTACJI, LICYTACJA, KONIEC_LICYTACJI, PROPOZYCJA};

enum typy_przekazu {GOTOWKA, PALIWO};

struct Ramka
{
  int typ_ramki;
  long czas_wyslania;
  int iID_adresata;      // nr ID adresata wiadomości (pozostali uczestnicy powinni wiadomość zignorować)

  int nr_przedmiotu;     // nr przedmiotu, który został wzięty lub odzyskany
  Wektor3 wdV_kolid;     // wektor prędkości wyjściowej po kolizji (uczestnik o wskazanym adresie powinien
                         // przyjąć tą prędkość)

  int typ_przekazu;        // gotówka, paliwo
  float wartosc_przekazu;  // ilość gotówki lub paliwa
  int nr_druzyny;

  StanObiektu stan;
};


//******************************************
// Funkcja obsługi wątku odbioru komunikatów
DWORD WINAPI WatekOdbioru(void *ptr)
{
  multicast_net *pmt_net=(multicast_net*)ptr;  // wskaźnik do obiektu klasy multicast_net
  int rozmiar;                                 // liczba bajtów ramki otrzymanej z sieci
  Ramka ramka;
  StanObiektu stan;

  while(1)
  {
    rozmiar = pmt_net->reciv((char*)&ramka,sizeof(Ramka));   // oczekiwanie na nadejście ramki
    switch (ramka.typ_ramki)
    {
    case STAN_OBIEKTU:           // podstawowy typ ramki informującej o stanie obiektu
      {
        stan = ramka.stan;
        //fprintf(f,"odebrano stan iID = %d, ID dla mojego obiektu = %d\n",stan.iID,pMojObiekt->iID);
        int niewlasny = 1;
        if ((stan.iID != pMojObiekt->iID))          // jeśli to nie mój własny obiekt
        {

          if ((rejestracja_uczestnikow)&&(IndeksyOb[stan.iID] == -1))        // nie ma jeszcze takiego obiektu w tablicy -> trzeba go stworzyć
          {
            CudzeObiekty[iLiczbaCudzychOb] = new ObiektRuchomy();
            IndeksyOb[stan.iID] = iLiczbaCudzychOb;     // wpis do tablicy indeksowanej numerami ID
            // ułatwia wyszukiwanie, alternatywą może być tabl. rozproszona
            iLiczbaCudzychOb++;
            CudzeObiekty[IndeksyOb[stan.iID]]->ZmienStan(stan);   // aktualizacja stanu obiektu obcego
          }
          else if (IndeksyOb[stan.iID] != -1)
            CudzeObiekty[IndeksyOb[stan.iID]]->ZmienStan(stan);   // aktualizacja stanu obiektu obcego
          else
          {
            Ramka ramka;
            ramka.typ_ramki = PROSBA_O_ZAMKNIECIE;                // żądanie zamkięcia aplikacji
            ramka.iID_adresata = stan.iID;
            int iRozmiar = multi_send->send((char*)&ramka,sizeof(Ramka));
          }
        }
        break;
      }
    case WZIECIE_PRZEDMIOTU:            // ramka informująca, że ktoś wziął przedmiot o podanym numerze
      {
        if ((ramka.nr_przedmiotu < teren.liczba_przedmiotow)&&(stan.iID != pMojObiekt->iID))
        {
          teren.p[ramka.nr_przedmiotu].do_wziecia = 0;
          teren.p[ramka.nr_przedmiotu].czy_ja_wzialem = 0;
          rejestracja_uczestnikow = 0;
          sprintf(napis2,"Pojazd_id_%d_zabral_przedmiot_nr_%d",stan.iID,ramka.nr_przedmiotu);
        }
        break;
      }
    case ODNOWIENIE_SIE_PRZEDMIOTU:       // ramka informujaca, że przedmiot wcześniej wzięty pojawił się znowu w tym samym miejscu
      {
        if (ramka.nr_przedmiotu < teren.liczba_przedmiotow)
          teren.p[ramka.nr_przedmiotu].do_wziecia = 1;
        break;
      }
    case KOLIZJA:                       // ramka informująca o tym, że obiekt uległ kolizji
      {
        if (ramka.iID_adresata == pMojObiekt->iID)  // ID pojazdu, który uczestniczył w kolizji zgadza się z moim ID
        {
          pMojObiekt->wdV_kolid = ramka.wdV_kolid; // przepisuje poprawkę własnej prędkości
          pMojObiekt->iID_kolid = pMojObiekt->iID; // ustawiam nr. kolidujacego jako własny na znak, że powinienem poprawić prędkość
        }
        break;
      }
    case PRZEKAZ:                       // ramka informująca o przelewie pieniężnym lub przekazaniu towaru
      {
        if (ramka.iID_adresata == pMojObiekt->iID)  // ID pojazdu, ktory otrzymal przelew zgadza się z moim ID
        {
          if (ramka.typ_przekazu == GOTOWKA)
            pMojObiekt->pieniadze += ramka.wartosc_przekazu;
          else if (ramka.typ_przekazu == PALIWO)
            pMojObiekt->ilosc_paliwa += ramka.wartosc_przekazu;

          // należałoby jeszcze przelew potwierdzić (w UDP ramki mogą być gubione!)
        }
        break;
      }
    case PROSBA_O_ZAMKNIECIE:           // ramka informująca, że powinieneś się zamknąć
      {
        if (ramka.iID_adresata == pMojObiekt->iID)
        {
          SendMessage(okno,WM_DESTROY,0,100);
        }
        break;
      }
    case NEGOCJACJE_HANDLOWE:
      {
        // ------------------------------------------------------------------------
        // --------------- MIEJSCE #1 NA NEGOCJACJE HANDLOWE  ---------------------
        // (szczegóły na stronie w instrukcji do zadania)




        // ------------------------------------------------------------------------

        break;
      }
	case ZAPROSZENIE:

		if (ramka.stan.iID != pMojObiekt->iID)
		{
			sprintf(buff, "Uzytkownik %d chce zaczac wspolpracowac!!", ramka.stan.iID);
			if (MessageBox(okno, buff, "Zaproszenie", MB_OKCANCEL) == IDOK)
			{
				odpowiadam = true;
				idZapraszajacego = stan.iID;
			}
		}

		break;
	case ODPOWIEDZ:
		if (ramka.idZapraszajacego == pMojObiekt->iID && idDruzyny == -1)
		{
			sprintf(buff, "Uzytkownik %d odpowiedzial na zaproszenie!!", ramka.stan.iID);
			if (MessageBox(okno, buff, "Odpowiedz", MB_OKCANCEL) == IDOK)
			{
				idKolaboratora = ramka.stan.iID;
				zgadzam = true;
				sprintf(buff, "%d%d", pMojObiekt->iID, idKolaboratora);
				idDruzyny = atoi(buff);
				pMojObiekt->idDruzyny = idDruzyny;
				CudzeObiekty[IndeksyOb[idKolaboratora]]->idDruzyny = idDruzyny;
			}
		}
		break;

	case ZGODA:
		if (ramka.stan.iID == idZapraszajacego)
		{
			idKolaboratora = idZapraszajacego;
			idDruzyny = ramka.nr_druzyny;
			pMojObiekt->idDruzyny = idDruzyny;
			CudzeObiekty[IndeksyOb[idKolaboratora]]->idDruzyny = idDruzyny;
		}
		listaIdDruzyn[iloscDruzyn] = ramka.nr_druzyny;
	case LICYTACJA:
		printf("ROZMIAR: %d\n", rozmiar);
		if (!licytacja)
		{
			licytacja = ramka.licytacja;
			idLicytenta = ramka.idLic;
		}

		if (ramka.secLeft)
		{
			czasDoZakonczenia = ramka.secLeft;
		}
		oferta1 = ramka.o1;
		oferta2 = ramka.o2;
		idGraczaNajlepszego = ramka.idNajlep;
		break;
	case KONIEC_LICYTACJI:
		licytacja = false;
		break;
	case PROPOZYCJA:
		if (ramka.idLic == pMojObiekt->iID)
		{
			if (ramka.o2 < oferta2)
			{
				oferta2 = ramka.o2;
				oferta1 = 100 - oferta2;
				idGraczaNajlepszego = ramka.stan.iID;
				czasDoZakonczeniaWlasciciel += 3;
			}
		}

    } // switch po typach ramek
  }  // while(1)
  return 1;
}

// *****************************************************************
// ****    Wszystko co trzeba zrobić podczas uruchamiania aplikacji
// ****    poza grafiką
void PoczatekInterakcji()
{
  DWORD dwThreadId;

  pMojObiekt = new ObiektRuchomy();    // tworzenie wlasnego obiektu

  for (long i=0;i<1000;i++)            // inicjacja indeksow obcych obiektow
    IndeksyOb[i] = -1;

  czas_cyklu_WS = clock();             // pomiar aktualnego czasu

  // obiekty sieciowe typu multicast (z podaniem adresu WZR oraz numeru portu)
  multi_reciv = new multicast_net("224.10.11.11",10001);      // obiekt do odbioru ramek sieciowych
  multi_send = new multicast_net("224.10.11.11",10001);       // obiekt do wysyłania ramek

  if (opoznienia)
  {
    float srednie_opoznienie = 3*(float)rand()/RAND_MAX, wariancja_opoznienia = 2;
    multi_send->PrepareDelay(srednie_opoznienie,wariancja_opoznienia);
  }

  // uruchomienie watku obslugujacego odbior komunikatow
  threadReciv = CreateThread(
    NULL,                        // no security attributes
    0,                           // use default stack size
    WatekOdbioru,                // thread function
    (void *)multi_reciv,               // argument to thread function
    0,                           // use default creation flags
    &dwThreadId);                // returns the thread identifier

}


// *****************************************************************
// ****    Wszystko co trzeba zrobić w każdym cyklu działania
// ****    aplikacji poza grafiką
void Cykl_WS()
{
  licznik_sym++;

  // obliczenie średniego czasu pomiędzy dwoma kolejnnymi symulacjami po to, by zachować  fizycznych
  if (licznik_sym % 50 == 0)          // jeśli licznik cykli przekroczył pewną wartość, to
  {                                   // należy na nowo obliczyć średni czas cyklu fDt
    char text[200];
    long czas_pop = czas_cyklu_WS;
    czas_cyklu_WS = clock();
    float fFps = (50*CLOCKS_PER_SEC)/(float)(czas_cyklu_WS-czas_pop);
    if (fFps!=0) fDt=1.0/fFps; else fDt=1;

    sprintf(napis1," %0.0f_fps, paliwo = %0.2f, gotowka = %d,",fFps,pMojObiekt->ilosc_paliwa,pMojObiekt->pieniadze);
    if (licznik_sym % 500 == 0) sprintf(napis2,"");
  }

  pMojObiekt->Symulacja(fDt);                    // symulacja własnego obiektu


  if ((pMojObiekt->iID_kolid > -1)&&             // wykryto kolizję - wysyłam specjalną ramkę, by poinformować o tym drugiego uczestnika
    (pMojObiekt->iID_kolid != pMojObiekt->iID)) // oczywiście wtedy, gdy nie chodzi o mój pojazd
  {
    Ramka ramka;
    ramka.typ_ramki = KOLIZJA;
    ramka.iID_adresata = pMojObiekt->iID_kolid;
    ramka.wdV_kolid = pMojObiekt->wdV_kolid;
    int iRozmiar = multi_send->send((char*)&ramka,sizeof(Ramka));

    char text[128];
    sprintf(napis2,"Kolizja_z_obiektem_o_ID = %d",pMojObiekt->iID_kolid);
    //SetWindowText(okno,text);

    pMojObiekt->iID_kolid = -1;
  }

  // wyslanie komunikatu o stanie obiektu przypisanego do aplikacji (pMojObiekt):
  if (licznik_sym % 1 == 0)
  {
    Ramka ramka;
    ramka.typ_ramki = STAN_OBIEKTU;
    ramka.stan = pMojObiekt->Stan();         // stan własnego obiektu
    int iRozmiar = multi_send->send((char*)&ramka,sizeof(Ramka));
  }

  long czas_akt = clock();

  // sprawdzam, czy nie najechałem na monetę lub beczkę z paliwem. Jeśli tak, to zdobywam pieniądze lub paliwo oraz wysyłam innym uczestnikom
  // informację o zabraniu beczki: (wcześniej trzeba wcisnąć P)
  for (long i=0;i<teren.liczba_przedmiotow;i++)
  {
    if ((teren.p[i].do_wziecia == 1)&&(podnoszenie_przedm)&&
      ((teren.p[i].wPol - pMojObiekt->wPol + Wektor3(0,pMojObiekt->wPol.y - teren.p[i].wPol.y,0)).dlugosc() < pMojObiekt->promien))
    {

      long wartosc = teren.p[i].wartosc;

      if (teren.p[i].typ == MONETA)
      {
        if (czy_umiejetnosci)
          wartosc = (long)(float)wartosc*pMojObiekt->umiejetn_zb_monet;
        pMojObiekt->pieniadze += wartosc;
        sprintf(napis2,"Wziecie_gotowki_o_wartosci_ %d",wartosc);
      }
      else
      {
        if (czy_umiejetnosci)
          wartosc = (float)wartosc*pMojObiekt->umiejetn_zb_paliwa;
        pMojObiekt->ilosc_paliwa += wartosc;
        sprintf(napis2,"Wziecie_paliwa_w_ilosci_ %d",wartosc);
      }

      teren.p[i].do_wziecia = 0;
      teren.p[i].czy_ja_wzialem = 1;
      teren.p[i].czas_wziecia = clock();
      rejestracja_uczestnikow = 0;     // koniec rejestracji nowych uczestników

      Ramka ramka;
      ramka.typ_ramki = WZIECIE_PRZEDMIOTU;
      ramka.nr_przedmiotu = i;
      ramka.stan = pMojObiekt->Stan();
      int iRozmiar = multi_send->send((char*)&ramka,sizeof(Ramka));
    }
    else if ((teren.p[i].do_wziecia == 0)&&(teren.p[i].czy_ja_wzialem)&&(teren.p[i].czy_odnawialny)&&
      (czas_akt - teren.p[i].czas_wziecia >= czas_odnowy_przedm*CLOCKS_PER_SEC))
    {                              // jeśli minął pewnien okres czasu przedmiot może zostać przywrócony
      teren.p[i].do_wziecia = 1;
      Ramka ramka;
      ramka.typ_ramki = ODNOWIENIE_SIE_PRZEDMIOTU;
      ramka.nr_przedmiotu = i;
      int iRozmiar = multi_send->send((char*)&ramka,sizeof(Ramka));
    }
  } // for po przedmiotach

}

// *****************************************************************
// ****    Wszystko co trzeba zrobić podczas zamykania aplikacji
// ****    poza grafiką
void ZakonczenieInterakcji()
{
  fprintf(f,"Koniec interakcji\n");
  fclose(f);
}

// Funkcja wysylajaca ramke z przekazem, zwraca zrealizowaną wartość przekazu
float WyslaniePrzekazu(int ID_adresata, int typ_przekazu, float wartosc_przekazu)
{
  Ramka ramka;
  ramka.typ_ramki = PRZEKAZ;
  ramka.iID_adresata = ID_adresata;
  ramka.typ_przekazu = typ_przekazu;
  ramka.wartosc_przekazu = wartosc_przekazu;

  // tutaj należałoby uzyskać potwierdzenie przekazu zanim sumy zostaną odjęte
  if (typ_przekazu == GOTOWKA)
  {
    if (pMojObiekt->pieniadze < wartosc_przekazu)
      ramka.wartosc_przekazu = pMojObiekt->pieniadze;
    pMojObiekt->pieniadze -= ramka.wartosc_przekazu;
    sprintf(napis2,"Przelew_sumy_ %f _na_rzecz_ID_ %d",wartosc_przekazu,ID_adresata);
  }
  else if (typ_przekazu == PALIWO)
  {
    // odszukanie adresata, sprawdzenie czy jest odpowiednio blisko:
    int indeks_adresata = -1;
    for (int i=0;i<iLiczbaCudzychOb;i++)
      if (CudzeObiekty[i]->iID == ID_adresata) {indeks_adresata = i; break;}
    if ((CudzeObiekty[indeks_adresata]->wPol - pMojObiekt->wPol).dlugosc() >
         CudzeObiekty[indeks_adresata]->dlugosc + pMojObiekt->dlugosc)
      ramka.wartosc_przekazu = 0;
    else
    {
      if (pMojObiekt->ilosc_paliwa < wartosc_przekazu)
        ramka.wartosc_przekazu = pMojObiekt->ilosc_paliwa;
      pMojObiekt->ilosc_paliwa -= ramka.wartosc_przekazu;
      sprintf(napis2,"Przekazanie_paliwa_w_ilości_ %f _na_rzecz_ID_ %d",wartosc_przekazu,ID_adresata);
    }
  }

  if (ramka.wartosc_przekazu > 0)
    int iRozmiar = multi_send->send((char*)&ramka,sizeof(Ramka));

  return ramka.wartosc_przekazu;
}


// ************************************************************************
// ****    Obsługa klawiszy służących do sterowania obiektami lub
// ****    widokami
void KlawiszologiaSterowania(UINT kod_meldunku, WPARAM wParam, LPARAM lParam)
{

  switch (kod_meldunku)
  {

  case WM_LBUTTONDOWN: //reakcja na lewy przycisk myszki
    {
      int x = LOWORD(lParam);
      int y = HIWORD(lParam);
      if (sterowanie_myszkowe)
        pMojObiekt->F = 4100.0;        // siła pchająca do przodu
      break;
    }
  case WM_RBUTTONDOWN: //reakcja na prawy przycisk myszki - zaznaczanie obiektów
    {
      int x = LOWORD(lParam);
      int y = HIWORD(lParam);
      if (sterowanie_myszkowe)
        pMojObiekt->F = -2100.0;        // siła pchająca do tylu
      else                       // zaznaczanie obiektów
      {
			  RECT r;
			  //GetWindowRect(okno,&r);
			  GetClientRect(okno,&r);
        Wektor3 w = WspolrzedneKursora3D(x,r.bottom - r.top - y);
        //float promien = (w - punkt_klik).dlugosc();
        float odl_min = 1e10;
			  long ind_min = -1;
        bool czy_ob_ruch;
			  for (long i=0;i<iLiczbaCudzychOb;i++)
			  {
				  float xx,yy,zz;
				  WspolrzedneEkranu(&xx,&yy,&zz, CudzeObiekty[i]->wPol);
				  yy = r.bottom - r.top - yy;
				  float odl_kw = (xx-x)*(xx-x) + (yy-y)*(yy-y);
				  if (odl_min > odl_kw)
				  {
					  odl_min = odl_kw;
					  ind_min = i;
            czy_ob_ruch = 1;
				  }
			  }

        for (long i=0;i<teren.liczba_przedmiotow;i++)
			  {
				  float xx,yy,zz;
          WspolrzedneEkranu(&xx,&yy,&zz, teren.p[i].wPol);
				  yy = r.bottom - r.top - yy;
				  float odl_kw = (xx-x)*(xx-x) + (yy-y)*(yy-y);
				  if (odl_min > odl_kw)
				  {
					  odl_min = odl_kw;
					  ind_min = i;
            czy_ob_ruch = 0;
				  }
			  }
			  if (ind_min > -1)
			  {
				  //fprintf(f,"zaznaczono przedmiot %d pol = (%f, %f, %f)\n",ind_min,teren.p[ind_min].wPol.x,teren.p[ind_min].wPol.y,teren.p[ind_min].wPol.z);
				  //teren.p[ind_min].czy_zazn = 1 - teren.p[ind_min].czy_zazn;
          if (czy_ob_ruch)
            CudzeObiekty[ind_min]->czy_zazn = 1 - CudzeObiekty[ind_min]->czy_zazn;
          else
            teren.p[ind_min].czy_zazn = 1 - teren.p[ind_min].czy_zazn;
				  //char lan[256];
				  //sprintf(lan, "kliknięto w przedmiot %d pol = (%f, %f, %f)\n",ind_min,teren.p[ind_min].wPol.x,teren.p[ind_min].wPol.y,teren.p[ind_min].wPol.z);
				  //SetWindowText(okno,lan);
			  }
        Wektor3 punkt_klik = WspolrzedneKursora3D(x,r.bottom - r.top - y);

      }
      break;
    }
  case WM_MBUTTONDOWN: //reakcja na środkowy przycisk myszki : uaktywnienie/dezaktywacja sterwania myszkowego
    {
      sterowanie_myszkowe = 1 - sterowanie_myszkowe;
      kursor_x = LOWORD(lParam);
      kursor_y = HIWORD(lParam);
      break;
    }
  case WM_LBUTTONUP: //reakcja na puszczenie lewego przycisku myszki
    {
      if (sterowanie_myszkowe)
        pMojObiekt->F = 0.0;        // siła pchająca do przodu
      break;
    }
  case WM_RBUTTONUP: //reakcja na puszczenie lewy przycisk myszki
    {
      if (sterowanie_myszkowe)
        pMojObiekt->F = 0.0;        // siła pchająca do przodu
      break;
    }
  case WM_MOUSEMOVE:
    {
      int x = LOWORD(lParam);
      int y = HIWORD(lParam);
      if (sterowanie_myszkowe)
      {
        float kat_skretu = (float)(kursor_x - x)/20;
        if (kat_skretu > 45) kat_skretu = 45;
        if (kat_skretu < -45) kat_skretu = -45;
        pMojObiekt->alfa = PI*kat_skretu/180;
      }
      break;
    }
  case WM_KEYDOWN:
    {

      switch (LOWORD(wParam))
      {
      case VK_SHIFT:
        {
          SHIFTwcisniety = 1;
          break;
        }
      case VK_SPACE:
        {
          pMojObiekt->ham = 1.0;       // stopień hamowania (reszta zależy od siły docisku i wsp. tarcia)
          break;                       // 1.0 to maksymalny stopień (np. zablokowanie kół)
        }
      case VK_UP:
        {

          pMojObiekt->F = 4100.0;        // siła pchająca do przodu
          break;
        }
      case VK_DOWN:
        {
          pMojObiekt->F = -2100.0;        // sila pchajaca do tylu
          break;
        }
      case VK_LEFT:
        {
          if (SHIFTwcisniety) pMojObiekt->alfa = PI*35/180;
          else pMojObiekt->alfa = PI*15/180;

          break;
        }
      case VK_RIGHT:
        {
          if (SHIFTwcisniety) pMojObiekt->alfa = -PI*35/180;
          else pMojObiekt->alfa = -PI*15/180;
          break;
        }
      case 'W':   // przybliżenie widoku
        {
          //pol_kamery = pol_kamery - kierunek_kamery*0.3;
          if (oddalenie > 0.5) oddalenie /= 1.2;
          else oddalenie = 0;
          break;
        }
      case 'S':   // oddalenie widoku
        {
          //pol_kamery = pol_kamery + kierunek_kamery*0.3;
          if (oddalenie > 0) oddalenie *= 1.2;
          else oddalenie = 0.5;
          break;
        }
      case 'Q':   // widok z góry
        {
          pol_kamery = Wektor3(0,100,0);
          kierunek_kamery = Wektor3(0,-1,0.01);
          pion_kamery = Wektor3(0,0,-1);
          break;
        }
      case 'E':   // obrót kamery ku górze (względem lokalnej osi z)
        {
          kat_kam_z += PI*5/180;
          break;
        }
      case 'D':   // obrót kamery ku dołowi (względem lokalnej osi z)
        {
          kat_kam_z -= PI*5/180;
          break;
        }
      case 'A':   // włączanie, wyłączanie trybu śledzenia obiektu
        {
          sledzenie = 1 - sledzenie;
          break;
        }
      case 'Z':   // zoom - zmniejszenie kąta widzenia
        {
          zoom /= 1.1;
          RECT rc;
          GetClientRect (okno, &rc);
          ZmianaRozmiaruOkna(rc.right - rc.left,rc.bottom-rc.top);
          break;
        }
      case 'X':   // zoom - zwiększenie kąta widzenia
        {
          zoom *= 1.1;
          RECT rc;
          GetClientRect (okno, &rc);
          ZmianaRozmiaruOkna(rc.right - rc.left,rc.bottom-rc.top);
          break;
        }
      case 'P':   // podnoszenie przedmiotów
        {
          //Wektor3 w_przod = pMojObiekt->qOrient.obroc_wektor(Wektor3(1,0,0));
          //+ Wector3(0,pMojObiekt->wPol.y - teren.p[i].wPol.y,0)
          podnoszenie_przedm = 1 - podnoszenie_przedm;
          break;
        }
      case 'F':  // przekazanie 10 kg paliwa pojazdowi, który znajduje się najbliżej
        {
          float min_odleglosc = 1e10;
          int indeks_min = -1;
          for (int i=0;i<iLiczbaCudzychOb;i++)
          {
            if (min_odleglosc > (CudzeObiekty[i]->wPol - pMojObiekt->wPol).dlugosc() )
            {
              min_odleglosc = (CudzeObiekty[i]->wPol - pMojObiekt->wPol).dlugosc();
              indeks_min = i;
            }
          }

          float ilosc_p =  0;
          if (indeks_min > -1)
            ilosc_p = WyslaniePrzekazu(CudzeObiekty[indeks_min]->iID, PALIWO, 10);

          if (ilosc_p == 0)
            MessageBox(okno,"Paliwa nie dało się przekazać, bo być może najbliższy obiekt ruchomy znajduje się zbyt daleko.",
              "Nie dało się przekazać paliwa!",MB_OK);
          break;
        }
      case 'G':  // przekazanie 100 jednostek gotowki pojazdowi, który znajduje się najbliżej
        {
          float min_odleglosc = 1e10;
          int indeks_min = -1;
          for (int i=0;i<iLiczbaCudzychOb;i++)
          {
            if (min_odleglosc > (CudzeObiekty[i]->wPol - pMojObiekt->wPol).dlugosc() )
            {
              min_odleglosc = (CudzeObiekty[i]->wPol - pMojObiekt->wPol).dlugosc();
              indeks_min = i;
            }
          }

          float ilosc_p =  0;
          if (indeks_min > -1)
            ilosc_p = WyslaniePrzekazu(CudzeObiekty[indeks_min]->iID, GOTOWKA, 100);

          if (ilosc_p == 0)
            MessageBox(okno,"Gotówki nie dało się przekazać, bo być może najbliższy obiekt ruchomy znajduje się zbyt daleko.",
              "Nie dało się przekazać gotówki!",MB_OK);
          break;
        }
      } // switch po klawiszach

      break;
    }
  case WM_KEYUP:
    {
      switch (LOWORD(wParam))
      {
      case VK_SHIFT:
        {
          SHIFTwcisniety = 0;
          break;
        }
      case VK_SPACE:
        {
          pMojObiekt->ham = 0.0;
          break;
        }
      case VK_UP:
        {
          pMojObiekt->F = 0.0;

          break;
        }
      case VK_DOWN:
        {
          pMojObiekt->F = 0.0;
          break;
        }
      case VK_LEFT:
        {
          pMojObiekt->Fb = 0.00;
          pMojObiekt->alfa = 0;
          break;
        }
      case VK_RIGHT:
        {
          pMojObiekt->Fb = 0.00;
          pMojObiekt->alfa = 0;
          break;
        }

      }

      break;
    }

  } // switch po komunikatach
}