341 lines
11 KiB
C++
341 lines
11 KiB
C++
#include "game.h"
|
|
|
|
#define DELAY 30000
|
|
|
|
Game::Game()
|
|
:max_x(1000), max_y(800), direction(0), window(sf::VideoMode(max_x, max_y), "ASCII RACER"),
|
|
racecar(400.0f, 30.0f, 1.7f) { // maxSpeed, acceleration, and steerSpeed values
|
|
if (!font.loadFromFile("cascaydia.otf")) {
|
|
std::cerr << "Failed to load font" << std::endl;
|
|
exit(1);
|
|
}
|
|
|
|
if (!backgroundMusic.openFromFile("background_music.wav")) {
|
|
std::cerr << "Failed to load background music" << std::endl;
|
|
exit(1);
|
|
}
|
|
|
|
// Set the volume (adjust as needed)
|
|
backgroundMusic.setVolume(50);
|
|
|
|
// Play the background music
|
|
backgroundMusic.play();
|
|
|
|
// Create a text object for displaying speed
|
|
speedText.setFont(font);
|
|
|
|
// Create a map text object and set its properties
|
|
mapText.setFont(font);
|
|
mapText.setCharacterSize(24);
|
|
mapText.setFillColor(sf::Color::White);
|
|
mapText.setPosition(0, 0);
|
|
mapText.setOutlineColor(sf::Color::Red);
|
|
|
|
timerText.setFont(font);
|
|
timerText.setCharacterSize(24);
|
|
timerText.setFillColor(sf::Color::White);
|
|
|
|
racecar.setPosition(1000, 80); // Set initial position for the racecar
|
|
racecar.setRotation(180);
|
|
|
|
// Initialize the times and quadrants data structure
|
|
timesAndQuadrants.push_back(std::make_pair(1, "00:00:000"));
|
|
}
|
|
|
|
void Game::run() {
|
|
sf::Clock clock;
|
|
|
|
// Create a view that will follow the racecar
|
|
view = sf::View(sf::FloatRect(0, 0, max_x, max_y));
|
|
view.setCenter(racecar.getX(), racecar.getY()); // Center the view on the racecar
|
|
window.setView(view);
|
|
|
|
backgroundMusic.setLoop(true);
|
|
|
|
while (window.isOpen()) {
|
|
float dt = clock.restart().asSeconds();
|
|
|
|
if(lapPoints.size() < 3) {
|
|
|
|
|
|
// Update game time
|
|
sf::Time gameTime = gameTimeClock.getElapsedTime();
|
|
int milis = static_cast<int>(gameTime.asMilliseconds());
|
|
int seconds = static_cast<int>(gameTime.asSeconds());
|
|
int minutes = seconds / 60;
|
|
seconds %= 60;
|
|
milis %= 1000;
|
|
|
|
// Use std::setw and std::setfill to format numbers as two digits
|
|
std::ostringstream timerStream;
|
|
timerStream << std::setw(2) << std::setfill('0') << minutes << ":"
|
|
<< std::setw(2) << std::setfill('0') << seconds << ":"
|
|
<< std::setw(2) << std::setfill('0') << milis;
|
|
|
|
std::string timerString = timerStream.str();
|
|
timerText.setString(timerString);
|
|
|
|
// Detect when the racecar changes quadrants and save the time
|
|
int currentQuadrant = determineQuadrant(racecar.getX(), racecar.getY());
|
|
if (currentQuadrant != timesAndQuadrants.back().first) {
|
|
timesAndQuadrants.push_back(std::make_pair(currentQuadrant, timerString));
|
|
}
|
|
|
|
determineLap(static_cast<int>(gameTime.asMilliseconds()), timerString);
|
|
}
|
|
|
|
sf::Event event;
|
|
while (window.pollEvent(event)) {
|
|
if (event.type == sf::Event::Closed) {
|
|
window.close();
|
|
backgroundMusic.stop();
|
|
}
|
|
}
|
|
|
|
if(lapPoints.size() < 3) {
|
|
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
|
|
if (racecar.getSpeed() < 0) {
|
|
racecar.brake(dt);
|
|
} else {
|
|
float newX = racecar.getX() + ((racecar.getSpeed() + 1.1) * dt * cos(racecar.getRotation()));
|
|
float newY = racecar.getY() + ((racecar.getSpeed() + 1.1) * dt * sin(racecar.getRotation()));
|
|
//std::cout << "New: " << newX << "," << newY << " Old: " << racecar.getX() << "," << racecar.getY() << std::endl;
|
|
|
|
if (!isTrackCollision(newX, newY)) {
|
|
racecar.accelerate(dt);
|
|
mapText.setOutlineThickness(0);
|
|
} else {
|
|
//racecar.stop();
|
|
modifier += 0.01;
|
|
mapText.setOutlineThickness(6);
|
|
}
|
|
}
|
|
} else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
|
|
if (racecar.getSpeed() > 0) {
|
|
racecar.brake(dt);
|
|
} else {
|
|
float newX = racecar.getX() + ((racecar.getSpeed() + 1.1) * dt * cos(racecar.getRotation()));
|
|
float newY = racecar.getY() + ((racecar.getSpeed() + 1.1) * dt * sin(racecar.getRotation()));
|
|
//std::cout << "New: " << newX << "," << newY << " Old: " << racecar.getX() << "," << racecar.getY() << std::endl;
|
|
|
|
if (!isTrackCollision(newX, newY)) {
|
|
racecar.reverse(dt);
|
|
mapText.setOutlineThickness(0);
|
|
} else {
|
|
//racecar.stop();
|
|
modifier += 0.01;
|
|
mapText.setOutlineThickness(6);
|
|
}
|
|
}
|
|
} else {
|
|
racecar.decelerate(dt);
|
|
}
|
|
|
|
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
|
|
racecar.steer(dt, -1.0f); // Steer left
|
|
} else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
|
|
racecar.steer(dt, 1.0f); // Steer right
|
|
}
|
|
|
|
racecar.update(dt);
|
|
|
|
speedText.setString(std::to_string(static_cast<int>(racecar.getSpeed())) + " km/h");
|
|
speedText.setCharacterSize(24);
|
|
speedText.setFillColor(sf::Color::Green);
|
|
speedText.setPosition(racecar.getX() - 475, racecar.getY() + 350);
|
|
if(racecar.getSpeed() < 0){
|
|
speedText.setFillColor(sf::Color::Blue);
|
|
}
|
|
if(racecar.getSpeed() >= 250){
|
|
speedText.setCharacterSize(27);
|
|
speedText.setFillColor(sf::Color::Yellow);
|
|
}
|
|
if(racecar.getSpeed() >= 360){
|
|
speedText.setCharacterSize(30);
|
|
speedText.setFillColor(sf::Color::Red);
|
|
}
|
|
timerText.setPosition(racecar.getX() - 80, racecar.getY() - 350);
|
|
|
|
// Update the view to follow the racecar
|
|
view.setCenter(racecar.getX(), racecar.getY());
|
|
window.setView(view);
|
|
}
|
|
|
|
window.clear();
|
|
mapText.setString(asciiMap);
|
|
window.draw(mapText);
|
|
window.draw(racecar.getDrawable());
|
|
window.draw(speedText);
|
|
|
|
|
|
if (lapPoints.size() == 3) {
|
|
displayEndGame();
|
|
}
|
|
else {
|
|
window.draw(timerText);
|
|
}
|
|
displaySavedTimes();
|
|
window.display();
|
|
|
|
sf::sleep(sf::microseconds(DELAY));
|
|
}
|
|
}
|
|
|
|
bool Game::isTrackCollision(float x, float y) {
|
|
if (x <= 0) {
|
|
return true;
|
|
} else if (y <= 0) {
|
|
return true;
|
|
} else {
|
|
int currX = (x / 13.85) - 1;
|
|
int currY = (y / 27.88) - 1;
|
|
char currentChar = asciiMap[currY * 194 + currX];
|
|
//std::cout << x << ", " << y << std::endl;
|
|
if (currentChar == '\\' || currentChar == '|' || currentChar == '/' || currentChar == '-' || currentChar == '_') {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false; // No collision with track or out of bounds
|
|
}
|
|
|
|
void Game::determineLap(int millis, std::string timerString) {
|
|
lapFinished = true;
|
|
int requiredOrder[] = {1,2,1,2,3,4,1};
|
|
if(timesAndQuadrants.size() >= 7) {
|
|
for (int i = 0; i < 7; i++) {
|
|
if (std::get<0>(timesAndQuadrants[i]) != requiredOrder[i])
|
|
lapFinished = false;
|
|
}
|
|
}
|
|
else {
|
|
lapFinished = false;
|
|
}
|
|
|
|
if (lapFinished) {
|
|
int penality = (millis - lastRound) * modifier;
|
|
if (penality > 100000 ) penality = 100000;
|
|
unsigned int points = (100000 - penality);
|
|
lapPoints.push_back(points);
|
|
timesAndQuadrants.clear();
|
|
timesAndQuadrants.push_back(std::make_pair(1, timerString));
|
|
lastRound = millis;
|
|
modifier = 1.0f;
|
|
}
|
|
}
|
|
|
|
int Game::determineQuadrant(float x, float y) {
|
|
if (y <= 460 && x <= 1150)
|
|
return 1;
|
|
if (y > 460 && x <= 1150)
|
|
return 2;
|
|
if (y > 460 && x > 1150)
|
|
return 3;
|
|
if (y <= 460 && x > 1150)
|
|
return 4;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void Game::displaySavedTimes() {
|
|
// Display the saved times on the left side of the screen
|
|
int textY = 10; // Adjust the vertical position as needed
|
|
for (const auto& lapTime : lapPoints) {
|
|
std::string timeString = "Lap points: " + std::to_string(lapTime);
|
|
sf::Text text;
|
|
text.setFont(font);
|
|
text.setCharacterSize(18);
|
|
text.setFillColor(sf::Color::White);
|
|
text.setPosition(racecar.getX() - 475, (racecar.getY() - 300) + textY);
|
|
text.setString(timeString);
|
|
window.draw(text);
|
|
textY += 30; // Adjust the spacing as needed
|
|
}
|
|
for (const auto& timeAndQuadrant : timesAndQuadrants) {
|
|
std::string timeString = "Quadrant " + std::to_string(timeAndQuadrant.first) + ": " + timeAndQuadrant.second;
|
|
sf::Text text;
|
|
text.setFont(font);
|
|
text.setCharacterSize(18);
|
|
text.setFillColor(sf::Color::White);
|
|
text.setPosition(racecar.getX() - 475, (racecar.getY() - 300) + textY);
|
|
text.setString(timeString);
|
|
window.draw(text);
|
|
textY += 30; // Adjust the spacing as needed
|
|
}
|
|
}
|
|
|
|
void Game::displayEndGame() {
|
|
// Load high scores from a file
|
|
loadHighScores();
|
|
|
|
// Get the best score from the current run
|
|
std::sort(lapPoints.begin(), lapPoints.end());
|
|
int bestScore = lapPoints.back();
|
|
|
|
// If the new score is in the top ten, add it
|
|
if (highScores.size() < 10 || bestScore > highScores.back()) {
|
|
highScores.push_back(bestScore);
|
|
}
|
|
|
|
// Sort the high scores in descending order
|
|
std::sort(highScores.rbegin(), highScores.rend());
|
|
|
|
// Keep only the top ten scores
|
|
if (highScores.size() > 10) {
|
|
highScores.pop_back();
|
|
}
|
|
|
|
// Write the updated high scores back to the file
|
|
writeHighScores();
|
|
|
|
// Display the best score from the current run and the top ten high scores
|
|
int textY = 10; // Adjust the vertical position as needed
|
|
|
|
// Display the best score from the current run
|
|
std::string bestScoreString = "Best Lap: " + std::to_string(bestScore);
|
|
sf::Text bestScoreText;
|
|
bestScoreText.setFont(font);
|
|
bestScoreText.setCharacterSize(20);
|
|
bestScoreText.setFillColor(sf::Color::White);
|
|
bestScoreText.setPosition(racecar.getX(), (racecar.getY() - 300) + textY);
|
|
bestScoreText.setString(bestScoreString);
|
|
window.draw(bestScoreText);
|
|
textY += 30; // Adjust the spacing as needed
|
|
|
|
// Display the top ten high scores
|
|
for (size_t i = 0; i < highScores.size(); ++i) {
|
|
std::string scoreString = "High Score #" + std::to_string(i + 1) + ": " + std::to_string(highScores[i]);
|
|
sf::Text scoreText;
|
|
scoreText.setFont(font);
|
|
scoreText.setCharacterSize(20);
|
|
scoreText.setFillColor(sf::Color::White);
|
|
scoreText.setPosition(racecar.getX(), (racecar.getY() - 300) + textY);
|
|
scoreText.setString(scoreString);
|
|
window.draw(scoreText);
|
|
textY += 30; // Adjust the spacing as needed
|
|
}
|
|
}
|
|
|
|
void Game::loadHighScores() {
|
|
std::ifstream file(highScoresFile);
|
|
if (file.is_open()) {
|
|
int score;
|
|
while (file >> score) {
|
|
highScores.push_back(score);
|
|
}
|
|
file.close();
|
|
}
|
|
}
|
|
|
|
// Function to write high scores to a file
|
|
void Game::writeHighScores() {
|
|
std::ofstream file(highScoresFile);
|
|
if (file.is_open()) {
|
|
for (const int& score : highScores) {
|
|
file << score << std::endl;
|
|
}
|
|
file.close();
|
|
}
|
|
}
|
|
|