Dynamic.h

#pragma once

#include <string>
#include "Stats.h"

class cEngine;

namespace olc
{
	class Sprite;
}

class cDynamic
{
protected:
	float fTime; // czas aktualizacji animacji
	cEngine* engine; // wskaźnik do silnika gry
	olc::Sprite* sprite; // grafika obiektu
	float fKnockbackTimer; // timer czasu w powietrzu (knockback)
	void SlowDown(float& v, float fElapsedTime, float rate);
public:
	cDynamic(cEngine* _engine);
	cDynamic(cEngine* _engine, std::string _name, float _px, float _py, olc::Sprite* spr);
	cDynamic(cEngine* _engine, std::string _name, float _px, float _py, olc::Sprite* spr, bool _solidvssolid, bool _solidvsdynamic);
	cDynamic(cEngine* _engine, std::string _name, float _px, float _py, olc::Sprite* spr, bool _solidvssolid, bool _solidvsdynamic, bool _friendly);

	enum INTERACT_NATURE	//enum możliwych typów interakcji z obiektem
	{
		INTERACT_KEY,
		WALK_ON,
		TALK
	};

	//////////////////////		KONFIGUTACJA cDynamic		//////////////////////
	std::string sName;	// nazwa

	float px;	// pozycja w świecie gry
	float py;
	float vx;	// prędkość
	float vy;
	float fWidth;	// wymiary
	float fHeight;
	bool bSolidVsSolid;	// podleganie kolizji statycznej
	bool bSolidVsDynamic;// i dynamicznej
	short nLayer;	// warstwa od której zależy w jakiej kolejności obiekt jest rysowany (0 - przedmioty na ziemii i elementy mapy, 1 - zwłoki/nieprzytomni, 2 - domyślna, 3 - latające, 4 - emotki)
	bool bFriendly; // czy obiekt jest przyjazny graczowi
	bool bIsProjectile; // czy obiekt jest pociskiem
	bool bIsKnockbacked; // czy obiekt jest w powietrzu
	bool bIsRedundant; // czy obiekt powinien zostać usunięty
	float fProjectileTime; // czas aktualizacji istnienia jako pocisk
	bool bInvincible; // nieśmiertelność obiektu

	// Metody: //
	virtual void Knockback(float x, float y, float time) { }	// "zwykły" obiekt dynamiczny nie posiada obsługi odrzutu 
	virtual void ReceiveDamage(float dmg) { }					// ani bycia zaatakowanym
	virtual void DrawSelf(float fOffsetX, float fOffsetY);
	virtual bool OnInteract(cDynamic* player, INTERACT_NATURE nature, cDynamic* object) { return false; }	// funkcja powinna zwrócić true jeśli główna pętla gry ma się zacząć
																											// na nowo po wykonaniu interakcji (np. teleportacja i zmiana mapy)
	// aktualizacja obiektu wywoływana w każdej klatce
	virtual void Update(float fElapsedTime, cDynamic* player = nullptr) {};				
	//////////////////////////////////////////////////////////////////////////////

	bool bIsMovedByScript;
	virtual void ZeroNewVelocities() { } // wywoływana przy skryptach mających całkowicie zatrzymać postać po ich zakończeniu

	enum Direction
	{
		NORTH = 0,
		EAST = 1,
		SOUTH = 2,
		WEST = 3
	} nDirection;
};

class cDynamicCreature : public cDynamic
{
public:
	enum CREATURE_STATE
	{
		STATE_STANDING,
		STATE_WALKING,
		STATE_DEAD,
		STATE_MELEE_ATTACK,
		STATE_SLEEPING,
		STATE_UNCONSCIOUS
	}	nState;
public:
	//////////////////////		KONFIGUTACJA cDynamicCreature		//////////////////////

	float fMaxHP; // zdrowie obecne i maksymalne
	float fHP;
	cCreatureStats stats; // statystyki bojowe
	float fAnimationDefaultInterval; // domyślny okres aktualizacji animacji (kiedy obiekt się nie porusza) (domyślnie 1.0f)
	float fAIUpdateInterval; // okres aktualizacji AI (domyślnie 1.0f)
	float fProneToKnockbackMultiplier; // mnożnik początkowej szybkości nadawanej stworowi przy byciu odrzuconym (im więcej tym większa początkowa prędkość - efekt mniejszej masy stwora) (domyślnie 1.0f)
	float fKnockbackSpeedDeclineMultiplier; // mnożnik szybkości zanikania prędkości odrzutu (im więcej tym szybciej stwór spowalnia po zostaniu odrzuconym - efekt mniejszego poślizgu) (domyślnie 1.0f)
	bool bIsResistantToKnockback; // odporność na odrzut (domyślnie false)
	float fAIActivationDistance; // dystans aktywacji AI (domyślnie 5.0f)
	float fWalkAnimationSpeedMultiplier; // mnożnik szybkości wykonywania animacji podczas chodzenia (ważne: ta jest aktualizowana zależnie od szybkości stwora) (domyślnie 1.0f)
	bool bWalkAnimationAlwaysOn; // flaga zmieniająca sposób animowania stwora na taki w którym ciągle jest wykonywana animacja poruszania (np. stwory latające) (domyślnie false)
	float fMaxWalkingVel; // szybkość poruszania się obiektu (domyślnie (bazowa szybkość gracza) 2.0f)

	//////////////////////////////////////////////////////////////////////////////////////
protected:
	int nFrame; // klatka animacji - albo 0, albo 1
	float fAnimationInterval; // okres aktualizacji animacji (przy ruchu obliczany dynamicznie w zależności od prędkości)
	float fTime2; // czas aktualizacji AI
public:
	float fTime3; // czas aktualizacji ataku wręcz
	float fTime4; // czas aktualizacji okresu bezruchu po wykonaniu ataku wręcz
	short nDefaultLayer; // domyślna warstwa rysowania
protected:
	float fScalarSpeed; // prędkośc skalarna (obliczana przez ClampWalkingVel())

	float fNewvx; // potencjalne nowe prędkości
	float fNewvy; // (aktualizowane przez AI)
public:
	cDynamicCreature(cEngine* _engine, std::string _name, float _px, float _py, olc::Sprite* spr, bool _solidvssolid, bool _solidvsdynamic, 
		float _sizex, float _sizey, CREATURE_STATE _state, float _maxHP, bool _friendly, short _layer = 2);

	////////////
	// Przykładowe AI:
	void AI_SimpleFollow(float fElapsedTime, cDynamic* player); // outdated!
	void AI_SimpleFollowHostile(float fElapsedTime, cDynamic* player);
	void AI_Default(float fElapsedTime, cDynamic* player);
	/////////////

	float fMaxAxisSpeed; // szybkość poruszania się obiektu w osiach ( aktualizowane automatycznie )
	
	// wywoływana przy skryptach mających całkowicie zatrzymać postać po ich zakończeniu
	void ZeroNewVelocities()	{	fNewvx = 0.0f;	fNewvy = 0.0f;	}
	void SetState(CREATURE_STATE _state);
	void ReceiveDamage(float dmg);
	virtual void PerformAttack(cDynamic* target);
	virtual void PerformInstantAttack(cDynamic* target);
	void DrawSelf(float fOffsetX, float fOffsetY);
	virtual void Update(float fElapsedTime, cDynamic* player);

	// domyślne AI - nie robi nic, przekazuje dalej potencjalne nowe prędkości w niezmienionej formie - takie AI ma tylko gracz i obiekty których nie da się zaatakować
	virtual void UpdateAI(float fElapsedTime, cDynamic* player) {	fNewvx = vx;	fNewvy = vy;	}
	void ClampWalkingVel(); // ważne: aktualizuje skalarną szybkość obiektu
	virtual void Knockback(float x, float y, float time); // odrzut
};

class c3FrameAnimatedDynamic : public cDynamic
{
private:
	short nFrame;
	float fFrameTime;
public:
	void DrawSelf(float fOffsetX, float fOffsetY);
	void Update(float fElapsedTime, cDynamic* player = nullptr);
	c3FrameAnimatedDynamic(cEngine* _engine, std::string _name, float _px, float _py, olc::Sprite* spr, float _frametime = 1.0f);
	c3FrameAnimatedDynamic(cEngine* _engine, std::string _name, float _px, float _py, olc::Sprite* spr, bool _solidvssolid, bool _solidvsdynamic, float _frametime = 1.0f);
};

class cOpenable : public cDynamic
{
protected:
	bool bOpen;
	short nFrame;
	bool bAnimOpening;
	bool bAnimClosing;
	float fFrameTime;
	bool bHasBeenYetOpened;
public:
	void Open() { bAnimOpening = true; }
	virtual void FirstOpen() { }
	bool OnInteract(cDynamic* player, INTERACT_NATURE nature, cDynamic* target) override;
	void DrawSelf(float fOffsetX, float fOffsetY);
	virtual void Update(float fElapsedTime, cDynamic* player = nullptr);
	cOpenable(cEngine* _engine, float _px, float _py, olc::Sprite* _sprite, std::string _name, bool _solidvssolid, bool _solidvsdynamic, float _frametime = 0.3f);
};