Merge pull request #300 from OneLoneCoder/develop

PGE 2.20 + Utilities

Author: OneLoneCoder

examples/TEST_Animate2D.cpp

@@ -0,0 +1,278 @@
+/*
+	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;
+}