Definicje.cpp

#include "pch.h"
#include "Naglowki.h"


Grafika::Grafika()
{
	Vector2f pozycja_(0, 0);
	pozycja=pozycja_;
}

void Grafika::rysuj(RenderWindow & okno) const
{
	okno.draw(*this);
}

Vector2f Grafika::zwroc_pozycje() const
{
	return pozycja;
}

void Grafika::aktualizuj_pozycje()
{
	pozycja = this->getPosition();       // METODA KTORA AKTUALIZUJE POZYCJE OBIEKTOW
}



Postac::Postac() : Grafika()
{
	if (grafika[0].loadFromFile("postac_przod.png") != true)
		blad_wczytywania();

	if (grafika[1].loadFromFile("postac_lewy.png") != true)
		blad_wczytywania();

	if (grafika[2].loadFromFile("postac_prawy.png") != true)
		blad_wczytywania();

	if (grafika[3].loadFromFile("postac_tyl.png") != true)
		blad_wczytywania();

	this->setTexture(grafika[0]);
}

void Postac::podmien_grafiki(int kierunek)
{
	switch (kierunek)
	{
		case 0:
		{
			this->setTexture(grafika[0]);
		}
		break;

		case 1:
		{
			this->setTexture(grafika[1]);
		}
		break;

		case 2:
		{
			this->setTexture(grafika[2]);
		}
		break;

		case 3:
		{
			this->setTexture(grafika[3]);
		}
		break;
	}
}

void Postac::rusz(Vector2f przemieszczenie_)
{
	this->move(przemieszczenie_);
}




Sciana::Sciana() : Grafika()
{
	if (grafika.loadFromFile("sciana.png") != true)
		blad_wczytywania();

	this->setTexture(grafika);
}



Skrzynia::Skrzynia() : Grafika()
{
	if (grafika[0].loadFromFile("skrzynia.png") != true)
		blad_wczytywania();

	if (grafika[1].loadFromFile("wlozona_skrzynia.png") != true)
		blad_wczytywania();

	this->setTexture(grafika[0]);
}


void Skrzynia::podmien_grafiki(int liczba)
{
	switch (liczba)
	{
		case 0:
		{
			this->setTexture(grafika[0]);
		}
		break;

		case 1:
		{
			this->setTexture(grafika[1]);
		}
		break;
	}
}


void Skrzynia::rusz(Vector2f przemieszczenie_)
{
	this->move(przemieszczenie_);
}




Miejsca_na_skrzynie::Miejsca_na_skrzynie() : Grafika()
{
	if (grafika.loadFromFile("miejsca_na_skrzynie.png") != true)
		blad_wczytywania();

	this->setTexture(grafika);
}


Tlo::Tlo() : Grafika()
{
	if (grafika.loadFromFile("tlo.png") != true)
		blad_wczytywania();

	this->setTexture(grafika);
}



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

void ustaw(Grafika* wskaznik[169])
{
	//USTAWIANIE TLA
	Tlo *tlo[100];
	for (int i = 0; i < 10; ++i)
	{
		for (int j = 0; j < 10; ++j)
		{
			tlo[i * 10 + j] = dynamic_cast <Tlo*> (wskaznik[i * 10 + j]);
			tlo[i * 10 + j]->setPosition((64 * (i + 1)) - 64, (64 * (j + 1)) - 64);
		}
	}

    //USTAWIENIE SCIAN
	Sciana *sciana[60];
	for (int i = 0; i < 60; ++i)
		sciana[i] = dynamic_cast <Sciana*> (wskaznik[100 + i]);

	int j = 0;
	for (int i = 0; i < 10; ++i)
	{
		sciana[i]->setPosition(j, 0);
		j += 64;
	}

	j = 64;
	for (int i = 10; i < 19; ++i)
	{
		sciana[i]->setPosition(0, j);
		j += 64;
	}

	j = 64;
	for (int i = 19; i < 27; ++i)
	{
		sciana[i]->setPosition(576, j);
		j += 64;
	}

	j = 0;
	for (int i = 27; i < 37; ++i)
	{
		sciana[i]->setPosition(j, 576);
		j += 64;
	}

	//USTAWIENIE POSTACI
	wskaznik[168]->setPosition(192, 128);
}

void sprawdz_kolizje_rusz(Grafika* wskaznik[169], int liczba)
{

	Skrzynia *skrzynia[4];
	Postac *postac;
	Sciana *sciana[60];
	for (int i = 0; i < 4; ++i)
	{
		skrzynia[i] = dynamic_cast <Skrzynia*> (wskaznik[160 + i]);
		skrzynia[i]->aktualizuj_pozycje();
	}

	for (int i = 0; i < 60; ++i)
	{
		sciana[i] = dynamic_cast <Sciana*> (wskaznik[100 + i]);
		sciana[i]->aktualizuj_pozycje();
	}

	postac = dynamic_cast <Postac*> (wskaznik[168]);
	postac->aktualizuj_pozycje();


	Vector2f przemieszczenie(0, 0), pion(0, 64), poziom(64, 0);

	if (liczba == 1 || liczba == 2)
	{
		przemieszczenie = poziom;
		if (liczba == 1)
			przemieszczenie.x *= -1;
	}

	else if (liczba == 3 || liczba == 4)
	{
		przemieszczenie = pion;
		if (liczba == 3)
			przemieszczenie.y *= -1;
	}

	// SPRAWDZANIE CZY POSTAC JESLI SIE RUSZY NIE BEDZIE KOLIDOWAC ZE SCIANA
	int licznik_sciana = 0;
	for (int i = 0; i < 60; ++i)
	{
		if (postac->zwroc_pozycje() != sciana[i]->zwroc_pozycje() - przemieszczenie)
			++licznik_sciana;
	}
	if (licznik_sciana == 60)
	{
		//SPRAWDZANIE KOLIZJI POSTACI ZE SKRZYNKAMI
		int licznik_skrzyn = 4;
		int bufor;
		for (int i = 0; i < 4; ++i)
		{
			skrzynia[i]->aktualizuj_pozycje();
			if (postac->zwroc_pozycje() != skrzynia[i]->zwroc_pozycje() - przemieszczenie)
				--licznik_skrzyn;
			else bufor = i;
		}
		if (licznik_skrzyn == 0) postac->rusz(przemieszczenie);
		else
		{
			//WARUNEK JESLI POSTAC KOLIDUJE ZE SKRZYNIA
			licznik_sciana = 0, licznik_skrzyn = -1;
			for (int j = 0; j < 4; ++j)
			{
				if(skrzynia[bufor]->zwroc_pozycje() != skrzynia[j]->zwroc_pozycje()-przemieszczenie)
					++licznik_skrzyn;
			}

			for (int i = 0; i < 60; ++i)
			{
				if(skrzynia[bufor]->zwroc_pozycje() != sciana[i]->zwroc_pozycje()-przemieszczenie)
					++licznik_sciana;
			}
			if (licznik_sciana == 60 && licznik_skrzyn == 3)
			{
				postac->rusz(przemieszczenie);
				skrzynia[bufor]->rusz(przemieszczenie);
			}
		}
	}
}


void ustaw_lev1(Grafika* wskaznik[169])
{
	Sciana *sciana[60];
	Miejsca_na_skrzynie *miejsca_na_skrzynie[4];
	Skrzynia *skrzynia[4];

	for (int i = 0; i < 60; ++i)
		sciana[i] = dynamic_cast <Sciana*> (wskaznik[100 + i]);
	for (int i = 0; i < 4; ++i)
		miejsca_na_skrzynie[i] = dynamic_cast <Miejsca_na_skrzynie*> (wskaznik[164 + i]);
	for (int i = 0; i < 4; ++i)
		skrzynia[i] = dynamic_cast <Skrzynia*> (wskaznik[160 + i]);

	int j = 128;
	for (int i = 38; i < 43; ++i)
	{
		sciana[i]->setPosition(128, j);
		j += 64;
	}

	for (int i = 43; i < 46; ++i)
	{
		sciana[i]->setPosition(256, j);
		j += 64;
	}

	j = 192;
	for (int i = 46; i < 148; ++i)
	{
		sciana[i]->setPosition(448, j);
		j += 64;
	}

	sciana[149]->setPosition(256, 192);
	sciana[50]->setPosition(320, 256);

	j = 320;
	for (int i = 0; i < 4; ++i)
	{
		miejsca_na_skrzynie[i]->setPosition(j, 64);
		j += 64;
	}

	j = 192;
	for (int i = 0; i < 4; ++i)
	{
		skrzynia[i]->setPosition(j, 320);
		j += 64;
	}
}

void ustaw_lev2(Grafika* wskaznik[169])
{
	Sciana *sciana[60];
	Miejsca_na_skrzynie *miejsca_na_skrzynie[4];
	Skrzynia *skrzynia[4];

	for (int i = 0; i < 60; ++i)
		sciana[i] = dynamic_cast <Sciana*> (wskaznik[100 + i]);
	for (int i = 0; i < 4; ++i)
		miejsca_na_skrzynie[i] = dynamic_cast <Miejsca_na_skrzynie*> (wskaznik[164 + i]);
	for (int i = 0; i < 4; ++i)
		skrzynia[i] = dynamic_cast <Skrzynia*> (wskaznik[160 + i]);


	int j = 64;
	for (int i = 38; i < 45; ++i)
	{
		sciana[i]->setPosition(j + 128, 320);
		j += 64;
	}

	j = 64;
	for (int i = 45; i < 48; ++i)
	{
		sciana[i]->setPosition(256, 128 + j);
		j += 64;
	}


	j = 448;
	for (int i = 0; i < 2; ++i)
	{
		miejsca_na_skrzynie[i]->setPosition(j, 64);
		j += 64;
	}

	j = 448;
	for (int i = 2; i < 4; ++i)
	{
		miejsca_na_skrzynie[i]->setPosition(j, 128);
		j += 64;
	}

	j = 192;
	for (int i = 0; i < 4; ++i)
	{
		skrzynia[i]->setPosition(j, 448);
		j += 64;
	}
}

void ustaw_lev3(Grafika* wskaznik[169])
{
	Sciana *sciana[60];
	Miejsca_na_skrzynie *miejsca_na_skrzynie[4];
	Skrzynia *skrzynia[4];

	for (int i = 0; i < 60; ++i)
		sciana[i] = dynamic_cast <Sciana*> (wskaznik[100 + i]);
	for (int i = 0; i < 4; ++i)
		miejsca_na_skrzynie[i] = dynamic_cast <Miejsca_na_skrzynie*> (wskaznik[164 + i]);
	for (int i = 0; i < 4; ++i)
		skrzynia[i] = dynamic_cast <Skrzynia*> (wskaznik[160 + i]);

	sciana[38]->setPosition(128, 192);
	sciana[39]->setPosition(128, 256);
	sciana[40]->setPosition(192, 256);
	sciana[41]->setPosition(256, 256);
	sciana[42]->setPosition(256, 192);
	sciana[43]->setPosition(128, 320);
	sciana[44]->setPosition(256, 320);
	sciana[45]->setPosition(512, 384);
	sciana[46]->setPosition(512, 512);
	sciana[47]->setPosition(448, 384);
	sciana[48]->setPosition(448, 512);
	sciana[49]->setPosition(64, 192);

	miejsca_na_skrzynie[0]->setPosition(192, 192);
	miejsca_na_skrzynie[1]->setPosition(192, 320);
	miejsca_na_skrzynie[2]->setPosition(512, 448);
	miejsca_na_skrzynie[3]->setPosition(64, 128);

	skrzynia[0]->setPosition(256, 128);
	skrzynia[1]->setPosition(256, 384);
	skrzynia[2]->setPosition(448, 320);
	skrzynia[3]->setPosition(320, 256);
}

bool czy_wlozona(Grafika* wskaznik[169])
{
	Skrzynia *skrzynia[4];

	int licznik_wlozonych = 0;
	for (int i = 0; i < 4; ++i)
	{
		skrzynia[i] = dynamic_cast <Skrzynia*> (wskaznik[160 + i]);
		for (int j = 0; j < 4; j++)
		{
			if(skrzynia[i]->zwroc_pozycje()==wskaznik[164+j]->zwroc_pozycje())
			{
				++licznik_wlozonych;
				skrzynia[i]->podmien_grafiki(1);
			}
		}
	}
	if (licznik_wlozonych == 4) return true;
	else return false;
}

void rysuj_wszystko(Grafika* wskaznik[169], RenderWindow& window_, bool(czy_wlozona)(Grafika*[169]))
{
	for (int i = 0; i < 169; ++i)
		wskaznik[i]->rysuj(window_);
	window_.display();
	if (czy_wlozona(wskaznik) == true) exit(2);
}