Cocos2D-X Platformer tutorial Part 4 – Animation

Okay time to continue with my cocos2d-x tutorial, it has been a while but I intend to finish it.
Before I begin, it is going to be a bit different from the animations you may already know.

Why? It is because I have more control and it is cleaner this way, I think.

New Stuff

fields for Animate objects in GameScene.h
setupAnimations() – init animations
animate.setTarget(player_sprite) – target for my animation, meaning animate where the players position is
animate.setDuration(0.80f) – duration of animation
walkRight.startWithTarget(player_sprite) – well there was no method to reset the animation once it was over, because when its over it won’t animate anymore and I didn’t wanna create a ‘new’ object every time, for my luck this one did the trick 😀
I’m also checking for the animation after damping, since I move a little more even if I’m not pressing right or left


#pragma once
 
#include "cocos2d.h"
#include "Level.h"
#include "Player.h"
#include <algorithm>
#include <vector>
#include <string>
 
using namespace std;
USING_NS_CC;
 
class GameScene : public cocos2d::Layer
{
public:
   
    //FIELDS
    Level * level;
    Player *player;
    Sprite *player_sprite;

	Animate *walkRight;
	Animate *jumping;
	Animate *falling;

    vector<EventKeyboard::KeyCode> heldKeys;
 
    //CONSTRUCTOR & METHODS
 
    virtual void onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event);
    virtual void onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event);
    
	void updateScene(float interval);
	void updatePlayer(float interval);
	void updatePlayerSprite(float interval);

    int signum(float x);
 
    static cocos2d::Scene* createScene();
 
    virtual bool init();  
    
    void menuCloseCallback(cocos2d::Ref* pSender);
	void setupAnimations();
    
    CREATE_FUNC(GameScene);
 
    GameScene(void);
    virtual ~GameScene(void);
};

#pragma once

#include "cocos2d.h"

#include "Level.h"

#include "Player.h"

#include <algorithm>

#include <vector>

#include <string>

using namespace std;

USING_NS_CC;

class GameScene : public cocos2d::Layer

{

public:

//FIELDS

Level * level;

Player *player;

Sprite *player_sprite;

Animate *walkRight;

Animate *jumping;

Animate *falling;

vector<EventKeyboard::KeyCode> heldKeys;

//CONSTRUCTOR & METHODS

virtual void onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event);

virtual void onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event);

void updateScene(float interval);

void updatePlayer(float interval);

void updatePlayerSprite(float interval);

int signum(float x);

static cocos2d::Scene* createScene();

virtual bool init();

void menuCloseCallback(cocos2d::Ref* pSender);

void setupAnimations();

CREATE_FUNC(GameScene);

GameScene(void);

virtual ~GameScene(void);

};


#include "GameScene.h"
#include "globals.h"
 
 
Scene* GameScene::createScene()
{
    auto scene = Scene::create();
    
    auto layer = GameScene::create();
 
    scene->addChild(layer);
   
    return scene;
}
 
bool GameScene::init()
{
    if ( !Layer::init() )
    {
        return false;
    }
 
    level = new Level();
    level->loadMap("level1.tmx");
    level->retain();
 
    auto director = Director::getInstance();
    level->getMap()->setScale(SCALE_FACTOR);
 
    this->addChild(level->getMap());
 
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("solbrain.plist");
	AnimationCache::getInstance()->addAnimationsWithFile("solbrain-animations.plist");
 
    player_sprite = Sprite::createWithSpriteFrameName("idle");
	player_sprite->setScale(SCALE_FACTOR);
    player_sprite->setFlippedX(true);

 
    Point point = Point(10,2);
    Size size = player_sprite->getContentSize();
 
    player_sprite->setPosition(level->positionForTileCoordinate(size, point));
 
    player = new Player();
    player->retain();
	player->state = Player::State::Standing;
	this->setupAnimations();
 
    this->addChild(player_sprite);
    this->schedule(schedule_selector(GameScene::updateScene));
    return true;
}

void GameScene::setupAnimations(){

	AnimationCache *cache = AnimationCache::getInstance(); 
	Animation *animation = cache->getAnimation("walk");
	Animate* animate = Animate::create(animation);
	animate->getAnimation()->setRestoreOriginalFrame(true);
	animate->setDuration(0.80f);
	animate->setTarget(player_sprite);
	
	this->walkRight = animate;
	this->walkRight->retain();

}
 
void GameScene::updateScene(float delta){
 
	this->updatePlayer(delta);
 
}

void GameScene::updatePlayer(float delta){

	    if(std::find(heldKeys.begin(), heldKeys.end(), RIGHT_ARROW) != heldKeys.end()){

            player->velocity.x = PLAYER_MAX_VELOCITY;
            
			if(player->grounded){
                player->state = Player::State::Walking;				
            }

            player->facingRight = true;
        }
 
        if(std::find(heldKeys.begin(), heldKeys.end(), LEFT_ARROW) != heldKeys.end()){
               player->velocity.x = -PLAYER_MAX_VELOCITY;
            if(player->grounded){
                player->state = Player::State::Walking;
            }
            player->facingRight = false;
        }
        // clamp the velocity to the maximum, x-axis only
        if (std::abs(player->velocity.x) > PLAYER_MAX_VELOCITY) {
            player->velocity.x = signum(player->velocity.x) * PLAYER_MAX_VELOCITY;
        }
        // clamp the velocity to 0 if it's < 1, and set the state to standing
        if (std::abs(player->velocity.x) < 1) {
            player->velocity.x = 0;
            if (player->grounded) {
               player->state = Player::State::Standing;
            }
        }
 
        // unscale the velocity by the inverse delta time and set
        // the latest position
        player->velocity = player->velocity * delta;
        player->position = player->position + player->velocity;
        player->velocity = player->velocity * 1/delta;
 
        player->velocity.x *= DAMPING;
		this->updatePlayerSprite(delta);
}

void GameScene::updatePlayerSprite(float delta){

	if(player->state == Player::State::Walking){

		if(walkRight->isDone()){
           walkRight->startWithTarget(player_sprite);
        }

		walkRight->step(delta);

		if(player->facingRight){    
			player_sprite->setFlippedX(true);
		}else {
			player_sprite->setFlippedX(false);
		}

	}else if(player->state == Player::State::Jumping){
		
	}else{
		player_sprite->setSpriteFrame(Sprite::createWithSpriteFrameName("idle")->getSpriteFrame());
	}
    
    player_sprite->setPositionX(player_sprite->getPositionX() + player->velocity.x);
}
 
void GameScene::onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)
{
    if(std::find(heldKeys.begin(), heldKeys.end(), keyCode) == heldKeys.end()){
            heldKeys.push_back(keyCode);
    }
}
 
void GameScene::onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event)
{
    heldKeys.erase(std::remove(heldKeys.begin(), heldKeys.end(), keyCode), heldKeys.end());
}
 
int GameScene::signum(float x) 
{ 
  if (x > 0.0L) 
    return 1.0L; 
  else if (x < 0.0L)   
    return -1.0L; 
  else   
    return 0.0L; 
}
 
void GameScene::menuCloseCallback(Ref* pSender)
{
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
    return;
#endif
 
    Director::getInstance()->end();
 
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
    exit(0);
#endif
}
 
GameScene::GameScene(void)
{
    setKeyboardEnabled(true);    
}
GameScene::~GameScene(void)
{
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

#include "GameScene.h"

#include "globals.h"

Scene* GameScene::createScene()

{

auto scene = Scene::create();

auto layer = GameScene::create();

scene->addChild(layer);

return scene;

}

bool GameScene::init()

{

if ( !Layer::init() )

{

return false;

}

level = new Level();

level->loadMap("level1.tmx");

level->retain();

auto director = Director::getInstance();

level->getMap()->setScale(SCALE_FACTOR);

this->addChild(level->getMap());

SpriteFrameCache::getInstance()->addSpriteFramesWithFile("solbrain.plist");

AnimationCache::getInstance()->addAnimationsWithFile("solbrain-animations.plist");

player_sprite = Sprite::createWithSpriteFrameName("idle");

player_sprite->setScale(SCALE_FACTOR);

player_sprite->setFlippedX(true);

Point point = Point(10,2);

Size size = player_sprite->getContentSize();

player_sprite->setPosition(level->positionForTileCoordinate(size, point));

player = new Player();

player->retain();

player->state = Player::State::Standing;

this->setupAnimations();

this->addChild(player_sprite);

this->schedule(schedule_selector(GameScene::updateScene));

return true;

}

void GameScene::setupAnimations(){

AnimationCache *cache = AnimationCache::getInstance();

Animation *animation = cache->getAnimation("walk");

Animate* animate = Animate::create(animation);

animate->getAnimation()->setRestoreOriginalFrame(true);

animate->setDuration(0.80f);

animate->setTarget(player_sprite);

this->walkRight = animate;

this->walkRight->retain();

}

void GameScene::updateScene(float delta){

this->updatePlayer(delta);

}

void GameScene::updatePlayer(float delta){

if(std::find(heldKeys.begin(), heldKeys.end(), RIGHT_ARROW) != heldKeys.end()){

player->velocity.x = PLAYER_MAX_VELOCITY;

if(player->grounded){

player->state = Player::State::Walking;

}

player->facingRight = true;

}

if(std::find(heldKeys.begin(), heldKeys.end(), LEFT_ARROW) != heldKeys.end()){

player->velocity.x = -PLAYER_MAX_VELOCITY;

if(player->grounded){

player->state = Player::State::Walking;

}

player->facingRight = false;

}

// clamp the velocity to the maximum, x-axis only

if (std::abs(player->velocity.x) > PLAYER_MAX_VELOCITY) {

player->velocity.x = signum(player->velocity.x) * PLAYER_MAX_VELOCITY;

}

// clamp the velocity to 0 if it's < 1, and set the state to standing

if (std::abs(player->velocity.x) < 1) {

player->velocity.x = 0;

if (player->grounded) {

player->state = Player::State::Standing;

}

// unscale the velocity by the inverse delta time and set

// the latest position

player->velocity = player->velocity * delta;

player->position = player->position + player->velocity;

player->velocity = player->velocity * 1/delta;

player->velocity.x *= DAMPING;

this->updatePlayerSprite(delta);

}

void GameScene::updatePlayerSprite(float delta){

if(player->state == Player::State::Walking){

if(walkRight->isDone()){

walkRight->startWithTarget(player_sprite);

}

walkRight->step(delta);

if(player->facingRight){

player_sprite->setFlippedX(true);

}else {

player_sprite->setFlippedX(false);

}

}else if(player->state == Player::State::Jumping){

}else{

player_sprite->setSpriteFrame(Sprite::createWithSpriteFrameName("idle")->getSpriteFrame());

}

player_sprite->setPositionX(player_sprite->getPositionX() + player->velocity.x);

}

void GameScene::onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)

{

if(std::find(heldKeys.begin(), heldKeys.end(), keyCode) == heldKeys.end()){

heldKeys.push_back(keyCode);

}

void GameScene::onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event)

{

heldKeys.erase(std::remove(heldKeys.begin(), heldKeys.end(), keyCode), heldKeys.end());

}

int GameScene::signum(float x)

{

if (x > 0.0L)

return 1.0L;

else if (x < 0.0L)

return -1.0L;

else

return 0.0L;

}

void GameScene::menuCloseCallback(Ref* pSender)

{

#if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)

return;

#endif

Director::getInstance()->end();

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)

exit(0);

#endif

}

GameScene::GameScene(void)

{

setKeyboardEnabled(true);

}

GameScene::~GameScene(void)

{

}

This entry was posted in Cocos2D-X and tagged animate,animations,cocos2dx,platformer on September 23, 2014

Cocos2D-X Platformer tutorial Part 4 – Animation

Recent Posts

Categories