coffee_crisis_arcade_edition/source/moving_sprite.cpp

#include "moving_sprite.h"
#include "texture.h" // for Texture

// Constructor
MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_Rect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip)
	: Sprite(texture, pos),
	  x_(pos.x),
	  y_(pos.y),
	  rotate_(rotate),
	  zoom_w_(zoom_w),
	  zoom_h_(zoom_h),
	  flip_(flip) {}

MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_Rect pos)
	: Sprite(texture, pos),
	  x_(pos.x),
	  y_(pos.y),
	  rotate_({false, 0, 0, 0.0f, 0.0f, nullptr}),
	  zoom_w_(1.0f),
	  zoom_h_(1.0f),
	  flip_(SDL_FLIP_NONE) {}

MovingSprite::MovingSprite(std::shared_ptr<Texture> texture)
	: Sprite(texture),
	  rotate_({false, 0, 0, 0.0f, 0.0f, nullptr}),
	  zoom_w_(1.0f),
	  zoom_h_(1.0f),
	  flip_(SDL_FLIP_NONE) {}

// Reinicia todas las variables
void MovingSprite::clear()
{
	x_ = 0.0f; // Posición en el eje X
	y_ = 0.0f; // Posición en el eje Y

	vx_ = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
	vy_ = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse

	ax_ = 0.0f; // Aceleración en el eje X. Variación de la velocidad
	ay_ = 0.0f; // Aceleración en el eje Y. Variación de la velocidad

	rotate_.enabled = false;  // Indica si ha de rotar
	rotate_.counter = 0;	  // Contador
	rotate_.speed = 0;		  // Velocidad de giro
	rotate_.angle = 0.0f;	  // Angulo para dibujarlo
	rotate_.amount = 0.0f;	  // Cantidad de grados a girar en cada iteración
	rotate_.center = nullptr; // Centro de rotación

	zoom_w_ = 1.0f; // Zoom aplicado a la anchura
	zoom_h_ = 1.0f; // Zoom aplicado a la altura

	flip_ = SDL_FLIP_NONE; // Establece como se ha de voltear el sprite

	setPos((SDL_Rect){0, 0, 0, 0});
	setSpriteClip((SDL_Rect){0, 0, 0, 0});
}

// Mueve el sprite
void MovingSprite::move()
{
	x_ += vx_;
	y_ += vy_;

	vx_ += ax_;
	vy_ += ay_;

	syncPos();
}

// Actualiza las variables internas del objeto
void MovingSprite::update()
{
	move();
	rotate();
}

// Muestra el sprite por pantalla
void MovingSprite::render()
{
	texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_w_, zoom_h_, rotate_.angle, rotate_.center, flip_);
}

// Obtiene el valor de la variable
float MovingSprite::getZoomW() const
{
	return zoom_w_;
}

// Obtiene el valor de la variable
float MovingSprite::getZoomH() const
{
	return zoom_h_;
}

// Obtiene el valor de la variable
double MovingSprite::getAngle() const
{
	return rotate_.angle;
}

// Establece el valor de la variable
void MovingSprite::setZoomW(float value)
{
	zoom_w_ = value;
}

// Establece el valor de la variable
void MovingSprite::setZoomH(float value)
{
	zoom_h_ = value;
}

// Establece el valor de la variable
void MovingSprite::setAngle(double value)
{
	rotate_.angle = value;
}

// Incrementa el valor del ángulo
void MovingSprite::updateAngle()
{
	rotate_.angle += rotate_.amount;
}

// Obtiene el valor de la variable
bool MovingSprite::isRotating() const
{
	return rotate_.enabled;
}

// Obtiene el valor de la variable
int MovingSprite::getRotateSpeed() const
{
	return rotate_.speed;
}

// Establece la rotacion
void MovingSprite::rotate()
{
	if (rotate_.enabled)
	{
		++rotate_.counter;
		if (rotate_.counter % rotate_.speed == 0)
		{
			updateAngle();
			rotate_.counter = 0;
		}
	}
}

// Establece el valor de la variable
void MovingSprite::enableRotate()
{
	rotate_.enabled = true;
	rotate_.counter = 0;
}

// Establece el valor de la variable
void MovingSprite::disableRotate()
{
	rotate_.enabled = false;
	rotate_.counter = 0;
}

// Establece el valor de la variable
void MovingSprite::setRotateSpeed(int value)
{
	rotate_.speed = std::max(1, value);
}

// Establece el valor de la variable
void MovingSprite::setRotateAmount(double value)
{
	rotate_.amount = value;
}

// Cambia el sentido de la rotación
void MovingSprite::switchRotate()
{
	rotate_.amount *= -1;
}

// Establece el valor de la variable
void MovingSprite::setFlip(SDL_RendererFlip flip)
{
	flip_ = flip;
}

// Gira el sprite horizontalmente
void MovingSprite::flip()
{
	flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL;
}

// Obtiene el valor de la variable
SDL_RendererFlip MovingSprite::getFlip()
{
	return flip_;
}

// Obtiene el valor de la variable
float MovingSprite::getPosX() const
{
	return x_;
}

// Obtiene el valor de la variable
float MovingSprite::getPosY() const
{
	return y_;
}

// Obtiene el valor de la variable
float MovingSprite::getVelX() const
{
	return vx_;
}

// Obtiene el valor de la variable
float MovingSprite::getVelY() const
{
	return vy_;
}

// Obtiene el valor de la variable
float MovingSprite::getAccelX() const
{
	return ax_;
}

// Obtiene el valor de la variable
float MovingSprite::getAccelY() const
{
	return ay_;
}

// Establece la posición y_ el tamaño del objeto
void MovingSprite::setPos(SDL_Rect rect)
{
	x_ = (float)rect.x;
	y_ = (float)rect.y;

	pos_ = rect;
}

// Establece el valor de las variables
void MovingSprite::setPos(float x, float y)
{
	x_ = x;
	y_ = y;

	syncPos();
}

// Establece el valor de la variable
void MovingSprite::setPosX(float value)
{
	x_ = value;
	pos_.x = (int)x_;
}

// Establece el valor de la variable
void MovingSprite::setPosY(float value)
{
	y_ = value;
	pos_.y = (int)y_;
}

// Establece el valor de la variable
void MovingSprite::setVelX(float value)
{
	vx_ = value;
}

// Establece el valor de la variable
void MovingSprite::setVelY(float value)
{
	vy_ = value;
}

// Establece el valor de la variable
void MovingSprite::setAccelX(float value)
{
	ax_ = value;
}

// Establece el valor de la variable
void MovingSprite::setAccelY(float value)
{
	ay_ = value;
}

// Sincroniza la posición
void MovingSprite::syncPos()
{
	pos_.x = (int)x_;
	pos_.y = (int)y_;
}