Draft of how a scenario objective system could be made

Condition.h

#pragma once

#include <variant>

#include "Deadline.h"
#include "GuestCount.h"
#include "ParkValue.h"

namespace Objectives
{
    using Condition = std::variant<Deadline, GuestCount, ParkValue>;

    using ScrenarioObjective = Objective<Condition>;
} // namespace Objectives

Deadline.cpp

#include "Deadline.h"

// Globals - refactor to get through objective variable interface
Date gDate = 0;
bool gEarlyScenarioCompletion = false;

namespace Objectives
{
    Deadline::Deadline(Date deadline)
        : _deadline(deadline * 30 * 8) // Converts days to years
    {
    }

    Status Deadline::OnDailyCheck() const
    {
        if (gDate > _deadline)
            return Status::Failed;
        if (gDate == _deadline || gEarlyScenarioCompletion)
            return Status::Complete;
        return Status::Incomplete;
    }
} // namespace Objectives

Deadline.h

#pragma once

#include "Status.h"

using Date = int;

namespace Objectives
{
    class Deadline
    {
    public:
        Deadline(Date deadline);
        Status OnDailyCheck() const;

    private:
        Date _deadline;
    };
} // namespace Objectives

GuestCount.cpp

#include "GuestCount.h"

// Global - refactor to get through objective variable interface
int gGuestCount = 0;

namespace Objectives
{
    GuestCount::GuestCount(int parkValue)
        : _requiredGuests(parkValue)
    {
    }

    Status GuestCount::OnDailyCheck() const
    {
        return gGuestCount >= _requiredGuests ? Status::Complete : Status::Incomplete;
    }
} // namespace Objectives

GuestCount.h

#pragma once

#include "Status.h"

namespace Objectives
{
    class GuestCount
    {
    public:
        GuestCount(int parkValue);
        Status OnDailyCheck() const;

    private:
        int _requiredGuests;
    };
} // namespace Objectives

Objective.hpp

#pragma once

#include <list>
#include <variant>

namespace Objectives
{
    template <typename TCondition>
    class Objective
    {
    public:
        Objective()
            : _conditions({
                    GuestCount(123),
                    ParkValue(700),
                    Deadline(4),
                })
        {
        }

        Status Evaluate() const
        {
            auto onDailyCheck = [](const auto& condition) constexpr {
                return condition.OnDailyCheck();
            };

            auto state = Status::Complete;
            for (const auto& condition : _conditions)
            {
                const auto result = std::visit(onDailyCheck, condition);
                switch (result)
                {
                case Status::Failed:
                    return Status::Failed;
                case Status::Incomplete:
                    state = Status::Incomplete;
                    break;
                }
            }
            return state;
        }

    private:
        std::list<TCondition> _conditions;
    };
} // namespace Objectives

ParkValue.cpp

#include "ParkValue.h"

// Global - refactor to get through objective variable interface
int gParkValue = 0;

namespace Objectives {
    ParkValue::ParkValue(int parkValue)
        : _desiredParkValue(parkValue)
    {
    }

    Status ParkValue::OnDailyCheck() const
    {
        return gParkValue >= _desiredParkValue ? Status::Complete : Status::Incomplete;
    }
} // namespace Objectives

ParkValue.h

#pragma once

#include "Status.h"

namespace Objectives {
    class ParkValue
    {
    public:
        ParkValue(int parkValue);
        Status OnDailyCheck() const;

    private:
        int _desiredParkValue;
    };
} // namespace Objectives

ScenarioMain.cpp

#include <cstdio>

#include "Condition.h"
#include "Objective.hpp"

class Scenario
{
public:
    void OnDailyTick()
    {
        // Game tick...
        //gDate++;
        //gGuestCount++;
        //gParkValue++;

        auto state = _objective.Evaluate();
        if (state == Objectives::Status::Failed)
            std::puts("Scenario failed");
        else if (state == Objectives::Status::Complete)
            std::puts("Scenario finished");
    }

private:
    Objectives::ScrenarioObjective _objective;
};

int main()
{
    Scenario scenario;

    while (true)
    {
        scenario.OnDailyTick();
    }
}

Status.h

#pragma once

namespace Objectives
{
    enum class Status
    {
        Failed,
        Complete,
        Incomplete,
    };
} // namespace Objectives