tests/logicTests.cpp

Go to the documentation of this file.

#include <vector>
#include <list>
#include <utility>
using namespace std;

#include <gtest/gtest.h>

#include "../source/logic/CollisionDetector.h"
#include "../source/logic/PlayerCar.h"
#include "../source/logic/EnemyCar.h"
#include "../source/logic/Checkpoint.h"
#include "../source/logic/Rock.h"
#include "../source/logic/Smokescreen.h"
#include "../source/logic/Maze.h"
#include "../source/logic/MazeMath.h"
#include "../source/logic/DestroyedObjectPopup.h"

TEST(Car, updateMovesPlayerUpInEmptyMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(2,2,Maze::UP);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 2;
    double expectY = 2-player.speed();
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}

TEST(Car, updateMovesPlayerDownInEmptyMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(2,2,Maze::DOWN);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 2;
    double expectY = 2+player.speed();
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}

TEST(Car, updateMovesPlayerLeftInEmptyMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(2,2,Maze::LEFT);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 2-player.speed();
    double expectY = 2;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}

TEST(Car, updateMovesPlayerRightInEmptyMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(2,2,Maze::RIGHT);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 2+player.speed();
    double expectY = 2;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}

TEST(Car, carNotMovedWhenPathUpBlocked)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    walls.push_back(make_pair(3,3));
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(3,4,Maze::UP);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 3;
    double expectY = 4;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}
TEST(Car, carNotMovedWhenPathDownBlocked)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    walls.push_back(make_pair(3,3));
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(3,2,Maze::DOWN);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 3;
    double expectY = 2;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}
TEST(Car, carNotMovedWhenPathLeftBlocked)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    walls.push_back(make_pair(3,3));
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(4,3,Maze::LEFT);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 4;
    double expectY = 3;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}
TEST(Car, carNotMovedWhenPathRightBlocked)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    walls.push_back(make_pair(3,3));
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(2,3,Maze::RIGHT);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 2;
    double expectY = 3;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}

TEST(Car, carDoesNotMoveUpOutMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(3,0,Maze::UP);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 3;
    double expectY = 0;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}
TEST(Car, carDoesNotMoveDownOutMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(3,5,Maze::DOWN);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 3;
    double expectY = 5;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}
TEST(Car, carDoesNotMoveLeftOutMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(0,3,Maze::LEFT);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 0;
    double expectY = 3;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}
TEST(Car, carDoesNotMoveRightOutMaze)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(5,3,Maze::RIGHT);

    list<Smokescreen> smokescreens;
    player.update(testMaze, smokescreens);

    double expectX = 5;
    double expectY = 3;
    EXPECT_FLOAT_EQ(expectX, player.x());
    EXPECT_FLOAT_EQ(expectY, player.y());
}

TEST(Checkpoint, countIncrementsAndDecrements)
{
    vector<Checkpoint> checkpoints;
    EXPECT_EQ(0, Checkpoint::checkpointCount());

    for (int i=0; i<1000; ++i)
    {
        checkpoints.push_back(Checkpoint(i,i));
    }
    EXPECT_EQ(1000, Checkpoint::checkpointCount());

    //brackets to limit scope
    {
        Checkpoint extraCheck1(0,0);
        Checkpoint extraCheck2 = extraCheck1;
        EXPECT_EQ(1002, Checkpoint::checkpointCount());
        extraCheck2 = extraCheck1;
        EXPECT_EQ(1002, Checkpoint::checkpointCount());
    }
    EXPECT_EQ(1000, Checkpoint::checkpointCount());

    while(!checkpoints.empty())
    {
        checkpoints.pop_back();
    }
    EXPECT_EQ(0, Checkpoint::checkpointCount());
}

TEST(CollisionDetector, playerAndEnemyBothDestroyed)
{
    list<PlayerCar> players;
    list<EnemyCar> enemies;
    list<Checkpoint> checkpoints;
    list<Rock> rocks;
    list<Smokescreen> smokescreens;
    CollisionDetector detector;

    players.push_back(PlayerCar(5,5));
    players.push_back(PlayerCar(5,6));
    players.push_back(PlayerCar(6,5));
    players.push_back(PlayerCar(7,7.5));

    enemies.push_back(EnemyCar(5,6));
    enemies.push_back(EnemyCar(4,5));
    enemies.push_back(EnemyCar(6,6));
    enemies.push_back(EnemyCar(6.5,8));

    detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);

    list<PlayerCar>::const_iterator playerIter = players.begin();
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_TRUE(playerIter->destroyed());
    ++playerIter;
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_TRUE(playerIter->destroyed());

    list<EnemyCar>::const_iterator enemyIter = enemies.begin();
    EXPECT_TRUE(enemyIter->destroyed());
    ++enemyIter;
    EXPECT_FALSE(enemyIter->destroyed());
    ++enemyIter;
    EXPECT_FALSE(enemyIter->destroyed());
    ++enemyIter;
    EXPECT_TRUE(enemyIter->destroyed());
}

TEST(CollisionDetector, playerDestroyedByRock)
{
    list<PlayerCar> players;
    list<EnemyCar> enemies;
    list<Checkpoint> checkpoints;
    list<Rock> rocks;
    list<Smokescreen> smokescreens;
    CollisionDetector detector;

    players.push_back(PlayerCar(5,5));
    players.push_back(PlayerCar(5,6));
    players.push_back(PlayerCar(6,5));
    players.push_back(PlayerCar(7,7.5));

    rocks.push_back(Rock(5,6));
    rocks.push_back(Rock(4,5));
    rocks.push_back(Rock(6,6));
    rocks.push_back(Rock(6.5,8));

    detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);

    list<PlayerCar>::const_iterator playerIter = players.begin();
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_TRUE(playerIter->destroyed());
    ++playerIter;
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_TRUE(playerIter->destroyed());

    list<Rock>::const_iterator rockIter = rocks.begin();
    EXPECT_FALSE(rockIter->destroyed());
    ++rockIter;
    EXPECT_FALSE(rockIter->destroyed());
    ++rockIter;
    EXPECT_FALSE(rockIter->destroyed());
    ++rockIter;
    EXPECT_FALSE(rockIter->destroyed());
}

TEST(CollisionDetector, checkpointDestroyedByPlayer)
{
    list<PlayerCar> players;
    list<EnemyCar> enemies;
    list<Checkpoint> checkpoints;
    list<Rock> rocks;
    list<Smokescreen> smokescreens;
    CollisionDetector detector;

    players.push_back(PlayerCar(5,5));
    players.push_back(PlayerCar(5,6));
    players.push_back(PlayerCar(6,5));
    players.push_back(PlayerCar(7,7.5));

    checkpoints.push_back(Checkpoint(5,6));
    checkpoints.push_back(Checkpoint(4,5));
    checkpoints.push_back(Checkpoint(6,6));
    checkpoints.push_back(Checkpoint(6.5,8));

    detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);

    list<PlayerCar>::const_iterator playerIter = players.begin();
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_FALSE(playerIter->destroyed());
    ++playerIter;
    EXPECT_FALSE(playerIter->destroyed());

    list<Checkpoint>::const_iterator checkpointIter = checkpoints.begin();
    EXPECT_TRUE(checkpointIter->destroyed());
    ++checkpointIter;
    EXPECT_FALSE(checkpointIter->destroyed());
    ++checkpointIter;
    EXPECT_FALSE(checkpointIter->destroyed());
    ++checkpointIter;
    EXPECT_TRUE(checkpointIter->destroyed());
}

TEST(CollisionDetector, enemyStoppedBySmokescreen)
{
    list<PlayerCar> players;
    list<EnemyCar> enemies;
    list<Checkpoint> checkpoints;
    list<Rock> rocks;
    list<Smokescreen> smokescreens;
    CollisionDetector detector;

    enemies.push_back(EnemyCar(5,5));
    enemies.push_back(EnemyCar(5,6));
    enemies.push_back(EnemyCar(6,5));
    enemies.push_back(EnemyCar(7,7.5));

    smokescreens.push_back(Smokescreen(5,6));
    smokescreens.push_back(Smokescreen(4,5));
    smokescreens.push_back(Smokescreen(6,6));
    smokescreens.push_back(Smokescreen(6.5,8));

    detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);

    list<EnemyCar>::const_iterator enemyIter = enemies.begin();
    EXPECT_GT(enemyIter->speed(),0);
    ++enemyIter;
    EXPECT_FLOAT_EQ(0, enemyIter->speed());
    ++enemyIter;
    EXPECT_GT(enemyIter->speed(),0);
    ++enemyIter;
    EXPECT_FLOAT_EQ(0, enemyIter->speed());
}

TEST(DestroyedObjectPopup, destroyedAfterSetTime)
{
    DestroyedObjectPopup testPopup(3,2,BitmapStore::CRASHED_CAR);

    int i=0;
    while (!testPopup.destroyed())
    {
        testPopup.update();
        ++i;
    }

    EXPECT_EQ(30,i);
}

TEST(Maze, queryOutsideBoundsReturnsSolid)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    EXPECT_FALSE(testMaze.getSolid(5,5));
    EXPECT_FALSE(testMaze.getSolid(0,0));
    EXPECT_TRUE(testMaze.getSolid(6,5));
    EXPECT_TRUE(testMaze.getSolid(5,6));
    EXPECT_TRUE(testMaze.getSolid(-1,3));
    EXPECT_TRUE(testMaze.getSolid(3,-1));
}

TEST(Maze, generationWithWallsWithoutObjectMax)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    walls.push_back(make_pair(1,2));
    walls.push_back(make_pair(4,3));
    testMaze.generateMaze(walls);

    //test random empty blocks
    EXPECT_FALSE(testMaze.getSolid(2,1));
    EXPECT_FALSE(testMaze.getSolid(0,0));

    //test wall blocks
    EXPECT_TRUE(testMaze.getSolid(1,2));
    EXPECT_TRUE(testMaze.getSolid(4,3));

    //test bounds are being set right
    EXPECT_TRUE(testMaze.getSolid(4,4));
    EXPECT_TRUE(testMaze.getSolid(5,3));
}

TEST(Maze, generationWithWallsWithObjectMax)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    walls.push_back(make_pair(1,2));
    walls.push_back(make_pair(4,3));
    testMaze.generateMaze(walls,5,6);

    //test random empty blocks
    EXPECT_FALSE(testMaze.getSolid(2,1));
    EXPECT_FALSE(testMaze.getSolid(0,0));

    //test wall blocks
    EXPECT_TRUE(testMaze.getSolid(1,2));
    EXPECT_TRUE(testMaze.getSolid(4,3));

    //test bounds are being set right
    EXPECT_FALSE(testMaze.getSolid(4,4));
    EXPECT_FALSE(testMaze.getSolid(5,6));
    EXPECT_TRUE(testMaze.getSolid(6,6));
    EXPECT_TRUE(testMaze.getSolid(5,7));
}

TEST(MazeMath, distanceGivesExpectedResult)
{
    //right angle triange with sides of length 3, 4, and 5
    double x1 = 1;
    double y1 = 1;
    double x2 = 4;
    double y2 = 5;

    double expectedResult = 5;

    EXPECT_DOUBLE_EQ(expectedResult, MazeMath::distance(x1,y1,x2,y2));
}

TEST(MazeMath, roundGivesExpectedResult)
{
    //right angle triange with sides of length 3, 4, and 5
    double roundUp = 5.5;
    double roundDown = 5.49;

    double expectUp = 6;
    double expectDown = 5;

    EXPECT_DOUBLE_EQ(expectUp, MazeMath::round(roundUp));
    EXPECT_DOUBLE_EQ(expectDown, MazeMath::round(roundDown));
}

TEST(PlayerCar, creationAndDestructionCanHappen)
{
    EXPECT_NO_THROW({
        vector<PlayerCar> players;
        for (int i=0; i<10; ++i)
        {
            players.push_back(PlayerCar(i,i));
        }
        while(!players.empty())
        {
            players.pop_back();
        }
    });

    EXPECT_FALSE(al_is_system_installed());
}

TEST(PlayerCar, playerSpeedAffectedByPetrol)
{
    Maze testMaze;
    vector<pair<int,int> > walls;
    testMaze.generateMaze(walls,5,5);

    PlayerCar player(5,3,Maze::RIGHT);

    list<Smokescreen> smokescreens;
    for (int i=0; i<1429; ++i)
    {
        player.update(testMaze, smokescreens);
    }

    EXPECT_FLOAT_EQ(0, player.petrol());
    EXPECT_FLOAT_EQ(0.05, player.speed());

    player.gotCheckpoint();
    EXPECT_GT(player.petrol(), 0);
    EXPECT_FLOAT_EQ(0.1, player.speed());
}

TEST(Smokescreen, destroyedAfterSetTime)
{
    Smokescreen testSmokescreen(3,2);

    int i=0;
    while (!testSmokescreen.destroyed())
    {
        testSmokescreen.update();
        ++i;
    }

    EXPECT_EQ(60,i);
}