#ifndef OBRAZ_ELEMENTU_SWIATA
#define OBRAZ_ELEMENTU_SWIATA
/*  Plik ten  zawiera deklaracje klas odpowiedzialnych za wizualizacje 
    elementow swiata. Obiekty tych klas zarzadzaja spritami opowiadajcymi
    zadanym elementom swiata.
    Hierarchia klas:
      -ObrazElementuSwiata
        |-ObrazLeminga
	|  |-ObrazBlokera
	|  |-ObrazPracujacego
	|  |   |-ObrazPijusa 
	|  |   |-ObrazSchodkarza
	|  |   |   -ObrazSchodkarzaGornego
	|  |   |   -ObrazSchodkarzaDolnego
	|  |   |   -ObrazSchodkarzaPoziomego
	|  |   |-ObrazKopacza
	|  |       -ObrazKopaczaPoziomego
	|  |	   -ObrazKopaczaPionowego
	|  |	   -ObrazKopaczaSkonsegoWGore
	|  |	   -ObrazKopaczaSkosnegoWDol
      	|-ObrazWejscioWyjscia
  	|     -ObrazWyjscia
        |     -ObrazWejscia
	|-ObrazBomby;
	
   W konstruktorach podaje sie wskaznik na opowiadajacy element swiata,
   i wskaznik na ObrazPlanszy. W przypadku braku pierwszego parametru jest
   przyjmowany tryb tzw. kursora tzn. bedzie wyswietlany sprit obrazujacy
   dany element i bedzie nastepowala zmiana klatek lecz za kazdym razem	
   trzeba mu podac wspolrzedne wyswietlania naogol wspolrzedne kursora 
   myszki w przypadku braku wspolrzednych element stoi w miejscu.
   W trybie zwyklym kazdy obiekt otrzymawszy sygnal na slot rysujSie()
   odczyta potrzebne informacje od odpowiadajacego mu elementu swiata takie jak:
   stan, zwrot_nosa, liczba_impulsow, licznik_impulsow, zapas sil i dobierze
   odpowiedni rysunek w odpowiednim miejscu na ekranie.
   
   Autor: Michal Wiktor Zmijewski  (grupa nr 5)
*/   
   	      	  	   
class ObrazElementuSwiata;
class ObrazLeminga;

#ifndef OBRAZ_PLANSZY
#include "naglowki/ObrazPlanszy.h"
#endif

class ObrazElementuSwiata : public QObject {
 Q_OBJECT
public:
     ObrazElementuSwiata():obraz(0),zwrot(0){};
     ObrazElementuSwiata(ObrazPlanszy* plansza):obrazPlanszy(plansza),obraz(0),zwrot(0){};
     virtual ~ObrazElementuSwiata(){ delete obraz;};
     virtual void pokazSie(QPoint,QPoint){};
     virtual void pokazSie(){};
     virtual void odwrocSie(){};
              int  podajZwrot(){ return zwrot; };
     virtual QPoint podajSrodek(QPoint p){ return p;};	     
public slots:
    virtual void rysujSie()=0;
protected:
    ObrazPlanszy* obrazPlanszy; /* wskaznik na ObrazPlanszy zarzadce */
    QwSprite *obraz; /* sprite - elementu */
    int  liczba_klatek;
    unsigned int stan;
    int zwrot;
    QPoint wspl;
    virtual void pobierzAnimacje(int,typ_rodzaj);/* pobiera animacje elementu w stanie */
    virtual void wyliczSwojaPozycje(float wspol=1){};/* wylicza pozycje elemntu wynikajaca
            ze wspolczynnika wspol bedacego wartoscia funkcji od licznika_impulsow i liczby_impulsow*/
};
/* OBRAZ LEMINGA */
class ObrazLeminga : public ObrazElementuSwiata {
 Q_OBJECT
public:
      ObrazLeminga(){};     // tryb kursora
      ObrazLeminga(Leming *lem,ObrazPlanszy *obraz);
      ObrazLeminga(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazLeminga(){};
      virtual void pokazSie(QPoint,QPoint);/* kaze wyswietlic kursor w pozycji */
         /* UWAGA !! funkcja scisle uzalezniona od obrazu planszy i jej trybu pracy */
      virtual void pokazSie();/* kaze zmienic klatke kursora */
      virtual void odwrocSie();/* odwraca Leminga tzn. pobiera klatki odwroconego */
      virtual QPoint podajSrodek(QPoint);/* podaje srodek bitmapy leminga */	     
protected:
     enum { kursor, zwykly } tryb;
     Leming* leming;
     Para   pozycja;

     void inicjacjaKursora();
     void wyliczSwojaPozycje(float wspol=1);
     void pobierzAnimacje(int nr,typ_rodzaj kto=LEMING)
                     { ObrazElementuSwiata::pobierzAnimacje(nr,kto);}
     virtual void narysujSie(typ_rodzaj kto=LEMING);
            
public slots:
      virtual void rysujSie();
};
/* OBRAZ BLOKERA */
class ObrazBlokera : public ObrazLeminga {
 Q_OBJECT
public:
      ObrazBlokera(Bloker *blo,ObrazPlanszy *obraz,int sit=10);
      ObrazBlokera(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazBlokera(){};
        void odwrocSie(){};
public slots:
      virtual void rysujSie();
private:
       int sito;
};

/*                           OBRAZ PRACUJACEGO */
class ObrazPracujacego : public ObrazLeminga {
 Q_OBJECT
public:
      ObrazPracujacego(KomandosPracujacy *blo,ObrazPlanszy *obraz);
      ObrazPracujacego(ObrazPlanszy *obraz);        // tryb kursora
      ~ObrazPracujacego(){};
protected:
       virtual void narysujSie(typ_rodzaj kto=LEMING);
};
/* OBRAZ PIJUSA */
class ObrazPijusa : public ObrazPracujacego {
 Q_OBJECT
public:
      ObrazPijusa(Pijus *blo,ObrazPlanszy *obraz);
      ObrazPijusa(ObrazPlanszy *obraz);        // tryb kursora

      virtual ~ObrazPijusa(){};
        void odwrocSie();
public slots:
      virtual void rysujSie();
};

/* OBRAZ SCHODKARZA */
class ObrazSchodkarza : public ObrazPracujacego {
 Q_OBJECT
public:
      ObrazSchodkarza(Schodkarz *blo,ObrazPlanszy *obraz)
       :ObrazPracujacego(blo,obraz){};
      ObrazSchodkarza(ObrazPlanszy *obraz)        // tryb kursora
       :ObrazPracujacego(obraz){};
      ~ObrazSchodkarza(){};
};

/* OBRAZ SCHODKARZA GORNEGO*/
class ObrazSchodkarzaGornego : public ObrazSchodkarza {
 Q_OBJECT
public:
      ObrazSchodkarzaGornego(SchodkarzGorny *blo,ObrazPlanszy *obraz);
      ObrazSchodkarzaGornego(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazSchodkarzaGornego(){};
      void odwrocSie();
public slots:
      void rysujSie();
};

/* OBRAZ SCHODKARZA DOLNEGO*/

class ObrazSchodkarzaDolnego : public ObrazSchodkarza {
 Q_OBJECT
public:
      ObrazSchodkarzaDolnego(SchodkarzDolny *blo,ObrazPlanszy *obraz);
      ObrazSchodkarzaDolnego(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazSchodkarzaDolnego(){};
      void odwrocSie();
public slots:
      void rysujSie();
};

/* OBRAZ SCHODKARZA POZIOMEGO*/

class ObrazSchodkarzaPoziomego : public ObrazSchodkarza {
 Q_OBJECT
public:
      ObrazSchodkarzaPoziomego(SchodkarzPoziomy *blo,ObrazPlanszy *obraz);
      ObrazSchodkarzaPoziomego(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazSchodkarzaPoziomego(){};
      void odwrocSie();
public slots:
      void rysujSie();
};

/* OBRAZ KOPACZA */
class ObrazKopacza : public ObrazPracujacego {
 Q_OBJECT
public:
      ObrazKopacza(Kopacz *blo,ObrazPlanszy *obraz)
             :ObrazPracujacego(blo,obraz){};

      ObrazKopacza(ObrazPlanszy *obraz)        // tryb kursora
             :ObrazPracujacego(obraz){};

      ~ObrazKopacza(){};
};

/* OBRAZ KOPACZA PIONOWEGO */
class ObrazKopaczaPionowego : public ObrazKopacza {
 Q_OBJECT
public:
      ObrazKopaczaPionowego(KopaczPionowy *blo,ObrazPlanszy *obraz);
      ObrazKopaczaPionowego(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazKopaczaPionowego(){};
      void odwrocSie();
public slots:
      void rysujSie();
};

/* OBRAZ KOPACZA POZIOMEGO */

class ObrazKopaczaPoziomego : public ObrazKopacza {
 Q_OBJECT
public:
      ObrazKopaczaPoziomego(KopaczPoziomy *blo,ObrazPlanszy *obraz);
      ObrazKopaczaPoziomego(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazKopaczaPoziomego(){};
      void odwrocSie();
public slots:
      void rysujSie();
};

/* OBRAZ KOPACZA SKOSNEGO W GORE i W DOL */

class ObrazKopaczaSkosnegoWGore : public ObrazKopacza {
 Q_OBJECT
public:
      ObrazKopaczaSkosnegoWGore(KopaczSkosnyWGore *blo,ObrazPlanszy *obraz);
      ObrazKopaczaSkosnegoWGore(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazKopaczaSkosnegoWGore(){};
      void odwrocSie();
public slots:
      void rysujSie();
};
class ObrazKopaczaSkosnegoWDol : public ObrazKopacza {
 Q_OBJECT
public:
      ObrazKopaczaSkosnegoWDol(KopaczSkosnyWDol *blo,ObrazPlanszy *obraz);
      ObrazKopaczaSkosnegoWDol(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazKopaczaSkosnegoWDol(){};
      void odwrocSie();
public slots:
      void rysujSie();
};

/* OBRAZ WEJSCIOWYJSCIA */
class ObrazWejscioWyjscia: public ObrazElementuSwiata {
Q_OBJECT
public:
      ObrazWejscioWyjscia(ElementSwiata *,ObrazPlanszy *);
      virtual ~ObrazWejscioWyjscia(){};
protected:
     Para   pozycja;
     ElementSwiata *element;
     
     void wyliczSwojaPozycje(float wspol=1);
     void pobierzAnimacje(int nr,typ_rodzaj kto=WEJSCIE)
                     { ObrazElementuSwiata::pobierzAnimacje(nr,kto);}
     virtual void narysujSie(typ_rodzaj kto=WEJSCIE);
            
};
/* OBRAZ WEJSCIA */
class ObrazWejscia : public ObrazWejscioWyjscia {
 Q_OBJECT
public:
      ObrazWejscia(Wejscie *,ObrazPlanszy *obraz);
     virtual ~ObrazWejscia(){};
public slots:
      void rysujSie();
};
/* OBRAZ WYJSCIA */
class ObrazWyjscia : public ObrazWejscioWyjscia {
 Q_OBJECT
public:
      ObrazWyjscia(Wyjscie *,ObrazPlanszy *obraz);
      virtual ~ObrazWyjscia(){};
public slots:
      void rysujSie();
};
/* KONIEC OBRAZU WEJSCIOWYJSCIA */
/* OBRAZ BOMBY */
class ObrazBomby : public ObrazElementuSwiata {
 Q_OBJECT
public:
      ObrazBomby(){};     // tryb kursora
      ObrazBomby(Bomba *lem,ObrazPlanszy *obraz);
      ObrazBomby(ObrazPlanszy *obraz);        // tryb kursora
      virtual ~ObrazBomby(){};
      virtual void pokazSie(QPoint,QPoint);
      virtual void pokazSie();
      virtual void odwrocSie(){};/* nie moze sie odwracac */
      virtual QPoint podajSrodek(QPoint);	     
protected:
     enum { kursor, zwykly } tryb;
     Bomba* bomba;
     Para   pozycja;

     void inicjacjaKursora();
     void wyliczSwojaPozycje(float wpol=1);
     void narysujSie();
            
public slots:
      virtual void rysujSie();
};
#endif