/* Plik naglowkowy zawiera definicje typow i funkcje potrzebne do tworzenia i
*  obslugi elementu gry zwanego 'graczem'.
*
*          autor: r.Q
*          licencja GNU GPL
*
W PROGRAMIE RYSUJEMY IGIELKE W SPOSOB NASTEPUJACY: 
////////////////////////////////////////////////////////////////////////////////
     Dla 'gory' rysujemy cos takiego:
        |
        |\
        | \
        |  \
     ---|   \ ---- srodek (wspolrzedne gracza)
////////////////////////////////////////////////////////////////////////////////
     Dla 'dolu' rysujemy cos takiego:
     ---|   / ---- srodek
        |  /
        | /
        |/  
        |    
////////////////////////////////////////////////////////////////////////////////
    Dla 'lewo' rysujemy cos takiego (zachowujemy proporcje!)
        /
       / 
      / 
     ----  srodek, czyli wspolrzedne odnosza sie do spodu igly
////////////////////////////////////////////////////////////////////////////////
    Dla 'lewo' rysujemy cos takiego (zachowujemy proporcje!)
      \
       \
        \
     ----  srodek, czyli wspolrzedne odnosza sie do spodu igly
*/
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <windef.h>
#include "ustawieniaGry.h"

#ifndef _GRACZ_H_
#define _GRACZ_H_

typedef struct {                       // struktura opisuje gracza...
        POINT polozenie;               // ...polozenie jego srodka...
        KIERUNEK kierunek;             // ...jego kierunek...
        unsigned int ileRuchow;        // ...i ilosc ruchow
        } GRACZ;

void UstawGracza(GRACZ*, POINT*, KIERUNEK);
void LosujPozycjeGracza(GRACZ*, ushort_t&, ushort_t&);
void RysujGracza(HDC&, GRACZ*);
void UstawIloscRuchow(GRACZ*, unsigned int);
unsigned int PobierzIloscRuchow(GRACZ*);

#ifndef _SETPOS_F_
#define _SETPOS_F_
POINT SetPos(int xMax, int yMax) {
         int xTmp, yTmp;
         POINT ptTemp;
         // ponizsze dzialanie sprawia, ze elementy znajduja sie w obrebie
         // widocznosci gracza
         xTmp = (rand() % (xMax - SREDNICA_KORALIKA)) + PROMIEN_KORALIKA;
         yTmp = (rand() % (yMax - SREDNICA_KORALIKA)) + PROMIEN_KORALIKA;
         // teraz trzeba nam skorygowac wyniki w taki sposob
         // aby mozliwe bylo przejscie igla przez srodek koralika
         xTmp -= (xTmp % WIELKOSC_KROKU);
         yTmp -= (yTmp % WIELKOSC_KROKU);
         ptTemp.x = xTmp;
         ptTemp.y = yTmp;
         return ptTemp;
}
#endif /* _SETPOS_F_ */

//////////////////////////////////Implementacja////////////////////////////////////////////////////
void UstawGracza(GRACZ* gracz, POINT* ptPoint, KIERUNEK kierunek) {
     gracz->polozenie = *ptPoint;
     gracz->kierunek = kierunek;
}
void LosujPozycjeGracza(GRACZ* gracz, ushort_t& xObszarGry, ushort_t& yObszarGry) {
     POINT ptPoint;
     ptPoint = SetPos(xObszarGry, yObszarGry);
     UstawGracza(gracz, &ptPoint, (KIERUNEK)((rand() % 4) + 1));
}
void RysujGracza(HDC& hdc, GRACZ* gracz) {
     int i;
     POINT ptTemp;
     POINT ptPunkty[4];    
     ptTemp = gracz->polozenie;
     for(i = 0; i < 4; i++) {
           if(i == 1) {
                switch(gracz->kierunek) {
                                 case GORA:
                                 case DOL: {
                                      ptPunkty[i].y = ptTemp.y + (gracz->kierunek == GORA ? 
                                                                  -SREDNICA_KORALIKA : 
                                                                  SREDNICA_KORALIKA);
                                      ptPunkty[i].x = ptTemp.x;
                                      break;
                                 }
                                 case LEWO:
                                 case PRAWO: {
                                      ptPunkty[i].x = ptTemp.x + (gracz->kierunek == LEWO ? 
                                                                  -SREDNICA_KORALIKA :
                                                                  SREDNICA_KORALIKA);
                                      ptPunkty[i].y = ptTemp.y;
                                      break;
                                 }
                }
           }
           else if(i == 2) {
                switch(gracz->kierunek) {
                                 case GORA:
                                 case DOL: {
                                      ptPunkty[i].x = ptTemp.x + PROMIEN_KORALIKA / 2;
                                      ptPunkty[i].y = ptTemp.y;
                                      break;
                                 }
                                 case LEWO:
                                 case PRAWO: {
                                      ptPunkty[i].y = ptTemp.y - PROMIEN_KORALIKA / 2;
                                      ptPunkty[i].x = ptTemp.x;
                                      break;
                                 }
                }
           }
           else {
                ptPunkty[i].x = ptTemp.x;
                ptPunkty[i].y = ptTemp.y;
           }
     }     
     Polyline(hdc, ptPunkty, 4);
}
void UstawIloscRuchow(GRACZ* gracz, unsigned int ile) {
     gracz->ileRuchow = ile;
}
unsigned int PobierzIloscRuchow(GRACZ* gracz) {
         return (gracz->ileRuchow);
}

#endif /* _GRACZ_H_ */
