/*
	Example file for olcUTIL_Animate2D.h

	License (OLC-3)
	~~~~~~~~~~~~~~~

	Copyright 2018 - 2022 OneLoneCoder.com

	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions
	are met:

	1. Redistributions or derivations of source code must retain the above
	copyright notice, this list of conditions and the following disclaimer.

	2. Redistributions or derivative works in binary form must reproduce
	the above copyright notice. This list of conditions and the following
	disclaimer must be reproduced in the documentation and/or other
	materials provided with the distribution.

	3. Neither the name of the copyright holder nor the names of its
	contributors may be used to endorse or promote products derived
	from this software without specific prior written permission.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	Links
	~~~~~
	YouTube:	https://www.youtube.com/javidx9
	Discord:	https://discord.gg/WhwHUMV
	Twitter:	https://www.twitter.com/javidx9
	Twitch:		https://www.twitch.tv/javidx9
	GitHub:		https://www.github.com/onelonecoder
	Homepage:	https://www.onelonecoder.com

	Author
	~~~~~~
	David Barr, aka javidx9, ŠOneLoneCoder 2019, 2020, 2021, 2022

*/


#define OLC_PGE_APPLICATION
#include "olcPixelGameEngine.h"

#include "utilities/olcUTIL_Animate2D.h"

class TEST_Animate2D : public olc::PixelGameEngine
{
public:
	TEST_Animate2D()
	{		
		sAppName = "Animate2D Utility Test";
	}

	// These are the states the dude can exist in, we'll need these for physics
	// and animation. The physics side of things moves the dude around according to state,
	// while the animator chooses the frames based upon state and time
	enum class DudeState: uint8_t
	{
		WALK_N, WALK_S, WALK_E, WALK_W, IDLE_STAND,	LAUGH, CHEER, YES, NO
	};

	// !! - IMPORTANT - !!
	// The animation set
	olc::utils::Animate2D::Animation<DudeState> animDude;

	// One big sprite containing all the graphics
	olc::Renderable gfxAll;

	// Small object to reprsent a dude walking around doing things
	struct sWalkingDude
	{
		// Which dude overall out of graophic?
		int32_t id = 0;
		// Where are they?
		olc::vf2d pos;
		// What are they doing?
		DudeState UserState = DudeState::IDLE_STAND;
		// For how long should they do it?
		float fTick = 0.0f;

		// !! - IMPORTANT - !!
		// Animation Token - links this object's state to animator. Note
		// there is no 'ownership' or memory issues here, this is a token
		// that the animator can use to quickly get to where it needs
		// in order to return frames upon request for this object.
		olc::utils::Animate2D::AnimationState animstate;
	};

	// Introducing.... The dudes!
	size_t nDudes = 500;
	std::vector<sWalkingDude> vDudes;

public:
	bool OnUserCreate() override
	{	
		// For this appliaction I have a single image that contains
		// 28x2 unique characters, each character contains 8 animations of 3
		// frames each. Each frame is 26x36 pixels
		gfxAll.Load("./assets/MegaSprite1.png");

		// Thats A LOT of individual graphics, but they all follow a similar pattern
		// because the asset was created usefully (take note certain popular asset creators)
		// which means we can reuse the animation without needing to define it
		// individually for all the "dudes" - the "cookie cutter" approach

		// Manually construct sequences - gfxAll could in fact be nullptr for this
		// application, but ive kept it here for convenience
		olc::utils::Animate2D::FrameSequence anim_fs_walk_s;
		anim_fs_walk_s.AddFrame({ &gfxAll, {{0,0}, {26,36}} });
		anim_fs_walk_s.AddFrame({ &gfxAll, {{26,0}, {26,36}} });
		anim_fs_walk_s.AddFrame({ &gfxAll, {{52,0}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_walk_w;
		anim_fs_walk_w.AddFrame({ &gfxAll, {{ 0,36}, {26,36}} });
		anim_fs_walk_w.AddFrame({ &gfxAll, {{26,36}, {26,36}} });
		anim_fs_walk_w.AddFrame({ &gfxAll, {{52,36}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_walk_e;
		anim_fs_walk_e.AddFrame({ &gfxAll, {{ 0,72}, {26,36}} });
		anim_fs_walk_e.AddFrame({ &gfxAll, {{26,72}, {26,36}} });
		anim_fs_walk_e.AddFrame({ &gfxAll, {{52,72}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_walk_n;
		anim_fs_walk_n.AddFrame({ &gfxAll, {{ 0,108}, {26,36}} });
		anim_fs_walk_n.AddFrame({ &gfxAll, {{26,108}, {26,36}} });
		anim_fs_walk_n.AddFrame({ &gfxAll, {{52,108}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_yes;
		anim_fs_yes.AddFrame({ &gfxAll, {{ 0,144}, {26,36}} });
		anim_fs_yes.AddFrame({ &gfxAll, {{26,144}, {26,36}} });
		anim_fs_yes.AddFrame({ &gfxAll, {{52,144}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_no;
		anim_fs_no.AddFrame({ &gfxAll, {{ 0,180}, {26,36}} });
		anim_fs_no.AddFrame({ &gfxAll, {{26,180}, {26,36}} });
		anim_fs_no.AddFrame({ &gfxAll, {{52,180}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_laugh;
		anim_fs_laugh.AddFrame({ &gfxAll, {{ 0,216}, {26,36}} });
		anim_fs_laugh.AddFrame({ &gfxAll, {{26,216}, {26,36}} });
		anim_fs_laugh.AddFrame({ &gfxAll, {{52,216}, {26,36}} });

		olc::utils::Animate2D::FrameSequence anim_fs_cheer;
		anim_fs_cheer.AddFrame({ &gfxAll, {{ 0,252}, {26,36}} });
		anim_fs_cheer.AddFrame({ &gfxAll, {{26,252}, {26,36}} });
		anim_fs_cheer.AddFrame({ &gfxAll, {{52,252}, {26,36}} });

		// A special "idle" animation just consists of a single frame
		olc::utils::Animate2D::FrameSequence anim_fs_idle;
		anim_fs_idle.AddFrame({ &gfxAll, {{26,0}, {26,36}} });

		// We have constructed teh individual sequences, now its time
		// to add them to an animation, along with a state name/enum.
		//
		// I have chosen to use the enum shown earlier. You could use
		// std::string too, which is conveninent if you need to display
		// the states, though potentially far less performant

		animDude.AddState(DudeState::WALK_S, anim_fs_walk_s);
		animDude.AddState(DudeState::WALK_W, anim_fs_walk_w);
		animDude.AddState(DudeState::WALK_E, anim_fs_walk_e);
		animDude.AddState(DudeState::WALK_N, anim_fs_walk_n);
		animDude.AddState(DudeState::IDLE_STAND, anim_fs_idle);
		animDude.AddState(DudeState::YES, anim_fs_yes);
		animDude.AddState(DudeState::NO, anim_fs_no);
		animDude.AddState(DudeState::LAUGH, anim_fs_laugh);
		animDude.AddState(DudeState::CHEER, anim_fs_cheer);
		
		// Initialise the dudes
		for (size_t n = 0; n < nDudes; n++)
		{
			sWalkingDude dude;

			// Random dude
			dude.id = rand() % (28 * 2);

			// Begin in idle state, at random location
			dude.UserState = DudeState::IDLE_STAND;
			dude.pos = { float(rand() % ScreenWidth()), float(rand() % ScreenHeight()) };

			// The animation token needs to be updated too
			animDude.ChangeState(dude.animstate, dude.UserState);

			vDudes.push_back(dude);
		}
		return true;
	}

	bool OnUserUpdate(float fElapsedTime) override
	{	
		// Update Dudes		
		float fSpeed = 32.0f;
		
		for (auto& dude : vDudes)
		{
			// If a dude's tick reaches 0, it will select a new state
			dude.fTick -= fElapsedTime;
			if (dude.fTick < 0.0f)
			{
				// Choose one out of the 9 randomly
				int nAction = rand() % 9;

				// Choose for how long it should do it in seconds
				dude.fTick = (float(rand()) / float(RAND_MAX)) * 5.0f;

				// Assign the state depending on the dice roll - (since enum
				// we could cast here too, but, well, meh...)
				if (nAction == 0) dude.UserState = DudeState::IDLE_STAND;
				if (nAction == 1) dude.UserState = DudeState::WALK_S;
				if (nAction == 2) dude.UserState = DudeState::WALK_N;
				if (nAction == 3) dude.UserState = DudeState::WALK_E;
				if (nAction == 4) dude.UserState = DudeState::WALK_W;
				if (nAction == 5) dude.UserState = DudeState::YES;
				if (nAction == 6) dude.UserState = DudeState::NO;
				if (nAction == 7) dude.UserState = DudeState::LAUGH;
				if (nAction == 8) dude.UserState = DudeState::CHEER;

				// State has changed, so update animation token
				// !! - IMPORTANT - !!
				animDude.ChangeState(dude.animstate, dude.UserState);
			}

			// Update "physics", if walking move in that direction at speed
			if (dude.UserState == DudeState::WALK_S) dude.pos += olc::vf2d(0, +1) * fSpeed * fElapsedTime;
			if (dude.UserState == DudeState::WALK_N) dude.pos += olc::vf2d(0, -1) * fSpeed * fElapsedTime;
			if (dude.UserState == DudeState::WALK_E) dude.pos += olc::vf2d(+1, 0) * fSpeed * fElapsedTime;
			if (dude.UserState == DudeState::WALK_W) dude.pos += olc::vf2d(-1, 0) * fSpeed * fElapsedTime;

			// If walk off screen, wrap around to other side
			if (dude.pos.x > ScreenWidth()) dude.pos.x -= ScreenWidth();
			if (dude.pos.y > ScreenHeight()) dude.pos.x -= ScreenHeight();
			if (dude.pos.x < 0) dude.pos.x += ScreenWidth();
			if (dude.pos.y < 0) dude.pos.y += ScreenHeight();

			// Update animation token every frame
			// !! - IMPORTANT - !!
			animDude.UpdateState(dude.animstate, fElapsedTime);
		}
		
		// Render Dudes
		for (const auto& dude : vDudes)
		{
			// Get the frame, this contains both source image and source location rectangle
			// !! - IMPORTANT - !!
			const auto& frame = animDude.GetFrame(dude.animstate);

			// Thats cool, but there are 28x2 dudes on the sprite sheet, so using the ID, construct
			// an offset to the correct dude
			olc::vi2d vOffset = { (dude.id % 28) * 78, (dude.id / 28) * 288 };

			// Use DrawPartialDecal to chop out the correct dude frm the image source
			DrawPartialDecal(dude.pos, frame.GetSourceImage()->Decal(), frame.GetSourceRect().pos + vOffset, frame.GetSourceRect().size);
		}

		// That's it
		return true;
	}
};

int main()
{
	TEST_Animate2D demo;
	if (demo.Construct(640, 480, 2, 2))
		demo.Start();
	return 0;
}