coffee_crisis_arcade_edition/source/background.h

#pragma once

#include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
#include <stddef.h>          // Para size_t
#include <memory>            // Para unique_ptr, shared_ptr
#include <vector>            // Para vector
#include "utils.h"           // Para Color
class MovingSprite;          // lines 7-7
class Sprite;                // lines 8-8
class Texture;               // lines 9-9

/*
    Esta clase es la encargada de dibujar el fondo que aparece durante la sección
    jugable.

    Utiliza una textura donde compone la imagen y luego tiene una textura superior
    rellena de un color sólido cuya opacidad se puede modificar.

    El objeto tiene un tamaño total definido en la variable "rect". En principio este
    tamaño coincide con el tamaño de la ventana o resolución del juego, pero se pinta
    solo el rectangulo definido en srcRect en la posición de la pantalla definida en
    dstRect.

    Ambos rectangulos han de coincidir en tamaño y por definición, el punto comun es el inferior derecho el rectangulo.

    Utiliza varios métodos para definir su comportamiento:
        - setCloudsSpeed(float value)
          Velocidad a la que se desplazan las nubes cada frame

        - setGradientNumber(int value)
          Escoge el índice de la textura de fondo a usar (el color del cielo)

        - setTransition(float value)
          Porcentaje (entre 0.0f (textura actual) y 1.0f (textura siguiente)) para mostrar entre la textura de fondo actual y la siguiente

        - setColor(Color color)
          Establece el color de la textura de superposición

        - setAlpha(int alpha)
          Establece la transparencia de la textura de superposición
*/

// Clase Background
class Background
{
private:
  // Objetos y punteros
  SDL_Renderer *renderer_; // El renderizador de la ventana

  std::shared_ptr<Texture> buildings_texture_;     // Textura con los edificios de fondo
  std::shared_ptr<Texture> top_clouds_texture_;    // Textura con las nubes de fondo
  std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
  std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
  std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
  std::shared_ptr<Texture> sun_texture_;           // Textura con el sol
  std::shared_ptr<Texture> moon_texture_;          // Textura con la luna

  std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
  std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
  std::unique_ptr<MovingSprite> bottom_clouds_sprite_a_; // Sprite para las nubes inferiores
  std::unique_ptr<MovingSprite> bottom_clouds_sprite_b_; // Sprite para las nubes inferiores

  std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
  std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
  std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
  std::unique_ptr<Sprite> sun_sprite_;       // Sprite para el sol
  std::unique_ptr<Sprite> moon_sprite_;      // Sprite para la luna

  SDL_Texture *canvas_;        // Textura para componer el fondo
  SDL_Texture *color_texture_; // Textura para atenuar el fondo

  // Variables
  SDL_Rect gradient_rect_[4];        // Vector con las coordenadas de los 4 degradados para el cielo
  SDL_Rect top_clouds_rect_[4];      // Vector con las coordenadas de los 4 nubes de arriba
  SDL_Rect bottom_clouds_rect_[4];   // Vector con las coordenadas de los 4 nubes de abajo
  int gradient_number_ = 0;          // Indica el número de degradado de fondo que se va a dibujar
  int alpha_ = 0;                    // Transparencia entre los dos degradados
  float clouds_speed_ = 0;           // Velocidad a la que se desplazan las nubes
  float transition_ = 0;             // Nivel de transición del fondo 0..1
  int counter_ = 0;                  // Contador interno
  SDL_Rect rect_;                    // Tamaño del objeto fondo
  SDL_Rect src_rect_;                // Parte del objeto fondo que se va a dibujará en pantalla
  SDL_Rect dst_rect_;                // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
  int base_;                         // Linea de fondo coincidente con el area inferior de la zona de juego
  Color attenuate_color_;            // Color para atenuar el fondo
  int alpha_color_text_;             // Alpha para atenuar el fondo
  int alpha_color_text_temp_;        // Valor temporal para hacer la transición de alpha
  std::vector<SDL_Point> sun_path_;  // Vector con el recorrido del sol
  std::vector<SDL_Point> moon_path_; // Vector con el recorrido de la luna
  size_t sun_index_ = 0;             // Posición del vector del recorrido del sol
  size_t moon_index_ = 0;            // Posición del vector del recorrido de la luna

  // Dibuja el gradiente de fondo
  void renderGradient();

  // Dibuja las nubes de arriba
  void renderTopClouds();

  // Dibuja las nubes de abajo
  void renderBottomClouds();

  // Compone todos los elementos del fondo en la textura
  void fillCanvas();

  // Actualiza el valor de alpha
  void updateAlphaColorTexture();

  // Actualiza las nubes
  void updateClouds();

  // Precalcula el vector con el recorrido del sol
  void createSunPath();

  // Precalcula el vector con el recorrido de la luna
  void createMoonPath();

public:
  // Constructor
  Background();

  // Destructor
  ~Background();

  // Actualiza la lógica del objeto
  void update();

  // Dibuja el objeto
  void render();

  // Establece la posición del objeto
  void setPos(SDL_Rect pos);

  // Ajusta el valor de la variable
  void setCloudsSpeed(float value);

  // Ajusta el valor de la variable
  void setGradientNumber(int value);

  // Ajusta el valor de la variable
  void setTransition(float value);

  // Establece el color de atenuación
  void setColor(Color color);

  // Establece la transparencia de la atenuación
  void setAlpha(int alpha);

  // Establece la posición del sol
  void setSunProgression(float progress);

  // Establece la posición de la luna
  void setMoonProgression(float progress);
};