lib/src/RaceSimulatorAPI.cpp - master - plato/RaceProject

lib/src/RaceSimulatorAPI.cpp
188 строк5 KB
Evanivan
feat: program almost done
09 дек 2025, 22:04
09 дек 2025, 22:04e9ce965
#include "RaceSimulatorAPI.h"
#include "VehicleAdapter.h"

// Включаем заголовки внутренних транспортных средств
#include "Camel.h"
#include "FastCamel.h"
#include "Centaur.h"
#include "AllTerrainBoots.h"
#include "MagicCarpet.h"
#include "Eagle.h"
#include "Broom.h"

#include <vector>
#include <algorithm>
#include <cstring>
#include <string>
#include <memory>

using namespace std;

// ============================================================================
// ФАБРИЧНЫЕ ФУНКЦИИ ДЛЯ СОЗДАНИЯ ТРАНСПОРТНЫХ СРЕДСТВ
// ============================================================================

extern "C" {
    
RACESIMULATOR_API IVehicle* createCamel() {
    return new VehicleAdapter(new Camel());
}

RACESIMULATOR_API IVehicle* createFastCamel() {
    return new VehicleAdapter(new FastCamel());
}

RACESIMULATOR_API IVehicle* createCentaur() {
    return new VehicleAdapter(new Centaur());
}

RACESIMULATOR_API IVehicle* createAllTerrainBoots() {
    return new VehicleAdapter(new AllTerrainBoots());
}

RACESIMULATOR_API IVehicle* createMagicCarpet() {
    return new VehicleAdapter(new MagicCarpet());
}

RACESIMULATOR_API IVehicle* createEagle() {
    return new VehicleAdapter(new Eagle());
}

RACESIMULATOR_API IVehicle* createBroom() {
    return new VehicleAdapter(new Broom());
}

} // extern "C"

// ============================================================================
// РЕАЛИЗАЦИЯ IRace (RaceImpl)
// ============================================================================

class RaceImpl : public IRace {
private:
    Type type;
    double distance;
    vector<IVehicle*> vehicles;
    
    bool isGroundVehicle(const char* vehicleType) const {
        return strcmp(vehicleType, "Ground") == 0;
    }
    
    bool isAirVehicle(const char* vehicleType) const {
        return strcmp(vehicleType, "Air") == 0;
    }
    
    bool canParticipate(const char* vehicleType) const {
        if (type == GROUND && !isGroundVehicle(vehicleType)) return false;
        if (type == AIR && !isAirVehicle(vehicleType)) return false;
        return true;
    }
    
public:
    RaceImpl(Type t, double dist) : type(t), distance(dist) {}
    
    ~RaceImpl() override {
        vehicles.clear();
    }
    
    bool registerVehicle(IVehicle* vehicle) override {
        if (!vehicle) return false;
        
        // Получаем тип транспортного средства
        const char* vehicleType = vehicle->getType();
        
        // Проверяем возможность участия в гонке
        if (!canParticipate(vehicleType)) {
            return false;
        }
        
        // Проверяем дублирование
        for (auto v : vehicles) {
            if (strcmp(v->getName(), vehicle->getName()) == 0) {
                return false;
            }
        }
        
        // Регистрируем транспортное средство
        vehicles.push_back(vehicle);
        return true;
    }
    
    IVehicle* getVehicle(int index) const override {
        if (index >= 0 && index < (int)vehicles.size()) {
            return vehicles[index];
        }
        return nullptr;
    }
    
    int getVehicleCount() const override {
        return vehicles.size();
    }
    
    Type getRaceType() const override {
        return type;
    }
    
    double getDistance() const override {
        return distance;
    }
    
    void getResults(double* times, const char** names, int size) const override {
        // Вектор для хранения результатов
        vector<pair<double, IVehicle*>> results;
        
        // Рассчитываем время для каждого транспортного средства
        for (auto vehicle : vehicles) {
            double time = vehicle->calculateTime(distance);
            results.push_back({time, vehicle});
        }
        
        sort(results.begin(), results.end(),
            [](const auto& a, const auto& b) {
                return a.first < b.first;
            });
        
        int count = min(size, (int)results.size());
        for (int i = 0; i < count; i++) {
            times[i] = results[i].first;
            names[i] = results[i].second->getName();
        }
        
        for (int i = count; i < size; i++) {
            times[i] = 0.0;
            names[i] = nullptr;
        }
    }
};

const char* IRace::typeToString(Type type) {
    switch (type) {
        case GROUND: return "Только для наземных ТС";
        case AIR:    return "Только для воздушных ТС";
        case MIXED:  return "Для наземных и воздушных ТС";
        default:     return "Неизвестный тип";
    }
}

extern "C" {

RACESIMULATOR_API IRace* createRace(IRace::Type type, double distance) {
    if (distance <= 0.0) {
        return nullptr;
    }
    return new RaceImpl(type, distance);
}

RACESIMULATOR_API void deleteVehicle(IVehicle* vehicle) {
    if (vehicle) {
        delete vehicle;
    }
}

RACESIMULATOR_API void deleteRace(IRace* race) {
    if (race) {
        delete static_cast<RaceImpl*>(race);
    }
}

} // extern "C"