Gaming Event System. More...

Collaboration diagram for scenarios::GamingEventSystem:

Classes
struct	GameEvent

Public Member Functions
void	simulate_gaming_scenario ()

Private Member Functions
void	process_game_event (const GameEvent &event)

void	send_achievement_notification (const std::string &player_id, const std::string &achievement)

void	print_leaderboard ()

Private Attributes
std::atomic< int >	events_processed_ {0}

std::atomic< int >	achievements_unlocked_ {0}

std::map< std::string, int >	player_scores_

std::mutex	scores_mutex_

Detailed Description

Gaming Event System.

Examples: real_world_scenarios.cpp.

Definition at line 314 of file real_world_scenarios.cpp.

Member Function Documentation

◆ print_leaderboard()

void scenarios::GamingEventSystem::print_leaderboard ( )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 457 of file real_world_scenarios.cpp.

                             {
        std::cout << "\n  === Leaderboard ===" << std::endl;
 
        std::vector<std::pair<std::string, int>> leaderboard;
        {
            std::lock_guard<std::mutex> lock(scores_mutex_);
            for (const auto& entry : player_scores_) {
                leaderboard.emplace_back(entry.first, entry.second);
            }
        }
 
        std::sort(leaderboard.begin(), leaderboard.end(),
                  [](const auto& a, const auto& b) { return a.second > b.second; });
 
        for (size_t i = 0; i < std::min(size_t(5), leaderboard.size()); ++i) {
            std::cout << "  " << (i + 1) << ". " << leaderboard[i].first
                      << ": " << leaderboard[i].second << " points" << std::endl;
        }
        std::cout << "  ===================" << std::endl;
    }

References player_scores_, and scores_mutex_.

Referenced by simulate_gaming_scenario().

Here is the caller graph for this function:

◆ process_game_event()

void scenarios::GamingEventSystem::process_game_event ( const GameEvent & event )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 407 of file real_world_scenarios.cpp.

                                                    {
        auto container = std::make_shared<value_container>();
        container->set_source("game_client", event.player_id);
        container->set_target("game_server", "event_processor");
        container->set_message_type("game_event");
 
        container->set("player_id", event.player_id);
        container->set("event_type", event.event_type);
        container->set("timestamp", static_cast<int64_t>(
            std::chrono::duration_cast<std::chrono::milliseconds>(
                event.timestamp.time_since_epoch()).count()));
 
        for (const auto& data_pair : event.event_data) {
            container->set(data_pair.first, data_pair.second);
        }
 
        if (event.event_data.find("score") != event.event_data.end()) {
            int score = std::stoi(event.event_data.at("score"));
            {
                std::lock_guard<std::mutex> lock(scores_mutex_);
                player_scores_[event.player_id] += score;
            }
        }
 
        if (event.event_type == "level_up" && event.event_data.find("new_level") != event.event_data.end()) {
            int level = std::stoi(event.event_data.at("new_level"));
            if (level >= 25) {
                achievements_unlocked_++;
                send_achievement_notification(event.player_id, "High Level Achiever");
            }
        }
 
        container->serialize_string(value_container::serialization_format::binary).value();
    }

References achievements_unlocked_, scenarios::GamingEventSystem::GameEvent::event_data, scenarios::GamingEventSystem::GameEvent::event_type, scenarios::GamingEventSystem::GameEvent::player_id, player_scores_, scores_mutex_, send_achievement_notification(), and scenarios::GamingEventSystem::GameEvent::timestamp.

Referenced by simulate_gaming_scenario().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_achievement_notification()

void scenarios::GamingEventSystem::send_achievement_notification	(	const std::string &	player_id,
		const std::string &	achievement )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 442 of file real_world_scenarios.cpp.

                                                                                                 {
        auto notification = std::make_shared<value_container>();
        notification->set_source("achievement_system", "unlock_processor");
        notification->set_target("notification_service", "player_notifier");
        notification->set_message_type("achievement_unlocked");
 
        notification->set("player_id", player_id);
        notification->set("achievement_name", achievement);
        notification->set("timestamp", static_cast<int64_t>(
            std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::system_clock::now().time_since_epoch()).count()));
 
        std::cout << "  ACHIEVEMENT: " << player_id << " unlocked '" << achievement << "'" << std::endl;
    }

Referenced by process_game_event().

Here is the caller graph for this function:

◆ simulate_gaming_scenario()

void scenarios::GamingEventSystem::simulate_gaming_scenario ( )

inline

Examples: real_world_scenarios.cpp.

Definition at line 329 of file real_world_scenarios.cpp.

                                    {
        std::cout << "\n=== Gaming Event System Scenario ===" << std::endl;
 
        const int num_players = 10;
        const int events_per_player = 50;
        std::vector<std::thread> player_threads;
 
        std::queue<GameEvent> event_queue;
        std::mutex event_mutex;
        std::condition_variable event_cv;
        std::atomic<bool> game_active{true};
 
        std::thread event_processor([&]() {
            while (game_active || !event_queue.empty()) {
                std::unique_lock<std::mutex> lock(event_mutex);
                event_cv.wait(lock, [&]() { return !event_queue.empty() || !game_active; });
 
                if (!event_queue.empty()) {
                    GameEvent event = event_queue.front();
                    event_queue.pop();
                    lock.unlock();
 
                    process_game_event(event);
                    events_processed_++;
                }
            }
        });
 
        std::random_device rd;
        for (int player_id = 0; player_id < num_players; ++player_id) {
            player_threads.emplace_back([&, player_id]() {
                std::mt19937 gen(rd());
                std::uniform_int_distribution<> action_dist(0, 4);
                std::uniform_int_distribution<> score_dist(10, 500);
                std::uniform_int_distribution<> level_dist(1, 50);
 
                std::vector<std::string> actions = {"kill", "death", "level_up", "item_collected", "quest_completed"};
 
                for (int event_count = 0; event_count < events_per_player; ++event_count) {
                    GameEvent event;
                    event.player_id = "player_" + std::to_string(player_id);
                    event.event_type = actions[action_dist(gen)];
                    event.timestamp = std::chrono::system_clock::now();
 
                    if (event.event_type == "kill") {
                        event.event_data["target"] = "player_" + std::to_string((player_id + 1) % num_players);
                        event.event_data["score"] = std::to_string(score_dist(gen));
                    } else if (event.event_type == "level_up") {
                        event.event_data["new_level"] = std::to_string(level_dist(gen));
                    }
 
                    {
                        std::lock_guard<std::mutex> lock(event_mutex);
                        event_queue.push(event);
                    }
                    event_cv.notify_one();
 
                    std::this_thread::sleep_for(std::chrono::milliseconds(20));
                }
            });
        }
 
        for (auto& thread : player_threads) {
            thread.join();
        }
 
        game_active = false;
        event_cv.notify_all();
        event_processor.join();
 
        print_leaderboard();
 
        std::cout << "Gaming simulation completed:" << std::endl;
        std::cout << "  Events processed: " << events_processed_.load() << std::endl;
        std::cout << "  Achievements unlocked: " << achievements_unlocked_.load() << std::endl;
    }