task

#include <iostream>
#include <vector>

struct sPos {
    sPos() { x = 0; y = 0; }
    //sPos(int aX, int aY) { x = aX; y = aY; }
    int x;
    int y;
};

struct sSize
{
    sSize() { width = 0; height = 0; }
    //sSize(int aW, int aH) { width = aW; height = aW; }
    int width;
    int height;
};

struct sRect
{
    sRect() = default;
    sRect(int x, int y, int w, int h) { pos.x = x; pos.y = y; size.width = w; size.height = h; }
    sPos pos;
    sSize size;
    bool intersects(const sRect& other) {
        return !((other.pos.x + other.size.width <= pos.x) ||
                 (other.pos.y + other.size.height <= pos.y) ||
                 (other.pos.x >= pos.x + size.width) ||
                 (other.pos.y >= pos.y + size.height));
    }
};

enum class eDirection {
    UP,
    LEFT,
    RIGHT,
    DOWN
};

struct sCar {
    sRect rect;
    eDirection dir = eDirection::UP;
    int speed = 0;
    virtual void move() {
        switch (dir) {
            case eDirection::UP:
                rect.pos.y += speed;
            case eDirection::DOWN:
                rect.pos.y -= speed;
            case eDirection::RIGHT:
                rect.pos.x += speed;
            case eDirection::LEFT:
                rect.pos.x -= speed;
        }
    }

    sRect getFuturePos() {
        switch (dir) {
            case eDirection::UP:
                return sRect(rect.pos.x, rect.pos.y + speed, rect.size.width, rect.size.height);
            case eDirection::DOWN:
                return sRect(rect.pos.x, rect.pos.y - speed, rect.size.width, rect.size.height);
            case eDirection::RIGHT:
                return sRect(rect.pos.x + speed, rect.pos.y, rect.size.width, rect.size.width);
            case eDirection::LEFT:
                return sRect(rect.pos.x - speed, rect.pos.y, rect.size.width, rect.size.height);
        }
    }

    bool needPassOtherCar(sCar* otherCar) {
        bool result = false;
        auto otherdir = otherCar->dir;
        switch (dir) {
            case eDirection::UP:
                if (otherdir == eDirection::LEFT)
                    result = true;
                break;
            case eDirection::DOWN:
                if (otherdir == eDirection::RIGHT)
                    result = true;
                break;
            case eDirection::RIGHT:
                if (otherdir == eDirection::UP)
                    result = true;
                break;
            case eDirection::LEFT:
                if (otherdir == eDirection::DOWN)
                    result = true;
                break;
        }
        return result;
    }

    //virtual ~sCar() = 0;

    virtual int getFuel() = 0;
    virtual void refill(int count) = 0;
};

struct sGasEngine : virtual sCar {
    int getFuel() override { return fuel; }
    void refill(int count) override { fuel += count; }
    void move() override { fuel--; sCar::move(); }
    int fuel = 0;
};

struct sElectroCar : virtual sCar {
    int getFuel() override { return charge; }
    void refill(int count) override { charge += count; }
    void move() override { charge--; sCar::move(); }
    int charge = 0;
};

struct sHybrid : sGasEngine, sElectroCar {
    void refill(int count) override { charge += count / 2; fuel += count / 2; }
    int getFuel() override { return charge + fuel; }
    void move() override {
        if (rand() % 2 == 0)
            sElectroCar::move();
        else
            sGasEngine::move();
    }
};

std::vector<sCar*> asdasd;
const int initialCarsCount = 10;

#define SCREEN_WIDTH 1024
#define SCREEN_HEIGHT 768

void spawnCarFromTop() {
    sCar* car;
    int carType = rand();
    if (carType % 3 == 0) {
        car = new sGasEngine();
    }
    else if (carType % 3 == 1) {
        car = new sElectroCar();
    }
    else /*if (carType % 3 == 2)*/ {
        car = new sHybrid();
    }
    car->rect = sRect(SCREEN_WIDTH / 2, SCREEN_HEIGHT, 100, 100);
    car->speed = 1;
    car->dir = eDirection::DOWN;
}

void spawnCarFromBot() {
    sCar* car;
    int carType = rand();
    if (carType % 3 == 0) {
        car = new sGasEngine();
    }
    else if (carType % 3 == 1) {
        car = new sElectroCar();
    }
    else/* if (carType % 3 == 2)*/ {
        car = new sHybrid();
    }
    car->rect = sRect(SCREEN_WIDTH / 2, 0, 100, 100);
    car->speed = 1;
    car->dir = eDirection::UP;
}

void SpawnCarFromLeft() {
    sCar* car;
    int carType = rand();
    if (carType % 3 == 0) {
        car = new sGasEngine();
    }
    else if (carType % 3 == 1) {
        car = new sElectroCar();
    }
    else /*if (carType % 3 == 2)*/ {
        car = new sHybrid();
    }
    car->rect = sRect(0, SCREEN_HEIGHT / 2, 100, 100);
    car->speed = 1;
    car->dir = eDirection::RIGHT;
}

void spawnCarFromRight() {
    sCar* car;
    int carType = rand();
    if (carType % 3 == 0) {
        car = new sGasEngine();
    }
    else if (carType % 3 == 1) {
        car = new sElectroCar();
    }
    else /*if (carType % 3 == 2)*/ {
        car = new sHybrid();
    }
    car->rect = sRect(SCREEN_WIDTH, SCREEN_HEIGHT / 2, 100, 100);
    car->speed = 1;
    car->dir = eDirection::LEFT;
}

void spawnCar() {
    if (rand() % 4 == 1)
        spawnCarFromRight();
    else if (rand() % 4 == 2)
        spawnCarFromTop();
    else if (rand() % 4 == 3)
        spawnCarFromBot();
    else if (rand() % 4 == 4)
        SpawnCarFromLeft();
}

void /*bool*/ main_loop() {
    for (auto car : asdasd) {
        for (auto car22 : asdasd) {
            if (car->getFuturePos().intersects(car22->getFuturePos())) {
                if (car->needPassOtherCar(car22))
                    car->move();
            }
            else {
                car22->move();
            }
        }
        if (!(car->rect.pos.x <= 0 || car->rect.pos.x >= SCREEN_WIDTH
            || car->rect.pos.y <= 0 || car->rect.pos.y >= SCREEN_HEIGHT))
            spawnCar();
    }
    //return main_loop();
}

int main(int argc, char** argv) {
    for (auto i = 0; i < initialCarsCount; ++i) {
        spawnCar();
    }
    main_loop();
    return 0;
}