RythmGame/SimpleGame/src/Source/Game.cpp

#include "Game.hpp"
#include "AudioEmitter.hpp"
#include "GameData.hpp"
#include "NoteSprite.hpp"
#include "NoteTile.hpp"
#include "TilePattern.hpp"
#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/RectangleShape.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/Texture.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/Window/Keyboard.hpp>
#include <format>
#include <iostream>
#include <math.h>
#include <string>

const sf::Time Game::TimePerFrame = sf::seconds(1.f / 60.f);
sf::Texture bgTexture;

Game::Game() : backGround(PLACE_HOLDER_TEXTURE) {
  assert(mFont.openFromFile("media/Sansation.ttf"));
  mStatisticsText.setPosition({5.f, 5.f});
  mStatisticsText.setCharacterSize(10);

  leftPressZone = sf::RectangleShape(sf::Vector2f(50, 10));
  middlePressZone = sf::RectangleShape(sf::Vector2f(50, 10));
  rightPressZone = sf::RectangleShape(sf::Vector2f(50, 10));

  leftPressZone.setPosition(
      sf::Vector2f(NOTE_PLACE_X_POS[0], NOTE_PRESS_HEIGHT));
  middlePressZone.setPosition(
      sf::Vector2f(NOTE_PLACE_X_POS[1], NOTE_PRESS_HEIGHT));
  rightPressZone.setPosition(
      sf::Vector2f(NOTE_PLACE_X_POS[2], NOTE_PRESS_HEIGHT));

  leftPressZone.setFillColor(sf::Color::Black);
  middlePressZone.setFillColor(sf::Color::Black);
  rightPressZone.setFillColor(sf::Color::Black);

  ScoreText.setPosition({SCREEN_WIDTH - 200, 5});
  ScoreText.setFillColor(sf::Color::Black);
  ScoreText.setCharacterSize(20);
  ScoreMultiplierText.setPosition({SCREEN_WIDTH - 200, 25});
  ScoreMultiplierText.setFillColor(sf::Color::Black);
  ScoreMultiplierText.setCharacterSize(20);

  if (!bgTexture.loadFromFile("media/sprites/bureau.png")) {
    printf("sprite bureau not loaded\n");
  }
  backGround.setTexture(bgTexture, true);
  float sx = backGround.getTexture().getSize().x;
  float sy = backGround.getTexture().getSize().y;
  backGround.setScale(sf::Vector2f(SCREEN_WIDTH / sx, SCREEN_HEIGHT / sy));
}

void generateTilePatternAndMusic(AudioEmitter &audio_emitter) {
  generateTilePattern(audio_emitter.generateMusic(), audio_emitter);
}

bool updateAudio(AudioEmitter &audioEmitter, bool generated) {
  if (32.f - fmod(audioEmitter.getTimeTempo(), 32.f) <
      audioEmitter.timeBeforeNewGeneration) {
    if (!generated) {
      generateTilePatternAndMusic(audioEmitter);
      generated = true;
    }
  } else {
    generated = false;
  }

  return generated;
}

void Game::run() {
  AudioEmitter audioEmitter = AudioEmitter();
  generateTilePatternAndMusic(audioEmitter);
  bool generated = false;

  mWindow.setFramerateLimit(60);
  while (mWindow.isOpen()) {

    render();
    generated = updateAudio(audioEmitter, generated);
    processEvents(audioEmitter);
    audioEmitter.audioUpdate();
    update(TimePerFrame);
    updateStatistics(audioEmitter);
  }
}

void Game::processEvents(AudioEmitter &audioEmitter) {
  while (const std::optional event = mWindow.pollEvent()) {
    if (event->is<sf::Event::Closed>()) {
      audioEmitter.audioEnd();
      mWindow.close();
      break;
    }
    if (const auto *keyPressed = event->getIf<sf::Event::KeyPressed>()) {
      sf::Keyboard::Scancode key_scan_code = keyPressed->scancode;
      switch (key_scan_code) {
      case sf::Keyboard::Scancode::Left:
        update_scores(
            NoteTile::checkPress(audioEmitter.getTime(), NotePlaceEnum::Left));
        break;
      case sf::Keyboard::Scancode::Up:
        update_scores(NoteTile::checkPress(audioEmitter.getTime(),
                                           NotePlaceEnum::Middle));
        break;
      case sf::Keyboard::Scancode::Right:
        update_scores(
            NoteTile::checkPress(audioEmitter.getTime(), NotePlaceEnum::Right));
        break;
      }
    }
  }
}

void Game::update(const sf::Time elapsedTime) {}

void Game::render() {
  mWindow.clear(sf::Color::Yellow);
  mWindow.draw(backGround);
  mWindow.draw(leftPressZone);
  mWindow.draw(middlePressZone);
  mWindow.draw(rightPressZone);
  if (!NoteTile::update(1.0 / 60, mWindow))
    update_scores(false);
  mWindow.draw(mStatisticsText);
  mWindow.draw(ScoreText);
  mWindow.draw(ScoreMultiplierText);
  mWindow.display();
}

void Game::updateStatistics(AudioEmitter &audioEmitter) {
  mStatisticsText.setString(std::format(
      "Mesure = {}\nBeat = {} us", ceil(audioEmitter.getTimeTempo() / 8.f),
      ceil(fmod(audioEmitter.getTimeTempo(), 8.f))));

  mStatisticsUpdateTime -= sf::seconds(1.0f);
  mStatisticsNumFrames = 0;
}

void Game::update_scores(bool good_action) {
  if (good_action) {
    score += score_multiplier;
    score_multiplier++;
  } else {
    score_multiplier = 1;
  }
  ScoreText.setString(std::format("Score = {}", score));
  ScoreMultiplierText.setString(
      std::format("ScoreMultiplier = {}", score_multiplier));
}