-
Notifications
You must be signed in to change notification settings - Fork 913
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge pull request #300 from OneLoneCoder/develop
PGE 2.20 + Utilities
- Loading branch information
Showing
10 changed files
with
2,522 additions
and
20 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -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; | ||
| } |
Oops, something went wrong.