I need helping with the animated Object cpp in c$++$ I$\text{'}$m not sure how to add what's needed to the code. Please, please help!

Player Class:

Starting with the changes to the player class there is a new bool isDead$\{$ false $\}$; private member that keeps track of if the player has collided with an enemy or if the player has gone off the bottom of the screen. Either of these conditions would turn the member to true. A getter will also be needed for this member.

The main changes to the class are the update method. You still need to check that the player doesn$$t go off the left side of the screen. However, moving right is different.

First, I created a non$-$member, helper function with the following declaration:

bool lastBlockOnScreen$($const std::vector$>$& objects$)$

This loops over the objects vector and finds the object with the largest x value $($being sure not to check the player$).$ It returns true if that value is less than or equal to GUI::screenDimensions.x otherwise false.

The next addition to the player$$s update method is side scrolling.$$

If the player$$s x position is greater than half the screen$$s width and the last block is not on the screen, then$$

you should subtract the difference between the player$$s x position and screenDimensions.x$/2$ from EVERY object in the game.$$

This will have the effect of sliding everything but the player to the left and it will appear that the player is walking to the right.

A minor change to the moveRight$()$ and moveLeft$()$ methods. The respective jumping states need to also adjust the position by the walkSpeed. So$,$ if the player is in the jumpRight state, pressing the right key will make the player move right. For this to be effective, the user would need to tap the jump button, then quickly press and hold the right key.

If you did not add jumping to the previous quest, you can use my solution to have jumping available.

AnimatedObject Class:

The only change to the AnimatedObject class is the collision method, it has a new declaration:$$

bool collision$($const Object$*$ object, bool full $=$ false$)$;

NOTE:: you can pass by & instead of raw pointers if you like.

The motivation for this change is to allow the player to be on different levels of blocks and not automatically bumped to the top of a block that he collides with. This image will help:

The red box indicates where we want to detect collisions. The simple fix is that the block$$s height will just be considered the same as the value of gravity.y$.$ This way, when gravity is applied, the player will be popped back on top of the block.

$$I also removed checking to see if the player$$s top was within the collision area. That way a jump will not bump the player more than a gravity hit.$$

So checking for block collision should pass in $$false$$ for full, but checking for collision with an enemy, we want to pass in $$true$.$ If full is $$true$$ then it uses the previous collision detection. $```$

#include

#include

#include "AnimatedObject.h$"$

#include "Block.h$"$

#include "GUI.h$"$

using namespace std;

const Vector$2$D AnimatedObject::gravity$\{0\mathrm{.}0$f$,10\mathrm{.}0$f $\}$;

const float AnimatedObject::deltaT$\{0\mathrm{.}5$f $\}$;

AnimatedObject::AnimatedObject$($std::string animationFile, Vector$2$D position, Type name, const GUI& gui$)$: Object$($position$,$ name, gui$)$

$\{$

fstream fin;

fin.open$($animationFile$)$;

if $(!$fin.is$\_$open$())$ cout $$ "File does not exist!";

$\backslash$square

$\backslash$

int numStates;

fin $>>$ numStates;

for $($int i$\{0\}$; i $$ numStates; i$++)$

$\{$

int numAnimations;

fin $>>$ numAnimations;

for $($int j$\{0\}$; j $$ numAnimations; j$++)$

$\{$

int spriteSequence;

fin $>>$ spriteSequence;

sprites$[($State$)$i$].$push$\_$back$($spriteSequence$)$;

$\}$

$\}$

updateSprite$()$;

$\}$

int AnimatedObject::getCurrentSprite$()$ const

$``````$

return currentSprite;

$\}$

void AnimatedObject::updateSprite$()$

$\{$

currentAnimation$++$;

currentAnimation $8=$ sprites$[$state$].$size$()$;

currentSprite $=$ sprites$[$state$][$currentAnimation$]$;

$\}$

void AnimatedObject::doPhysics$($const std::vector& blocks$)$

$\{$

applyGravity$()$;

for $($const auto& block : blocks$)$

$\{$

switch $($block$.$getName$())$

$\{$

case Object::Type::bridge$\_$center:

case Object::Type::bridge$\_$end:

case Object::Type::bridge$\_$start:

case Object::Type::top$\_$block:

case Object::Type::water$\_$top:

if $($collision$($block$))$

$\{$

position.y $=$ block.getPosition$().$y $-$ gui.getDimensions$(*$this$).$y;

velocity.y $=0$;

if $($state $==$ AnimatedObject::State::jumpLeft$)$

$\{$

state $=$ AnimatedObject::State::stillLeft;

$\}$

else if $($state $==$ AnimatedObject::State::jumpRight$)$

$\{$

state $=$ AnimatedObject::State::stillRight;

$\}$

$\}$

$``````$

$\}$

$\}$

$\}$

$\}$

$\}$

void AnimatedObject::applyGravity$()$

$\{$

position.y $+=$ deltaT $*$ velocity.y;

velocity.y $+=$ deltaT $*$ gravity.y;

$\}$

bool AnimatedObject::collision$($const Object& object$)$

$\{$

bool leftInColumn$\{($position$.$x $>=$ object.getPosition$().$x

&& position.x object.getPosition$().$x $+$ object.getDimensions$().$x$)\}$;

bool rightInColumn$\{($position$.$x $+$ getDimensions$().$x $>=$ object.getPosition$().$x

&& position.x $+$ getDimensions$().$x object.getPosition$().$x $+$ object.getDimensions$().$x$)\}$;

bool topInRow$\{($position$.$y $>=$ object.getPosition$().$y