updated animatedsprite.cpp

source/animatedsprite.cpp

@@ -1,16 +1,18 @@
-#include "const.h"
+//#include "const.h"
 #include "animatedsprite.h"
-#include <iostream>
+//#include <iostream>
 
 // Constructor
 AnimatedSprite::AnimatedSprite()
 {
+	MovingSprite::init(0, 0, 0, 0, 0, 0, 0, 0, nullptr, nullptr);
 	init(nullptr, nullptr);
 }
 
 // Destructor
 AnimatedSprite::~AnimatedSprite()
 {
+	MovingSprite::init(0, 0, 0, 0, 0, 0, 0, 0, nullptr, nullptr);
 	init(nullptr, nullptr);
 }
 
@@ -19,72 +21,90 @@ void AnimatedSprite::init(LTexture *texture, SDL_Renderer *renderer)
 {
 	mRenderer = renderer;
 	mTexture = texture;
+
 	for (Uint8 i = 0; i < 20; i++)
 	{
 		mAnimation[i].numFrames = 0;
 		mAnimation[i].speed = 0;
 		mAnimation[i].loop = true;
-		for (Uint8 j = 0; i < 20; i++)
+		mAnimation[i].currentFrame = 0;
+		mAnimation[i].counter = 0;
+		for (Uint8 j = 0; i < 50; i++)
 		{
-			mAnimation[i].frames[j].x = 0;
-			mAnimation[i].frames[j].y = 0;
-			mAnimation[i].frames[j].w = 0;
-			mAnimation[i].frames[j].h = 0;
+			mAnimation[i].frame[j].x = 0;
+			mAnimation[i].frame[j].y = 0;
+			mAnimation[i].frame[j].w = 0;
+			mAnimation[i].frame[j].h = 0;
 		}
 	}
-	mCurrentFrame = 0;
-	mAnimationCounter = 0;
+
+	mCurrentAnimation = 0;
 }
 
 // Calcula el frame correspondiente a la animación
 void AnimatedSprite::animate(int index)
 {
 	// Calculamos el frame actual a partir del contador
-	mCurrentFrame = mAnimationCounter / mAnimation[index].speed;
+	mAnimation[index].currentFrame = mAnimation[index].counter / mAnimation[index].speed;
 
-	// Si alcanzamos el final de la animación, reiniciamos el contador de la animación
-	// en función de la variable loop
-	if (mCurrentFrame >= mAnimation[index].numFrames)
+	// Final de la animación
+	if (mAnimation[index].currentFrame >= mAnimation[index].numFrames)
 	{
+		// Si se reproduce en bucle
 		if (mAnimation[index].loop)
 		{
-			mAnimationCounter = 0;
+			// Reiniciamos el contador de la animación
+			mAnimation[index].counter = 0;
 		}
 		else
 		{
-			mCurrentFrame = mAnimation[index].numFrames;
+			// Mantenemos el ultimo frame
+			mAnimation[index].currentFrame = mAnimation[index].numFrames;
 		}
 	}
-	// En caso contrario
+	// La animación no ha llegado a su fin
 	else
 	{
-		// Escogemos el frame correspondiente de la animación
-		setSpriteClip(mAnimation[index].frames[mCurrentFrame]);
+		// Establece el frame correspondiente de la animación
+		setSpriteClip(mAnimation[index].frame[mAnimation[index].currentFrame]);
 
-		// Incrementamos el contador de la animacion
-		++mAnimationCounter;
+		// Incrementa el contador de la animacion
+		mAnimation[index].counter++;
 	}
 }
 
+// Actualiza todas las variables del objeto: posición, velocidad y animación
+void AnimatedSprite::update()
+{
+	MovingSprite::update();
+	animate(mCurrentAnimation);
+}
+
 // Establece el frame actual de la animación
-void AnimatedSprite::setCurrentFrame(Uint8 num)
+void AnimatedSprite::setCurrentFrame(Uint8 index, Uint8 num)
 {
-	mCurrentFrame = num;
+	mAnimation[index].currentFrame = num;
 }
 
 // Establece el valor del contador
-void AnimatedSprite::setAnimationCounter(Uint16 num)
+void AnimatedSprite::setAnimationCounter(Uint8 index, Uint16 num)
 {
-	mAnimationCounter = num;
+	mAnimation[index].counter = num;
 }
 
 // Establece el rectangulo para un frame de una animación
-void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
+void AnimatedSprite::setAnimationFrames(Uint8 index, Uint8 frame, int x, int y, int w, int h)
 {
-	mAnimation[index_animation].frames[index_frame].x = x;
-	mAnimation[index_animation].frames[index_frame].y = y;
-	mAnimation[index_animation].frames[index_frame].w = w;
-	mAnimation[index_animation].frames[index_frame].h = h;
+	mAnimation[index].frame[frame].y = y;
+	mAnimation[index].frame[frame].w = w;
+	mAnimation[index].frame[frame].h = h;
+	mAnimation[index].frame[frame].x = x;
+}
+
+// Establece el rectangulo para un frame de una animación
+void AnimatedSprite::setAnimationFrames(Uint8 index, Uint8 frame, SDL_Rect rect)
+{
+	mAnimation[index].frame[frame] = rect;
 }
 
 // Establece la velocidad de una animación
@@ -96,7 +116,8 @@ void AnimatedSprite::setAnimationSpeed(Uint8 index, Uint8 speed)
 // Establece el numero de frames de una animación
 void AnimatedSprite::setAnimationNumFrames(Uint8 index, Uint8 num)
 {
-	mAnimation[index].numFrames = num;
+	if (num < MAX_FRAMES)
+		mAnimation[index].numFrames = num;
 }
 
 // Establece si la animación se reproduce en bucle
@@ -106,7 +127,20 @@ void AnimatedSprite::setAnimationLoop(Uint8 index, bool loop)
 }
 
 // Devuelve el rectangulo de una animación y frame concreto
-SDL_Rect AnimatedSprite::getAnimationClip(Uint8 index_animation, Uint8 index_frame)
+SDL_Rect AnimatedSprite::getAnimationClip(Uint8 index, Uint8 frame)
 {
-	return mAnimation[index_animation].frames[index_frame];
+	return mAnimation[index].frame[frame];
+}
+
+// Establece la animación actual
+void AnimatedSprite::setCurrentAnimation(Uint8 index)
+{
+	if (index < MAX_ANIMATIONS)
+		mCurrentAnimation = index;
+}
+
+// Obtiene la animación actual
+Uint8 AnimatedSprite::getCurrentAnimation()
+{
+	return mCurrentAnimation;
 }