LocalMapGameloop.cpp

#include "Engine.h"
#include "Dynamic.h"
#include "Map.h"
#include "All_Dynamics.h"

bool cEngine::UpdateLocalMap(float fElapsedTime) // tryb gry 1 - mapa lokalna
{
	//obsługa sterowania
	bool bHasPlayerAcceleratedX = false;
	bool bHasPlayerAcceleratedY = false;

	bool bKeyPressedInteract = false;
	bool bKeyPressedAttack = false;

	//pobieranie sterowania tylko jeśli okno gry jest aktywne
	if (IsFocused())
	{
		// jeśli silnik uznaje że gracz ma kontrolę (nie działa żaden skrypt itp) to zezwól na sterowanie
		if (ScriptEngine.bPlayerInControl)
		{
			if (!bPause) // jeśli gra nie jest spauzowana
			{
				if (pPlayer->nState != cDynamicCreature::STATE_DEAD) // zezwól na sterowanie tylko jeśli gracz nie jest martwy
				{
					if (!m_bShowMessage) // jeśli nie wyświetla się komunikat
					{
						// poruszanie, atak i interakcja gracza możliwa tylko jeśli ten nie jest obecnie odrzucany (knockback) 
						// ani nie jest w trakcie bezruchu po wykonaniu ataku podstawowego
						if (!pPlayer->bIsKnockbacked && pPlayer->fTime4 == 0.0f)
						{
							if (pPlayer->nState != cDynamicCreature::STATE_SLEEPING && pPlayer->nState != cDynamicCreature::STATE_UNCONSCIOUS)
							{
								if (GetKey(olc::Key::W).bHeld) // W
								{
									pPlayer->vy -= 26.0f * fElapsedTime;
									bHasPlayerAcceleratedY = true;
									pPlayer->nDirection = cDynamic::NORTH;
								}

								if (GetKey(olc::Key::A).bHeld) // A
								{
									pPlayer->vx -= 26.0f * fElapsedTime;
									bHasPlayerAcceleratedX = true;
									pPlayer->nDirection = cDynamic::WEST;
								}

								if (GetKey(olc::Key::S).bHeld) // S
								{
									pPlayer->vy += 26.0f * fElapsedTime;
									bHasPlayerAcceleratedY = true;
									pPlayer->nDirection = cDynamic::SOUTH;
								}

								if (GetKey(olc::Key::D).bHeld) // D
								{
									pPlayer->vx += 26.0f * fElapsedTime;
									bHasPlayerAcceleratedX = true;
									pPlayer->nDirection = cDynamic::EAST;
								}
								if (GetKey(olc::Key::E).bPressed) // E - interakcja z otoczeniem
								{
									if (m_bShowDialog == false && m_bShowMessage == false) // jeśli nie wyświetla się żaden dialog ani komunikat
										bKeyPressedInteract = true;
								}
								if (GetKey(olc::Key::SPACE).bPressed) // spacja - atak
								{
									bKeyPressedAttack = true;
								}
								if (GetKey(olc::Key::ENTER).bPressed) // enter - odskok
								{
									if (PlayerData.fStamina >= PlayerData.fStaminaDashCost) // jeśli gracz ma wystarczająco wytrzymałości
									{
										if (abs(pPlayer->vx) > 0.2f || abs(pPlayer->vy) > 0.2f) // jeśli nie stoi w miejscu przed wykonaniem doskoku
										{
											pPlayer->Knockback(pPlayer->vx * 3.0f * PlayerData.fDashVelocityMultiplier,
												pPlayer->vy * 3.0f * PlayerData.fDashVelocityMultiplier, PlayerData.fDashExecutionTime);
										}
										else // jeśli gracz stoi w miejscu to odskok wykonaj w kierunku zgodnym z kierunkiem jego sprite'a
										{
											switch (pPlayer->nDirection)
											{
											case cDynamic::NORTH:
												pPlayer->Knockback(0.0f, pPlayer->fMaxWalkingVel * -3.0f * PlayerData.fDashVelocityMultiplier,
													PlayerData.fDashExecutionTime);
												break;
											case cDynamic::EAST:
												pPlayer->Knockback(pPlayer->fMaxWalkingVel * 3.0f * PlayerData.fDashVelocityMultiplier, 0.0f,
													PlayerData.fDashExecutionTime);
												break;
											case cDynamic::SOUTH:
												pPlayer->Knockback(0.0f, pPlayer->fMaxWalkingVel * 3.0f * PlayerData.fDashVelocityMultiplier,
													PlayerData.fDashExecutionTime);
												break;
											case cDynamic::WEST:
												pPlayer->Knockback(pPlayer->fMaxWalkingVel * -3.0f * PlayerData.fDashVelocityMultiplier, 0.0f,
													PlayerData.fDashExecutionTime);
												break;
											default:
												break;
											}
										}

										PlayerData.fStamina -= PlayerData.fStaminaDashCost;
										PlayerData.fStaminaTimer = PlayerData.fStaminaRegenDelay;
									}
								}
							}
							// sterowanie niezależne od tego, że postać gracza śpi lub jest nieprzytomna
							// ...
						}
						// sterowanie niezależne od bycia w powietrzu
						// ...
					}

					//sterowanie niezależne od tego, że wyświetla się komunikat
					if (GetKey(olc::Key::E).bPressed) // E - pominięcie obecnego dialogu jeśli nie wyświetla się żaden komunikat ani żaden skrypt nie oczekuje na pominięcie
					{
						if (!m_bShowMessage)
							if(!ScriptEngine.bWaitForManualSkip)
								if (m_bShowDialog)
									NextDialog();
						
					}
				}
				//sterowanie nezależne od bycia martwym
				// ...
			}
			// sterowanie niezależne od pauzy i bycia martwym
			// ...
		}
		//sterowanie niezależne od tego, że silnik skryptów nie zezwala na sterowanie
		if (GetKey(olc::Key::E).bPressed) // E - pominięcie obecnego komunikatu, a jeśli żadnego nie ma, to pominięcie obecnego skryptu czekającego na manualne pominięcie
		{
			if (m_bShowMessage)
				NextMessage();
			else
			{
				if (ScriptEngine.bWaitForManualSkip)
					if (!bPause) // pod warunkiem że gra nie została spauzowana
						ScriptEngine.bWaitForManualSkip = false;
			}
		}

		if (GetKey(olc::Key::O).bPressed) // przełączanie ustawień graficznych - czy silnik ma obsługiwać częściową przeźroczystość sprite'ów
		{
			if (bGfxHighSettings)
				bGfxHighSettings = false;
			else
				bGfxHighSettings = true;
		}

		if (GetKey(olc::Key::P).bPressed) // pauza
		{
			if (bPause)
				bPause = false;
			else
				bPause = true;
		}

		//dev:
		if (GetKey(olc::Key::M).bPressed) // dev
		{
		}
		if (GetKey(olc::Key::L).bPressed) // dev
		{
		}
	}

	if (!bPause) //jeśli gra nie jest zpauzowana
	{
		if (!m_bShowMessage) //jeśli nie wyświetla się żaden komunikat
		{
			//obsługa skrypytów
			ScriptEngine.UpdateScripts(fElapsedTime);

			//jeśli żaden skrypt nie zamroził czasu
			if (!ScriptEngine.bTimeIsFreezed)
			{
				//przekalkulowanie statystyk gracza
				RecalculatePlayerStats();

				//timer czasu od ostatniego użycia akcji wymagającej wytrzymałości
				PlayerData.fStaminaTimer -= fElapsedTime;
				if (PlayerData.fStaminaTimer < 0.0f)
					PlayerData.fStaminaTimer = 0.0f;

				// regeneracja wytrzymałości
				if (PlayerData.fStaminaTimer == 0.0f)
				{
					PlayerData.fStamina += fElapsedTime * PlayerData.fStaminaRegenPerSecond;
					if (PlayerData.fStamina > PlayerData.fMaxStamina)
						PlayerData.fStamina = PlayerData.fMaxStamina;
				}

				if (bKeyPressedAttack) // atak gracza
				{
					if (pPlayer->fTime3 == 0.0f) // czas odnowienia ataku podstawowego
					{
						if (PlayerData.currentWeapon != nullptr) // jeśli gracz posiada założoną broń
						{
							//ustawienie statusu gracza jako w trakcie wykonywania ataku
							pPlayer->nState = cDynamicCreature::STATE_MELEE_ATTACK;
							//ustawienie czasu odnowienia ataku podstawowego
							pPlayer->fTime3 = pPlayer->stats.fMeleeAttackCooldown;
							//ustawienie czasu odnowienia bezruchu po ataku podstawowym
							pPlayer->fTime4 = pPlayer->stats.fMeleeAttackImmobilityCooldown;

							switch (pPlayer->nDirection)
							{
							case cDynamic::NORTH:
								m_currentMap->vecDyn.push_back(new cPlayerMelee(this, (pPlayer->px - 0.125f), (pPlayer->py - 0.875f)));
								break;
							case cDynamic::EAST:
								m_currentMap->vecDyn.push_back(new cPlayerMelee(this, (pPlayer->px + pPlayer->fWidth), (pPlayer->py + 0.125f)));
								break;
							case cDynamic::SOUTH:
								m_currentMap->vecDyn.push_back(new cPlayerMelee(this, (pPlayer->px - 0.125f), (pPlayer->py + pPlayer->fHeight)));
								break;
							case cDynamic::WEST:
								m_currentMap->vecDyn.push_back(new cPlayerMelee(this, (pPlayer->px - 0.875f), (pPlayer->py + 0.0625f)));
								break;
							}
						}
					}
				}

				//obliczanie ruchu wszystkich obiektów dynamicznych
				for (unsigned int i = 0; i < m_currentMap->vecDyn.size(); i++)
				{
					//obsługa "pocisków" - aktualizacja czasu i statusu przestarzałego
					if (m_currentMap->vecDyn[i]->bIsProjectile)
					{
						m_currentMap->vecDyn[i]->fProjectileTime -= fElapsedTime;
						if (m_currentMap->vecDyn[i]->fProjectileTime <= 0.0f)
							m_currentMap->vecDyn[i]->bIsRedundant = true;
					}

					// modyfikacje ruchu gracza
					if (m_currentMap->vecDyn[i]->sName == "player")
					{
						// jeśli gracz właśnie nie jest odrzucany i nie podlega właśnie skryptowi
						if (m_currentMap->vecDyn[i]->bIsKnockbacked == false && pPlayer->bIsMovedByScript == false)
						{
							//spowolnienie
							if (!bHasPlayerAcceleratedX)
							{
								float decelerationX = -16.0f * m_currentMap->vecDyn[i]->vx * fElapsedTime;

								//zabezpieczenie przed spowolnieniem powodującym zmianę zwrotu kierunku wektora prędkości gracza
								//przy niskiej wartości klatek na sekundę
								if (abs(decelerationX) > m_currentMap->vecDyn[i]->vx)
									decelerationX = -m_currentMap->vecDyn[i]->vx;

								m_currentMap->vecDyn[i]->vx += decelerationX;
							}
							if (!bHasPlayerAcceleratedY)
							{
								float decelerationY = -16.0f * m_currentMap->vecDyn[i]->vy * fElapsedTime;

								//zabezpieczenie przed spowolnieniem powodującym zmianę zwrotu kierunku wektora prędkości gracza
								//przy niskiej wartości klatek na sekundę
								if (abs(decelerationY) > m_currentMap->vecDyn[i]->vy)
									decelerationY = -m_currentMap->vecDyn[i]->vy;

								m_currentMap->vecDyn[i]->vy += decelerationY;
							}
						}
					}

					//aktualizacja stanu, animacji, odrzutu i AI każdego obiektu dynamicznego
					m_currentMap->vecDyn[i]->Update(fElapsedTime, pPlayer);

					// jeśli po aktualizacji obiektów dynamicznych zmieniła się prędkość gracza i nie stoi on już w miejscu
					// (grafika miecza i gracza nie pokrywałaby się)
					// to wtedy usuń miecz gracza
					if (m_currentMap->vecDyn[i]->sName == "player melee")
						if (pPlayer->vx != 0.0f || pPlayer->vy != 0.0f)
							m_currentMap->vecDyn[i]->bIsRedundant = true;

					//ustawienie prędkości każdego ciała jako zero przy prędkościach bliskich zeru
					if (abs(m_currentMap->vecDyn[i]->vx) < 0.005f)	m_currentMap->vecDyn[i]->vx = 0.0f;
					if (abs(m_currentMap->vecDyn[i]->vy) < 0.005f)	m_currentMap->vecDyn[i]->vy = 0.0f;

					//potencjalne nowe położenie
					float fNewpx = m_currentMap->vecDyn[i]->px + (m_currentMap->vecDyn[i]->vx * fElapsedTime);
					float fNewpy = m_currentMap->vecDyn[i]->py + (m_currentMap->vecDyn[i]->vy * fElapsedTime);

					//krawędź kolizji statycznej
					float fBorder = 0.1f;

					//kolizja statyczna
					if (m_currentMap->vecDyn[i]->bSolidVsSolid)
					{
						if (m_currentMap->vecDyn[i]->vx <= 0)	// ruch w lewo
						{
							if (m_currentMap->vecDyn[i]->fWidth > 1.0f) // sprawdzenie czy obiekt jest szerszy niż szerokość jednej kafelki i obsługa kolizji w odpowiedni sposób
							{
								//sprawdzenie czy wierzchołki kolidują z mapą
								bool bCollision = false;
								if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(m_currentMap->vecDyn[i]->py + 0.0f)) ||
									m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight - fBorder)))
								{
									bCollision = true;
								}

								if (!bCollision) // jeśli wierzchołki nie kolidują, sprawdź punkty położone na krawędziach pokrywające cały bok prostokąta w równych odstępach
									for (int z = 1; z < m_currentMap->vecDyn[i]->fHeight; z++)
										if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(m_currentMap->vecDyn[i]->py + z)))
											bCollision = true;

								if (bCollision) // egzekucja kolizji
								{
									fNewpx = (int)fNewpx + 1.0f;
									m_currentMap->vecDyn[i]->vx = 0.0f;
								}
							}
							else // szerokość obiektu jest mniejsza lub równa 1
							{
								if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(m_currentMap->vecDyn[i]->py + 0.0f)) ||
									m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight - fBorder)))
								{
									fNewpx = (int)fNewpx + 1.0f;
									m_currentMap->vecDyn[i]->vx = 0.0f;
								}
							}
						}
						else						// ruch w prawo
						{
							if (m_currentMap->vecDyn[i]->fWidth > 1.0f) // sprawdzenie czy obiekt jest szerszy niż szerokość jednej kafelki i obsługa kolizji w odpowiedni sposób
							{
								//sprawdzenie czy wierzchołki kolidują z mapą
								bool bCollision = false;
								if (m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth), (int)(m_currentMap->vecDyn[i]->py + 0.0f)) ||
									m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth), (int)(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight - fBorder)))
								{
									bCollision = true;
								}

								if (!bCollision) // jeśli wierzchołki nie kolidują, sprawdź punkty położone na krawędziach pokrywające cały bok prostokąta w równych odstępach
									for (int z = 1; z < m_currentMap->vecDyn[i]->fHeight; z++)
										if (m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth), (int)(m_currentMap->vecDyn[i]->py + z)))
											bCollision = true;

								if (bCollision) // egzekucja kolizji
								{
									fNewpx = (int)fNewpx + (int)m_currentMap->vecDyn[i]->fWidth - m_currentMap->vecDyn[i]->fWidth;
									m_currentMap->vecDyn[i]->vx = 0.0f;
								}
							}
							else // szerokość obiektu jest mniejsza lub równa 1
							{
								if (m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth), (int)(m_currentMap->vecDyn[i]->py + 0.0f)) ||
									m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth), (int)(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight - fBorder)))
								{
									fNewpx = (int)fNewpx + (1.0f - m_currentMap->vecDyn[i]->fWidth);
									m_currentMap->vecDyn[i]->vx = 0.0f;
								}
							}
						}

						if (m_currentMap->vecDyn[i]->vy <= 0)	// ruch w górę
						{
							if (m_currentMap->vecDyn[i]->fHeight > 1.0f) // sprawdzenie czy obiekt jest wyższy niż wysokość jednej kafelki i obsługa kolizji w odpowiedni sposób
							{
								//sprawdzenie czy wierzchołki kolidują z mapą
								bool bCollision = false;
								if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(fNewpy)) || m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth - fBorder), (int)(fNewpy)))
								{
									bCollision = true;
								}

								if (!bCollision) // jeśli wierzchołki nie kolidują, sprawdź punkty położone na krawędziach pokrywające cały bok prostokąta w równych odstępach
									for (int z = 1; z < m_currentMap->vecDyn[i]->fHeight; z++)
										if (m_currentMap->GetSolid((int)(fNewpx + z), (int)(fNewpy)))
											bCollision = true;

								if (bCollision) // egzekucja kolizji
								{
									fNewpy = (int)fNewpy + 1.0f;
									m_currentMap->vecDyn[i]->vy = 0.0f;
								}
							}
							else // wysokość obiektu jest mniejsza lub równa 1
							{
								if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(fNewpy)) || m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth - fBorder), (int)(fNewpy)))
								{
									fNewpy = (int)fNewpy + 1.0f;
									m_currentMap->vecDyn[i]->vy = 0.0f;
								}
							}
						}
						else						// ruch w dół
						{
							if (m_currentMap->vecDyn[i]->fHeight > 1.0f) // sprawdzenie czy obiekt jest wyższy niż wysokość jednej kafelki i obsługa kolizji w odpowiedni sposób
							{
								//sprawdzenie czy wierzchołki kolidują z mapą
								bool bCollision = false;
								if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(fNewpy + m_currentMap->vecDyn[i]->fHeight)) ||
									m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth - fBorder), (int)(fNewpy + m_currentMap->vecDyn[i]->fHeight)))
								{
									bCollision = true;
								}

								if (!bCollision) // jeśli wierzchołki nie kolidują, sprawdź punkty położone na krawędziach pokrywające cały bok prostokąta w równych odstępach
									for (int z = 1; z < m_currentMap->vecDyn[i]->fHeight; z++)
										if (m_currentMap->GetSolid((int)(fNewpx + z), (int)(fNewpy + m_currentMap->vecDyn[i]->fHeight)))
											bCollision = true;

								if (bCollision) // egzekucja kolizji
								{
									fNewpy = fNewpy = (int)fNewpy + (int)m_currentMap->vecDyn[i]->fHeight - m_currentMap->vecDyn[i]->fHeight;
									m_currentMap->vecDyn[i]->vy = 0.0f;
								}
							}
							else // wysokość obiektu jest mniejsza lub równa 1
							{
								if (m_currentMap->GetSolid((int)(fNewpx + 0.0f), (int)(fNewpy + m_currentMap->vecDyn[i]->fHeight)) ||
									m_currentMap->GetSolid((int)(fNewpx + m_currentMap->vecDyn[i]->fWidth - fBorder), (int)(fNewpy + m_currentMap->vecDyn[i]->fHeight)))
								{
									fNewpy = (int)fNewpy + (1.0f - m_currentMap->vecDyn[i]->fHeight);
									m_currentMap->vecDyn[i]->vy = 0.0f;
								}
							}
						}
					}

					//właściwa kolizja dynamiczna + (INTERACT_NATURE::WALK_ON)
					//kolizja wszystkich obiektów dynamicznych...
					for (unsigned int j = 0; j < m_currentMap->vecDyn.size(); j++) // z każdym innym obiektem dynamicznym,...
					{
						if (i != j) // ...ale nie z samym sobą
						{
							if (DistanceBetweenDynCenterPow2(m_currentMap->vecDyn[i], m_currentMap->vecDyn[j]) < fCollisionDetectionDistancePow2)
								// sprawdzenie kolizji przeprowadź tylko jeżeli obiekty sa blisko siebie 
								// (funkcja zwraca odległość do kwadradu, aby uniknąć zasobochłonnego pierwiastkowania liczby zmiennoprzecinkowej)
							{
								//sprawdzanie kolizji w osi X
								if (fNewpx < (m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth) && (fNewpx + m_currentMap->vecDyn[i]->fWidth) > m_currentMap->vecDyn[j]->px &&
									m_currentMap->vecDyn[i]->py < (m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight) &&
									(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight) > m_currentMap->vecDyn[j]->py)
									// sprawdzenie czy prostokąty się nakładają (oś Y to stara pozycja)
								{
									if (m_currentMap->vecDyn[i]->vx <= 0)	// kolizja nastąpiła przy ruchu w lewo
									{
										if (m_currentMap->vecDyn[i]->bSolidVsDynamic && m_currentMap->vecDyn[j]->bSolidVsDynamic) // Egzekucja kolizji następuje tylko wetdy 
											//kiedy obydwa obiekty podlegają kolizji dynamicznej
										{
											m_currentMap->vecDyn[i]->vx = 0.0f;
											fNewpx = m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth;
										}

										// jeśli zaszła kolizja wywołaj interakcję między obiektami
										// jeśli funkcja zwróci true to przerwij wykowynawie obecnej iteracji pętli gry i rozpocznij następną
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::WALK_ON, m_currentMap->vecDyn[i]))
											return true;

									}
									else						// kolizja nastąpiła przy ruchu w prawo
									{
										if (m_currentMap->vecDyn[i]->bSolidVsDynamic && m_currentMap->vecDyn[j]->bSolidVsDynamic) // Egzekucja kolizji następuje tylko wetdy 
											//kiedy obydwa obiekty podlegają kolizji dynamicznej
										{
											m_currentMap->vecDyn[i]->vx = 0.0f;
											fNewpx = m_currentMap->vecDyn[j]->px - m_currentMap->vecDyn[i]->fWidth;
										}

										// jeśli zaszła kolizja wywołaj interakcję między obiektami
										// jeśli funkcja zwróci true to przerwij wykowynawie obecnej iteracji pętli gry i rozpocznij następną
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::WALK_ON, m_currentMap->vecDyn[i]))
											return true;

									}
								}

								//sprawdzanie kolizji w osi Y
								if (fNewpx < (m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth) && (fNewpx + m_currentMap->vecDyn[i]->fWidth) > m_currentMap->vecDyn[j]->px &&
									fNewpy < (m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight) && (fNewpy + m_currentMap->vecDyn[i]->fHeight) > m_currentMap->vecDyn[j]->py)
									// sprawdzenie czy prostokąty się nakładają (oś Y to nowa pozycja)
								{
									if (m_currentMap->vecDyn[i]->vy <= 0)	// kolizja nastąpiła przy ruchu w górę
									{
										if (m_currentMap->vecDyn[i]->bSolidVsDynamic && m_currentMap->vecDyn[j]->bSolidVsDynamic) // Egzekucja kolizji następuje tylko wetdy 
											//kiedy obydwa obiekty podlegają kolizji dynamicznej
										{
											m_currentMap->vecDyn[i]->vy = 0.0f;
											fNewpy = m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight;
										}

										// jeśli zaszła kolizja wywołaj interakcję między obiektami
										// jeśli funkcja zwróci true to przerwij wykowynawie obecnej iteracji pętli gry i rozpocznij następną
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::WALK_ON, m_currentMap->vecDyn[i]))
											return true;

									}
									else						//kolizja nastąpiła przy ruchu w dół
									{
										if (m_currentMap->vecDyn[i]->bSolidVsDynamic && m_currentMap->vecDyn[j]->bSolidVsDynamic) // Egzekucja kolizji następuje tylko wetdy 
											//kiedy obydwa obiekty podlegają kolizji dynamicznej
										{
											m_currentMap->vecDyn[i]->vy = 0.0f;
											fNewpy = m_currentMap->vecDyn[j]->py - m_currentMap->vecDyn[i]->fHeight;
										}

										// jeśli zaszła kolizja wywołaj interakcję między obiektami
										// jeśli funkcja zwróci true to przerwij wykowynawie obecnej iteracji pętli gry i rozpocznij następną
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::WALK_ON, m_currentMap->vecDyn[i]))
											return true;

									}
								}

								//koniec sprawdzania właściwej kolizji
							}
						}
					}



					//jeżeli obiekt jest graczem, przeprowadź dodatkową detekcję kolizji aktywującą interakcję
					if (m_currentMap->vecDyn[i]->sName == "player")
					{
						if (bKeyPressedInteract) // jeśli gracz wcisnął klawisz interakcji
						{
							// sprawdź czy podczas próby interakcji gracz nie znajduje się na obiekcie 
							// z którym można wykonać interakcję (INTERACT_NATURE::INTERACT_KEY)

							for (unsigned int j = 0; j < m_currentMap->vecDyn.size(); j++) // sprawdź dla każdego obiektu dynamicznego
							{
								if (m_currentMap->vecDyn[i]->vx <= 0) //ruch w lewo
								{
									if (fNewpx < (m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth) && (fNewpx + m_currentMap->vecDyn[i]->fWidth) > m_currentMap->vecDyn[j]->px &&
										m_currentMap->vecDyn[i]->py < (m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight) &&
										(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight) > m_currentMap->vecDyn[j]->py)
										// sprawdzenie czy prostokąty się nakładają (oś Y to stara pozycja)
									{
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::INTERACT_KEY, pPlayer))
											return true;
									}
								}
								else // ruch w prawo
								{
									if (fNewpx < (m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth) && (fNewpx + m_currentMap->vecDyn[i]->fWidth) > m_currentMap->vecDyn[j]->px &&
										m_currentMap->vecDyn[i]->py < (m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight) &&
										(m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight) > m_currentMap->vecDyn[j]->py)
										// sprawdzenie czy prostokąty się nakładają (oś Y to stara pozycja)
									{
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::INTERACT_KEY, pPlayer))
											return true;
									}
								}

								if (m_currentMap->vecDyn[i]->vy <= 0)//ruch w górę
								{
									//sprawdzanie kolizji w osi Y
									if (fNewpx < (m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth) && (fNewpx + m_currentMap->vecDyn[i]->fWidth) > m_currentMap->vecDyn[j]->px &&
										fNewpy < (m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight) && (fNewpy + m_currentMap->vecDyn[i]->fHeight) > m_currentMap->vecDyn[j]->py)
										// sprawdzenie czy prostokąty się nakładają (oś Y to nowa pozycja)
									{
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::INTERACT_KEY, pPlayer))
											return true;
									}
								}
								else // ruch w dół
								{
									//sprawdzanie kolizji w osi Y
									if (fNewpx < (m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth) && (fNewpx + m_currentMap->vecDyn[i]->fWidth) > m_currentMap->vecDyn[j]->px &&
										fNewpy < (m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight) && (fNewpy + m_currentMap->vecDyn[i]->fHeight) > m_currentMap->vecDyn[j]->py)
										// sprawdzenie czy prostokąty się nakładają (oś Y to nowa pozycja)
									{
										if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::INTERACT_KEY, pPlayer))
											return true;
									}
								}
							}

							// sprawdź czy nie zachodzi kolizja punktu testowego z innym obiektem
							// dynamicznym z którym może zajść interakcja (INTERACT_NATURE::TALK)
							for (unsigned int j = 0; j < m_currentMap->vecDyn.size(); j++) // sprawdź dla każdego obiektu dynamicznego
							{
								if (i != j) // ale nie dla samego siebie
								{
									// dla każdego kierunku w którą zwrócony jest gracz
									// ustaw położenie punktu testowego pół pola przed graczem
									switch (m_currentMap->vecDyn[i]->nDirection)
									{
									case cDynamic::NORTH:
									{
										float fTestX = m_currentMap->vecDyn[i]->px + (m_currentMap->vecDyn[i]->fWidth / 2.0f);
										float fTestY = m_currentMap->vecDyn[i]->py - 0.5f;
										// sprawdzenie czy punkt testowy zawarty jest w drugim obiekcie
										if (fTestX < m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth && fTestX > m_currentMap->vecDyn[j]->px &&
											fTestY < m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight && fTestY > m_currentMap->vecDyn[j]->py)
										{
											if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::TALK, m_currentMap->vecDyn[i]))
												return true;
										}
										break;
									}
									case cDynamic::EAST:
									{
										float fTestX = m_currentMap->vecDyn[i]->px + m_currentMap->vecDyn[i]->fWidth + 0.5f;
										float fTestY = m_currentMap->vecDyn[i]->py + (m_currentMap->vecDyn[i]->fHeight / 2.0f);
										// sprawdzenie czy punkt testowy zawarty jest w drugim obiekcie
										if (fTestX < m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth && fTestX > m_currentMap->vecDyn[j]->px &&
											fTestY < m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight && fTestY > m_currentMap->vecDyn[j]->py)
										{
											if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::TALK, m_currentMap->vecDyn[i]))
												return true;
										}
										break;
									}
									case cDynamic::SOUTH:
									{
										float fTestX = m_currentMap->vecDyn[i]->px + (m_currentMap->vecDyn[i]->fWidth / 2.0f);
										float fTestY = m_currentMap->vecDyn[i]->py + m_currentMap->vecDyn[i]->fHeight + 0.5f;
										// sprawdzenie czy punkt testowy zawarty jest w drugim obiekcie
										if (fTestX < m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth && fTestX > m_currentMap->vecDyn[j]->px &&
											fTestY < m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight && fTestY > m_currentMap->vecDyn[j]->py)
										{
											if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::TALK, m_currentMap->vecDyn[i]))
												return true;
										}
										break;
									}
									case cDynamic::WEST:
									{
										float fTestX = m_currentMap->vecDyn[i]->px - 0.5f;
										float fTestY = m_currentMap->vecDyn[i]->py + (m_currentMap->vecDyn[i]->fHeight / 2.0f);
										// sprawdzenie czy punkt testowy zawarty jest w drugim obiekcie
										if (fTestX < m_currentMap->vecDyn[j]->px + m_currentMap->vecDyn[j]->fWidth && fTestX > m_currentMap->vecDyn[j]->px &&
											fTestY < m_currentMap->vecDyn[j]->py + m_currentMap->vecDyn[j]->fHeight && fTestY > m_currentMap->vecDyn[j]->py)
										{
											if (m_currentMap->vecDyn[j]->OnInteract(pPlayer, cDynamic::TALK, m_currentMap->vecDyn[i]))
												return true;
										}
										break;
									}

									}	// switch
								}
							}
						}
						// niezależnie czy zaszła kolizja czy nie, po próbie wykrycia interakcji ustaw flagę
						// wciśnięcia klawiszu interakcji użytkownika jako nieaktywną
						bKeyPressedInteract = false;
					}

					//aktualizacja położenia po sprawdzeniu czy nie zajdzie kolizja statyczna i dynamiczna
					m_currentMap->vecDyn[i]->px = fNewpx;
					m_currentMap->vecDyn[i]->py = fNewpy;

					// jeśli obiekt jest niepotrzebny (np. jako pocisk trafił na ścianę lub minęła jego żywotność) to go usuń
					if (m_currentMap->vecDyn[i]->bIsRedundant)
						m_currentMap->RemoveDynamic(i);
				}
			}
		}
	}
	
	//aktualizacja timera animacji elementów mapy
	if (!m_bShowMessage && !bPause)
	{
		m_fStaticAnimTime -= fElapsedTime;

		if (m_fStaticAnimTime < 0.0f)
			m_fStaticAnimTime = 0.0f;

		if (m_fStaticAnimTime == 0.0f)
		{
			if (m_nStaticAnimFrame == 0)
				m_nStaticAnimFrame = 1;
			else
				m_nStaticAnimFrame = 0;

			m_fStaticAnimTime = m_fStacicAnimInterval;
		}
	}

	//render!

	//rysowanie mapy z wykorzystaniem przewijania ekranu:

	//pozycja kamery (przyklejonia do gracza) jeśli silnik skryptów na to zezwala
	if (ScriptEngine.bCameraFollowsPlayer)
	{
		fCameraPosX = pPlayer->px;
		fCameraPosY = pPlayer->py;
	}

	//obliczanie liczby widocznych pól na ekranie
	int nVisibleTilesX = ScreenWidth() / nTileWidth;
	int nVisibleTilesY = ScreenHeight() / nTileHeight;

	//obliczanie offsetu
	float fOffsetX = fCameraPosX - (float)nVisibleTilesX / 2.0f;
	float fOffsetY = fCameraPosY - (float)nVisibleTilesY / 2.0f;

	//ograniczenie offestu przy krawędziach mapy
	if (fOffsetX < 0) fOffsetX = 0.0f;
	if (fOffsetY < 0) fOffsetY = 0.0f;
	if (fOffsetX > m_currentMap->nLevelWidth - nVisibleTilesX) fOffsetX = (float)(m_currentMap->nLevelWidth - nVisibleTilesX);
	if (fOffsetY > m_currentMap->nLevelHeight - nVisibleTilesY) fOffsetY = (float)(m_currentMap->nLevelHeight - nVisibleTilesY);

	//offset pojedyńczego pola do płynnego przewijania mapy 
	float fTileOffsetX = (fOffsetX - (int)fOffsetX) * nTileWidth;
	float fTileOffsetY = (fOffsetY - (int)fOffsetY) * nTileHeight;

	//rysowanie mapy warstwa pierwsza
	for (int x = 0; x < nVisibleTilesX + 1; x++)
	{
		for (int y = 0; y < nVisibleTilesY + 1; y++)
		{
			int index = m_currentMap->GetIndex((int)(x + fOffsetX), (int)(y + fOffsetY));
			if (index != 0)
			{
				// sprawdzenie czy mamy do czynienia z animowanym polem i jeśli tak to którą klatkę należy wyświetlić
				if (m_currentMap->GetIsAnimated((int)(x + fOffsetX), (int)(y + fOffsetY)) == 1)
					if (m_nStaticAnimFrame == 1)
						index++;	// jeśli należy wyświetlić drugą klatkę animacji to wyświetl grafikę o ID zwiększonym o jeden

				// interpretacja indeksu jako współrzędnych pól w całym tile secie
				int ix = index % 10;
				int iy = index / 10;
				DrawPartialSprite((int)(x* nTileWidth - fTileOffsetX), (int)(y* nTileHeight - fTileOffsetY),
					m_currentMap->sprite, ix* nTileWidth, iy* nTileHeight, nTileWidth, nTileHeight);
			}
		}
	}

	// jeśli włączono odpowienie ustawienia
	// ustawienie trybu renderowania na uwzględniający przeźroczystość drugiej i trzeciej warstwy mapy i obiektów dynamicznych
	if(bGfxHighSettings)
		SetPixelMode(olc::Pixel::ALPHA);
	else
		SetPixelMode(olc::Pixel::MASK);

	//rysowanie mapy warstwa druga
	for (int x = 0; x < nVisibleTilesX + 1; x++)
	{
		for (int y = 0; y < nVisibleTilesY + 1; y++)
		{
			int index2 = m_currentMap->GetIndex2((int)(x + fOffsetX), (int)(y + fOffsetY));
			if (index2 != 0)
			{
				// interpretacja indeksu jako współrzędnych pól w całym tile secie
				int ix2 = index2 % 10;
				int iy2 = index2 / 10;
				DrawPartialSprite((int)(x * nTileWidth - fTileOffsetX), (int)(y * nTileHeight - fTileOffsetY), 
					m_currentMap->sprite, ix2 * nTileWidth, iy2 * nTileHeight, nTileWidth, nTileHeight);
			}
		}
	}

	// rysowanie wszystkich obiektów dynamicznych

	// najpierw narysuj wszystkie obiekty warstwy 0 (np. poświata teleporterów, przedmioty na ziemii, interaktywne elementy mapy, itp)
	for (unsigned int i = 0; i < m_currentMap->vecDyn.size(); i++)
		if (m_currentMap->vecDyn[i]->nLayer == 0)
			m_currentMap->vecDyn[i]->DrawSelf(fOffsetX, fOffsetY);

	// później narysuj obiekty wartswy 1 (zwłoki)
	for (unsigned int i = 0; i < m_currentMap->vecDyn.size(); i++)
		if (m_currentMap->vecDyn[i]->nLayer == 1)
			m_currentMap->vecDyn[i]->DrawSelf(fOffsetX, fOffsetY);

	// później narysuj obiekty warstwy 2 (większość obiektów)
	for (unsigned int i = 0; i < m_currentMap->vecDyn.size(); i++)
		if (m_currentMap->vecDyn[i]->nLayer == 2)
			m_currentMap->vecDyn[i]->DrawSelf(fOffsetX, fOffsetY);

	// rysowanie mapy warstwa trzecia: warstwa która zawsze rysowana jest nad obiektami dynamicznymi
	// np. górne części filarów które są "przed" stworami
	for (int x = 0; x < nVisibleTilesX + 1; x++)
	{
		for (int y = 0; y < nVisibleTilesY + 1; y++)
		{
			int index3 = m_currentMap->GetIndex3((int)(x + fOffsetX), (int)(y + fOffsetY));
			if (index3 != 0)
			{
				// interpretacja indeksu jako współrzędnych pól w całym tile secie
				int ix3 = index3 % 10;
				int iy3 = index3 / 10;
				DrawPartialSprite((int)(x * nTileWidth - fTileOffsetX), (int)(y * nTileHeight - fTileOffsetY),
					m_currentMap->sprite, ix3 * nTileWidth, iy3 * nTileHeight, nTileWidth, nTileHeight);
			}
		}
	}

	// później narysuj obiekty warstwy 3 (obiekty "latające", bądź położone ponad resztą obiektów dynamicznych)
	for (unsigned int i = 0; i < m_currentMap->vecDyn.size(); i++)
		if (m_currentMap->vecDyn[i]->nLayer == 3)
			m_currentMap->vecDyn[i]->DrawSelf(fOffsetX, fOffsetY);

	//na koniec narysuj obiekty dynamiczne warstwy 4 (bańki emotikony)
	for (unsigned int i = 0; i < m_currentMap->vecDyn.size(); i++)
		if (m_currentMap->vecDyn[i]->nLayer == 4)
			m_currentMap->vecDyn[i]->DrawSelf(fOffsetX, fOffsetY);

	//Interfejs!

	//Dialogi - wyświetlanie
	if (!m_bShowMessage)
		if (m_bShowDialog)
			DrawFrontDialog(UI_FromScreenBorder, UI_FromScreenBorder);
	
	//HP, wytrzymałość i wygaszenie ekranu
	DrawUI(fElapsedTime);

	//Komunikaty - wyświetlanie
	if(m_bShowMessage)
		DisplayFrontMessage();

	//komunikat o zapauzowanej grze
	if (bPause)
	{
		FillRect((ScreenWidth() - 42) / 2, UI_FromScreenBorder * 2 - 1, 49, 18, olc::RED);
		DrawText("Pause", (ScreenWidth() - 42) / 2, UI_FromScreenBorder * 2, TXT_WHITE);
		DrawText("Press P", (ScreenWidth() - 42) / 2, UI_FromScreenBorder * 2 + 8, TXT_WHITE);
	}

	// powrót do domyślnego trybu renderowania aby zaoszczędzić wydajność
	SetPixelMode(olc::Pixel::NORMAL);

	return true;
}