From f4d9687f04f928be9e9d4f7c4b4b429d4581137b Mon Sep 17 00:00:00 2001 From: cmkrist Date: Sun, 16 Nov 2025 23:18:31 -0500 Subject: [PATCH 01/79] Add enum loading for auto attacks --- src/systems/data_loader.cpp | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/src/systems/data_loader.cpp b/src/systems/data_loader.cpp index 66859c9..ed48e26 100644 --- a/src/systems/data_loader.cpp +++ b/src/systems/data_loader.cpp @@ -3,6 +3,22 @@ #include #include +#include + +/** + * Convert string to DamageType enum. + * @param str The string to convert (case-insensitive) + * @return DamageType enum value, defaults to PHYSICAL if unrecognized + */ +static DamageType string_to_damage_type(const std::string& str) { + if (str == "magical" || str == "magic") { + return DamageType::MAGICAL; + } else if (str == "true_damage" || str == "true") { + return DamageType::TRUE_DAMAGE; + } + // Default to PHYSICAL for unrecognized or empty strings + return DamageType::PHYSICAL; +} /** * Convenience macro. Loads the attribute from the node if the node has it, and sets it in the component. @@ -19,6 +35,21 @@ } \ } +/** + * Convenience macro for loading enum attributes from XML. + * @param node A pugi::xml_node which (maybe) has the attribute + * @param comp The Component in which to set the value of the attribute + * @param attr The attribute to load. Must match exactly both the attribute name in the xml and the property in the Component. + * @param converter A function that converts string to the enum type + */ +#define LOAD_ENUM_ATTRIBUTE(node, comp, attr, converter) \ + { \ + pugi::xml_attribute loaded = node.attribute(#attr); \ + if(!loaded.empty()) { \ + comp->attr = converter(loaded.as_string()); \ + } \ + } + EntityTemplate DataLoader::load_entity_template(std::string file_name) { EntityTemplate temp; @@ -47,7 +78,6 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { pugi::xml_node movementNode = rootNode.child("movement"); if(movementNode != NULL) { std::shared_ptr movement = std::make_shared(); - LOAD_ATTRIBUTE(movementNode, movement, move_speed, float) temp.component_templates.push_back(movement); } @@ -71,6 +101,9 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { LOAD_ATTRIBUTE(statsNode, stats, attack_range, float) LOAD_ATTRIBUTE(statsNode, stats, attack_speed, float) // TODO what to do about enums (like DamageType auto_damage_type)? - ploinky 14/11/2025 + // | + // This v -- cmkrist 16/11/2025 + LOAD_ENUM_ATTRIBUTE(statsNode, stats, auto_damage_type, string_to_damage_type) LOAD_ATTRIBUTE(statsNode, stats, crit_chance, float) LOAD_ATTRIBUTE(statsNode, stats, crit_bonus, int) LOAD_ATTRIBUTE(statsNode, stats, true_bonus, int) From cc475af92b7049e70d82fac974dff73c1203215a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Sun, 16 Nov 2025 23:37:03 -0500 Subject: [PATCH 02/79] Add entity state machines --- src/components/entity_state.hpp | 29 +++++++++++++++++++++++++++++ src/components/pathfinding.hpp | 13 +++++++++++-- src/components/state.hpp | 23 ----------------------- src/systems/movement_system.cpp | 28 ++++++++++++++++++++++++---- src/systems/wave_system.cpp | 33 +++++++++++++++++++++++++++++---- 5 files changed, 93 insertions(+), 33 deletions(-) create mode 100644 src/components/entity_state.hpp delete mode 100644 src/components/state.hpp diff --git a/src/components/entity_state.hpp b/src/components/entity_state.hpp new file mode 100644 index 0000000..5777278 --- /dev/null +++ b/src/components/entity_state.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include "component.hpp" + +/** + * Entity state enumeration. + * Defines all possible states an entity can be in during its lifecycle. + */ +enum class EntityState { + SPAWNED, + IDLE, + PATHFINDING_WAITING, + MOVING, + STUCK, + ATTACKING, + DEAD +}; + +/** + * EntityState component for state machine management. + * Tracks the current state of an entity and enables state-based behaviors. + */ +struct EntityStateComponent : public Component { + + EntityState current_state = EntityState::SPAWNED; + float state_duration_ms = 0.0f; + + COMPONENT_TYPE_ID(EntityStateComponent, 2010) +}; diff --git a/src/components/pathfinding.hpp b/src/components/pathfinding.hpp index 3d705ab..d4dbb51 100644 --- a/src/components/pathfinding.hpp +++ b/src/components/pathfinding.hpp @@ -8,19 +8,28 @@ /** * Pathfinding component for entities. * Stores path waypoints and tracks progress along the path. + * Entity state is tracked in EntityStateComponent (PATHFINDING_WAITING, MOVING, STUCK). */ struct PathfindingComponent : public Component { + // Current path waypoints (3D positions) std::vector waypoints; + + // Index of the next waypoint to move toward int current_waypoint_index = 0; + + // Target spawnpoint ID (the destination spawnpoint this path leads to) uint32_t target_spawnpoint_id = 0; - bool is_waiting_for_path = false; // Request ID for tracking async pathfinding requests uint32_t path_request_id = 0; + // Track last position to detect if entity is stuck Vec2 last_position = Vec2(0.0f, 0.0f); + + // Time spent stuck without progress (milliseconds) float stuck_time_ms = 0.0f; - // Stuck Timeout Threshold + + // Threshold for considering entity stuck (milliseconds) static constexpr float STUCK_THRESHOLD_MS = 2000.0f; COMPONENT_TYPE_ID(PathfindingComponent, 2009) diff --git a/src/components/state.hpp b/src/components/state.hpp deleted file mode 100644 index 1cd20e6..0000000 --- a/src/components/state.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include "component.hpp" -#include "../systems/math.hpp" - -/** - * Component State Machine for entities. - * Manages the current state of an entity (e.g., idle, moving, attacking). - */ - -enum class EntityState { - IDLE, - MOVING, - ATTACKING, - CASTING, - STUNNED, - DEAD -}; - -struct State : public Component { - EntityState current_state = EntityState::IDLE; - COMPONENT_TYPE_ID(State, 2000) -}; \ No newline at end of file diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index 1c88743..c7f1fa6 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -3,6 +3,7 @@ #include "services/navigation_service.hpp" #include #include +#include #include #include @@ -22,6 +23,7 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav // Update stuck detection for entities with pathfinding if (pathfinding) { float delta_time_ms = delta_time * 1000.0f; + EntityStateComponent* entity_state = entity->get_component(); // Check if entity has moved since last frame float movement_distance = distance(movement->position, pathfinding->last_position); @@ -32,11 +34,16 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav // If stuck too long and not already waiting for path, request new one if (pathfinding->stuck_time_ms >= PathfindingComponent::STUCK_THRESHOLD_MS && - !pathfinding->is_waiting_for_path && + entity_state && entity_state->current_state == EntityState::MOVING && !pathfinding->waypoints.empty()) { LOG_DEBUG("Minion %u is stuck, requesting new path", entity->get_id()); if (navigation_service && map && pathfinding->target_spawnpoint_id < map->spawnpoints.size()) { request_new_path(*entity, pathfinding->target_spawnpoint_id, navigation_service, map); + // Transition to waiting state + if (entity_state) { + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; + } } pathfinding->waypoints.clear(); pathfinding->current_waypoint_index = 0; @@ -51,14 +58,23 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav } // If entity has pathfinding, move along the path (but not while waiting for new path) - if (pathfinding && !pathfinding->is_waiting_for_path && !pathfinding->waypoints.empty()) { + if (pathfinding && !pathfinding->waypoints.empty()) { + EntityStateComponent* entity_state = entity->get_component(); + + // Only move if in MOVING state + if (!entity_state || entity_state->current_state != EntityState::MOVING) { + continue; + } + // Get current waypoint if (pathfinding->current_waypoint_index >= pathfinding->waypoints.size()) { // Reached end of path - request path to next spawnpoint if possible if (map && pathfinding->target_spawnpoint_id < map->spawnpoints.size()) { uint32_t next_spawnpoint = (pathfinding->target_spawnpoint_id + 1) % map->spawnpoints.size(); - if (navigation_service) { + if (navigation_service && entity_state) { request_new_path(*entity, next_spawnpoint, navigation_service, map); + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; } } pathfinding->waypoints.clear(); @@ -179,7 +195,11 @@ void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint request.entity_pathing_radius = 0.5f; if (navigation_service->MakeRequest(request)) { - pathfinding->is_waiting_for_path = true; + EntityStateComponent* entity_state = entity.get_component(); + if (entity_state) { + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; + } pathfinding->target_spawnpoint_id = target_spawnpoint_id; LOG_DEBUG("Minion %u requested path to spawnpoint %u", entity.get_id(), target_spawnpoint_id); } diff --git a/src/systems/wave_system.cpp b/src/systems/wave_system.cpp index 8784726..5dde189 100644 --- a/src/systems/wave_system.cpp +++ b/src/systems/wave_system.cpp @@ -6,6 +6,7 @@ #include "services/navigation_service.hpp" #include #include +#include #include #include #include @@ -51,15 +52,21 @@ void WaveSystem::tick(float delta_time_ms) { Entity* entity = entity_manager_->get_entity(result->entity_id); if (entity && entity->has_component()) { PathfindingComponent* pathfinding = entity->get_component(); + EntityStateComponent* entity_state = entity->get_component(); + pathfinding->waypoints = result->path; pathfinding->current_waypoint_index = 0; - pathfinding->is_waiting_for_path = false; if (result->path.empty()) { LOG_WARN("Minion %u received EMPTY path!", entity->get_id()); } else { LOG_DEBUG("Minion %u received path with %zu waypoints", entity->get_id(), result->path.size()); + // Transition to MOVING state when path is received + if (entity_state) { + entity_state->current_state = EntityState::MOVING; + entity_state->state_duration_ms = 0.0f; + } } } result = navigation_service_->GetResult(); @@ -67,11 +74,15 @@ void WaveSystem::tick(float delta_time_ms) { } // Retry pending pathfinding requests (entities waiting for paths) + if (navigation_service_) { auto entities = entity_manager_->get_entities_with_component(); for (auto* entity : entities) { PathfindingComponent* pathfinding = entity->get_component(); - if (pathfinding && pathfinding->is_waiting_for_path && pathfinding->waypoints.empty()) { + EntityStateComponent* entity_state = entity->get_component(); + if (pathfinding && entity_state && + entity_state->current_state == EntityState::PATHFINDING_WAITING && + pathfinding->waypoints.empty()) { request_minion_path(*entity, pathfinding->target_spawnpoint_id); } } @@ -132,6 +143,11 @@ bool WaveSystem::create_minion(const std::string& minion_template, uint8_t team_ auto pathfinding = std::make_unique(); minion.add_component(std::move(pathfinding)); + // Add entity state component (starts in SPAWNED state) + auto entity_state = std::make_unique(); + entity_state->current_state = EntityState::SPAWNED; + minion.add_component(std::move(entity_state)); + // Request initial path to next spawnpoint (enemy spawn) // TODO: Make this better -- cmkrist 16/11/2025 uint32_t target_spawnpoint = (spawn_point_id + 1) % (map_ ? map_->spawnpoints.size() : 2); @@ -175,14 +191,23 @@ void WaveSystem::request_minion_path(Entity& entity, uint32_t target_spawnpoint_ request.destination = goal; request.entity_pathing_radius = 0.5f; + EntityStateComponent* entity_state = entity.get_component(); + if (navigation_service_->MakeRequest(request)) { - pathfinding->is_waiting_for_path = true; pathfinding->target_spawnpoint_id = target_spawnpoint_id; + // Transition to waiting state + if (entity_state) { + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; + } LOG_DEBUG("Path request queued for minion %u", entity.get_id()); } else { // Mark as waiting for path so we retry next tick - pathfinding->is_waiting_for_path = true; pathfinding->target_spawnpoint_id = target_spawnpoint_id; + if (entity_state) { + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; + } LOG_DEBUG("Pathfinding queue full, will retry for minion %u", entity.get_id()); } } From 65f950b7a0ead9e257fd40eab094b57fbd4c39f5 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Sun, 16 Nov 2025 23:37:48 -0500 Subject: [PATCH 03/79] Add component registry to prevent overlaps, fix cmake header --- CMakeLists.txt | 1 + src/components/component_registry.hpp | 34 +++++++++++++++++++++++++++ src/components/experience.hpp | 2 +- src/systems/data_loader.cpp | 4 ++++ src/systems/data_loader.hpp | 1 + 5 files changed, 41 insertions(+), 1 deletion(-) create mode 100644 src/components/component_registry.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 5fcbdb4..bc4b2bb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,6 +59,7 @@ set(GAMESERVER_SOURCES src/systems/map_system.cpp src/systems/combat_system.cpp src/systems/movement_system.cpp + src/systems/network_sync_system.cpp src/systems/serialization_system.cpp src/systems/wave_system.cpp ) diff --git a/src/components/component_registry.hpp b/src/components/component_registry.hpp new file mode 100644 index 0000000..693a135 --- /dev/null +++ b/src/components/component_registry.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include + +/** + * Central registry of all component type IDs. + * + * Organized by range: + * 0-999: Reserved (do not use) + * 1000-1999: Physics, Transform, Movement + * 2000-2999: Gameplay (Stats, Experience, Combat, AI) + * 3000-3999: Network, Player-specific + * 4000-4999: Client-side (visual, UI) + * 5000+: Custom, Modding + */ +namespace ComponentTypes { + // === Core Gameplay (2000-2099) === + constexpr uint32_t MOVEMENT = 2001; + constexpr uint32_t STATS = 2002; + + // === State Management (2010-2099) === + constexpr uint32_t ENTITY_STATE = 2010; + constexpr uint32_t PATHFINDING = 2009; + constexpr uint32_t EXPERIENCE = 2011; + + // === Network & Player (3000-3099) === + constexpr uint32_t CLIENT_INFO = 3001; + constexpr uint32_t READINESS = 3002; + constexpr uint32_t NETWORK_METADATA = 3003; + constexpr uint32_t NETWORK_ENTITY = 3004; + + // === Wave System (2050-2099) === + constexpr uint32_t WAVE_STATE = 2050; +} \ No newline at end of file diff --git a/src/components/experience.hpp b/src/components/experience.hpp index 90e8c08..d003d36 100644 --- a/src/components/experience.hpp +++ b/src/components/experience.hpp @@ -7,5 +7,5 @@ struct ExperienceComponent : public Component { float required_exp = 1.0f; // Experience required for next level float exp_growth_rate = 1.2f; // Growth rate for required experience per level - COMPONENT_TYPE_ID(ExperienceComponent, 2010) + COMPONENT_TYPE_ID(ExperienceComponent, 2011) }; \ No newline at end of file diff --git a/src/systems/data_loader.cpp b/src/systems/data_loader.cpp index ed48e26..34dadee 100644 --- a/src/systems/data_loader.cpp +++ b/src/systems/data_loader.cpp @@ -3,6 +3,7 @@ #include #include +#include #include /** @@ -54,6 +55,9 @@ static DamageType string_to_damage_type(const std::string& str) { EntityTemplate DataLoader::load_entity_template(std::string file_name) { EntityTemplate temp; + // NOTE: Component type IDs should match those defined in src/component_registry.hpp + // See ComponentTypes namespace for authoritative type ID assignments. + // TODO should probably not let pugi load the file for us; thinking .pak files etc... - ploinky 14/11/2025 pugi::xml_document doc; pugi::xml_parse_status status = doc.load_file(file_name.c_str()).status; diff --git a/src/systems/data_loader.hpp b/src/systems/data_loader.hpp index c517c62..63f4784 100644 --- a/src/systems/data_loader.hpp +++ b/src/systems/data_loader.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include #include From 4742c7197633646a91806d38c16c59fb8811d422 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Sun, 16 Nov 2025 23:41:16 -0500 Subject: [PATCH 04/79] add player components --- src/components/client_info.hpp | 21 +++++++++++++ src/components/network_metadata.hpp | 46 +++++++++++++++++++++++++++++ src/components/readiness.hpp | 18 +++++++++++ 3 files changed, 85 insertions(+) create mode 100644 src/components/client_info.hpp create mode 100644 src/components/network_metadata.hpp create mode 100644 src/components/readiness.hpp diff --git a/src/components/client_info.hpp b/src/components/client_info.hpp new file mode 100644 index 0000000..febde95 --- /dev/null +++ b/src/components/client_info.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include "component.hpp" +#include + +/** + * ClientInfoComponent - Player network identification + * + * USAGE: Add to player entities only + * SYSTEMS: PlayerManager, NetworkService + * REQUIRED COMPANIONS: ReadinessComponent, NetworkMetadataComponent + * + * Maps network client_id to in-game player_id for identification + * across server systems. + */ +struct ClientInfoComponent : public Component { + std::string client_id; // Unique network identifier + uint32_t player_id; // Server-assigned player ID + + COMPONENT_TYPE_ID(ClientInfoComponent, 3001) +}; diff --git a/src/components/network_metadata.hpp b/src/components/network_metadata.hpp new file mode 100644 index 0000000..b5a4420 --- /dev/null +++ b/src/components/network_metadata.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include "component.hpp" +#include + +/** + * NetworkMetadataComponent - Player connection metadata + * + * USAGE: Track connection health and latency for player entities + * SYSTEMS: PlayerManager, NetworkService + * + * Replaces Player struct fields: last_activity, latency_ms + * Provides methods to check connection staleness and update activity. + */ +struct NetworkMetadataComponent : public Component { + std::chrono::steady_clock::time_point last_activity; + unsigned int latency_ms = 0; // Last measured ping in milliseconds + + /** + * Constructor - initializes last_activity to current time + */ + NetworkMetadataComponent() + : last_activity(std::chrono::steady_clock::now()) {} + + /** + * Check if player connection is stale (no activity for timeout_ms). + * @param timeout_ms Timeout in milliseconds (default: 30 seconds) + * @return true if last activity exceeds timeout + */ + bool is_stale(unsigned int timeout_ms = 30000) const { + auto now = std::chrono::steady_clock::now(); + auto elapsed = std::chrono::duration_cast( + now - last_activity); + return elapsed.count() > timeout_ms; + } + + /** + * Update last activity timestamp to current time. + * Call this whenever the player sends a packet. + */ + void update_activity() { + last_activity = std::chrono::steady_clock::now(); + } + + COMPONENT_TYPE_ID(NetworkMetadataComponent, 3003) +}; diff --git a/src/components/readiness.hpp b/src/components/readiness.hpp new file mode 100644 index 0000000..4f848aa --- /dev/null +++ b/src/components/readiness.hpp @@ -0,0 +1,18 @@ +#pragma once + +#include "component.hpp" + +/** + * ReadinessComponent - Player readiness state + * + * USAGE: Add to player entities for lobby/game readiness tracking + * SYSTEMS: PlayerManager, GameplayCoordinator + * + * Tracks whether a player has marked themselves as ready to begin + * the game. Used for lobby state management and game start validation. + */ +struct ReadinessComponent : public Component { + bool is_ready = false; // Player has marked themselves ready + + COMPONENT_TYPE_ID(ReadinessComponent, 3002) +}; From 3dd884bb80d2996a16dac96924b45d9d497fe630 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Sun, 16 Nov 2025 23:42:16 -0500 Subject: [PATCH 05/79] Add System Context as map of systems implemented --- src/systems/system_context.hpp | 73 ++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 src/systems/system_context.hpp diff --git a/src/systems/system_context.hpp b/src/systems/system_context.hpp new file mode 100644 index 0000000..b21e1af --- /dev/null +++ b/src/systems/system_context.hpp @@ -0,0 +1,73 @@ +#pragma once + +#include +#include "entity_manager.hpp" + +// Forward declarations to avoid circular dependencies +class NavigationService; +class NetworkService; +struct Map; + +/** + * SystemContext - Unified context for all game systems + * + * Contains references to the entity manager and all required services. + * Passed to all system update methods instead of varying parameters. + * + * BENEFITS: + * - Single, extensible context structure + * - No need to modify system signatures when adding new services + * - Clear documentation of system dependencies + * - Easier to mock for testing + * + * USAGE: + * SystemContext ctx{ + * .entity_manager = entity_manager_, + * .navigation_service = navigation_service_.get(), + * .network_service = &network_service_, + * .map = map_pointer_.get(), + * .delta_time_ms = delta_time_ms + * }; + * + * movement_system_.update(ctx); + * wave_system_.update(ctx); + * network_sync_system_.update(ctx); + */ +struct SystemContext { + // === ECS Core === + EntityManager& entity_manager; // Required: access to all entities + + // === Optional Services === + NavigationService* navigation_service = nullptr; // For pathfinding requests + NetworkService* network_service = nullptr; // For network broadcasting + const Map* map = nullptr; // For map data queries + + // === Timing === + float delta_time_ms = 0.0f; // Frame delta time in milliseconds + + // === Convenience Methods === + + /** + * Check if navigation service is available. + * @return true if navigation_service is not nullptr + */ + bool has_navigation_service() const { + return navigation_service != nullptr; + } + + /** + * Check if network service is available. + * @return true if network_service is not nullptr + */ + bool has_network_service() const { + return network_service != nullptr; + } + + /** + * Check if map data is available. + * @return true if map is not nullptr + */ + bool has_map() const { + return map != nullptr; + } +}; From 2d71ce6dbf203dd57f00a5e39502119289af4c12 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 17 Nov 2025 08:37:50 -0500 Subject: [PATCH 06/79] add player manager, new packet for lobby full --- src/systems/packet_validator.hpp | 3 + src/systems/player_manager.cpp | 186 +++++++++++++++++++++++++++++++ src/systems/player_manager.hpp | 144 ++++++++++++++++++++++++ 3 files changed, 333 insertions(+) create mode 100644 src/systems/player_manager.cpp create mode 100644 src/systems/player_manager.hpp diff --git a/src/systems/packet_validator.hpp b/src/systems/packet_validator.hpp index 190a66d..bb83ac7 100644 --- a/src/systems/packet_validator.hpp +++ b/src/systems/packet_validator.hpp @@ -6,11 +6,14 @@ /** * Packet type enumeration for network communication. */ +// TODO: Move packet types to xml definition for synchronization with client +// For now, update the NetworkManager in the client project as well. enum class PACKET_TYPE : uint8_t { // Engine reserved packet types GAME_START, GAME_STATE, GAME_TIME, + LOBBY_FULL, MAP_SPAWN, MAP_LOAD, // Spawn packets diff --git a/src/systems/player_manager.cpp b/src/systems/player_manager.cpp new file mode 100644 index 0000000..32c462b --- /dev/null +++ b/src/systems/player_manager.cpp @@ -0,0 +1,186 @@ +#include "player_manager.hpp" +#include "components/client_info.hpp" +#include "components/readiness.hpp" +#include "components/network_metadata.hpp" +#include + +EntityID PlayerManager::on_client_connect(const std::string& client_id, EntityManager& entity_manager) { + // Check if already connected + if (client_to_entity_.find(client_id) != client_to_entity_.end()) { + LOG_WARN("Client %s already connected", client_id.c_str()); + return INVALID_ENTITY_ID; + } + + // Create player entity + EntityID player_entity_id = create_player_entity(client_id, entity_manager); + + if (player_entity_id == INVALID_ENTITY_ID) { + LOG_ERROR("Failed to create player entity for client %s", client_id.c_str()); + return INVALID_ENTITY_ID; + } + + // Map client to entity + client_to_entity_[client_id] = player_entity_id; + + LOG_INFO("Player connected: client_id=%s, entity_id=%u, total_players=%zu", + client_id.c_str(), player_entity_id, client_to_entity_.size()); + + return player_entity_id; +} + +bool PlayerManager::on_client_disconnect(const std::string& client_id, EntityManager& entity_manager) { + auto it = client_to_entity_.find(client_id); + if (it == client_to_entity_.end()) { + LOG_WARN("Disconnect request for unknown client: %s", client_id.c_str()); + return false; + } + + EntityID player_entity_id = it->second; + + // Destroy player entity + if (!entity_manager.destroy_entity(player_entity_id)) { + LOG_ERROR("Failed to destroy player entity %u", player_entity_id); + } + + // Remove mapping + client_to_entity_.erase(it); + + LOG_INFO("Player disconnected: client_id=%s, entity_id=%u, remaining=%zu", + client_id.c_str(), player_entity_id, client_to_entity_.size()); + + return true; +} + +bool PlayerManager::set_player_ready(const std::string& client_id, bool is_ready, EntityManager& entity_manager) { + auto it = client_to_entity_.find(client_id); + if (it == client_to_entity_.end()) { + LOG_WARN("Set ready for unknown client: %s", client_id.c_str()); + return false; + } + + EntityID player_entity_id = it->second; + Entity* player_entity = entity_manager.get_entity(player_entity_id); + if (!player_entity) { + LOG_ERROR("Player entity not found: %u", player_entity_id); + return false; + } + + ReadinessComponent* readiness = player_entity->get_component(); + if (!readiness) { + LOG_ERROR("Player entity missing ReadinessComponent: %u", player_entity_id); + return false; + } + + readiness->is_ready = is_ready; + + LOG_INFO("Player %s is now %s", client_id.c_str(), is_ready ? "ready" : "not ready"); + + return true; +} + +bool PlayerManager::are_all_players_ready(EntityManager& entity_manager) const { + if (client_to_entity_.empty()) { + return false; + } + + // Query all entities with ReadinessComponent + auto ready_entities = entity_manager.get_entities_with_component(); + + if (ready_entities.size() != client_to_entity_.size()) { + LOG_WARN("Readiness check: not all players have ReadinessComponent (%zu entities vs %zu players)", + ready_entities.size(), client_to_entity_.size()); + return false; + } + + // Check if all are marked ready + for (const auto* entity : ready_entities) { + const auto* readiness = entity->get_component(); + if (!readiness || !readiness->is_ready) { + return false; + } + } + + return true; +} + +bool PlayerManager::is_full(int max_clients) const { + return (int)client_to_entity_.size() >= max_clients; +} + +size_t PlayerManager::get_player_count() const { + return client_to_entity_.size(); +} + +EntityID PlayerManager::get_player_entity_id(const std::string& client_id) const { + auto it = client_to_entity_.find(client_id); + if (it == client_to_entity_.end()) { + return INVALID_ENTITY_ID; + } + return it->second; +} + +std::vector PlayerManager::get_all_player_entities() const { + std::vector result; + for (const auto& [client_id, entity_id] : client_to_entity_) { + result.push_back(entity_id); + } + return result; +} + +void PlayerManager::update_player_latency(const std::string& client_id, EntityManager& entity_manager, unsigned int latency_ms) { + auto it = client_to_entity_.find(client_id); + if (it == client_to_entity_.end()) { + return; + } + + Entity* player_entity = entity_manager.get_entity(it->second); + if (!player_entity) { + return; + } + + auto* metadata = player_entity->get_component(); + if (metadata) { + metadata->latency_ms = latency_ms; + metadata->update_activity(); + } +} + +void PlayerManager::reset_all_players(EntityManager& entity_manager) { + for (auto* entity : entity_manager.get_entities_with_component()) { + auto* readiness = entity->get_component(); + if (readiness) { + readiness->is_ready = false; + } + } +} + +void PlayerManager::clear() { + client_to_entity_.clear(); + next_player_id_ = 0; +} + +EntityID PlayerManager::create_player_entity(const std::string& client_id, EntityManager& entity_manager) { + // Create entity from template + Entity& player_entity = entity_manager.create_entity_from_template("player"); + EntityID player_id = player_entity.get_id(); + + // Set client info + auto client_comp = std::make_unique(); + client_comp->client_id = client_id; + client_comp->player_id = next_player_id_++; + player_entity.add_component(std::move(client_comp)); + + // Ensure readiness component exists + if (!player_entity.has_component()) { + auto readiness_comp = std::make_unique(); + player_entity.add_component(std::move(readiness_comp)); + } + + // Ensure network metadata exists + if (!player_entity.has_component()) { + auto metadata_comp = std::make_unique(); + player_entity.add_component(std::move(metadata_comp)); + } + + return player_id; +} diff --git a/src/systems/player_manager.hpp b/src/systems/player_manager.hpp new file mode 100644 index 0000000..137cb74 --- /dev/null +++ b/src/systems/player_manager.hpp @@ -0,0 +1,144 @@ +#pragma once + +#include +#include +#include +#include +#include "entity_manager.hpp" + +/** + * PlayerManager - Manages all player entities and their lifecycle + * + * RESPONSIBILITIES: + * - Map client_id to player entity IDs + * - Handle player connection/disconnection + * - Query player readiness + * - Track active players + * + * DOES NOT: + * - Directly manage entity components (use EntityManager) + * - Handle network communication (use NetworkService) + * - Manage game state (use GameplayCoordinator) + * + * USAGE: + * PlayerManager player_mgr; + * EntityID player_id = player_mgr.on_client_connect("client123", entity_manager); + * player_mgr.set_player_ready("client123", true, entity_manager); + * if (player_mgr.are_all_players_ready(entity_manager)) { + * // Start game + * } + */ +class PlayerManager { +public: + PlayerManager() = default; + ~PlayerManager() = default; + + // Prevent copying + PlayerManager(const PlayerManager&) = delete; + PlayerManager& operator=(const PlayerManager&) = delete; + + // Allow moving + PlayerManager(PlayerManager&&) = default; + PlayerManager& operator=(PlayerManager&&) = default; + + /** + * Register a new player entity on client connection. + * Creates a player entity from the "player" template and applies + * ClientInfoComponent, ReadinessComponent, and NetworkMetadataComponent. + * @param client_id Network client identifier + * @param entity_manager The entity manager (passed for component creation) + * @return Entity ID of the created player entity, or INVALID_ENTITY_ID on failure + */ + EntityID on_client_connect(const std::string& client_id, EntityManager& entity_manager); + + /** + * Unregister a player entity on client disconnection. + * Destroys the player entity and removes all player tracking. + * @param client_id Network client identifier + * @param entity_manager The entity manager (passed for entity destruction) + * @return true if player was found and removed, false if unknown client + */ + bool on_client_disconnect(const std::string& client_id, EntityManager& entity_manager); + + /** + * Mark a player as ready or not ready. + * Updates the ReadinessComponent for the player. + * @param client_id Network client identifier + * @param is_ready New readiness state + * @param entity_manager Entity manager for updating component + * @return true if player was found and updated, false if unknown client + */ + bool set_player_ready(const std::string& client_id, bool is_ready, EntityManager& entity_manager); + + /** + * Check if all connected players are ready. + * Queries all entities with ReadinessComponent and verifies all are marked ready. + * @param entity_manager Entity manager for querying components + * @return true if all players have is_ready = true, false if any are not ready or no players connected + */ + bool are_all_players_ready(EntityManager& entity_manager) const; + + /** + * Check if lobby is at capacity. + * @param max_clients Maximum allowed players + * @return true if player count >= max_clients + */ + bool is_full(int max_clients) const; + + /** + * Get number of connected players. + * @return Count of players currently connected + */ + size_t get_player_count() const; + + /** + * Get player entity ID by client ID. + * @param client_id Network client identifier + * @return Entity ID, or INVALID_ENTITY_ID if not found + */ + EntityID get_player_entity_id(const std::string& client_id) const; + + /** + * Get all connected player entity IDs. + * @return Vector of entity IDs for all connected players + */ + std::vector get_all_player_entities() const; + + /** + * Update player connection metadata (latency, last activity). + * Updates the NetworkMetadataComponent for the player. + * @param client_id Network client identifier + * @param entity_manager Entity manager for updating component + * @param latency_ms Measured latency in milliseconds + */ + void update_player_latency(const std::string& client_id, EntityManager& entity_manager, unsigned int latency_ms); + + /** + * Reset all players to not-ready state. + * Used for transitioning between game states (e.g., end of game). + * @param entity_manager Entity manager for resetting components + */ + void reset_all_players(EntityManager& entity_manager); + + /** + * Clear all player tracking (typically on shutdown). + * Removes all client_id to entity mappings but does NOT destroy entities. + * Entities will be destroyed separately via EntityManager. + */ + void clear(); + +private: + // Map from client_id to player entity ID + std::map client_to_entity_; + + // Track next player ID for assignment + uint32_t next_player_id_ = 0; + + /** + * Helper: Create player entity from template and apply all player components. + * @param client_id Network client identifier + * @param entity_manager Entity manager for entity creation + * @return Entity ID of created player, or INVALID_ENTITY_ID on failure + */ + EntityID create_player_entity(const std::string& client_id, EntityManager& entity_manager); +}; From 0e6ceca26f267ee49b99097244518ed9dee77135 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 17 Nov 2025 15:45:32 -0500 Subject: [PATCH 07/79] minor xml updates --- data/entities/champions/champion.xml | 23 +++++++++++++++++++++++ data/entities/minions/_minion.xsd | 11 +++++++++++ 2 files changed, 34 insertions(+) create mode 100644 data/entities/champions/champion.xml create mode 100644 data/entities/minions/_minion.xsd diff --git a/data/entities/champions/champion.xml b/data/entities/champions/champion.xml new file mode 100644 index 0000000..e60d7fa --- /dev/null +++ b/data/entities/champions/champion.xml @@ -0,0 +1,23 @@ + + + + + + + diff --git a/data/entities/minions/_minion.xsd b/data/entities/minions/_minion.xsd new file mode 100644 index 0000000..4e4fc1c --- /dev/null +++ b/data/entities/minions/_minion.xsd @@ -0,0 +1,11 @@ + + + + + + \ No newline at end of file From be77969ee207127bd62a14ee7a6cec8612329ee0 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 17 Nov 2025 15:45:46 -0500 Subject: [PATCH 08/79] ignore markdown files (code audits) --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index db2669d..2a38c30 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ build -*.tscn \ No newline at end of file +*.tscn +*.md \ No newline at end of file From dfa5c909600e00fa1f2127f31ecd4aeca9eff42f Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 17 Nov 2025 15:46:36 -0500 Subject: [PATCH 09/79] Add combat, spawn, sync, movement, coordinator and other system to enable basic sync of movement and start of combat implementation --- CMakeLists.txt | 19 ++ src/components/attack.hpp | 40 ++++ src/components/auto_attack.hpp | 162 ++++++++++++++++ src/components/component_registry.hpp | 10 +- src/components/entity_state.hpp | 6 + src/components/network_entity.hpp | 84 ++++++++ src/components/player_owned.hpp | 35 ++++ src/components/target.hpp | 116 +++++++++++ src/components/wave_state.hpp | 61 ++++++ src/services/astar_pathfinding.cpp | 1 - src/services/navigation_service.cpp | 2 +- src/services/network_service.cpp | 13 ++ src/services/network_service.hpp | 6 + src/systems/combat_system.cpp | 268 ++++++++++++++++++++++++++ src/systems/combat_system.hpp | 102 +++++++++- src/systems/gameplay_coordinator.cpp | 28 +++ src/systems/gameplay_coordinator.hpp | 100 ++++++++++ src/systems/gameserver.cpp | 152 +++++---------- src/systems/gameserver.hpp | 54 ++---- src/systems/movement_system.cpp | 77 ++++++-- src/systems/movement_system.hpp | 11 +- src/systems/network_sync_system.cpp | 148 ++++++++++++-- src/systems/network_sync_system.hpp | 89 ++++++++- src/systems/packet_handler.cpp | 77 ++++++++ src/systems/packet_handler.hpp | 74 +++++++ src/systems/player_manager.cpp | 39 +++- src/systems/player_manager.hpp | 7 + src/systems/spawning_system.cpp | 73 +++++++ src/systems/spawning_system.hpp | 61 ++++++ src/systems/system_context.hpp | 4 + src/systems/wave_system.cpp | 130 +++++-------- src/systems/wave_system.hpp | 65 +++++-- 32 files changed, 1824 insertions(+), 290 deletions(-) create mode 100644 src/components/attack.hpp create mode 100644 src/components/auto_attack.hpp create mode 100644 src/components/network_entity.hpp create mode 100644 src/components/player_owned.hpp create mode 100644 src/components/target.hpp create mode 100644 src/components/wave_state.hpp create mode 100644 src/systems/gameplay_coordinator.cpp create mode 100644 src/systems/gameplay_coordinator.hpp create mode 100644 src/systems/packet_handler.cpp create mode 100644 src/systems/packet_handler.hpp create mode 100644 src/systems/spawning_system.cpp create mode 100644 src/systems/spawning_system.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index bc4b2bb..cfed164 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -61,7 +61,11 @@ set(GAMESERVER_SOURCES src/systems/movement_system.cpp src/systems/network_sync_system.cpp src/systems/serialization_system.cpp + src/systems/spawning_system.cpp src/systems/wave_system.cpp + src/systems/player_manager.cpp + src/systems/packet_handler.cpp + src/systems/gameplay_coordinator.cpp ) # Header files (for IDE organization) @@ -86,7 +90,22 @@ set(GAMESERVER_HEADERS src/systems/combat_system.hpp src/systems/movement_system.hpp src/systems/serialization_system.hpp + src/systems/spawning_system.hpp src/systems/wave_system.hpp + src/systems/network_sync_system.hpp + src/systems/player_manager.hpp + src/systems/system_context.hpp + src/systems/packet_handler.hpp + src/systems/gameplay_coordinator.hpp + src/components/client_info.hpp + src/components/readiness.hpp + src/components/network_metadata.hpp + src/components/wave_state.hpp + src/components/network_entity.hpp + src/components/player_owned.hpp + src/components/attack.hpp + src/components/target.hpp + src/components/auto_attack.hpp ) set(LIBRARY_SOURCES diff --git a/src/components/attack.hpp b/src/components/attack.hpp new file mode 100644 index 0000000..0b80e0f --- /dev/null +++ b/src/components/attack.hpp @@ -0,0 +1,40 @@ +#pragma once + +#include "component.hpp" +#include + +/** + * AttackComponent - Tracks current attack state and cooldown (DATA ONLY) + * + * USAGE: Add to any entity that can attack (champions, minions, towers) + * SYSTEMS: CombatSystem (for all update logic) + * COMPANIONS: Stats (for attack_speed, attack_range), TargetComponent + * + * PURPOSE: + * - Store attack state and cooldown + * - Cache attack parameters + * + * DESIGN: + * - Pure data component (no methods) + * - CombatSystem handles all update logic + * - Separates attack state from combat stats + */ +struct AttackComponent : public Component { + // === Attack State === + bool can_attack = true; // Can attack this frame + + // === Cooldown Tracking === + float attack_cooldown_ms = 0.0f; // Time until next attack available (0 = ready) + float last_attack_time_ms = 0.0f; // Timestamp of last attack + + // === Current Attack === + bool attack_in_progress = false; // Currently executing attack animation/projectile + float attack_animation_progress = 0.0f; // 0.0 to 1.0, used for timing hit/effects + + // === Attack Counters === + uint32_t total_attacks = 0; // Total attacks landed (for stats/quests) + uint32_t attacks_this_frame = 0; // Prevent multiple attacks per frame + + COMPONENT_TYPE_ID(AttackComponent, 2020) +}; + diff --git a/src/components/auto_attack.hpp b/src/components/auto_attack.hpp new file mode 100644 index 0000000..d209cfd --- /dev/null +++ b/src/components/auto_attack.hpp @@ -0,0 +1,162 @@ +#pragma once + +#include "component.hpp" +#include "stats.hpp" +#include + +/** + * AutoAttackComponent - AI behavior for automatic attacking + * + * USAGE: Add to minions and other AI entities that should auto-attack + * SYSTEMS: CombatSystem, AutoAttackSystem + * COMPANIONS: AttackComponent, TargetComponent, Stats, Movement + * + * PURPOSE: + * - Enable AI entities to automatically search for and attack targets + * - Separate auto-attack behavior from manual attack mechanics + * - Support different AI personalities and aggression levels + * - Control when auto-attacking is enabled/disabled + * + * DESIGN: + * - Acts as a behavior modifier on top of AttackComponent + * - Stores AI-specific parameters + * - Integrates with TargetComponent for target selection + * - Works with CombatSystem for actual damage resolution + * + * EXAMPLES: + * - Minions: Simple aggro, attack nearest enemy in range + * - Neutral units: No aggro, attack only if attacked + * - Champions (AI): Behavior-driven, target highest threat + * - Towers: Aggro-range based, attack closest in range + */ +struct AutoAttackComponent : public Component { + // === Auto-Attack Control === + bool enabled = true; // Can auto-attack + bool aggressive = true; // Search for targets actively + bool retaliate_only = false; // Only attack if attacked first + + // === Auto-Attack Parameters === + float aggression_range = 10.0f; // How far to search for enemies to attack + float retreat_range = 8.0f; // How far to retreat if outnumbered + + // === Behavior Control === + enum class AIPersonality { + PASSIVE, // No aggression, only retaliate + DEFENSIVE, // Attack if threatened, otherwise passive + BALANCED, // Normal minion behavior + AGGRESSIVE, // Actively seek targets + ZEALOUS // Very aggressive, ignore retreat + }; + + AIPersonality personality = AIPersonality::BALANCED; + + // === Target Preference === + bool prioritize_enemies = true; // Attack enemies over neutrals + bool prioritize_wounded = true; // Focus low-health targets + bool prioritize_attackers = false; // Focus entities attacking me + bool prioritize_closest = true; // Among valid targets, choose closest + + // === State Management === + bool in_combat = false; // Currently engaged in combat + float combat_timeout_ms = 5000.0f; // How long before leaving combat (5 seconds) + float time_since_attack_ms = 0.0f; // Time since last attack landed + + // === Auto-Attack Damage === + float base_damage_multiplier = 1.0f; // Damage multiplier from base stats + float bonus_damage = 0.0f; // Additional flat damage + DamageType damage_type = DamageType::PHYSICAL; // Damage type for resistances + + // === Attack Animation === + float attack_animation_duration_ms = 300.0f; // How long attack animation takes + float hit_timing_percent = 0.5f; // When in animation does damage occur (0.0-1.0) + + // === Kiting & Movement === + bool allow_kiting = true; // Can move while attacking + bool kite_while_attacking = false; // Actively move during auto-attacks + float movement_during_attack = 0.3f; // Movement speed multiplier during attack (0.0-1.0) + + /** + * Enable auto-attacking. + */ + void enable() { + enabled = true; + } + + /** + * Disable auto-attacking. + */ + void disable() { + enabled = false; + in_combat = false; + } + + /** + * Enter combat mode. + * Used by CombatSystem when combat starts. + */ + void enter_combat() { + in_combat = true; + time_since_attack_ms = 0.0f; + } + + /** + * Exit combat mode. + * Called when combat timeout expires. + */ + void exit_combat() { + in_combat = false; + } + + /** + * Update combat timer and potentially exit combat. + * @param delta_time_ms Time since last frame + * @return true if just exited combat + */ + bool update_combat_timer(float delta_time_ms) { + if (in_combat) { + time_since_attack_ms += delta_time_ms; + if (time_since_attack_ms > combat_timeout_ms) { + exit_combat(); + return true; // Just exited combat + } + } + return false; + } + + /** + * Mark that an attack occurred. + */ + void on_attack() { + time_since_attack_ms = 0.0f; + enter_combat(); + } + + /** + * Check if should be searching for targets. + * @return true if enabled and either not in combat or just exited combat + */ + bool should_search_targets() const { + return enabled && aggressive && !retaliate_only; + } + + /** + * Check if should auto-attack if target is available. + * @return true if auto-attacking is active + */ + bool should_auto_attack() const { + return enabled && (aggressive || in_combat); + } + + /** + * Get current movement speed modifier based on state. + * @return Movement speed multiplier (0.0-1.0) + */ + float get_movement_speed_modifier() const { + if (in_combat && kite_while_attacking) { + return movement_during_attack; + } + return 1.0f; + } + + COMPONENT_TYPE_ID(AutoAttackComponent, 2022) +}; diff --git a/src/components/component_registry.hpp b/src/components/component_registry.hpp index 693a135..502d277 100644 --- a/src/components/component_registry.hpp +++ b/src/components/component_registry.hpp @@ -23,12 +23,16 @@ namespace ComponentTypes { constexpr uint32_t PATHFINDING = 2009; constexpr uint32_t EXPERIENCE = 2011; + // === Attack & Combat (2020-2099) === + constexpr uint32_t ATTACK = 2020; + constexpr uint32_t TARGET = 2021; + constexpr uint32_t AUTO_ATTACK = 2022; + constexpr uint32_t WAVE_STATE = 2050; + // === Network & Player (3000-3099) === constexpr uint32_t CLIENT_INFO = 3001; constexpr uint32_t READINESS = 3002; constexpr uint32_t NETWORK_METADATA = 3003; constexpr uint32_t NETWORK_ENTITY = 3004; - - // === Wave System (2050-2099) === - constexpr uint32_t WAVE_STATE = 2050; + constexpr uint32_t PLAYER_OWNED = 3005; } \ No newline at end of file diff --git a/src/components/entity_state.hpp b/src/components/entity_state.hpp index 5777278..8063a0d 100644 --- a/src/components/entity_state.hpp +++ b/src/components/entity_state.hpp @@ -9,8 +9,11 @@ enum class EntityState { SPAWNED, IDLE, + // Idle is for players || If jungle is item and is attacked, it goes from SPAWNED -> IDLE -> ATTACKING PATHFINDING_WAITING, + HOLDING_FOR_TARGET, MOVING, + STOPPING, STUCK, ATTACKING, DEAD @@ -23,6 +26,9 @@ enum class EntityState { struct EntityStateComponent : public Component { EntityState current_state = EntityState::SPAWNED; + EntityID target_entity_id = INVALID_ENTITY_ID; + std::vector target_positions = {}; + float state_duration_ms = 0.0f; COMPONENT_TYPE_ID(EntityStateComponent, 2010) diff --git a/src/components/network_entity.hpp b/src/components/network_entity.hpp new file mode 100644 index 0000000..d4479b7 --- /dev/null +++ b/src/components/network_entity.hpp @@ -0,0 +1,84 @@ +#pragma once + +#include "component.hpp" +#include "movement.hpp" +#include "entity_state.hpp" +#include + +/** + * NetworkEntityComponent - Tracks network synchronization state + * + * USAGE: Add to entities that need to be synchronized to clients. + * Presence of this component means the entity should always be synced. + * SYSTEMS: NetworkSyncSystem + * + * PURPOSE: + * - Cache last synced state to detect changes + * - Optimize bandwidth by only sending changed data + * - Track sync state per entity + * + * BENEFITS: + * - Efficient change detection (position, state, custom properties) + * - Per-entity sync control via component presence + * - Easy to extend with new sync requirements + * + * EXAMPLE: + * // Check if entity has changed since last sync + * if (entity.get_component()->has_changed(entity)) { + * network_sync_system.sync_entity(entity_id); + * } + */ +struct NetworkEntityComponent : public Component { + // === Sync Control === + bool force_full_sync_next_frame = false; // Send all data next frame, not just deltas + + // === Sync Tracking === + uint32_t last_sync_frame = 0; // Frame number when last synced + + // === Last Known State (for delta detection) === + Vec2 last_synced_position = Vec2(0.0f, 0.0f); // Position at last sync + EntityState last_synced_state = EntityState::SPAWNED; // State at last sync + uint32_t last_synced_health = 0; // Health at last sync (if applicable) + + // === Bandwidth Optimization === + static constexpr uint32_t MIN_POSITION_CHANGE = 1; // Only sync if moved 1 unit + static constexpr uint32_t SYNC_FRAME_INTERVAL = 1; // Sync every frame + + /** + * Check if entity position has changed significantly since last sync. + * @param current_position Current entity position + * @return true if position change is significant + */ + bool has_position_changed(const Vec2& current_position) const { + float dx = current_position.x - last_synced_position.x; + float dy = current_position.y - last_synced_position.y; + float dist_sq = dx * dx + dy * dy; + return dist_sq >= (MIN_POSITION_CHANGE * MIN_POSITION_CHANGE); + } + + /** + * Check if entity state has changed since last sync. + * @param current_state Current entity state + * @return true if state has changed + */ + bool has_state_changed(EntityState current_state) const { + return current_state != last_synced_state; + } + + /** + * Mark this entity as fully synced with the given state. + * @param position Current position + * @param state Current state + * @param health Current health (optional) + * @param current_frame Frame number + */ + void mark_synced(const Vec2& position, EntityState state, uint32_t health, uint32_t current_frame) { + last_synced_position = position; + last_synced_state = state; + last_synced_health = health; + last_sync_frame = current_frame; + force_full_sync_next_frame = false; + } + + COMPONENT_TYPE_ID(NetworkEntityComponent, 3004) +}; diff --git a/src/components/player_owned.hpp b/src/components/player_owned.hpp new file mode 100644 index 0000000..b3bbd0e --- /dev/null +++ b/src/components/player_owned.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include "component.hpp" +#include + +/** + * PlayerOwnedComponent - Links a champion/entity to its owning player + * + * USAGE: Add to champion entities to track which player controls them + * SYSTEMS: PlayerManager, InputSystem + * + * PURPOSE: + * - Link champion entities to their player entity + * - Allow player inputs to control champion behavior + * - Track ownership for damage/kill credit + * + * BENEFITS: + * - Decouples player (input/connection) from champion (in-game avatar) + * - Multiple champions per player possible (future feature) + * - Clean architecture like League of Legends + * + * EXAMPLE: + * // Find the champion controlled by a player + * auto all_champions = entity_manager.get_entities_with_component(); + * for (auto* champion : all_champions) { + * if (champion->get_component()->owning_player_id == player_id) { + * // This is the player's champion + * } + * } + */ +struct PlayerOwnedComponent : public Component { + EntityID owning_player_id = INVALID_ENTITY_ID; // Entity ID of the owning player + + COMPONENT_TYPE_ID(PlayerOwnedComponent, 3005) +}; diff --git a/src/components/target.hpp b/src/components/target.hpp new file mode 100644 index 0000000..3f74ac9 --- /dev/null +++ b/src/components/target.hpp @@ -0,0 +1,116 @@ +#pragma once + +#include "component.hpp" +#include "../systems/entity_manager.hpp" +#include + +/** + * TargetComponent - Tracks current attack target + * + * USAGE: Add to entities that need target selection (minions, champions) + * SYSTEMS: CombatSystem, AutoAttackSystem, TargetingSystem + * COMPANIONS: AttackComponent, Movement + * + * PURPOSE: + * - Track current attack target + * - Store target priority and selection criteria + * - Support target switching and loss + * - Enable target-relative positioning + * + * DESIGN: + * - Separates target tracking from attack mechanics + * - Enables flexible targeting AI (priority targeting, defensive targeting, etc.) + * - Integrates with AttackComponent for actual attacks + * - Works with movement systems for approach/positioning + * + * EXAMPLES: + * - Minions auto-attack nearest enemy + * - Champions focus target selection + * - Towers attack closest enemy in range + */ +struct TargetComponent : public Component { + // === Target Tracking === + EntityID current_target = INVALID_ENTITY_ID; // Entity currently being attacked + + // === Target Selection === + enum class TargetPriority { + NEAREST, // Closest enemy + HIGHEST_THREAT, // Enemy dealing most damage + LOWEST_HEALTH, // Enemy with lowest HP + HIGHEST_DAMAGE, // Enemy with highest attack power + PRIORITY_TARGET // Player-selected or set target + }; + + TargetPriority targeting_mode = TargetPriority::NEAREST; + + // === Target Range === + float target_search_range = 10.0f; // How far to look for targets (game units) + float target_loss_range = 12.0f; // Range beyond which target is lost + + // === Target Timing === + float last_target_search_ms = 0.0f; // When last searched for new target + float target_search_interval_ms = 500.0f; // How often to search for targets (500ms) + + // === Target Status === + bool has_target = false; // Whether current_target is valid and in range + bool target_in_range = false; // Whether target is in attack range + float distance_to_target = 0.0f; // Cached distance to current target + + /** + * Set a specific target. + * @param target_id Entity ID to target + */ + void set_target(EntityID target_id) { + current_target = target_id; + has_target = (target_id != INVALID_ENTITY_ID); + last_target_search_ms = 0.0f; + } + + /** + * Clear current target. + */ + void clear_target() { + current_target = INVALID_ENTITY_ID; + has_target = false; + target_in_range = false; + distance_to_target = 0.0f; + } + + /** + * Check if should search for new target. + * @param current_time_ms Current game time + * @return true if enough time has passed since last search + */ + bool should_search_for_target(float current_time_ms) const { + return (current_time_ms - last_target_search_ms) >= target_search_interval_ms; + } + + /** + * Mark that target search was performed. + * @param current_time_ms Current game time + */ + void mark_target_searched(float current_time_ms) { + last_target_search_ms = current_time_ms; + } + + /** + * Check if current target is still valid. + * @return true if target exists and is in range + */ + bool is_target_valid() const { + return has_target && current_target != INVALID_ENTITY_ID && + distance_to_target <= target_loss_range; + } + + /** + * Update distance to target (usually called by CombatSystem). + * @param distance Current distance in game units + * @param attack_range Attack range threshold + */ + void update_target_distance(float distance, float attack_range) { + distance_to_target = distance; + target_in_range = (distance <= attack_range); + } + + COMPONENT_TYPE_ID(TargetComponent, 2021) +}; diff --git a/src/components/wave_state.hpp b/src/components/wave_state.hpp new file mode 100644 index 0000000..11aa20d --- /dev/null +++ b/src/components/wave_state.hpp @@ -0,0 +1,61 @@ +#pragma once + +#include "component.hpp" +#include +#include +#include + +/** + * WaveStateComponent - Tracks wave progression state + * + * USAGE: Add to a "wave entity" that represents the current wave + * SYSTEMS: WaveSystem + * + * The WaveSystem creates one of these entities to manage wave state. + * Much cleaner than tracking multiple variables across the system. + * + * RESPONSIBILITIES: + * - Track which phase the wave is in (waiting, spawning, active, complete) + * - Count minions spawned vs remaining + * - Store minion composition for this wave + * - Track elapsed time within each phase + * + * BENEFITS: + * - Wave state is now queryable as a component + * - Can subscribe to wave changes via entity system + * - Clean separation of data from logic + */ +struct WaveStateComponent : public Component { + /** + * Wave phases - represents the lifecycle of a single wave + */ + enum class WavePhase { + WAITING, // Waiting for timer before spawn (initial delay between waves) + SPAWNING, // Currently spawning minions (with delay between each minion) + ACTIVE, // Minions spawned, wave in progress (minions are alive/fighting) + COMPLETE // Wave finished, waiting for next (all minions killed or despawned) + }; + + // === Wave Identity === + int wave_number = 0; // Which wave (0-indexed) + int wave_type = 0; // Special vs default (0=default, 1=special) + + // === Phase Tracking === + WavePhase phase = WavePhase::WAITING; // Current phase + float phase_elapsed_ms = 0.0f; // Time spent in current phase + + // === Minion Counting === + int minions_in_wave = 0; // Total minions for this wave + int minions_spawned = 0; // How many have been spawned so far + int minions_remaining = 0; // How many are still alive + + // === Composition === + std::vector minion_composition; // List of minion templates for this wave + + // === Timing === + static constexpr float WAVE_START_DELAY_MS = 3000.0f; // 3 seconds before first minion + static constexpr float MINION_SPAWN_DELAY_MS = 400.0f; // 400ms between minions + static constexpr float WAVE_COMPLETE_DELAY_MS = 2000.0f; // 2 seconds after last minion killed + + COMPONENT_TYPE_ID(WaveStateComponent, 2050) +}; diff --git a/src/services/astar_pathfinding.cpp b/src/services/astar_pathfinding.cpp index ded50bd..238788c 100644 --- a/src/services/astar_pathfinding.cpp +++ b/src/services/astar_pathfinding.cpp @@ -146,7 +146,6 @@ std::vector AStarPathfinder::FindPath( vertices ); waypoints.push_back(edge_point); - current_poly = parent_poly; } diff --git a/src/services/navigation_service.cpp b/src/services/navigation_service.cpp index 698526d..193770b 100644 --- a/src/services/navigation_service.cpp +++ b/src/services/navigation_service.cpp @@ -95,7 +95,7 @@ struct NavigationService::NavServiceBackend { LOG_DEBUG("Navigation: Entity %u path with %zu waypoints", req.entity_id, res.path.size()); } - // we have our result, so let's hand it back to the main thread now + // we have our result, back to the main thread if(!lock.try_lock()) { // we couldn't lock, so cache this result for later // if we don't cache and submit this later, the request will be lost diff --git a/src/services/network_service.cpp b/src/services/network_service.cpp index 7cfa76d..04fa991 100644 --- a/src/services/network_service.cpp +++ b/src/services/network_service.cpp @@ -84,6 +84,19 @@ void NetworkService::disconnect() { is_connected_ = false; } +void NetworkService::disconnect_client(const std::string& client_id) { + auto it = backend_->clients_.find(client_id); + if (it != backend_->clients_.end()) { + ENetPeer* peer = it->second; + if (peer) { + // Request graceful disconnection + enet_peer_disconnect(peer, 0); + } + // Remove from clients map + backend_->clients_.erase(it); + } +} + bool NetworkService::run_callbacks() { if (!backend_->enet_server_) { return false; diff --git a/src/services/network_service.hpp b/src/services/network_service.hpp index e537be3..dd1bc52 100644 --- a/src/services/network_service.hpp +++ b/src/services/network_service.hpp @@ -36,6 +36,12 @@ class NetworkService { */ void disconnect(); + /** + * Disconnect a specific client. + * @param client_id ID of the client to disconnect + */ + void disconnect_client(const std::string& client_id); + /** * Send a packet of specified type to a peer. * @param packet_type Type of packet to send diff --git a/src/systems/combat_system.cpp b/src/systems/combat_system.cpp index 67efd53..db7c67d 100644 --- a/src/systems/combat_system.cpp +++ b/src/systems/combat_system.cpp @@ -1,7 +1,21 @@ #include "combat_system.hpp" +#include "components/movement.hpp" +#include "components/entity_state.hpp" +#include "components/network_entity.hpp" #include #include #include +#include + +void CombatSystem::update(const SystemContext& ctx) { + // Process all entities with auto-attack behavior + auto attacking_entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : attacking_entities) { + if (entity) { + update_auto_attack(ctx, *entity, ctx.delta_time_ms); + } + } +} std::vector CombatSystem::apply_damage( EntityManager& entity_manager, @@ -64,6 +78,17 @@ std::vector CombatSystem::apply_damage( float actual_damage = reduced_damage; target_stats->health -= actual_damage; + // Update entity state if dead + if (target_stats->health <= 0.0f) { + if (auto* entity_state = target_entity->get_component()) { + entity_state->current_state = EntityState::DEAD; + } + // Mark network entity as changed so death state syncs to clients + if (auto* network_entity = target_entity->get_component()) { + network_entity->force_full_sync_next_frame = true; + } + } + // Calculate lifesteal/spell vamp if (attacker_stats) { float lifesteal_amount = 0.0f; @@ -190,3 +215,246 @@ float CombatSystem::calculate_critical_hit(const Stats& attacker) return 1.0f; } + +void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms) { + auto* auto_attack = entity.get_component(); + auto* attack = entity.get_component(); + auto* target = entity.get_component(); + auto* stats = entity.get_component(); + + if (!auto_attack || !attack || !target || !stats) { + return; // Missing required components + } + + // Update combat timer + auto_attack->update_combat_timer(delta_time_ms); + + // Update attack cooldown + update_attack_cooldown(*attack, delta_time_ms); + + // Don't process if auto-attacking disabled + if (!auto_attack->should_auto_attack()) { + return; + } + + // Search for new target if needed + if (!target->is_target_valid() && auto_attack->should_search_targets()) { + if (target->should_search_for_target(0.0f)) { // TODO: Pass actual game time + EntityID new_target = find_best_target(ctx, entity, *auto_attack, *target); + if (new_target != INVALID_ENTITY_ID) { + target->set_target(new_target); + LOG_INFO("Entity (ID %u) acquired new target: %u", entity.get_id(), new_target); + } + target->mark_target_searched(0.0f); + } + } + + // If we have a valid target and are ready to attack + if (target->is_target_valid() && is_attack_ready(*attack)) { + Entity* target_entity = ctx.entity_manager.get_entity(target->current_target); + + if (target_entity && !is_dead(ctx.entity_manager, target->current_target)) { + // Calculate distance to target + auto* target_move = target_entity->get_component(); + auto* my_move = entity.get_component(); + + if (target_move && my_move) { + float dx = target_move->position.x - my_move->position.x; + float dy = target_move->position.y - my_move->position.y; + float distance = std::sqrt(dx * dx + dy * dy); + + target->update_target_distance(distance, stats->attack_range); + + // Attack if in range + if (target->target_in_range) { + // Begin attack animation + begin_attack_animation(*attack); + + // Calculate damage + float base_damage = stats->physical_power + auto_attack->bonus_damage; + base_damage *= auto_attack->base_damage_multiplier; + + // Apply damage + auto damage_events = apply_damage(ctx.entity_manager, entity.get_id(), + target->current_target, base_damage, + auto_attack->damage_type); + + if (!damage_events.empty()) { + // Start cooldown + start_attack_cooldown(*attack, stats->attack_speed); + auto_attack->on_attack(); + + LOG_INFO("Entity (ID %u) auto-attacked target (ID %u) for %.1f damage", + entity.get_id(), target->current_target, damage_events[0].damage_dealt); + } + } + } + } else { + // Target is dead or invalid, clear it + target->clear_target(); + } + } +} + +EntityID CombatSystem::find_best_target(const SystemContext& ctx, const Entity& attacker, + const AutoAttackComponent& auto_attack_comp, + TargetComponent& target_comp) const { + if (!attacker.has_component() || !attacker.has_component()) { + return INVALID_ENTITY_ID; + } + + const auto* attacker_move = attacker.get_component(); + const auto* attacker_stats = attacker.get_component(); + + EntityID best_target = INVALID_ENTITY_ID; + float best_score = -1e9f; + + // Get all entities with Movement (potential targets) + auto all_entities = ctx.entity_manager.get_entities_with_component(); + + for (auto* potential_target : all_entities) { + if (!potential_target || potential_target->get_id() == attacker.get_id()) { + continue; // Skip self + } + + // Check if valid target + if (!is_valid_target(ctx, attacker, *potential_target)) { + continue; + } + + // Calculate distance + auto* target_move = potential_target->get_component(); + if (!target_move) continue; + + float dx = target_move->position.x - attacker_move->position.x; + float dy = target_move->position.y - attacker_move->position.y; + float distance = std::sqrt(dx * dx + dy * dy); + + // Skip if out of aggro range + if (distance > auto_attack_comp.aggression_range) { + continue; + } + + // Calculate target score based on targeting mode + float score = 0.0f; + + auto* target_stats = potential_target->get_component(); + + switch (target_comp.targeting_mode) { + case TargetComponent::TargetPriority::NEAREST: + score = -distance; // Negative distance = higher score for closer + break; + + case TargetComponent::TargetPriority::LOWEST_HEALTH: + if (target_stats) { + score = -(target_stats->health); // Negative health = target low HP + } + break; + + case TargetComponent::TargetPriority::HIGHEST_THREAT: + if (target_stats) { + score = target_stats->physical_power + target_stats->magic_power; + } + break; + + case TargetComponent::TargetPriority::HIGHEST_DAMAGE: + if (target_stats) { + score = target_stats->physical_power; + } + break; + + default: + score = -distance; + break; + } + + // Prefer closer targets as tiebreaker + if (auto_attack_comp.prioritize_closest) { + score -= (distance * 0.1f); + } + + if (score > best_score) { + best_score = score; + best_target = potential_target->get_id(); + } + } + + return best_target; +} + +bool CombatSystem::is_valid_target(const SystemContext& ctx, const Entity& attacker, + const Entity& potential_target) const { + // Must have stats + if (!potential_target.has_component()) { + return false; + } + + const auto* attacker_stats = attacker.get_component(); + const auto* target_stats = potential_target.get_component(); + + if (!attacker_stats || !target_stats) { + return false; + } + + // Can't target dead units + if (target_stats->health <= 0.0f) { + return false; + } + + // Can't target same team (unless friendly fire enabled) + if (attacker_stats->team_id != 0 && target_stats->team_id == attacker_stats->team_id) { + return false; + } + + // Target must be on opposite team or attacker neutral + if (attacker_stats->team_id == 0 && target_stats->team_id == 0) { + return false; // Can't target neutrals as neutral + } + + return true; +} + +void CombatSystem::update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const { + if (attack.attack_cooldown_ms > 0.0f) { + attack.attack_cooldown_ms -= delta_time_ms; + if (attack.attack_cooldown_ms < 0.0f) { + attack.attack_cooldown_ms = 0.0f; + attack.can_attack = true; + } + } +} + +void CombatSystem::start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const { + if (attack_speed_stat > 0.0f) { + attack.attack_cooldown_ms = (1000.0f / attack_speed_stat); // Convert to milliseconds + } else { + attack.attack_cooldown_ms = 1000.0f; // Default 1 second + } + attack.can_attack = false; + attack.attacks_this_frame = 0; +} + +bool CombatSystem::is_attack_ready(const AttackComponent& attack) const { + return attack.attack_cooldown_ms <= 0.0f && attack.can_attack; +} + +void CombatSystem::begin_attack_animation(AttackComponent& attack) const { + attack.attack_in_progress = true; + attack.attack_animation_progress = 0.0f; + attack.attacks_this_frame++; + attack.total_attacks++; +} + +bool CombatSystem::update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const { + if (!attack.attack_in_progress) return false; + + attack.attack_animation_progress += delta_time_ms / animation_duration_ms; + + if (attack.attack_animation_progress >= 1.0f) { + attack.attack_animation_progress = 1.0f; + attack.attack_in_progress = false; + return true; // Attack complete + } + + return false; +} diff --git a/src/systems/combat_system.hpp b/src/systems/combat_system.hpp index fcfdd68..c2d4e18 100644 --- a/src/systems/combat_system.hpp +++ b/src/systems/combat_system.hpp @@ -1,15 +1,45 @@ #pragma once #include "entity_manager.hpp" +#include "system_context.hpp" #include "components/stats.hpp" +#include "components/attack.hpp" +#include "components/auto_attack.hpp" +#include "components/target.hpp" #include /** - * Generic combat system for all entities with Stats components. - * Handles damage calculation, critical hits, and various damage types. + * CombatSystem - Handles all combat mechanics + * + * RESPONSIBILITIES: + * - Damage calculation and application + * - Auto-attack execution and cooldown management + * - Target selection and validation + * - Combat state management (in-combat, cooldowns, etc.) + * - Critical hit calculation + * - Armor/resist/mitigation calculations + * + * COMPONENTS USED: + * - Stats (base damage, armor, resist, health) + * - AttackComponent (attack cooldown, state) + * - AutoAttackComponent (AI behavior) + * - TargetComponent (target tracking) + * - Movement (for distance calculations) + * + * SYSTEM INTERACTION: + * - Works with NetworkSyncSystem to broadcast combat effects + * - Integrates with MovementSystem for approach distance + * - Coordinates with GameplayCoordinator for execution order */ class CombatSystem { public: + /** + * Update all combat for this frame. + * Processes auto-attacks, cooldowns, and combat state for all entities. + * @param ctx System context with entity manager, services, and delta time + */ + void update(const SystemContext& ctx); + /** * Structure representing damage information for combat events. */ @@ -77,6 +107,74 @@ class CombatSystem { EntityManager& entity_manager, EntityID entity_id ) const; + + /** + * Update and process auto-attacks for an entity. + * Handles cooldowns, target selection, and attack execution for entities with AutoAttackComponent. + * @param ctx System context + * @param entity Entity to update + * @param delta_time_ms Time since last frame in milliseconds + */ + void update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms); + + /** + * Find best target for an entity based on targeting mode. + * @param ctx System context + * @param attacker Entity looking for target + * @param auto_attack_comp AutoAttackComponent for settings + * @param target_comp TargetComponent to update + * @return EntityID of best target, or INVALID_ENTITY_ID if none found + */ + EntityID find_best_target(const SystemContext& ctx, const Entity& attacker, + const AutoAttackComponent& auto_attack_comp, + TargetComponent& target_comp) const; + + /** + * Check if a potential target is valid (not dead, correct team, etc). + * @param ctx System context + * @param attacker Entity doing attacking + * @param potential_target Entity to validate + * @return true if valid target + */ + bool is_valid_target(const SystemContext& ctx, const Entity& attacker, + const Entity& potential_target) const; + + /** + * Update attack cooldown for an entity. + * Called each frame to reduce the cooldown timer. + * @param attack Attack component to update + * @param delta_time_ms Time elapsed since last frame + */ + void update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const; + + /** + * Start attack cooldown based on attack speed stat. + * @param attack Attack component to update + * @param attack_speed_stat Attack speed from Stats component (attacks per second) + */ + void start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const; + + /** + * Check if an entity is ready to attack. + * @param attack Attack component to check + * @return true if cooldown is finished and entity can attack + */ + bool is_attack_ready(const AttackComponent& attack) const; + + /** + * Begin attack animation. + * @param attack Attack component to update + */ + void begin_attack_animation(AttackComponent& attack) const; + + /** + * Update attack animation progress. + * @param attack Attack component to update + * @param delta_time_ms Time elapsed + * @param animation_duration_ms Total animation duration + * @return true if animation is complete + */ + bool update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const; private: /** diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp new file mode 100644 index 0000000..b47782b --- /dev/null +++ b/src/systems/gameplay_coordinator.cpp @@ -0,0 +1,28 @@ +#include "gameplay_coordinator.hpp" + +GameplayCoordinator::GameplayCoordinator() + : wave_system_(nullptr) { + // Systems initialized with default constructors + // WaveSystem will be initialized via initialize_wave_system() before use +} + +void GameplayCoordinator::initialize_wave_system(EntityManager* entity_manager, NetworkService* network_service, + NavigationService* navigation_service, const Map* map) { + wave_system_ = std::make_unique(); + wave_system_->initialize(entity_manager, network_service, navigation_service, map); +} + +void GameplayCoordinator::update(const SystemContext& ctx) { + // Execute systems in dependency order + + // ENGINE SYSTEMS + wave_system_->update(ctx); + + // ENTITY SYSTEMS + movement_system_.update(ctx); + combat_system_.update(ctx); + // PLAYER SYSTEMS + + // 5. Synchronize to clients + network_sync_system_.update(ctx); +} diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp new file mode 100644 index 0000000..6393bc3 --- /dev/null +++ b/src/systems/gameplay_coordinator.hpp @@ -0,0 +1,100 @@ +#pragma once + +#include "system_context.hpp" +#include "wave_system.hpp" +#include "movement_system.hpp" +#include "network_sync_system.hpp" +#include "combat_system.hpp" + +/** + * GameplayCoordinator - Orchestrates all game systems + * + * RESPONSIBILITIES: + * - Update all systems in correct order + * - Maintain game logic loop + * - Ensure systems execute in dependency order + * + * DOES NOT: + * - Manage players (use PlayerManager) + * - Handle networking directly (use NetworkService) + * - Manage game state transitions (use GameServer) + * + * SYSTEM UPDATE ORDER (important for correctness): + * 1. WaveSystem - Spawns new entities for this frame + * 2. MovementSystem - Updates entity positions based on paths + * 3. CombatSystem - Resolves damage and effects + * 4. NetworkSyncSystem - Sends state updates to clients + * + * USAGE: + * GameplayCoordinator gameplay; + * SystemContext ctx{...}; + * gameplay.update(ctx); + */ +class GameplayCoordinator { +public: + GameplayCoordinator(); + ~GameplayCoordinator() = default; + + // Prevent copying + GameplayCoordinator(const GameplayCoordinator&) = delete; + GameplayCoordinator& operator=(const GameplayCoordinator&) = delete; + + // Allow moving + GameplayCoordinator(GameplayCoordinator&&) = default; + GameplayCoordinator& operator=(GameplayCoordinator&&) = default; + + /** + * Initialize the WaveSystem with required services. + * Must be called before update() to properly set up entity spawning. + * @param entity_manager Pointer to entity manager + * @param network_service Pointer to network service (for broadcasting) + * @param navigation_service Pointer to navigation service (for pathfinding) + * @param map Pointer to map data + */ + void initialize_wave_system(EntityManager* entity_manager, NetworkService* network_service, + NavigationService* navigation_service, const Map* map); + + /** + * Update all game systems for a single frame. + * Systems are executed in dependency order to ensure correct behavior. + * + * Order: + * 1. WaveSystem::update() - Spawn new minions + * 2. MovementSystem::update() - Move entities + * 3. CombatSystem::update() - Auto-attacks and damage + * 4. NetworkSyncSystem::update() - Broadcast state + * + * @param ctx System context containing entity manager and services + */ + void update(const SystemContext& ctx); + + /** + * Get reference to wave system (for direct initialization if needed). + * @return Reference to WaveSystem + */ + WaveSystem& get_wave_system() { return *wave_system_; } + + /** + * Get reference to movement system. + * @return Reference to MovementSystem + */ + MovementSystem& get_movement_system() { return movement_system_; } + + /** + * Get reference to network sync system. + * @return Reference to NetworkSyncSystem + */ + NetworkSyncSystem& get_network_sync_system() { return network_sync_system_; } + + /** + * Get reference to combat system. + * @return Reference to CombatSystem + */ + CombatSystem& get_combat_system() { return combat_system_; } + +private: + std::unique_ptr wave_system_; + MovementSystem movement_system_; + NetworkSyncSystem network_sync_system_; + CombatSystem combat_system_; +}; diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index 96504bd..9e8e775 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -1,5 +1,6 @@ #include "gameserver.hpp" #include "packet_validator.hpp" +#include "system_context.hpp" #include #include #include @@ -11,6 +12,7 @@ #include #include +#include GameServer::GameServer(int port, int max_clients, const std::string& map_path) : max_clients_(max_clients) @@ -19,9 +21,10 @@ GameServer::GameServer(int port, int max_clients, const std::string& map_path) , map_pointer_(nullptr) , navigation_service_(nullptr) , current_state_(GAME_STATE::PREGAME) - , last_minion_broadcast_(std::chrono::high_resolution_clock::now()) , network_service_(NetworkService(port, max_clients)) - , wave_system_(nullptr) { + , player_manager_() + , packet_handler_(&player_manager_, &entity_manager_, &network_service_) + , gameplay_() { } @@ -56,8 +59,8 @@ ERROR_CODE GameServer::initialize() { return net_result; } - // Initialize Wave System with navigation and map - wave_system_ = std::make_unique(&entity_manager_, &network_service_, navigation_service_.get(), map_pointer_.get()); + // Initialize GameplayCoordinator with services + initialize_coordinator(); return ERROR_CODE::ERROR_NONE; } @@ -75,26 +78,23 @@ void GameServer::run() { continue; } GameServer::frame_tick(); - - } - LOG_INFO("Server main loop ended"); } void GameServer::frame_tick() { float delta_time_ms = frame_timer_.frame_duration_in_ms(); - float delta_time_s = delta_time_ms / 1000.0f; - // Update waves - wave_system_->tick(delta_time_ms); + // Create system context with all services + SystemContext ctx(entity_manager_); + ctx.navigation_service = navigation_service_.get(); + ctx.network_service = &network_service_; + ctx.map = map_pointer_.get(); + ctx.delta_time_ms = delta_time_ms; - // Update entity movement - movement_system_.update(entity_manager_, delta_time_s, navigation_service_.get(), map_pointer_.get()); - - // Synchronize entity state to clients + // Update all game systems through coordinator if (current_state_ == GAME_STATE::ONGOING) { - network_sync_system_.update(entity_manager_, &network_service_); + gameplay_.update(ctx); } } @@ -107,18 +107,8 @@ bool GameServer::is_shutdown_requested() const { return shutdown_requested_; } -bool GameServer::is_lobby_ready() const { - if (players_.empty()) { - return false; - } - - for (const auto& pair : players_) { - if (!pair.second.is_ready) { - return false; - } - } - - return true; +bool GameServer::is_lobby_ready() { + return player_manager_.are_all_players_ready(entity_manager_); } GAME_STATE GameServer::get_current_state() const { @@ -143,7 +133,7 @@ bool GameServer::try_transition_state(GAME_STATE new_state) { } size_t GameServer::get_player_count() const { - return players_.size(); + return player_manager_.get_player_count(); } int GameServer::get_max_clients() const { @@ -151,115 +141,69 @@ int GameServer::get_max_clients() const { } bool GameServer::is_lobby_full() const { - return (int)players_.size() >= max_clients_; + return player_manager_.is_full(max_clients_); } void GameServer::on_client_connect(std::string client_id) { - // Create player - Player new_player(client_id); - new_player.player_id = (uint32_t)players_.size(); - - // Store in map - auto result = players_.emplace(client_id, new_player); + // Lobby check & Map Send - // Tell the player which map to load + if (player_manager_.is_full(max_clients_)) { + LOG_WARN("Lobby full! Rejecting new connection from %s", client_id.c_str()); + network_service_.disconnect_client(client_id); + network_service_.send_packet(PACKET_TYPE::LOBBY_FULL, client_id); + return; + } + EntityID player_entity_id = player_manager_.on_client_connect(client_id, entity_manager_); + if (map_pointer_) { network_service_.send_packet(PACKET_TYPE::MAP_LOAD, map_pointer_->name, client_id); } - LOG_INFO("Player %s added. Total players: %zu/%d", - client_id.c_str(), players_.size(), max_clients_); + LOG_INFO("Player %s added. Entity ID: %u", + client_id.c_str(), player_entity_id); - if (is_lobby_full()) { - LOG_INFO("Lobby full! Waiting for all players to be ready (%zu/%d)", - players_.size(), max_clients_); + if (player_manager_.is_full(max_clients_)) { + LOG_INFO("Lobby full! Waiting for all players to be ready"); } else { - LOG_INFO("Waiting for more players... (%zu/%d)", - players_.size(), max_clients_); + LOG_INFO("Waiting for more players..."); } - - broadcast_player_list(); } void GameServer::on_packet_received(std::string client_id, const uint8_t* data, size_t length) { - // Validate and process packet - if (!PacketValidator::validate_packet(data, length)) { - LOG_WARN("Invalid packet received from %s", client_id.c_str()); - return; - } - PACKET_TYPE packet_type = (PACKET_TYPE)(data[0]); + // Delegate to PacketHandler for processing + packet_handler_.handle_packet(client_id, data, length); - switch (packet_type) { - case PACKET_TYPE::PLAYER_READY: - handle_player_ready_packet(client_id, data, length); - break; - - default: - LOG_WARN("Unknown packet type: %d", (int)(packet_type)); - break; - } - - // Update last activity for this player - auto it = players_.find(client_id); - if (it != players_.end()) { - it->second.update_activity(); - } -} - -bool GameServer::handle_player_ready_packet(std::string client_id, const uint8_t* packet_data, size_t packet_length) { - bool is_ready = false; - if (!PacketValidator::extract_ready_status(packet_data, packet_length, is_ready)) { - LOG_WARN("Failed to extract ready status from packet"); - return false; - } - - // Update player ready status - auto it = players_.find(client_id); - if (it == players_.end()) { - LOG_WARN("Received ready packet from unknown player: %s", client_id.c_str()); - return false; - } - - it->second.is_ready = is_ready; - LOG_INFO("Player %s is now %s", client_id.c_str(), is_ready ? "ready" : "not ready"); - - // Check if we should transition to ONGOING + // Check if we should transition to ONGOING after processing packet if (current_state_ == GAME_STATE::PREGAME && - is_lobby_full() && - is_lobby_ready()) { + player_manager_.is_full(max_clients_) && + player_manager_.are_all_players_ready(entity_manager_)) { LOG_INFO("All players ready! Transitioning to ONGOING state"); - if(try_transition_state(GAME_STATE::ONGOING)) { + if (try_transition_state(GAME_STATE::ONGOING)) { // Notify all players that the game is starting network_service_.broadcast_packet(PACKET_TYPE::GAME_START); - GameServer::run(); } } - - broadcast_player_list(); - return true; } void GameServer::on_client_disconnect(std::string client_id) { - // Remove player from map - auto it = players_.find(client_id); - if (it != players_.end()) { - players_.erase(it); - LOG_INFO("Player removed. Remaining players: %zu", players_.size()); + // Remove player entity via PlayerManager + bool was_removed = player_manager_.on_client_disconnect(client_id, entity_manager_); + + if (was_removed) { + LOG_INFO("Player %s disconnected", client_id.c_str()); } // Handle state changes if game was ongoing - if (current_state_ == GAME_STATE::ONGOING && players_.empty()) { + if (current_state_ == GAME_STATE::ONGOING && player_manager_.get_player_count() == 0) { LOG_WARN("All players disconnected. Returning to PREGAME"); try_transition_state(GAME_STATE::PREGAME); } - - broadcast_player_list(); } -void GameServer::broadcast_player_list() { - // TODO: Implement broadcasting player list to all connected clients - // For now, this is a placeholder for future networking implementation +void GameServer::initialize_coordinator() { + // Set up WaveSystem with all required services + gameplay_.initialize_wave_system(&entity_manager_, &network_service_, navigation_service_.get(), map_pointer_.get()); } bool GameServer::is_valid_state_transition(GAME_STATE from, GAME_STATE to) const { diff --git a/src/systems/gameserver.hpp b/src/systems/gameserver.hpp index 510a251..e683947 100644 --- a/src/systems/gameserver.hpp +++ b/src/systems/gameserver.hpp @@ -11,16 +11,12 @@ #include "components/map.hpp" #include "libs/frame_timer.h" -// Entities -#include "entities/player.hpp" +// Managers +#include "player_manager.hpp" +#include "packet_handler.hpp" +#include "gameplay_coordinator.hpp" // Systems -#include "combat_system.hpp" #include "entity_manager.hpp" -#include "map_system.hpp" -#include "movement_system.hpp" -#include "network_sync_system.hpp" -#include "serialization_system.hpp" -#include "wave_system.hpp" // Services #include "services/navigation_service.hpp" #include "services/network_service.hpp" @@ -75,7 +71,7 @@ class GameServer { * Check if all players in lobby are ready. * @return true if all connected players have ready=true */ - bool is_lobby_ready() const; + bool is_lobby_ready(); /** * Get current game state. @@ -114,13 +110,8 @@ class GameServer { std::string map_path_; std::unique_ptr map_pointer_; NetworkService network_service_; - // Systems - std::unique_ptr wave_system_; - MovementSystem movement_system_; - NetworkSyncSystem network_sync_system_; - + // Server configuration - // Server tick rate in milliseconds // TODO this should be configurable, probably - ploinky 14/11/2025 FrameTimer frame_timer_ = FrameTimer(30); @@ -129,12 +120,16 @@ class GameServer { std::atomic shutdown_requested_; GAME_STATE current_state_; - // Minion broadcast tracking (for rate limiting) - std::chrono::high_resolution_clock::time_point last_minion_broadcast_; - static constexpr float MINION_BROADCAST_INTERVAL = 0.05f; // 50ms = ~20 updates/sec + // Managers + PlayerManager player_manager_; + PacketHandler packet_handler_; + GameplayCoordinator gameplay_; - // Player management (using hash map for O(1) lookup) - std::unordered_map players_; + /** + * Initialize GameplayCoordinator with required services. + * Must be called after map and navigation service are initialized. + */ + void initialize_coordinator(); // Services (Separate thread) std::unique_ptr navigation_service_; @@ -155,15 +150,6 @@ class GameServer { * @param packet The packet the is incoming */ void on_packet_received(std::string client_id, const uint8_t* data, size_t length); - - /** - * Handle player ready status packet. - * @param client_id ID of the client that has submitted the status - * @param packet_data Pointer to packet data - * @param packet_length Length of packet data - * @return true if handled successfully - */ - bool handle_player_ready_packet(std::string client_id, const uint8_t* packet_data, size_t packet_length); /** * Handle client disconnect. @@ -175,16 +161,6 @@ class GameServer { * Perform a single frame tick: process game logic, update states, and broadcast as needed. */ void frame_tick(); - /** - * Broadcast player list to all connected clients. - */ - void broadcast_player_list(); - - /** - * Broadcast all active minion states to all connected clients. - * Rate-limited to avoid excessive network traffic. - */ - void broadcast_minion_states(); /** * Validate state transition rules. diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index c7f1fa6..e346c5f 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -7,9 +7,53 @@ #include #include -void MovementSystem::update(EntityManager& entity_manager, float delta_time, NavigationService* navigation_service, const Map* map) { +void MovementSystem::update(const SystemContext& ctx) { + // Process pathfinding results for waiting entities + if (ctx.navigation_service) { + std::optional result = ctx.navigation_service->GetResult(); + while (result) { + Entity* entity = ctx.entity_manager.get_entity(result->entity_id); + LOG_INFO("Got pathfinding result for entity %u, path size=%zu", result->entity_id, result->path.size()); + if (entity && entity->has_component()) { + PathfindingComponent* pathfinding = entity->get_component(); + EntityStateComponent* entity_state = entity->get_component(); + + pathfinding->waypoints = result->path; + pathfinding->current_waypoint_index = 0; + + if (result->path.empty()) { + LOG_WARN("Entity %u received EMPTY path!", entity->get_id()); + } else { + LOG_INFO("Entity %u received path with %zu waypoints, transitioning to MOVING", + entity->get_id(), result->path.size()); + // Transition to MOVING state when path is received + if (entity_state) { + entity_state->current_state = EntityState::MOVING; + entity_state->state_duration_ms = 0.0f; + LOG_INFO("Entity %u state transitioned to MOVING (state=%d)", entity->get_id(), (int)entity_state->current_state); + } + } + } + result = ctx.navigation_service->GetResult(); + } + } + + // Retry pending pathfinding requests (entities waiting for paths) + if (ctx.navigation_service) { + auto entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : entities) { + PathfindingComponent* pathfinding = entity->get_component(); + EntityStateComponent* entity_state = entity->get_component(); + if (pathfinding && entity_state && + entity_state->current_state == EntityState::PATHFINDING_WAITING && + pathfinding->waypoints.empty()) { + request_new_path(*entity, pathfinding->target_spawnpoint_id, ctx.navigation_service, ctx.map); + } + } + } + // Get all entities with movement components - auto moving_entities = entity_manager.get_entities_with_component(); + auto moving_entities = ctx.entity_manager.get_entities_with_component(); for (auto* entity : moving_entities) { Movement* movement = entity->get_component(); @@ -19,12 +63,11 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav if (!movement || !stats) { continue; } - + // Update stuck detection for entities with pathfinding if (pathfinding) { - float delta_time_ms = delta_time * 1000.0f; - EntityStateComponent* entity_state = entity->get_component(); - + float delta_time_ms = ctx.delta_time_ms; + EntityStateComponent* entity_state = entity->get_component(); // Check if entity has moved since last frame float movement_distance = distance(movement->position, pathfinding->last_position); @@ -37,8 +80,8 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav entity_state && entity_state->current_state == EntityState::MOVING && !pathfinding->waypoints.empty()) { LOG_DEBUG("Minion %u is stuck, requesting new path", entity->get_id()); - if (navigation_service && map && pathfinding->target_spawnpoint_id < map->spawnpoints.size()) { - request_new_path(*entity, pathfinding->target_spawnpoint_id, navigation_service, map); + if (ctx.navigation_service && ctx.map && pathfinding->target_spawnpoint_id < ctx.map->spawnpoints.size()) { + request_new_path(*entity, pathfinding->target_spawnpoint_id, ctx.navigation_service, ctx.map); // Transition to waiting state if (entity_state) { entity_state->current_state = EntityState::PATHFINDING_WAITING; @@ -69,10 +112,10 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav // Get current waypoint if (pathfinding->current_waypoint_index >= pathfinding->waypoints.size()) { // Reached end of path - request path to next spawnpoint if possible - if (map && pathfinding->target_spawnpoint_id < map->spawnpoints.size()) { - uint32_t next_spawnpoint = (pathfinding->target_spawnpoint_id + 1) % map->spawnpoints.size(); - if (navigation_service && entity_state) { - request_new_path(*entity, next_spawnpoint, navigation_service, map); + if (ctx.map && pathfinding->target_spawnpoint_id < ctx.map->spawnpoints.size()) { + uint32_t next_spawnpoint = (pathfinding->target_spawnpoint_id + 1) % ctx.map->spawnpoints.size(); + if (ctx.navigation_service && entity_state) { + request_new_path(*entity, next_spawnpoint, ctx.navigation_service, ctx.map); entity_state->current_state = EntityState::PATHFINDING_WAITING; entity_state->state_duration_ms = 0.0f; } @@ -101,7 +144,7 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav // Normalize direction and apply speed float move_speed = stats->move_speed; - float distance_to_move = move_speed * delta_time; + float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); Vec2 new_position; if (distance_to_move >= distance) { @@ -114,17 +157,19 @@ void MovementSystem::update(EntityManager& entity_manager, float delta_time, Nav } // Check for collision with other entities - if (!has_collision(*entity, new_position, entity_manager)) { + if (!has_collision(*entity, new_position, ctx.entity_manager)) { movement->position = new_position; } else { // If direct path is blocked, try to move sideways to avoid collision + // TODO: Make this better with proper pathfinding around obstacles + // Maybe move to nearest point along a circle around the obstacle, then recalculate path? Vec2 perpendicular = Vec2(-direction.y, direction.x).normalized(); Vec2 sideways_left = current_pos + (perpendicular * distance_to_move); Vec2 sideways_right = current_pos + (perpendicular * -distance_to_move); - if (!has_collision(*entity, sideways_left, entity_manager)) { + if (!has_collision(*entity, sideways_left, ctx.entity_manager)) { movement->position = sideways_left; - } else if (!has_collision(*entity, sideways_right, entity_manager)) { + } else if (!has_collision(*entity, sideways_right, ctx.entity_manager)) { movement->position = sideways_right; } // If both sideways moves are blocked, just don't move (will accumulate stuck time) diff --git a/src/systems/movement_system.hpp b/src/systems/movement_system.hpp index 62cd95c..6dc38f1 100644 --- a/src/systems/movement_system.hpp +++ b/src/systems/movement_system.hpp @@ -5,11 +5,9 @@ #include "components/movement.hpp" #include "components/map.hpp" #include "math.hpp" +#include "system_context.hpp" #include -// Forward declaration to avoid circular dependencies -class NavigationService; - /** * System to handle entity movement along pathfinding waypoints. * Updates positions based on movement speed and follows path waypoints. @@ -20,12 +18,9 @@ class MovementSystem { /** * Update all moving entities. * Moves entities toward their current waypoints and handles path progression. - * @param entity_manager Reference to the entity manager - * @param delta_time Time elapsed since last update in seconds - * @param navigation_service Optional pointer to navigation service for requesting new paths - * @param map Optional pointer to map for spawnpoint information + * @param ctx System context containing entity manager, navigation service, and map */ - void update(EntityManager& entity_manager, float delta_time, NavigationService* navigation_service = nullptr, const Map* map = nullptr); + void update(const SystemContext& ctx); private: /** diff --git a/src/systems/network_sync_system.cpp b/src/systems/network_sync_system.cpp index f54f28e..98d5d86 100644 --- a/src/systems/network_sync_system.cpp +++ b/src/systems/network_sync_system.cpp @@ -1,24 +1,148 @@ #include "network_sync_system.hpp" #include "serialization_system.hpp" #include "components/movement.hpp" +#include "components/entity_state.hpp" +#include "components/network_entity.hpp" #include -void NetworkSyncSystem::update(EntityManager& entity_manager, NetworkService* network_service) { - if (!network_service) { +void NetworkSyncSystem::update(const SystemContext& ctx) { + if(current_frame_ % 30 == 0) { + LOG_INFO("NetworkSyncSystem::update - Frame %u", current_frame_); + } + + if (!ctx.network_service || !ctx.has_network_service()) { return; } - // Get all entities with movement components and broadcast their positions - auto moving_entities = entity_manager.get_entities_with_component(); + current_frame_++; + + // Get all Network Entities + auto network_entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : moving_entities) { - Movement* move_comp = entity->get_component(); - if (move_comp) { - std::vector packet = SerializationSystem::serialize_entity_position( - entity->get_id(), - move_comp->position - ); - network_service->broadcast_packet(packet); + for (auto* entity : network_entities) { + if (!entity) continue; + + auto* net_comp = entity->get_component(); + if (!net_comp) { + continue; // Should never happen since we queried for this component + } + + // For newly spawned entities (last_sync_frame == 0), always sync + bool is_first_sync = (net_comp->last_sync_frame == 0); + + // Check if this frame should sync this entity + if (!is_first_sync && !force_full_sync_next_frame_ && + (current_frame_ - net_comp->last_sync_frame) < SYNC_INTERVAL) { + LOG_DEBUG("Skipping sync for entity %u (frame %u)", entity->get_id(), current_frame_); + continue; // Skip this frame for this entity + } + + // Check if entity has actually changed + if (!has_entity_changed(*entity, current_frame_) && !force_full_sync_next_frame_ && !is_first_sync) { + LOG_DEBUG("Skipping sync for entity %u (frame %u)", entity->get_id(), current_frame_); + continue; // No changes to sync } + + // Serialize entity update + bool send_full_state = force_full_sync_next_frame_ || net_comp->force_full_sync_next_frame || is_first_sync; + std::vector packet = serialize_entity_update(entity->get_id(), *entity, send_full_state); + + if (!packet.empty()) { + ctx.network_service->broadcast_packet(packet); + + // Update last synced state + auto* move = entity->get_component(); + auto* state = entity->get_component(); + + Vec2 pos = move ? move->position : Vec2(0, 0); + EntityState state_val = state ? state->current_state : EntityState::SPAWNED; + + net_comp->mark_synced(pos, state_val, 0, current_frame_); + LOG_DEBUG("Synced entity %u (is_first_sync=%s) at position (%.1f, %.1f), state=%d", + entity->get_id(), is_first_sync ? "true" : "false", pos.x, pos.y, (int)state_val); + } else { + LOG_WARN("No data serialized for entity %u during sync", entity->get_id()); + } + } + + // Clear forced sync flag after processing + force_full_sync_next_frame_ = false; +} + +bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t current_frame) const { + auto* net_comp = entity.get_component(); + if (!net_comp) { + return false; + } + + auto* state = entity.get_component(); + auto* move = entity.get_component(); + + // Always sync entities in MOVING state + if (state && state->current_state == EntityState::MOVING) { + return true; + } + + // Check position change + if (move && net_comp->has_position_changed(move->position)) { + return true; + } + + // Check state change (for state transitions) + if (state && net_comp->has_state_changed(state->current_state)) { + return true; } + + // Force sync if requested + if (net_comp->force_full_sync_next_frame) { + return true; + } + + // Debug: log why entity isn't changing (first 50 frames only) + static uint32_t logged_frames = 0; + if (logged_frames < 50 && state) { + LOG_INFO("Frame %u: Entity %u state=%d, sync_check: moving=%s, pos_changed=%s, state_changed=%s, force=%s", + current_frame, entity.get_id(), (int)state->current_state, + (state->current_state == EntityState::MOVING) ? "yes" : "no", + move && net_comp->has_position_changed(move->position) ? "yes" : "no", + state && net_comp->has_state_changed(state->current_state) ? "yes" : "no", + net_comp->force_full_sync_next_frame ? "yes" : "no"); + logged_frames++; + } + + return false; +} + +std::vector NetworkSyncSystem::serialize_entity_update(EntityID entity_id, const Entity& entity, + bool send_full_state) const { + std::vector packet; + + // Get entity components + auto* move = entity.get_component(); + auto* state = entity.get_component(); + auto* net_comp = entity.get_component(); + + if (!move || !state) { + if (!move) { + LOG_WARN("Entity %u missing Movement component", entity_id); + } + if (!state) { + LOG_WARN("Entity %u missing EntityStateComponent", entity_id); + } + return packet; // Return empty packet + } + + // Use existing serialization system for now + // TODO: Implement delta compression for bandwidth optimization + if (send_full_state || !net_comp) { + // Full state sync - use existing serialization + packet = SerializationSystem::serialize_entity_position(entity_id, move->position); + } else { + // Delta sync - only position for now + if (net_comp->has_position_changed(move->position)) { + packet = SerializationSystem::serialize_entity_position(entity_id, move->position); + } + } + + return packet; } diff --git a/src/systems/network_sync_system.hpp b/src/systems/network_sync_system.hpp index 95cfe87..59eb889 100644 --- a/src/systems/network_sync_system.hpp +++ b/src/systems/network_sync_system.hpp @@ -1,19 +1,96 @@ #pragma once #include "entity_manager.hpp" +#include "system_context.hpp" #include "services/network_service.hpp" +#include +#include /** - * System responsible for synchronizing entity state to connected clients. - * Handles broadcasting entity positions and state changes to maintain - * consistent game state across all clients. + * NetworkSyncSystem - Synchronizes entity state to connected clients + * + * RESPONSIBILITIES: + * - Detect which entities changed this frame (position, state, etc.) + * - Serialize changed data into network packets + * - Broadcast updates to all clients who can see the entity + * - Track last-synced state for each entity + * - Optimize bandwidth by sending only changed data + * + * OPTIMIZATIONS: + * - Delta compression: Only sends changed components, not full state + * - Frame rate limiting: Syncs every N frames instead of every frame + * - Position thresholding: Only syncs if entity moved significant distance + * - Network visibility: Respects NetworkEntityComponent visibility flags + * - Batching: Multiple entity updates per packet + * + * COMPONENTS USED: + * - Movement (position, velocity) + * - EntityStateComponent (current state: spawned, alive, dead, etc.) + * - NetworkEntityComponent (sync tracking, visibility, change detection) + * + * USAGE: + * SystemContext ctx{...}; + * network_sync_system.update(ctx); */ class NetworkSyncSystem { public: + NetworkSyncSystem() = default; + ~NetworkSyncSystem() = default; + + // Prevent copying + NetworkSyncSystem(const NetworkSyncSystem&) = delete; + NetworkSyncSystem& operator=(const NetworkSyncSystem&) = delete; + + // Allow moving + NetworkSyncSystem(NetworkSyncSystem&&) = default; + NetworkSyncSystem& operator=(NetworkSyncSystem&&) = default; + /** * Update and broadcast entity state to all clients. - * @param entity_manager Reference to entity manager for querying entities - * @param network_service Pointer to network service for broadcasting + * + * Process: + * 1. Iterate all entities with NetworkEntityComponent + * 2. Check if entity is visible and has changed + * 3. Serialize changed data + * 4. Broadcast to network service + * 5. Update last-synced state in NetworkEntityComponent + * + * @param ctx System context with entity manager and network service */ - void update(EntityManager& entity_manager, NetworkService* network_service); + void update(const SystemContext& ctx); + + /** + * Force next sync to send all entity data (not just deltas). + * Useful when clients disconnect/reconnect or state becomes inconsistent. + */ + void force_full_sync() { + force_full_sync_next_frame_ = true; + } + +private: + uint32_t current_frame_ = 0; // Frame counter for sync interval checking + bool force_full_sync_next_frame_ = false; // Flag to force delta-free sync + + // Optimization: only sync every N frames for non-critical entities + static constexpr uint32_t SYNC_INTERVAL = 1; // Every frame for responsive movement + + /** + * Check if an entity has changed since last sync. + * Considers position, state, and health. + * @param entity Entity to check + * @param current_frame Current frame number + * @return true if position, state, or other tracked data has changed + */ + bool has_entity_changed(const Entity& entity, uint32_t current_frame) const; + + /** + * Serialize changed entity data into a packet. + * Only includes data that has actually changed (delta compression). + * @param entity_id ID of entity that changed + * @param entity The entity + * @param send_full_state If true, sends all data instead of just changes + * @return Serialized packet bytes ready to send to network + */ + std::vector serialize_entity_update(EntityID entity_id, const Entity& entity, + bool send_full_state) const; }; diff --git a/src/systems/packet_handler.cpp b/src/systems/packet_handler.cpp new file mode 100644 index 0000000..8eb5ff8 --- /dev/null +++ b/src/systems/packet_handler.cpp @@ -0,0 +1,77 @@ +#include "packet_handler.hpp" +#include "player_manager.hpp" +#include "entity_manager.hpp" +#include "services/network_service.hpp" +#include "systems/packet_validator.hpp" +#include "components/readiness.hpp" +#include "components/network_metadata.hpp" +#include + +PacketHandler::PacketHandler(PlayerManager* player_manager, + EntityManager* entity_manager, + NetworkService* network_service) + : player_manager_(player_manager) + , entity_manager_(entity_manager) + , network_service_(network_service) { +} + +void PacketHandler::handle_packet(const std::string& client_id, const uint8_t* data, size_t length) { + // Validate packet structure + if (!PacketValidator::validate_packet(data, length)) { + LOG_WARN("Invalid packet received from %s", client_id.c_str()); + return; + } + + // Extract packet type + PACKET_TYPE packet_type = (PACKET_TYPE)(data[0]); + + // Update player activity + EntityID player_entity_id = player_manager_->get_player_entity_id(client_id); + if (player_entity_id != INVALID_ENTITY_ID) { + Entity* player_entity = entity_manager_->get_entity(player_entity_id); + if (player_entity) { + auto* metadata = player_entity->get_component(); + if (metadata) { + metadata->update_activity(); + } + } + } + + // Dispatch to appropriate handler + switch (packet_type) { + case PACKET_TYPE::PLAYER_READY: + handle_player_ready_packet(client_id, data, length); + break; + + default: + handle_other_packets(client_id, (uint8_t)packet_type, data, length); + break; + } +} + +bool PacketHandler::handle_player_ready_packet(const std::string& client_id, const uint8_t* data, size_t length) { + bool is_ready = false; + if (!PacketValidator::extract_ready_status(data, length, is_ready)) { + LOG_WARN("Failed to extract ready status from packet"); + return false; + } + + // Update player readiness via PlayerManager + if (!player_manager_->set_player_ready(client_id, is_ready, *entity_manager_)) { + LOG_WARN("Failed to set player ready status for client: %s", client_id.c_str()); + return false; + } + + LOG_INFO("Player %s is now %s", client_id.c_str(), is_ready ? "ready" : "not ready"); + + // Note: Game start transition logic should be handled by GameServer/GameplayCoordinator + // This handler just processes the packet and updates state + + return true; +} + +bool PacketHandler::handle_other_packets(const std::string& client_id, uint8_t packet_type, + const uint8_t* data, size_t length) { + LOG_WARN("Unhandled packet type: %d from client: %s", (int)packet_type, client_id.c_str()); + return false; +} diff --git a/src/systems/packet_handler.hpp b/src/systems/packet_handler.hpp new file mode 100644 index 0000000..ab736e8 --- /dev/null +++ b/src/systems/packet_handler.hpp @@ -0,0 +1,74 @@ +#pragma once + +#include +#include + +class EntityManager; +class PlayerManager; +class NetworkService; + +/** + * PacketHandler - Centralized packet processing + * + * RESPONSIBILITIES: + * - Validate incoming packets + * - Dispatch to appropriate handlers + * - Update player state based on packets + * - Coordinate with managers + * + * DOES NOT: + * - Manage player state directly (use PlayerManager) + * - Manage entities directly (use EntityManager) + * - Handle networking (use NetworkService) + * + * USAGE: + * PacketHandler handler(&player_mgr, &entity_mgr, &net_service); + * handler.handle_packet(client_id, packet_data, packet_length); + */ +class PacketHandler { +public: + /** + * Constructor + * @param player_manager Pointer to PlayerManager for player state updates + * @param entity_manager Pointer to EntityManager for entity access + * @param network_service Pointer to NetworkService for packet broadcasting + */ + PacketHandler(PlayerManager* player_manager, + EntityManager* entity_manager, + NetworkService* network_service); + + /** + * Process an incoming packet from a client. + * Validates, dispatches, and handles the packet appropriately. + * @param client_id Source client identifier + * @param data Packet bytes + * @param length Packet length in bytes + */ + void handle_packet(const std::string& client_id, const uint8_t* data, size_t length); + +private: + PlayerManager* player_manager_; + EntityManager* entity_manager_; + NetworkService* network_service_; + + /** + * Handle PLAYER_READY packet. + * Updates player readiness state and checks for game start condition. + * @param client_id Source client identifier + * @param data Packet bytes + * @param length Packet length in bytes + * @return true if handled successfully + */ + bool handle_player_ready_packet(const std::string& client_id, const uint8_t* data, size_t length); + + /** + * Handle other packet types (extensible for future packets). + * @param client_id Source client identifier + * @param packet_type Type of packet received + * @param data Packet bytes + * @param length Packet length in bytes + * @return true if handled successfully + */ + bool handle_other_packets(const std::string& client_id, uint8_t packet_type, + const uint8_t* data, size_t length); +}; diff --git a/src/systems/player_manager.cpp b/src/systems/player_manager.cpp index 32c462b..9471712 100644 --- a/src/systems/player_manager.cpp +++ b/src/systems/player_manager.cpp @@ -2,6 +2,7 @@ #include "components/client_info.hpp" #include "components/readiness.hpp" #include "components/network_metadata.hpp" +#include "components/player_owned.hpp" #include EntityID PlayerManager::on_client_connect(const std::string& client_id, EntityManager& entity_manager) { @@ -37,6 +38,14 @@ bool PlayerManager::on_client_disconnect(const std::string& client_id, EntityMan EntityID player_entity_id = it->second; + // Find and destroy the champion owned by this player + EntityID champion_id = get_champion_entity_id(player_entity_id, entity_manager); + if (champion_id != INVALID_ENTITY_ID) { + if (!entity_manager.destroy_entity(champion_id)) { + LOG_WARN("Failed to destroy champion entity %u", champion_id); + } + } + // Destroy player entity if (!entity_manager.destroy_entity(player_entity_id)) { LOG_ERROR("Failed to destroy player entity %u", player_entity_id); @@ -45,8 +54,8 @@ bool PlayerManager::on_client_disconnect(const std::string& client_id, EntityMan // Remove mapping client_to_entity_.erase(it); - LOG_INFO("Player disconnected: client_id=%s, entity_id=%u, remaining=%zu", - client_id.c_str(), player_entity_id, client_to_entity_.size()); + LOG_INFO("Player disconnected: client_id=%s, player=%u, champion=%u, remaining=%zu", + client_id.c_str(), player_entity_id, champion_id, client_to_entity_.size()); return true; } @@ -119,6 +128,18 @@ EntityID PlayerManager::get_player_entity_id(const std::string& client_id) const return it->second; } +EntityID PlayerManager::get_champion_entity_id(EntityID player_entity_id, EntityManager& entity_manager) const { + // Find champion owned by this player + auto champions = entity_manager.get_entities_with_component(); + for (auto* champion : champions) { + auto* player_owned = champion->get_component(); + if (player_owned && player_owned->owning_player_id == player_entity_id) { + return champion->get_id(); + } + } + return INVALID_ENTITY_ID; +} + std::vector PlayerManager::get_all_player_entities() const { std::vector result; for (const auto& [client_id, entity_id] : client_to_entity_) { @@ -160,7 +181,7 @@ void PlayerManager::clear() { } EntityID PlayerManager::create_player_entity(const std::string& client_id, EntityManager& entity_manager) { - // Create entity from template + // Create player entity from template Entity& player_entity = entity_manager.create_entity_from_template("player"); EntityID player_id = player_entity.get_id(); @@ -182,5 +203,17 @@ EntityID PlayerManager::create_player_entity(const std::string& client_id, Entit player_entity.add_component(std::move(metadata_comp)); } + // Create champion entity from template + Entity& champion_entity = entity_manager.create_entity_from_template("champion"); + EntityID champion_id = champion_entity.get_id(); + + // Link champion to player + auto player_owned_comp = std::make_unique(); + player_owned_comp->owning_player_id = player_id; + champion_entity.add_component(std::move(player_owned_comp)); + + LOG_INFO("Created player (ID %u) with champion (ID %u) for client %s", + player_id, champion_id, client_id.c_str()); + return player_id; } diff --git a/src/systems/player_manager.hpp b/src/systems/player_manager.hpp index 137cb74..46664d1 100644 --- a/src/systems/player_manager.hpp +++ b/src/systems/player_manager.hpp @@ -98,6 +98,13 @@ class PlayerManager { */ EntityID get_player_entity_id(const std::string& client_id) const; + /** + * Get champion entity ID by player entity ID. + * @param player_entity_id Player entity ID + * @return Entity ID, or INVALID_ENTITY_ID if not found + */ + EntityID get_champion_entity_id(EntityID player_entity_id, EntityManager& entity_manager) const; + /** * Get all connected player entity IDs. * @return Vector of entity IDs for all connected players diff --git a/src/systems/spawning_system.cpp b/src/systems/spawning_system.cpp new file mode 100644 index 0000000..0265a59 --- /dev/null +++ b/src/systems/spawning_system.cpp @@ -0,0 +1,73 @@ +#include "spawning_system.hpp" +#include "components/movement.hpp" +#include "components/stats.hpp" +#include "components/network_entity.hpp" +#include "components/entity_state.hpp" +#include "serialization_system.hpp" +#include "services/network_service.hpp" +#include + +EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, + const std::string& template_id, + const Vec2& position, + uint8_t team_id) { + // Create entity from template + Entity& entity = ctx.entity_manager.create_entity_from_template(template_id); + EntityID entity_id = entity.get_id(); + + if (entity_id == INVALID_ENTITY_ID) { + LOG_ERROR("Failed to spawn entity from template: %s", template_id.c_str()); + return INVALID_ENTITY_ID; + } + + // Set position + auto* move = entity.get_component(); + if (move) { + move->position = position; + } + + // Set team ID + auto* stats = entity.get_component(); + if (stats) { + stats->team_id = team_id; + } + + // Add network entity component for syncing + if (!entity.has_component()) { + auto net_comp = std::make_unique(); + net_comp->force_full_sync_next_frame = true; // Ensure initial spawn is sent to clients + entity.add_component(std::move(net_comp)); + } + + // Add entity state component if not present + if (!entity.has_component()) { + auto entity_state = std::make_unique(); + entity_state->current_state = EntityState::SPAWNED; + entity.add_component(std::move(entity_state)); + } + + // Broadcast spawn to clients - NOTE: NetworkSyncSystem will handle first sync + // The entity position will be sent in the same frame via NetworkSyncSystem + broadcast_entity_spawn(ctx, entity_id, position, team_id, template_id); + + LOG_INFO("Spawned entity (ID %u) from template '%s' at (%.1f, %.1f), team %u", + entity_id, template_id.c_str(), position.x, position.y, team_id); + + return entity_id; +} + +void SpawningSystem::broadcast_entity_spawn(const SystemContext& ctx, + EntityID entity_id, + const Vec2& position, + uint8_t team_id, + const std::string& template_id) const { + if (!ctx.network_service) { + return; + } + + // Serialize and broadcast entity spawn packet + std::vector packet = SerializationSystem::serialize_entity_spawn(entity_id, position, team_id, template_id); + if (!packet.empty()) { + ctx.network_service->broadcast_packet(packet); + } +} diff --git a/src/systems/spawning_system.hpp b/src/systems/spawning_system.hpp new file mode 100644 index 0000000..b48724a --- /dev/null +++ b/src/systems/spawning_system.hpp @@ -0,0 +1,61 @@ +#pragma once + +#include "entity_manager.hpp" +#include "system_context.hpp" +#include + +/** + * SpawningSystem - Handles entity spawning and initialization + * + * RESPONSIBILITIES: + * - Spawn entities from templates + * - Initialize entity components + * - Link spawned entities to their controllers (players, waves, etc.) + * - Broadcast spawn events to clients + * + * COMPONENTS USED: + * - Movement (position tracking) + * - NetworkEntityComponent (for broadcasting to clients) + * - PlayerOwnedComponent (for linking champions to players) + * - Stats (for entity attributes) + * + * SYSTEM INTERACTION: + * - Called by WaveSystem, other spawning sources + * - Works with NetworkService to broadcast spawns + * - Integrates with EntityManager for entity creation + * + * USAGE: + * SpawningSystem spawning_system; + * EntityID minion_id = spawning_system.spawn_entity_from_template( + * ctx, "melee_minion", position, team_id + * ); + */ +class SpawningSystem { +public: + /** + * Spawn an entity from a template at a specific position. + * @param ctx System context with entity manager and network service + * @param template_id Template name (e.g., "melee_minion", "champion") + * @param position Starting position for the entity + * @param team_id Team assignment for the entity + * @return EntityID of spawned entity, or INVALID_ENTITY_ID on failure + */ + EntityID spawn_entity_from_template(const SystemContext& ctx, + const std::string& template_id, + const Vec2& position, + uint8_t team_id); + + /** + * Broadcast entity spawn to all connected clients. + * @param ctx System context with network service + * @param entity_id ID of entity that was spawned + * @param position Spawn position + * @param team_id Team of the entity + * @param template_id Template used for spawning + */ + void broadcast_entity_spawn(const SystemContext& ctx, + EntityID entity_id, + const Vec2& position, + uint8_t team_id, + const std::string& template_id) const; +}; diff --git a/src/systems/system_context.hpp b/src/systems/system_context.hpp index b21e1af..d378e71 100644 --- a/src/systems/system_context.hpp +++ b/src/systems/system_context.hpp @@ -45,6 +45,10 @@ struct SystemContext { // === Timing === float delta_time_ms = 0.0f; // Frame delta time in milliseconds + // === Constructor === + SystemContext(EntityManager& em) + : entity_manager(em) {} + // === Convenience Methods === /** diff --git a/src/systems/wave_system.cpp b/src/systems/wave_system.cpp index 5dde189..8a13c90 100644 --- a/src/systems/wave_system.cpp +++ b/src/systems/wave_system.cpp @@ -10,21 +10,21 @@ #include #include #include +#include -WaveSystem::WaveSystem(EntityManager* entity_manager, NetworkService* network_service, NavigationService* navigation_service, const Map* map) { +void WaveSystem::initialize(EntityManager* entity_manager, NetworkService* network_service, + NavigationService* navigation_service, const Map* map) { entity_manager_ = entity_manager; network_service_ = network_service; navigation_service_ = navigation_service; map_ = map; - wave_interval_ms = 30000.0f; - wave_delay_ms = 1000.0f; elapsed_time_ms = 0.0f; last_spawn_timestamp = 0.0f; minion_index = 0; wave_index = 0; special_wave_offset = 5; - // TODO: Load from config file mode -- cmkrist 11/16/2025 + // TODO: Load from config file -- cmkrist 11/16/2025 default_minion_wave = { "melee_minion", "melee_minion", @@ -43,50 +43,13 @@ WaveSystem::WaveSystem(EntityManager* entity_manager, NetworkService* network_se }; } -void WaveSystem::tick(float delta_time_ms) { - elapsed_time_ms += delta_time_ms; - // Process pathfinding results for waiting minions - if (navigation_service_) { - std::optional result = navigation_service_->GetResult(); - while (result) { - Entity* entity = entity_manager_->get_entity(result->entity_id); - if (entity && entity->has_component()) { - PathfindingComponent* pathfinding = entity->get_component(); - EntityStateComponent* entity_state = entity->get_component(); - - pathfinding->waypoints = result->path; - pathfinding->current_waypoint_index = 0; - - if (result->path.empty()) { - LOG_WARN("Minion %u received EMPTY path!", entity->get_id()); - } else { - LOG_DEBUG("Minion %u received path with %zu waypoints", - entity->get_id(), result->path.size()); - // Transition to MOVING state when path is received - if (entity_state) { - entity_state->current_state = EntityState::MOVING; - entity_state->state_duration_ms = 0.0f; - } - } - } - result = navigation_service_->GetResult(); - } +void WaveSystem::update(const SystemContext& ctx) { + if (!entity_manager_) { + return; } - // Retry pending pathfinding requests (entities waiting for paths) - - if (navigation_service_) { - auto entities = entity_manager_->get_entities_with_component(); - for (auto* entity : entities) { - PathfindingComponent* pathfinding = entity->get_component(); - EntityStateComponent* entity_state = entity->get_component(); - if (pathfinding && entity_state && - entity_state->current_state == EntityState::PATHFINDING_WAITING && - pathfinding->waypoints.empty()) { - request_minion_path(*entity, pathfinding->target_spawnpoint_id); - } - } - } + float delta_time_ms = ctx.delta_time_ms; + elapsed_time_ms += delta_time_ms; // Minion Spawning if(minion_index > 0) { @@ -94,6 +57,7 @@ void WaveSystem::tick(float delta_time_ms) { LOG_INFO("Spawning new minion from wave %d, index %d", wave_index, minion_index); for(uint8_t team_id = 1; team_id < 3; team_id++) { create_minion( + ctx, (wave_index % special_wave_offset == 0 ? special_minion_wave : default_minion_wave)[minion_index - 1], team_id, team_id - 1 // Spawn from team-specific spawnpoint @@ -118,49 +82,55 @@ void WaveSystem::tick(float delta_time_ms) { } } -bool WaveSystem::create_minion(const std::string& minion_template, uint8_t team_id, uint32_t spawn_point_id) { - Entity& minion = entity_manager_->create_entity_from_template(minion_template); - if (minion.get_id() == 0) { - LOG_ERROR("Failed to spawn minion of type %s", minion_template.c_str()); +bool WaveSystem::create_minion(const SystemContext& ctx, const std::string& minion_template, uint8_t team_id, uint32_t spawn_point_id) { + if (!map_ || spawn_point_id >= map_->spawnpoints.size()) { + LOG_WARN("Invalid spawn point %u for minion", spawn_point_id); return false; } - - // Set team ID - Stats* stats = minion.get_component(); - if (stats) { - stats->team_id = team_id; - } - if (map_->spawnpoints.size() == 0) { - LOG_WARN("Map has no spawnpoints defined, minion spawn position may be invalid"); - } - // Set Spawn - Movement* move_comp = minion.get_component(); - if (move_comp && map_ && spawn_point_id < map_->spawnpoints.size()) { - move_comp->position = find_free_spawn_position(spawn_point_id, move_comp->collision_radius); + + // Find spawn position + Vec2 spawn_pos = map_->spawnpoints[spawn_point_id]; + + // Get collision radius from template entity if available + Entity& temp = ctx.entity_manager.create_entity_from_template(minion_template); + float collision_radius = 0.5f; // Default + if (auto* move = temp.get_component()) { + collision_radius = move->collision_radius; } + ctx.entity_manager.destroy_entity(temp.get_id()); - // Add pathfinding component - auto pathfinding = std::make_unique(); - minion.add_component(std::move(pathfinding)); + // Find free spawn position + spawn_pos = find_free_spawn_position(spawn_point_id, collision_radius); - // Add entity state component (starts in SPAWNED state) - auto entity_state = std::make_unique(); - entity_state->current_state = EntityState::SPAWNED; - minion.add_component(std::move(entity_state)); + // Spawn entity using SpawningSystem + EntityID minion_id = spawning_system_.spawn_entity_from_template(ctx, minion_template, spawn_pos, team_id); + if (minion_id == INVALID_ENTITY_ID) { + LOG_ERROR("Failed to spawn minion of type %s", minion_template.c_str()); + return false; + } + + Entity* minion = ctx.entity_manager.get_entity(minion_id); + if (!minion) { + return false; + } - // Request initial path to next spawnpoint (enemy spawn) - // TODO: Make this better -- cmkrist 16/11/2025 - uint32_t target_spawnpoint = (spawn_point_id + 1) % (map_ ? map_->spawnpoints.size() : 2); - request_minion_path(minion, target_spawnpoint); + // Add pathfinding component if not already present + if (!minion->has_component()) { + auto pathfinding = std::make_unique(); + minion->add_component(std::move(pathfinding)); + } - // Notify clients of the new entity - // README: Not handled by NetworkSyncSystem (Manages ongoing entities only) -- cmkrist 16/11/2025 - if (network_service_ && move_comp) { - std::vector packet = SerializationSystem::serialize_entity_spawn(minion.get_id(), move_comp->position, team_id, minion_template); - network_service_->broadcast_packet(packet); + // Add entity state component if not already present + if (!minion->has_component()) { + auto entity_state = std::make_unique(); + entity_state->current_state = EntityState::SPAWNED; + minion->add_component(std::move(entity_state)); } - LOG_INFO("Spawned minion with ID %u for team %d from spawnpoint %u -> %u", minion.get_id(), team_id, spawn_point_id, target_spawnpoint); + // Request initial path to next spawnpoint + uint32_t target_spawnpoint = (spawn_point_id + 1) % map_->spawnpoints.size(); + request_minion_path(*minion, target_spawnpoint); + return true; } diff --git a/src/systems/wave_system.hpp b/src/systems/wave_system.hpp index 61867e3..159dba0 100644 --- a/src/systems/wave_system.hpp +++ b/src/systems/wave_system.hpp @@ -2,31 +2,65 @@ #include #include +#include +#include #include #include #include /** - * System to manage wave spawning and progression. - * Handles the timing and logic for enemy waves in the game. - * Minions spawn and automatically request paths to their target spawnpoints. + * WaveSystem - Manages enemy wave spawning and progression + * + * RESPONSIBILITIES: + * - Spawn minions at regular intervals + * - Track wave progression + * - Process pathfinding results for spawned minions + * - Coordinate with SpawningSystem for entity creation + * + * SYSTEMS USED: + * - SpawningSystem (for entity spawning) + * - NavigationService (for pathfinding) + * + * SYSTEM INTERACTION: + * - Called by GameplayCoordinator via update() + * - Spawns entities at regular intervals + * - Requests paths from NavigationService + * + * USAGE: + * WaveSystem wave_system; + * wave_system.initialize(entity_manager, network_service, navigation_service, map); + * // In game loop: + * wave_system.update(ctx); */ class WaveSystem { public: - WaveSystem(EntityManager* entity_manager, NetworkService* network_service = nullptr, NavigationService* navigation_service = nullptr, const Map* map = nullptr); - /** - * Tick the wave system to update wave state and process pathfinding results. - * @param delta_time_ms Time elapsed since last tick in milliseconds + WaveSystem() = default; + + /** + * Initialize the wave system with required services. + * Must be called before update(). + * @param entity_manager Entity manager for spawning + * @param network_service Network service for broadcasting spawns + * @param navigation_service Navigation service for pathfinding + * @param map Map data for spawnpoints + */ + void initialize(EntityManager* entity_manager, NetworkService* network_service, + NavigationService* navigation_service, const Map* map); + + /** + * Update wave system - spawn minions and process pathfinding results. + * @param ctx System context */ - void tick(float delta_time_ms); + void update(const SystemContext& ctx); private: - EntityManager* entity_manager_; - NetworkService* network_service_; - NavigationService* navigation_service_; - const Map* map_; - float wave_interval_ms; // 30 seconds between waves - float wave_delay_ms; // 1 second delay between minions in a wave + EntityManager* entity_manager_ = nullptr; + NetworkService* network_service_ = nullptr; + NavigationService* navigation_service_ = nullptr; + const Map* map_ = nullptr; + SpawningSystem spawning_system_; + float wave_interval_ms = 30000.0f; // 30 seconds between waves + float wave_delay_ms = 10000.0f; // 1 second delay between minions in a wave float elapsed_time_ms; float last_spawn_timestamp; int minion_index; @@ -37,12 +71,13 @@ class WaveSystem { /** * Try to spawn a minion of the given type. + * @param ctx System context (contains entity manager and network service) * @param minion_template The template name of the minion to spawn * @param team_id The team this minion belongs to * @param spawn_point_id Starting spawnpoint ID (0-indexed) * @return true if minion spawned successfully */ - bool create_minion(const std::string& minion_template, uint8_t team_id, uint32_t spawn_point_id); + bool create_minion(const SystemContext& ctx, const std::string& minion_template, uint8_t team_id, uint32_t spawn_point_id); /** * Request a path for a minion to its target spawnpoint. From ad96a40aedef480a0a98cb041d8d34ea9acf2fb5 Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 17 Nov 2025 23:23:30 +0100 Subject: [PATCH 10/79] Spawn champions --- data/entities/_entity.xsd | 6 ++++-- data/entities/champions/champion.xml | 2 ++ src/components/entity_state.hpp | 1 + src/components/template.hpp | 17 +++++++++++++++++ src/systems/data_loader.cpp | 15 +++++++++++++++ src/systems/entity_manager.hpp | 4 ++++ src/systems/network_sync_system.cpp | 17 +++++++++++++++++ 7 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 src/components/template.hpp diff --git a/data/entities/_entity.xsd b/data/entities/_entity.xsd index c93fce9..ded2d86 100644 --- a/data/entities/_entity.xsd +++ b/data/entities/_entity.xsd @@ -7,7 +7,7 @@ - + @@ -15,6 +15,8 @@ + + @@ -56,7 +58,7 @@ - + diff --git a/data/entities/champions/champion.xml b/data/entities/champions/champion.xml index e60d7fa..844d334 100644 --- a/data/entities/champions/champion.xml +++ b/data/entities/champions/champion.xml @@ -20,4 +20,6 @@ attack_speed="0.625" /> + + diff --git a/src/components/entity_state.hpp b/src/components/entity_state.hpp index 8063a0d..5a495f5 100644 --- a/src/components/entity_state.hpp +++ b/src/components/entity_state.hpp @@ -1,6 +1,7 @@ #pragma once #include "component.hpp" +#include /** * Entity state enumeration. diff --git a/src/components/template.hpp b/src/components/template.hpp new file mode 100644 index 0000000..d563e61 --- /dev/null +++ b/src/components/template.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include + +#include "component.hpp" + +/** + * This component indicates the template from which the entity was created. + * This is used to let client know what archetype to spawn. + */ +class TemplateComponent : public Component { +public: + TemplateComponent(std::string template_id) : template_id(template_id) {}; + std::string template_id; + + COMPONENT_TYPE_ID(TemplateComponent, 2311) +}; \ No newline at end of file diff --git a/src/systems/data_loader.cpp b/src/systems/data_loader.cpp index 34dadee..72c04a5 100644 --- a/src/systems/data_loader.cpp +++ b/src/systems/data_loader.cpp @@ -5,6 +5,8 @@ #include #include #include +#include +#include /** * Convert string to DamageType enum. @@ -91,6 +93,19 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { temp.component_templates.push_back(pathfinding); } + pugi::xml_node networkNode = rootNode.child("network"); + if(networkNode != NULL) { + std::shared_ptr network = std::make_shared(); + network->force_full_sync_next_frame = true; + temp.component_templates.push_back(network); + } + + pugi::xml_node stateNode = rootNode.child("state"); + if(stateNode != NULL) { + std::shared_ptr state = std::make_shared(); + temp.component_templates.push_back(state); + } + pugi::xml_node statsNode = rootNode.child("stats"); if(statsNode != NULL) { std::shared_ptr stats = std::make_shared(); diff --git a/src/systems/entity_manager.hpp b/src/systems/entity_manager.hpp index 5c6f5f3..9700cad 100644 --- a/src/systems/entity_manager.hpp +++ b/src/systems/entity_manager.hpp @@ -6,6 +6,7 @@ #include #include "components/component.hpp" +#include "components/template.hpp" #include /** @@ -160,6 +161,9 @@ class EntityManager { std::unique_ptr comp_copy = comp->clone(); new_entity.add_component(std::move(comp_copy)); } + + new_entity.add_component(std::make_unique(entity_type_id)); + // Register in cache entity_pools_[entity_type_id].push_back(new_entity.get_id()); dirty_entities.erase(std::remove(dirty_entities.begin(), dirty_entities.end(), new_entity.get_id()), dirty_entities.end()); // remove from dirty entities -- cmkrist 15/11/2025 diff --git a/src/systems/network_sync_system.cpp b/src/systems/network_sync_system.cpp index 98d5d86..3155a25 100644 --- a/src/systems/network_sync_system.cpp +++ b/src/systems/network_sync_system.cpp @@ -42,6 +42,23 @@ void NetworkSyncSystem::update(const SystemContext& ctx) { LOG_DEBUG("Skipping sync for entity %u (frame %u)", entity->get_id(), current_frame_); continue; // No changes to sync } + + if(is_first_sync) { + Vec2 spawn_position = Vec2(0, 0); + if(Movement* movement = entity->get_component()) { + spawn_position = movement->position; + } + // TODO what to do with team if there is no stats component? - ploinky 17/11/2025 + uint8_t team_id = 0; + if(Stats* stats = entity->get_component()) { + team_id = stats->team_id; + } + std::string template_id = ""; + if(TemplateComponent* templateComponent = entity->get_component()) { + template_id = templateComponent->template_id; + } + ctx.network_service->broadcast_packet(SerializationSystem::serialize_entity_spawn(entity->get_id(), spawn_position, team_id, template_id)); + } // Serialize entity update bool send_full_state = force_full_sync_next_frame_ || net_comp->force_full_sync_next_frame || is_first_sync; From 2097a339e5051dfd18df9dc53ef3fe649c4473ef Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 17 Nov 2025 23:44:07 +0100 Subject: [PATCH 11/79] Add some comments to entity xsd for clarity --- data/entities/_entity.xsd | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/data/entities/_entity.xsd b/data/entities/_entity.xsd index ded2d86..f100b77 100644 --- a/data/entities/_entity.xsd +++ b/data/entities/_entity.xsd @@ -8,15 +8,24 @@ + + + + + + + + + @@ -60,6 +69,7 @@ + From 2e386131e9381a2f04cc2492a0192b72f13b3209 Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 17 Nov 2025 23:48:54 +0100 Subject: [PATCH 12/79] Update TemplateComponent type id and register in component registry --- src/components/component_registry.hpp | 1 + src/components/template.hpp | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/components/component_registry.hpp b/src/components/component_registry.hpp index 502d277..99ad783 100644 --- a/src/components/component_registry.hpp +++ b/src/components/component_registry.hpp @@ -35,4 +35,5 @@ namespace ComponentTypes { constexpr uint32_t NETWORK_METADATA = 3003; constexpr uint32_t NETWORK_ENTITY = 3004; constexpr uint32_t PLAYER_OWNED = 3005; + constexpr uint32_t TEMPLATE = 3006; } \ No newline at end of file diff --git a/src/components/template.hpp b/src/components/template.hpp index d563e61..91a8b71 100644 --- a/src/components/template.hpp +++ b/src/components/template.hpp @@ -13,5 +13,5 @@ class TemplateComponent : public Component { TemplateComponent(std::string template_id) : template_id(template_id) {}; std::string template_id; - COMPONENT_TYPE_ID(TemplateComponent, 2311) + COMPONENT_TYPE_ID(TemplateComponent, 3006) }; \ No newline at end of file From 51cd08142069c308bb73a33e2953dd05016d1c89 Mon Sep 17 00:00:00 2001 From: ploinky Date: Tue, 18 Nov 2025 00:19:20 +0100 Subject: [PATCH 13/79] Handle player move packet --- src/systems/movement_system.cpp | 39 ++++++++++++++++++++++++++++++++ src/systems/packet_handler.cpp | 30 +++++++++++++++++++++++- src/systems/packet_handler.hpp | 9 ++++++++ src/systems/packet_validator.hpp | 27 ++++++++++++++++++++++ 4 files changed, 104 insertions(+), 1 deletion(-) diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index e346c5f..a4ad915 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -64,6 +64,45 @@ void MovementSystem::update(const SystemContext& ctx) { continue; } + if(EntityStateComponent* state_comp = entity->get_component()) { + if(state_comp->current_state == EntityState::MOVING && !state_comp->target_positions.empty()) { + Vec2 current_pos = movement->position; + Vec2 target_pos = state_comp->target_positions.at(0); + Vec2 direction = target_pos - current_pos; + float distance = direction.length(); + + constexpr float TARGET_THRESHOLD = 0.5f; + + if (distance < TARGET_THRESHOLD) { + // Reached target, delete from target vector + state_comp->target_positions.erase(state_comp->target_positions.begin()); + continue; + } + + // Normalize direction and apply speed + float move_speed = stats->move_speed; + float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); + + Vec2 new_position; + if (distance_to_move >= distance) { + // Move directly to waypoint + new_position = target_pos; + } else { + // Move towards waypoint + Vec2 normalized = direction.normalized(); + new_position = current_pos + (normalized * distance_to_move); + } + + // Check for collision with other entities + if (!has_collision(*entity, new_position, ctx.entity_manager)) { + movement->position = new_position; + } + + continue; + } + } + + // Update stuck detection for entities with pathfinding if (pathfinding) { float delta_time_ms = ctx.delta_time_ms; diff --git a/src/systems/packet_handler.cpp b/src/systems/packet_handler.cpp index 8eb5ff8..7c25eee 100644 --- a/src/systems/packet_handler.cpp +++ b/src/systems/packet_handler.cpp @@ -4,6 +4,7 @@ #include "services/network_service.hpp" #include "systems/packet_validator.hpp" #include "components/readiness.hpp" +#include "components/entity_state.hpp" #include "components/network_metadata.hpp" #include @@ -42,7 +43,9 @@ void PacketHandler::handle_packet(const std::string& client_id, const uint8_t* d case PACKET_TYPE::PLAYER_READY: handle_player_ready_packet(client_id, data, length); break; - + case PACKET_TYPE::PLAYER_MOVE: + handle_player_move_packet(client_id, data, length); + break; default: handle_other_packets(client_id, (uint8_t)packet_type, data, length); break; @@ -70,6 +73,31 @@ bool PacketHandler::handle_player_ready_packet(const std::string& client_id, con return true; } +bool PacketHandler::handle_player_move_packet(const std::string& client_id, const uint8_t* data, size_t length) { + std::optional target_position = PacketValidator::extract_move_target_position(data, length); + + if(!target_position.has_value()) { + LOG_WARN("Received invalid PLAYER_MOVE packet"); + return false; + } + + EntityID ent_id = player_manager_->get_champion_entity_id(player_manager_->get_player_entity_id(client_id), *entity_manager_); + Entity* entity = entity_manager_->get_entity(ent_id); + + if(!entity) { + LOG_WARN("Received valid PLAYER_MOVE packet but client %s does not have a valid entity", client_id); + return false; + } + + if(EntityStateComponent* ent_state = entity->get_component()) { + ent_state->current_state = EntityState::MOVING; + ent_state->target_positions.clear(); + ent_state->target_positions.push_back(target_position.value()); + } + + return true; +} + bool PacketHandler::handle_other_packets(const std::string& client_id, uint8_t packet_type, const uint8_t* data, size_t length) { LOG_WARN("Unhandled packet type: %d from client: %s", (int)packet_type, client_id.c_str()); diff --git a/src/systems/packet_handler.hpp b/src/systems/packet_handler.hpp index ab736e8..900daa8 100644 --- a/src/systems/packet_handler.hpp +++ b/src/systems/packet_handler.hpp @@ -61,6 +61,15 @@ class PacketHandler { */ bool handle_player_ready_packet(const std::string& client_id, const uint8_t* data, size_t length); + /** + * Handle PLAYER_MOVE packet. + * Finds the Players entity and moves it towards the position supplied by the player. + * @param client_id Source client identifier + * @param data Packet bytes + * @param length Packet length in bytes + * @return true if handled successfully + */ + bool handle_player_move_packet(const std::string& client_id, const uint8_t* data, size_t length); /** * Handle other packet types (extensible for future packets). * @param client_id Source client identifier diff --git a/src/systems/packet_validator.hpp b/src/systems/packet_validator.hpp index bb83ac7..989bdeb 100644 --- a/src/systems/packet_validator.hpp +++ b/src/systems/packet_validator.hpp @@ -2,6 +2,7 @@ #include #include +#include /** * Packet type enumeration for network communication. @@ -24,6 +25,8 @@ enum class PACKET_TYPE : uint8_t { // Player related packets PLAYER_READY, PLAYER_DISCONNECT, + // Player actions + PLAYER_MOVE }; /** @@ -41,6 +44,8 @@ class PacketValidator { switch (type) { case PACKET_TYPE::PLAYER_READY: return 2; // type (1) + ready_status (1) + case PACKET_TYPE::PLAYER_MOVE: + return 5; // type (1) + position_x (4) + position_y (4) case PACKET_TYPE::ENTITY_POSITION: return 13; // type (1) + entity_id (4) + position_x (4) + position_y (4) case PACKET_TYPE::ENTITY_SPAWN: @@ -101,4 +106,26 @@ class PacketValidator { out_ready = (packet_data[1] != 0); return true; } + + /** + * Extract and validate player move target from packet. + * @param packet_data Pointer to packet data + * @param packet_length Length of packet data + * @return Vec2 if the target position was extracted, nullopt otherwise + */ + static std::optional extract_move_target_position(const uint8_t* packet_data, size_t packet_length) { + if(!validate_packet(packet_data, packet_length)) { + return std::nullopt; + } + + if((PACKET_TYPE)(packet_data[0]) != PACKET_TYPE::PLAYER_MOVE) { + return std::nullopt; + } + + Vec2 vec{}; + std::memcpy(&vec.x, packet_data + 1, 4); // offset 1 (after packet type) + std::memcpy(&vec.y, packet_data + 5, 4); + + return std::make_optional(vec); + } }; From 0a61055d36e9ab6404b51feea37b49422fd2eb98 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 17 Nov 2025 22:38:14 -0500 Subject: [PATCH 14/79] Add input system to manage player input --- CMakeLists.txt | 2 + src/systems/gameplay_coordinator.cpp | 3 + src/systems/gameplay_coordinator.hpp | 8 +++ src/systems/gameserver.cpp | 3 +- src/systems/input_system.cpp | 49 ++++++++++++++++ src/systems/input_system.hpp | 85 ++++++++++++++++++++++++++++ src/systems/packet_handler.cpp | 21 ++++--- src/systems/packet_handler.hpp | 6 +- src/systems/system_context.hpp | 2 + 9 files changed, 169 insertions(+), 10 deletions(-) create mode 100644 src/systems/input_system.cpp create mode 100644 src/systems/input_system.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index cfed164..dae5374 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -56,6 +56,7 @@ set(GAMESERVER_SOURCES src/services/network_service.cpp src/systems/data_loader.cpp src/systems/gameserver.cpp + src/systems/input_system.cpp src/systems/map_system.cpp src/systems/combat_system.cpp src/systems/movement_system.cpp @@ -94,6 +95,7 @@ set(GAMESERVER_HEADERS src/systems/wave_system.hpp src/systems/network_sync_system.hpp src/systems/player_manager.hpp + src/systems/input_system.hpp src/systems/system_context.hpp src/systems/packet_handler.hpp src/systems/gameplay_coordinator.hpp diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index b47782b..347937b 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -15,6 +15,9 @@ void GameplayCoordinator::initialize_wave_system(EntityManager* entity_manager, void GameplayCoordinator::update(const SystemContext& ctx) { // Execute systems in dependency order + // INPUT SYSTEMS + input_system_.update(ctx); + // ENGINE SYSTEMS wave_system_->update(ctx); diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index 6393bc3..73a12d7 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -1,6 +1,7 @@ #pragma once #include "system_context.hpp" +#include "input_system.hpp" #include "wave_system.hpp" #include "movement_system.hpp" #include "network_sync_system.hpp" @@ -68,6 +69,12 @@ class GameplayCoordinator { */ void update(const SystemContext& ctx); + /** + * Get reference to input system. + * @return Reference to InputSystem + */ + InputSystem& get_input_system() { return input_system_; } + /** * Get reference to wave system (for direct initialization if needed). * @return Reference to WaveSystem @@ -93,6 +100,7 @@ class GameplayCoordinator { CombatSystem& get_combat_system() { return combat_system_; } private: + InputSystem input_system_; std::unique_ptr wave_system_; MovementSystem movement_system_; NetworkSyncSystem network_sync_system_; diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index 9e8e775..e41d2d3 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -23,7 +23,7 @@ GameServer::GameServer(int port, int max_clients, const std::string& map_path) , current_state_(GAME_STATE::PREGAME) , network_service_(NetworkService(port, max_clients)) , player_manager_() - , packet_handler_(&player_manager_, &entity_manager_, &network_service_) + , packet_handler_(&player_manager_, &entity_manager_, &network_service_, &gameplay_.get_input_system()) , gameplay_() { } @@ -87,6 +87,7 @@ void GameServer::frame_tick() { // Create system context with all services SystemContext ctx(entity_manager_); + ctx.input_system = &gameplay_.get_input_system(); ctx.navigation_service = navigation_service_.get(); ctx.network_service = &network_service_; ctx.map = map_pointer_.get(); diff --git a/src/systems/input_system.cpp b/src/systems/input_system.cpp new file mode 100644 index 0000000..bd0bb06 --- /dev/null +++ b/src/systems/input_system.cpp @@ -0,0 +1,49 @@ +#include "input_system.hpp" +#include "entity_manager.hpp" +#include "components/entity_state.hpp" +#include + +void InputSystem::queue_movement_input(EntityID entity_id, const Vec2& target_position) { + movement_inputs_.push({entity_id, target_position}); + LOG_DEBUG("Queued movement input for entity %u to (%.2f, %.2f)", entity_id, target_position.x, target_position.y); +} + +void InputSystem::update(const SystemContext& ctx) { + // Process all queued inputs + while (!movement_inputs_.empty()) { + const MovementInput& input = movement_inputs_.front(); + + Entity* entity = ctx.entity_manager.get_entity(input.entity_id); + if (!entity) { + LOG_WARN("Movement input for non-existent entity %u", input.entity_id); + movement_inputs_.pop(); + continue; + } + + if (process_movement_input(*entity, input.target_position)) { + LOG_DEBUG("Successfully processed movement input for entity %u", input.entity_id); + } else { + LOG_WARN("Failed to process movement input for entity %u", input.entity_id); + } + + movement_inputs_.pop(); + } +} + +bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_position) { + EntityStateComponent* ent_state = entity.get_component(); + + if (!ent_state) { + LOG_WARN("Entity %u missing EntityStateComponent", entity.get_id()); + return false; + } + + // Queue the movement target + ent_state->current_state = EntityState::MOVING; + ent_state->target_positions.clear(); + ent_state->target_positions.push_back(target_position); + + LOG_INFO("Entity %u queued to move to (%.2f, %.2f)", entity.get_id(), target_position.x, target_position.y); + + return true; +} diff --git a/src/systems/input_system.hpp b/src/systems/input_system.hpp new file mode 100644 index 0000000..ea414b7 --- /dev/null +++ b/src/systems/input_system.hpp @@ -0,0 +1,85 @@ +#pragma once + +#include "system_context.hpp" +#include "math.hpp" +#include +#include + +struct Entity; +typedef uint32_t EntityID; + +/** + * InputSystem - Processes player input and translates it into entity actions + * + * RESPONSIBILITIES: + * - Queue and process movement input from players + * - Translate input into entity state changes and target positions + * - Validate input against entity and game state + * - Coordinate with MovementSystem for execution + * + * ARCHITECTURE: + * PacketHandler -> InputSystem -> MovementSystem + * + * - PacketHandler: Validates network packets + * - InputSystem: Processes input logic and queues actions + * - MovementSystem: Executes movement and pathfinding + * + * USAGE: + * InputSystem input_system; + * // When packet arrives: + * input_system.queue_movement_input(entity_id, target_position); + * // In game loop: + * input_system.update(ctx); + */ +class InputSystem { +public: + InputSystem() = default; + ~InputSystem() = default; + + // Prevent copying + InputSystem(const InputSystem&) = delete; + InputSystem& operator=(const InputSystem&) = delete; + + // Allow moving + InputSystem(InputSystem&&) = default; + InputSystem& operator=(InputSystem&&) = default; + + /** + * Queue a movement input for an entity. + * Called by PacketHandler when receiving PLAYER_MOVE packets. + * + * @param entity_id ID of the entity to move + * @param target_position Target position to move to + */ + void queue_movement_input(EntityID entity_id, const Vec2& target_position); + + /** + * Process all queued inputs and apply them to entities. + * Called once per game frame by GameplayCoordinator. + * + * @param ctx System context containing entity manager + */ + void update(const SystemContext& ctx); + +private: + /** + * Movement input request + */ + struct MovementInput { + EntityID entity_id; + Vec2 target_position; + }; + + // Queue of pending movement inputs + std::queue movement_inputs_; + + /** + * Process a single movement input request. + * Applies the movement to the entity's state. + * + * @param entity Entity to move + * @param target_position Target position + * @return true if input was processed successfully + */ + static bool process_movement_input(Entity& entity, const Vec2& target_position); +}; diff --git a/src/systems/packet_handler.cpp b/src/systems/packet_handler.cpp index 7c25eee..9e52469 100644 --- a/src/systems/packet_handler.cpp +++ b/src/systems/packet_handler.cpp @@ -1,6 +1,7 @@ #include "packet_handler.hpp" #include "player_manager.hpp" #include "entity_manager.hpp" +#include "input_system.hpp" #include "services/network_service.hpp" #include "systems/packet_validator.hpp" #include "components/readiness.hpp" @@ -10,10 +11,12 @@ PacketHandler::PacketHandler(PlayerManager* player_manager, EntityManager* entity_manager, - NetworkService* network_service) + NetworkService* network_service, + InputSystem* input_system) : player_manager_(player_manager) , entity_manager_(entity_manager) - , network_service_(network_service) { + , network_service_(network_service) + , input_system_(input_system) { } void PacketHandler::handle_packet(const std::string& client_id, const uint8_t* data, size_t length) { @@ -89,13 +92,15 @@ bool PacketHandler::handle_player_move_packet(const std::string& client_id, cons return false; } - if(EntityStateComponent* ent_state = entity->get_component()) { - ent_state->current_state = EntityState::MOVING; - ent_state->target_positions.clear(); - ent_state->target_positions.push_back(target_position.value()); + // Queue the movement input through InputSystem + if (input_system_) { + input_system_->queue_movement_input(ent_id, target_position.value()); + LOG_DEBUG("Queued movement input for entity %u from client %s", ent_id, client_id.c_str()); + return true; + } else { + LOG_ERROR("InputSystem not initialized"); + return false; } - - return true; } bool PacketHandler::handle_other_packets(const std::string& client_id, uint8_t packet_type, diff --git a/src/systems/packet_handler.hpp b/src/systems/packet_handler.hpp index 900daa8..7b9dede 100644 --- a/src/systems/packet_handler.hpp +++ b/src/systems/packet_handler.hpp @@ -6,6 +6,7 @@ class EntityManager; class PlayerManager; class NetworkService; +class InputSystem; /** * PacketHandler - Centralized packet processing @@ -32,10 +33,12 @@ class PacketHandler { * @param player_manager Pointer to PlayerManager for player state updates * @param entity_manager Pointer to EntityManager for entity access * @param network_service Pointer to NetworkService for packet broadcasting + * @param input_system Pointer to InputSystem for queueing player input */ PacketHandler(PlayerManager* player_manager, EntityManager* entity_manager, - NetworkService* network_service); + NetworkService* network_service, + InputSystem* input_system); /** * Process an incoming packet from a client. @@ -50,6 +53,7 @@ class PacketHandler { PlayerManager* player_manager_; EntityManager* entity_manager_; NetworkService* network_service_; + InputSystem* input_system_; /** * Handle PLAYER_READY packet. diff --git a/src/systems/system_context.hpp b/src/systems/system_context.hpp index d378e71..bdce8c8 100644 --- a/src/systems/system_context.hpp +++ b/src/systems/system_context.hpp @@ -6,6 +6,7 @@ // Forward declarations to avoid circular dependencies class NavigationService; class NetworkService; +class InputSystem; struct Map; /** @@ -38,6 +39,7 @@ struct SystemContext { EntityManager& entity_manager; // Required: access to all entities // === Optional Services === + InputSystem* input_system = nullptr; // For processing player input NavigationService* navigation_service = nullptr; // For pathfinding requests NetworkService* network_service = nullptr; // For network broadcasting const Map* map = nullptr; // For map data queries From e4793804ec77c4b5990a8bcdfea2ef84e50d8d2c Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 00:05:41 -0500 Subject: [PATCH 15/79] Move collisions to new system --- CMakeLists.txt | 2 + src/systems/collision_system.cpp | 179 +++++++++++++++++++++++++++ src/systems/collision_system.hpp | 102 +++++++++++++++ src/systems/gameplay_coordinator.cpp | 7 +- src/systems/gameplay_coordinator.hpp | 13 +- src/systems/movement_system.cpp | 30 ++--- 6 files changed, 306 insertions(+), 27 deletions(-) create mode 100644 src/systems/collision_system.cpp create mode 100644 src/systems/collision_system.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index dae5374..12a4d2a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,6 +57,7 @@ set(GAMESERVER_SOURCES src/systems/data_loader.cpp src/systems/gameserver.cpp src/systems/input_system.cpp + src/systems/collision_system.cpp src/systems/map_system.cpp src/systems/combat_system.cpp src/systems/movement_system.cpp @@ -96,6 +97,7 @@ set(GAMESERVER_HEADERS src/systems/network_sync_system.hpp src/systems/player_manager.hpp src/systems/input_system.hpp + src/systems/collision_system.hpp src/systems/system_context.hpp src/systems/packet_handler.hpp src/systems/gameplay_coordinator.hpp diff --git a/src/systems/collision_system.cpp b/src/systems/collision_system.cpp new file mode 100644 index 0000000..3845d61 --- /dev/null +++ b/src/systems/collision_system.cpp @@ -0,0 +1,179 @@ +#include "collision_system.hpp" +#include "entity_manager.hpp" +#include "components/movement.hpp" +#include +#include + +void CollisionSystem::update(const SystemContext& ctx) { + // Get all entities with movement components + auto moving_entities = ctx.entity_manager.get_entities_with_component(); + + // Check all pairs of entities for collisions + for (size_t i = 0; i < moving_entities.size(); ++i) { + Entity* entity_a = moving_entities[i]; + Movement* move_a = entity_a->get_component(); + + if (!move_a) continue; + + float radius_a = move_a->collision_radius; + + // Check against all other entities + for (size_t j = i + 1; j < moving_entities.size(); ++j) { + Entity* entity_b = moving_entities[j]; + Movement* move_b = entity_b->get_component(); + + if (!move_b) continue; + + float radius_b = move_b->collision_radius; + float min_distance = radius_a + radius_b; + + float actual_distance = distance(move_a->position, move_b->position); + + // If entities are overlapping, push them apart + if (actual_distance < min_distance) { + // Calculate separation direction + Vec2 separation = (move_b->position - move_a->position); + if (actual_distance > 0.001f) { + separation = separation.normalized(); + } else { + // Fallback if entities are at exact same position + separation = Vec2(1.0f, 0.0f); + } + + float overlap = min_distance - actual_distance; + float push_per_entity = overlap / 2.0f + 0.001f; // Split push equally, add small buffer + + // Push both entities apart + move_a->position = move_a->position - (separation * push_per_entity); + move_b->position = move_b->position + (separation * push_per_entity); + + LOG_DEBUG("Separated entities %u and %u by %.3f units", + entity_a->get_id(), entity_b->get_id(), overlap); + } + } + } +} + +bool CollisionSystem::would_collide(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager) { + const Movement* entity_move = entity.get_component(); + if (!entity_move) { + return false; + } + + float entity_radius = entity_move->collision_radius; + + // Check collision with all other moving entities + auto moving_entities = entity_manager.get_entities_with_component(); + for (auto* other_entity : moving_entities) { + if (other_entity->get_id() == entity.get_id()) { + continue; // Skip self + } + + const Movement* other_move = other_entity->get_component(); + if (!other_move) { + continue; + } + + float other_radius = other_move->collision_radius; + float min_distance = entity_radius + other_radius; + + float actual_distance = distance(proposed_position, other_move->position); + + if (actual_distance < min_distance) { + return true; // Collision detected + } + } + + return false; // No collision +} + +Entity* CollisionSystem::get_colliding_entity(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager) { + const Movement* entity_move = entity.get_component(); + if (!entity_move) { + return nullptr; + } + + float entity_radius = entity_move->collision_radius; + + // Check collision with all other moving entities + auto moving_entities = entity_manager.get_entities_with_component(); + for (auto* other_entity : moving_entities) { + if (other_entity->get_id() == entity.get_id()) { + continue; // Skip self + } + + const Movement* other_move = other_entity->get_component(); + if (!other_move) { + continue; + } + + float other_radius = other_move->collision_radius; + float min_distance = entity_radius + other_radius; + + float actual_distance = distance(proposed_position, other_move->position); + + if (actual_distance < min_distance) { + return other_entity; // Return first colliding entity + } + } + + return nullptr; // No collision +} + +void CollisionSystem::push_entity(Entity& pushed_entity, const Vec2& push_direction, float push_distance) { + Movement* move = pushed_entity.get_component(); + if (!move) { + return; + } + + move->position = move->position + (push_direction * push_distance); + LOG_DEBUG("Pushed entity %u by %.3f units", pushed_entity.get_id(), push_distance); +} + +void CollisionSystem::push_colliding_entities(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager) { + const Movement* entity_move = entity.get_component(); + if (!entity_move) { + return; + } + + float entity_radius = entity_move->collision_radius; + Vec2 current_pos = entity_move->position; + Vec2 push_direction = (proposed_position - current_pos); + + if (push_direction.length() > 0.001f) { + push_direction = push_direction.normalized(); + } else { + return; // No movement, nothing to push + } + + // Find and push all colliding entities + auto moving_entities = entity_manager.get_entities_with_component(); + for (auto* other_entity : moving_entities) { + if (other_entity->get_id() == entity.get_id()) { + continue; // Skip self + } + + Movement* other_move = other_entity->get_component(); + if (!other_move) { + continue; + } + + float other_radius = other_move->collision_radius; + float min_distance = entity_radius + other_radius; + + // Check if this entity is colliding with the proposed position + float actual_distance = distance(proposed_position, other_move->position); + + if (actual_distance < min_distance) { + // Push the other entity in the direction of movement + float push_distance = min_distance - actual_distance + 0.01f; // Small buffer to separate them + push_entity(*other_entity, push_direction, push_distance); + } + } +} + +float CollisionSystem::distance(const Vec2& a, const Vec2& b) { + float dx = a.x - b.x; + float dy = a.y - b.y; + return std::sqrt(dx * dx + dy * dy); +} diff --git a/src/systems/collision_system.hpp b/src/systems/collision_system.hpp new file mode 100644 index 0000000..8191e67 --- /dev/null +++ b/src/systems/collision_system.hpp @@ -0,0 +1,102 @@ +#pragma once + +#include "system_context.hpp" +#include + +/** + * CollisionSystem - Handles entity collision detection and response + * + * RESPONSIBILITIES: + * - Detect collisions between moving entities + * - Push entities out of collision when they intersect + * - Report collision events + * - Prevent entities from overlapping + * + * FEATURES: + * - Circle-based collision detection (using collision_radius) + * - Elastic collision response (pushing entities apart) + * - Works with Movement component's collision_radius + * + * USAGE: + * CollisionSystem collision_system; + * // In game loop: + * collision_system.update(ctx); + * + * SYSTEM INTERACTION: + * - Runs before MovementSystem to prevent overlaps before they happen + * - Can be used independently or as part of GameplayCoordinator + * - Respects entity movement and collision radius + */ +class CollisionSystem { +public: + CollisionSystem() = default; + ~CollisionSystem() = default; + + // Prevent copying + CollisionSystem(const CollisionSystem&) = delete; + CollisionSystem& operator=(const CollisionSystem&) = delete; + + // Allow moving + CollisionSystem(CollisionSystem&&) = default; + CollisionSystem& operator=(CollisionSystem&&) = default; + + /** + * Update collision detection and response for all entities. + * Detects overlapping entities and pushes them apart. + * + * @param ctx System context containing entity manager + */ + void update(const SystemContext& ctx); + + /** + * Check if a position would collide with any other entity. + * Does not perform response, only detection. + * + * @param entity The entity to check collisions for + * @param proposed_position The position to check + * @param entity_manager Reference to entity manager + * @return true if collision would occur at proposed position + */ + static bool would_collide(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager); + + /** + * Get the first entity that would collide at a position. + * Useful for checking what specifically is blocking movement. + * + * @param entity The entity to check collisions for + * @param proposed_position The position to check + * @param entity_manager Reference to entity manager + * @return Entity pointer if collision found, nullptr otherwise + */ + static Entity* get_colliding_entity(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager); + + /** + * Push an entity away from another entity. + * Moves the pushed entity along the separation direction. + * + * @param entity The entity doing the pushing + * @param pushed_entity The entity being pushed + * @param push_direction Direction to push (usually direction of pushing entity's movement) + * @param push_distance How far to push + */ + static void push_entity(Entity& pushed_entity, const Vec2& push_direction, float push_distance); + + /** + * Push all entities colliding at a position away from it. + * When an entity moves into other entities, pushes all of them along the movement direction. + * + * @param entity The entity doing the pushing + * @param proposed_position The position being moved into + * @param entity_manager Reference to entity manager for finding colliding entities + */ + static void push_colliding_entities(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager); + +private: + /** + * Calculate distance between two 2D points. + * @param a First point + * @param b Second point + * @return Distance + */ + static float distance(const Vec2& a, const Vec2& b); +}; diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index 347937b..55cf471 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -21,11 +21,14 @@ void GameplayCoordinator::update(const SystemContext& ctx) { // ENGINE SYSTEMS wave_system_->update(ctx); - // ENTITY SYSTEMS + // MOVEMENT & PHYSICS SYSTEMS movement_system_.update(ctx); + collision_system_.update(ctx); + + // COMBAT SYSTEMS combat_system_.update(ctx); // PLAYER SYSTEMS - // 5. Synchronize to clients + // 6. Synchronize to clients network_sync_system_.update(ctx); } diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index 73a12d7..46db4ba 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -2,6 +2,7 @@ #include "system_context.hpp" #include "input_system.hpp" +#include "collision_system.hpp" #include "wave_system.hpp" #include "movement_system.hpp" #include "network_sync_system.hpp" @@ -23,8 +24,9 @@ * SYSTEM UPDATE ORDER (important for correctness): * 1. WaveSystem - Spawns new entities for this frame * 2. MovementSystem - Updates entity positions based on paths - * 3. CombatSystem - Resolves damage and effects - * 4. NetworkSyncSystem - Sends state updates to clients + * 3. CollisionSystem - Resolves overlaps and pushes entities apart + * 4. CombatSystem - Resolves damage and effects + * 5. NetworkSyncSystem - Sends state updates to clients * * USAGE: * GameplayCoordinator gameplay; @@ -81,6 +83,12 @@ class GameplayCoordinator { */ WaveSystem& get_wave_system() { return *wave_system_; } + /** + * Get reference to collision system. + * @return Reference to CollisionSystem + */ + CollisionSystem& get_collision_system() { return collision_system_; } + /** * Get reference to movement system. * @return Reference to MovementSystem @@ -102,6 +110,7 @@ class GameplayCoordinator { private: InputSystem input_system_; std::unique_ptr wave_system_; + CollisionSystem collision_system_; MovementSystem movement_system_; NetworkSyncSystem network_sync_system_; CombatSystem combat_system_; diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index a4ad915..dc31c22 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -1,4 +1,5 @@ #include "movement_system.hpp" +#include "collision_system.hpp" #include "entity_manager.hpp" #include "services/navigation_service.hpp" #include @@ -93,10 +94,8 @@ void MovementSystem::update(const SystemContext& ctx) { new_position = current_pos + (normalized * distance_to_move); } - // Check for collision with other entities - if (!has_collision(*entity, new_position, ctx.entity_manager)) { - movement->position = new_position; - } + // Always move - CollisionSystem runs after to handle any overlaps + movement->position = new_position; continue; } @@ -195,26 +194,11 @@ void MovementSystem::update(const SystemContext& ctx) { new_position = current_pos + (normalized * distance_to_move); } - // Check for collision with other entities - if (!has_collision(*entity, new_position, ctx.entity_manager)) { - movement->position = new_position; - } else { - // If direct path is blocked, try to move sideways to avoid collision - // TODO: Make this better with proper pathfinding around obstacles - // Maybe move to nearest point along a circle around the obstacle, then recalculate path? - Vec2 perpendicular = Vec2(-direction.y, direction.x).normalized(); - Vec2 sideways_left = current_pos + (perpendicular * distance_to_move); - Vec2 sideways_right = current_pos + (perpendicular * -distance_to_move); - - if (!has_collision(*entity, sideways_left, ctx.entity_manager)) { - movement->position = sideways_left; - } else if (!has_collision(*entity, sideways_right, ctx.entity_manager)) { - movement->position = sideways_right; - } - // If both sideways moves are blocked, just don't move (will accumulate stuck time) - } + // Always move - CollisionSystem runs after to handle any overlaps + movement->position = new_position; } } + } bool MovementSystem::has_collision(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager) { @@ -287,4 +271,4 @@ void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint pathfinding->target_spawnpoint_id = target_spawnpoint_id; LOG_DEBUG("Minion %u requested path to spawnpoint %u", entity.get_id(), target_spawnpoint_id); } -} +} \ No newline at end of file From 9aa94967b72ea053907a8e66be9c4c40104fd623 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 00:12:47 -0500 Subject: [PATCH 16/79] Movement System Refactor for Readability --- src/systems/movement_system.cpp | 389 ++++++++++++++++++-------------- src/systems/movement_system.hpp | 54 +++++ 2 files changed, 271 insertions(+), 172 deletions(-) diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index dc31c22..2bdaac6 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -8,199 +8,229 @@ #include #include +// ============================================================================ +// Constants +// ============================================================================ +namespace { + constexpr float TARGET_THRESHOLD = 0.5f; + constexpr float WAYPOINT_THRESHOLD = 0.5f; + constexpr float STUCK_DETECTION_THRESHOLD = 0.01f; +} + +// ============================================================================ +// Movement System Implementation +// ============================================================================ + void MovementSystem::update(const SystemContext& ctx) { - // Process pathfinding results for waiting entities - if (ctx.navigation_service) { - std::optional result = ctx.navigation_service->GetResult(); - while (result) { - Entity* entity = ctx.entity_manager.get_entity(result->entity_id); - LOG_INFO("Got pathfinding result for entity %u, path size=%zu", result->entity_id, result->path.size()); - if (entity && entity->has_component()) { - PathfindingComponent* pathfinding = entity->get_component(); - EntityStateComponent* entity_state = entity->get_component(); - - pathfinding->waypoints = result->path; - pathfinding->current_waypoint_index = 0; - - if (result->path.empty()) { - LOG_WARN("Entity %u received EMPTY path!", entity->get_id()); - } else { - LOG_INFO("Entity %u received path with %zu waypoints, transitioning to MOVING", - entity->get_id(), result->path.size()); - // Transition to MOVING state when path is received - if (entity_state) { - entity_state->current_state = EntityState::MOVING; - entity_state->state_duration_ms = 0.0f; - LOG_INFO("Entity %u state transitioned to MOVING (state=%d)", entity->get_id(), (int)entity_state->current_state); - } - } - } - result = ctx.navigation_service->GetResult(); - } + // Phase 1: Process pathfinding results and retry requests + process_pathfinding_phase(ctx); + + // Phase 2: Update all moving entities + auto moving_entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : moving_entities) { + update_entity_movement(ctx, *entity); } +} + +void MovementSystem::process_pathfinding_phase(const SystemContext& ctx) { + if (!ctx.navigation_service) return; + + // Process completed pathfinding results + process_completed_paths(ctx); - // Retry pending pathfinding requests (entities waiting for paths) - if (ctx.navigation_service) { - auto entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : entities) { - PathfindingComponent* pathfinding = entity->get_component(); - EntityStateComponent* entity_state = entity->get_component(); - if (pathfinding && entity_state && - entity_state->current_state == EntityState::PATHFINDING_WAITING && - pathfinding->waypoints.empty()) { - request_new_path(*entity, pathfinding->target_spawnpoint_id, ctx.navigation_service, ctx.map); + // Retry pending pathfinding requests + retry_stuck_entities(ctx); +} + +void MovementSystem::process_completed_paths(const SystemContext& ctx) { + std::optional result = ctx.navigation_service->GetResult(); + while (result) { + Entity* entity = ctx.entity_manager.get_entity(result->entity_id); + if (!entity || !entity->has_component()) { + result = ctx.navigation_service->GetResult(); + continue; + } + + PathfindingComponent* pathfinding = entity->get_component(); + EntityStateComponent* entity_state = entity->get_component(); + + pathfinding->waypoints = result->path; + pathfinding->current_waypoint_index = 0; + + if (result->path.empty()) { + LOG_WARN("Entity %u received EMPTY path!", entity->get_id()); + } else { + LOG_INFO("Entity %u received path with %zu waypoints", entity->get_id(), result->path.size()); + if (entity_state) { + entity_state->current_state = EntityState::MOVING; + entity_state->state_duration_ms = 0.0f; } } + + result = ctx.navigation_service->GetResult(); } +} - // Get all entities with movement components - auto moving_entities = ctx.entity_manager.get_entities_with_component(); - - for (auto* entity : moving_entities) { - Movement* movement = entity->get_component(); +void MovementSystem::retry_stuck_entities(const SystemContext& ctx) { + auto entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : entities) { PathfindingComponent* pathfinding = entity->get_component(); - Stats* stats = entity->get_component(); + EntityStateComponent* entity_state = entity->get_component(); - if (!movement || !stats) { - continue; + if (pathfinding && entity_state && + entity_state->current_state == EntityState::PATHFINDING_WAITING && + pathfinding->waypoints.empty()) { + request_new_path(*entity, pathfinding->target_spawnpoint_id, ctx.navigation_service, ctx.map); } + } +} - if(EntityStateComponent* state_comp = entity->get_component()) { - if(state_comp->current_state == EntityState::MOVING && !state_comp->target_positions.empty()) { - Vec2 current_pos = movement->position; - Vec2 target_pos = state_comp->target_positions.at(0); - Vec2 direction = target_pos - current_pos; - float distance = direction.length(); - - constexpr float TARGET_THRESHOLD = 0.5f; - - if (distance < TARGET_THRESHOLD) { - // Reached target, delete from target vector - state_comp->target_positions.erase(state_comp->target_positions.begin()); - continue; - } - - // Normalize direction and apply speed - float move_speed = stats->move_speed; - float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); - - Vec2 new_position; - if (distance_to_move >= distance) { - // Move directly to waypoint - new_position = target_pos; - } else { - // Move towards waypoint - Vec2 normalized = direction.normalized(); - new_position = current_pos + (normalized * distance_to_move); - } - - // Always move - CollisionSystem runs after to handle any overlaps - movement->position = new_position; - - continue; - } - } +void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& entity) { + Movement* movement = entity.get_component(); + PathfindingComponent* pathfinding = entity.get_component(); + Stats* stats = entity.get_component(); + EntityStateComponent* state_comp = entity.get_component(); + + if (!movement || !stats) return; + + // Update direct movement targets (players, point-based movement) + if (state_comp && state_comp->current_state == EntityState::MOVING && + !state_comp->target_positions.empty()) { + update_direct_movement(ctx, entity, *movement, *stats, *state_comp); + return; + } + + // Update pathfinding entities (minions following waypoints) + if (pathfinding) { + update_stuck_detection(ctx, entity, *movement, *pathfinding, state_comp); + update_waypoint_movement(ctx, entity, *movement, *stats, *pathfinding, state_comp); + } +} +void MovementSystem::update_direct_movement(const SystemContext& ctx, Entity& entity, + Movement& movement, Stats& stats, EntityStateComponent& state_comp) { + Vec2 current_pos = movement.position; + Vec2 target_pos = state_comp.target_positions.at(0); + Vec2 direction = target_pos - current_pos; + float distance = direction.length(); + + // Check if reached target + if (distance < TARGET_THRESHOLD) { + state_comp.target_positions.erase(state_comp.target_positions.begin()); + return; + } + + // Calculate new position based on speed + float move_speed = stats.move_speed; + float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); + + Vec2 new_position = (distance_to_move >= distance) + ? target_pos + : current_pos + (direction.normalized() * distance_to_move); + + movement.position = new_position; +} - // Update stuck detection for entities with pathfinding - if (pathfinding) { - float delta_time_ms = ctx.delta_time_ms; - EntityStateComponent* entity_state = entity->get_component(); - // Check if entity has moved since last frame - float movement_distance = distance(movement->position, pathfinding->last_position); - - if (movement_distance < 0.01f) { - // Entity hasn't moved - accumulate stuck time - pathfinding->stuck_time_ms += delta_time_ms; - - // If stuck too long and not already waiting for path, request new one - if (pathfinding->stuck_time_ms >= PathfindingComponent::STUCK_THRESHOLD_MS && - entity_state && entity_state->current_state == EntityState::MOVING && - !pathfinding->waypoints.empty()) { - LOG_DEBUG("Minion %u is stuck, requesting new path", entity->get_id()); - if (ctx.navigation_service && ctx.map && pathfinding->target_spawnpoint_id < ctx.map->spawnpoints.size()) { - request_new_path(*entity, pathfinding->target_spawnpoint_id, ctx.navigation_service, ctx.map); - // Transition to waiting state - if (entity_state) { - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - } - pathfinding->waypoints.clear(); - pathfinding->current_waypoint_index = 0; - } - } else { - // Entity moved - reset stuck timer - pathfinding->stuck_time_ms = 0.0f; - } - - // Update last position for next frame - pathfinding->last_position = movement->position; - } +void MovementSystem::update_stuck_detection(const SystemContext& ctx, Entity& entity, + Movement& movement, PathfindingComponent& pathfinding, + EntityStateComponent* entity_state) { + float movement_distance = distance(movement.position, pathfinding.last_position); + + if (movement_distance < STUCK_DETECTION_THRESHOLD) { + // Entity hasn't moved - accumulate stuck time + pathfinding.stuck_time_ms += ctx.delta_time_ms; - // If entity has pathfinding, move along the path (but not while waiting for new path) - if (pathfinding && !pathfinding->waypoints.empty()) { - EntityStateComponent* entity_state = entity->get_component(); - - // Only move if in MOVING state - if (!entity_state || entity_state->current_state != EntityState::MOVING) { - continue; - } - - // Get current waypoint - if (pathfinding->current_waypoint_index >= pathfinding->waypoints.size()) { - // Reached end of path - request path to next spawnpoint if possible - if (ctx.map && pathfinding->target_spawnpoint_id < ctx.map->spawnpoints.size()) { - uint32_t next_spawnpoint = (pathfinding->target_spawnpoint_id + 1) % ctx.map->spawnpoints.size(); - if (ctx.navigation_service && entity_state) { - request_new_path(*entity, next_spawnpoint, ctx.navigation_service, ctx.map); - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - } - pathfinding->waypoints.clear(); - pathfinding->current_waypoint_index = 0; - continue; - } + // Check if stuck long enough to request new path + if (pathfinding.stuck_time_ms >= PathfindingComponent::STUCK_THRESHOLD_MS && + entity_state && entity_state->current_state == EntityState::MOVING && + !pathfinding.waypoints.empty() && ctx.navigation_service && ctx.map && + pathfinding.target_spawnpoint_id < ctx.map->spawnpoints.size()) { - Vec3 current_waypoint = pathfinding->waypoints[pathfinding->current_waypoint_index]; - Vec2 waypoint_2d = Vec2(current_waypoint.x, current_waypoint.z); - Vec2 current_pos = movement->position; + LOG_DEBUG("Entity %u is stuck, requesting new path", entity.get_id()); + request_new_path(entity, pathfinding.target_spawnpoint_id, ctx.navigation_service, ctx.map); - // Calculate direction to waypoint - Vec2 direction = waypoint_2d - current_pos; - float distance = direction.length(); - - // Waypoint threshold for progress - constexpr float WAYPOINT_THRESHOLD = 0.5f; - - if (distance < WAYPOINT_THRESHOLD) { - // Reached waypoint, move to next one - pathfinding->current_waypoint_index++; - continue; - } - - // Normalize direction and apply speed - float move_speed = stats->move_speed; - float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); - - Vec2 new_position; - if (distance_to_move >= distance) { - // Move directly to waypoint - new_position = waypoint_2d; - } else { - // Move towards waypoint - Vec2 normalized = direction.normalized(); - new_position = current_pos + (normalized * distance_to_move); + if (entity_state) { + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; } - - // Always move - CollisionSystem runs after to handle any overlaps - movement->position = new_position; + pathfinding.waypoints.clear(); + pathfinding.current_waypoint_index = 0; } + } else { + // Entity moved - reset stuck timer + pathfinding.stuck_time_ms = 0.0f; + } + + // Update last position for next frame + pathfinding.last_position = movement.position; +} + +void MovementSystem::update_waypoint_movement(const SystemContext& ctx, Entity& entity, + Movement& movement, Stats& stats, + PathfindingComponent& pathfinding, + EntityStateComponent* entity_state) { + // Skip if waiting for pathfinding or no waypoints + if (!pathfinding.waypoints.size() || + !entity_state || entity_state->current_state != EntityState::MOVING) { + return; + } + + // Check if reached end of path + if (pathfinding.current_waypoint_index >= pathfinding.waypoints.size()) { + request_path_to_next_spawnpoint(ctx, entity, pathfinding, entity_state); + return; + } + + // Move toward current waypoint + Vec3 current_waypoint = pathfinding.waypoints[pathfinding.current_waypoint_index]; + Vec2 waypoint_2d = Vec2(current_waypoint.x, current_waypoint.z); + Vec2 current_pos = movement.position; + Vec2 direction = waypoint_2d - current_pos; + float distance = direction.length(); + + // Check if reached waypoint + if (distance < WAYPOINT_THRESHOLD) { + pathfinding.current_waypoint_index++; + return; + } + + // Calculate new position based on speed + float move_speed = stats.move_speed; + float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); + + Vec2 new_position = (distance_to_move >= distance) + ? waypoint_2d + : current_pos + (direction.normalized() * distance_to_move); + + movement.position = new_position; +} + +void MovementSystem::request_path_to_next_spawnpoint(const SystemContext& ctx, Entity& entity, + PathfindingComponent& pathfinding, + EntityStateComponent* entity_state) { + if (!ctx.map || pathfinding.target_spawnpoint_id >= ctx.map->spawnpoints.size()) { + return; + } + + uint32_t next_spawnpoint = (pathfinding.target_spawnpoint_id + 1) % ctx.map->spawnpoints.size(); + if (ctx.navigation_service && entity_state) { + request_new_path(entity, next_spawnpoint, ctx.navigation_service, ctx.map); + entity_state->current_state = EntityState::PATHFINDING_WAITING; + entity_state->state_duration_ms = 0.0f; } + pathfinding.waypoints.clear(); + pathfinding.current_waypoint_index = 0; } +// ============================================================================ +// Utility Functions +// ============================================================================ + +// ============================================================================ +// Utility Functions +// ============================================================================ + bool MovementSystem::has_collision(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager) { const Movement* entity_move = entity.get_component(); if (!entity_move) { @@ -240,6 +270,21 @@ float MovementSystem::distance(const Vec2& a, const Vec2& b) { return std::sqrt(dx * dx + dy * dy); } +float MovementSystem::distance(const Vec3& a, const Vec3& b) { + float dx = a.x - b.x; + float dy = a.y - b.y; + float dz = a.z - b.z; + return std::sqrt(dx * dx + dy * dy + dz * dz); +} + +Vec3 MovementSystem::normalize(const Vec3& v) { + float len = distance(Vec3(0, 0, 0), v); + if (len < 0.0001f) { + return v; + } + return Vec3(v.x / len, v.y / len, v.z / len); +} + void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint_id, NavigationService* navigation_service, const Map* map) { if (!navigation_service || !map || target_spawnpoint_id >= map->spawnpoints.size()) { return; @@ -269,6 +314,6 @@ void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint entity_state->state_duration_ms = 0.0f; } pathfinding->target_spawnpoint_id = target_spawnpoint_id; - LOG_DEBUG("Minion %u requested path to spawnpoint %u", entity.get_id(), target_spawnpoint_id); + LOG_DEBUG("Entity %u requested path to spawnpoint %u", entity.get_id(), target_spawnpoint_id); } } \ No newline at end of file diff --git a/src/systems/movement_system.hpp b/src/systems/movement_system.hpp index 6dc38f1..c15684e 100644 --- a/src/systems/movement_system.hpp +++ b/src/systems/movement_system.hpp @@ -4,6 +4,8 @@ #include "components/stats.hpp" #include "components/movement.hpp" #include "components/map.hpp" +#include "components/pathfinding.hpp" +#include "components/entity_state.hpp" #include "math.hpp" #include "system_context.hpp" #include @@ -23,6 +25,58 @@ class MovementSystem { void update(const SystemContext& ctx); private: + // ======================================================================== + // Phase processors + // ======================================================================== + + /** + * Process pathfinding-related updates (results and retries). + */ + void process_pathfinding_phase(const SystemContext& ctx); + + /** + * Process completed pathfinding results from NavigationService. + */ + static void process_completed_paths(const SystemContext& ctx); + + /** + * Retry pending pathfinding requests for stuck entities. + */ + static void retry_stuck_entities(const SystemContext& ctx); + + // ======================================================================== + // Entity movement handlers + // ======================================================================== + + /** + * Update a single entity's movement based on its type. + */ + void update_entity_movement(const SystemContext& ctx, Entity& entity); + + /** + * Update direct movement (player movement to target positions). + */ + static void update_direct_movement(const SystemContext& ctx, Entity& entity, Movement& movement, Stats& stats, EntityStateComponent& state_comp); + + /** + * Update stuck detection and trigger repath if needed. + */ + void update_stuck_detection(const SystemContext& ctx, Entity& entity, Movement& movement, PathfindingComponent& pathfinding, EntityStateComponent* entity_state); + + /** + * Update waypoint-based movement (minion path following). + */ + static void update_waypoint_movement(const SystemContext& ctx, Entity& entity, Movement& movement, Stats& stats, PathfindingComponent& pathfinding, EntityStateComponent* entity_state); + + /** + * Request path to next spawnpoint when current waypoints exhausted. + */ + static void request_path_to_next_spawnpoint(const SystemContext& ctx, Entity& entity, PathfindingComponent& pathfinding, EntityStateComponent* entity_state); + + // ======================================================================== + // Utility functions + // ======================================================================== + /** * Calculate distance between two 3D points. * @param a First point From 644b61a33cc480bb8a767bba073a9bea05e66215 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 00:13:02 -0500 Subject: [PATCH 17/79] Make players use A* instead of direct movement --- src/systems/input_system.cpp | 53 ++++++++++++++++++++++++++++++++---- src/systems/input_system.hpp | 6 ++-- 2 files changed, 52 insertions(+), 7 deletions(-) diff --git a/src/systems/input_system.cpp b/src/systems/input_system.cpp index bd0bb06..1221dec 100644 --- a/src/systems/input_system.cpp +++ b/src/systems/input_system.cpp @@ -1,6 +1,9 @@ #include "input_system.hpp" #include "entity_manager.hpp" #include "components/entity_state.hpp" +#include "components/movement.hpp" +#include "components/pathfinding.hpp" +#include "services/navigation_service.hpp" #include void InputSystem::queue_movement_input(EntityID entity_id, const Vec2& target_position) { @@ -20,7 +23,7 @@ void InputSystem::update(const SystemContext& ctx) { continue; } - if (process_movement_input(*entity, input.target_position)) { + if (process_movement_input(*entity, input.target_position, ctx)) { LOG_DEBUG("Successfully processed movement input for entity %u", input.entity_id); } else { LOG_WARN("Failed to process movement input for entity %u", input.entity_id); @@ -30,20 +33,60 @@ void InputSystem::update(const SystemContext& ctx) { } } -bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_position) { +bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_position, const SystemContext& ctx) { EntityStateComponent* ent_state = entity.get_component(); + Movement* movement = entity.get_component(); if (!ent_state) { LOG_WARN("Entity %u missing EntityStateComponent", entity.get_id()); return false; } - // Queue the movement target + if (!movement) { + LOG_WARN("Entity %u missing Movement component", entity.get_id()); + return false; + } + + // Attempt to use pathfinding if NavigationService and Map are available + if (ctx.navigation_service && ctx.map) { + // Ensure entity has PathfindingComponent + PathfindingComponent* pathfinding = entity.get_component(); + if (!pathfinding) { + auto pf = std::make_unique(); + entity.add_component(std::move(pf)); + pathfinding = entity.get_component(); + } + + // Request pathfinding path + Vec3 start = Vec3(movement->position.x, 0.0f, movement->position.y); + Vec3 goal = Vec3(target_position.x, 0.0f, target_position.y); + + PathRequest request; + request.entity_id = entity.get_id(); + request.current_position = start; + request.destination = goal; + request.entity_pathing_radius = 0.5f; + + if (ctx.navigation_service->MakeRequest(request)) { + // Transition to pathfinding state + ent_state->current_state = EntityState::PATHFINDING_WAITING; + ent_state->state_duration_ms = 0.0f; + ent_state->target_positions.clear(); + + LOG_INFO("Entity %u requested pathfinding to (%.2f, %.2f)", entity.get_id(), target_position.x, target_position.y); + return true; + } else { + LOG_WARN("Entity %u failed to request pathfinding", entity.get_id()); + // Fall through to direct movement as fallback + } + } + + // Fallback: Use direct movement if pathfinding unavailable + LOG_DEBUG("Entity %u using direct movement to (%.2f, %.2f) (pathfinding unavailable)", + entity.get_id(), target_position.x, target_position.y); ent_state->current_state = EntityState::MOVING; ent_state->target_positions.clear(); ent_state->target_positions.push_back(target_position); - LOG_INFO("Entity %u queued to move to (%.2f, %.2f)", entity.get_id(), target_position.x, target_position.y); - return true; } diff --git a/src/systems/input_system.hpp b/src/systems/input_system.hpp index ea414b7..9848c90 100644 --- a/src/systems/input_system.hpp +++ b/src/systems/input_system.hpp @@ -75,11 +75,13 @@ class InputSystem { /** * Process a single movement input request. - * Applies the movement to the entity's state. + * Uses pathfinding (A*) to find a navmesh-aware path to avoid holes. + * Falls back to direct movement if pathfinding fails. * * @param entity Entity to move * @param target_position Target position + * @param ctx System context with NavigationService and Map * @return true if input was processed successfully */ - static bool process_movement_input(Entity& entity, const Vec2& target_position); + static bool process_movement_input(Entity& entity, const Vec2& target_position, const SystemContext& ctx); }; From 49ec73e42aabf7c8a8a64454be0a8ecf8526b628 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 00:27:47 -0500 Subject: [PATCH 18/79] Add basic hashing for stats component checking --- src/components/network_entity.hpp | 18 ++++-- src/systems/network_sync_system.cpp | 87 +++++++++++++++++++++++------ 2 files changed, 83 insertions(+), 22 deletions(-) diff --git a/src/components/network_entity.hpp b/src/components/network_entity.hpp index d4479b7..a1c726f 100644 --- a/src/components/network_entity.hpp +++ b/src/components/network_entity.hpp @@ -38,7 +38,7 @@ struct NetworkEntityComponent : public Component { // === Last Known State (for delta detection) === Vec2 last_synced_position = Vec2(0.0f, 0.0f); // Position at last sync EntityState last_synced_state = EntityState::SPAWNED; // State at last sync - uint32_t last_synced_health = 0; // Health at last sync (if applicable) + uint32_t last_synced_stats_hash = 0; // Hash of stats at last sync (for any stats component) // === Bandwidth Optimization === static constexpr uint32_t MIN_POSITION_CHANGE = 1; // Only sync if moved 1 unit @@ -65,17 +65,27 @@ struct NetworkEntityComponent : public Component { return current_state != last_synced_state; } + /** + * Check if any stats have changed since last sync. + * Uses a simple hash of critical stats values for efficient comparison. + * @param stats_hash Hash of current stats (health, mana, level combined) + * @return true if stats have changed + */ + bool has_stats_changed(uint32_t stats_hash) const { + return stats_hash != last_synced_stats_hash; + } + /** * Mark this entity as fully synced with the given state. * @param position Current position * @param state Current state - * @param health Current health (optional) + * @param stats_hash Hash of current stats for change detection * @param current_frame Frame number */ - void mark_synced(const Vec2& position, EntityState state, uint32_t health, uint32_t current_frame) { + void mark_synced(const Vec2& position, EntityState state, uint32_t stats_hash, uint32_t current_frame) { last_synced_position = position; last_synced_state = state; - last_synced_health = health; + last_synced_stats_hash = stats_hash; last_sync_frame = current_frame; force_full_sync_next_frame = false; } diff --git a/src/systems/network_sync_system.cpp b/src/systems/network_sync_system.cpp index 3155a25..555fe0d 100644 --- a/src/systems/network_sync_system.cpp +++ b/src/systems/network_sync_system.cpp @@ -3,8 +3,33 @@ #include "components/movement.hpp" #include "components/entity_state.hpp" #include "components/network_entity.hpp" +#include "components/stats.hpp" #include +// Helper function to compute a simple hash of stats for change detection +static uint32_t compute_stats_hash(const Stats& stats) { + // Simple hash combining critical stats + // Using bit shifts and XOR to mix the values + uint32_t hash = 0; + + // Hash health and max_health (important for gameplay) + uint32_t health_bits = static_cast(stats.health * 100.0f); + uint32_t max_health_bits = static_cast(stats.max_health * 100.0f); + hash ^= health_bits; + hash ^= (max_health_bits << 8); + + // Hash mana and max_mana + uint32_t mana_bits = static_cast(stats.mana * 100.0f); + uint32_t max_mana_bits = static_cast(stats.max_mana * 100.0f); + hash ^= (mana_bits << 16); + hash ^= (max_mana_bits << 24); + + // Hash level + hash ^= stats.level; + + return hash; +} + void NetworkSyncSystem::update(const SystemContext& ctx) { if(current_frame_ % 30 == 0) { LOG_INFO("NetworkSyncSystem::update - Frame %u", current_frame_); @@ -60,23 +85,31 @@ void NetworkSyncSystem::update(const SystemContext& ctx) { ctx.network_service->broadcast_packet(SerializationSystem::serialize_entity_spawn(entity->get_id(), spawn_position, team_id, template_id)); } - // Serialize entity update + // Serialize entity update - returns vector of packets (one per changed component) bool send_full_state = force_full_sync_next_frame_ || net_comp->force_full_sync_next_frame || is_first_sync; - std::vector packet = serialize_entity_update(entity->get_id(), *entity, send_full_state); + std::vector> packets = serialize_entity_update(entity->get_id(), *entity, send_full_state); - if (!packet.empty()) { - ctx.network_service->broadcast_packet(packet); + if (!packets.empty()) { + // Broadcast all component update packets + // TODO: Implement Fog of War to avoid sending packets to unseen clients + for (const auto& packet : packets) { + if (!packet.empty()) { + ctx.network_service->broadcast_packet(packet); + } + } // Update last synced state auto* move = entity->get_component(); auto* state = entity->get_component(); + auto* stats = entity->get_component(); Vec2 pos = move ? move->position : Vec2(0, 0); EntityState state_val = state ? state->current_state : EntityState::SPAWNED; + uint32_t stats_hash = stats ? compute_stats_hash(*stats) : 0; - net_comp->mark_synced(pos, state_val, 0, current_frame_); - LOG_DEBUG("Synced entity %u (is_first_sync=%s) at position (%.1f, %.1f), state=%d", - entity->get_id(), is_first_sync ? "true" : "false", pos.x, pos.y, (int)state_val); + net_comp->mark_synced(pos, state_val, stats_hash, current_frame_); + LOG_DEBUG("Synced entity %u (is_first_sync=%s) at position (%.1f, %.1f), state=%d, packets=%zu", + entity->get_id(), is_first_sync ? "true" : "false", pos.x, pos.y, (int)state_val, packets.size()); } else { LOG_WARN("No data serialized for entity %u during sync", entity->get_id()); } @@ -130,13 +163,14 @@ bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t curren return false; } -std::vector NetworkSyncSystem::serialize_entity_update(EntityID entity_id, const Entity& entity, - bool send_full_state) const { - std::vector packet; +std::vector> NetworkSyncSystem::serialize_entity_update(EntityID entity_id, const Entity& entity, + bool send_full_state) const { + std::vector> packets; // Get entity components auto* move = entity.get_component(); auto* state = entity.get_component(); + auto* stats = entity.get_component(); auto* net_comp = entity.get_component(); if (!move || !state) { @@ -146,20 +180,37 @@ std::vector NetworkSyncSystem::serialize_entity_update(EntityID entity_ if (!state) { LOG_WARN("Entity %u missing EntityStateComponent", entity_id); } - return packet; // Return empty packet + return packets; // Return empty vector } - // Use existing serialization system for now - // TODO: Implement delta compression for bandwidth optimization + // ======================================================================== + // Position Update Packet + // ======================================================================== if (send_full_state || !net_comp) { - // Full state sync - use existing serialization - packet = SerializationSystem::serialize_entity_position(entity_id, move->position); + // Full state sync - always send position + packets.push_back(SerializationSystem::serialize_entity_position(entity_id, move->position)); } else { - // Delta sync - only position for now + // Delta sync - only if position changed if (net_comp->has_position_changed(move->position)) { - packet = SerializationSystem::serialize_entity_position(entity_id, move->position); + packets.push_back(SerializationSystem::serialize_entity_position(entity_id, move->position)); + } + } + + // ======================================================================== + // Stats Update Packet (Health, Mana, Level) + // ======================================================================== + if (stats) { + if (send_full_state || !net_comp) { + // Full state sync - send health/mana/level + packets.push_back(SerializationSystem::serialize_entity_stats(entity_id, *stats)); + } else { + // Delta sync - check if stats changed using generic hash comparison + uint32_t current_stats_hash = compute_stats_hash(*stats); + if (net_comp->has_stats_changed(current_stats_hash)) { + packets.push_back(SerializationSystem::serialize_entity_stats(entity_id, *stats)); + } } } - return packet; + return packets; } From 605c1b2d1cffe499465e741d003ebd23deaaeac2 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 00:28:12 -0500 Subject: [PATCH 19/79] fix header --- src/systems/network_sync_system.hpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/systems/network_sync_system.hpp b/src/systems/network_sync_system.hpp index 59eb889..bd52bcc 100644 --- a/src/systems/network_sync_system.hpp +++ b/src/systems/network_sync_system.hpp @@ -84,13 +84,19 @@ class NetworkSyncSystem { bool has_entity_changed(const Entity& entity, uint32_t current_frame) const; /** - * Serialize changed entity data into a packet. + * Serialize changed entity data into multiple packets (one per component type). * Only includes data that has actually changed (delta compression). + * + * Returns one packet per component that changed: + * - Position packet if entity moved + * - Stats packet if health/mana/level changed + * - Additional packets as new components are added + * * @param entity_id ID of entity that changed * @param entity The entity * @param send_full_state If true, sends all data instead of just changes - * @return Serialized packet bytes ready to send to network + * @return Vector of serialized packets, one per changed component */ - std::vector serialize_entity_update(EntityID entity_id, const Entity& entity, - bool send_full_state) const; + std::vector> serialize_entity_update(EntityID entity_id, const Entity& entity, + bool send_full_state) const; }; From 458a79fc85bcb24347313580e9cb4228acaaad02 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 00:28:44 -0500 Subject: [PATCH 20/79] fix other files for entity_stats packet --- src/systems/packet_validator.hpp | 2 ++ src/systems/serialization_system.cpp | 26 ++++++++++++++++++++++++++ src/systems/serialization_system.hpp | 11 +++++++++++ 3 files changed, 39 insertions(+) diff --git a/src/systems/packet_validator.hpp b/src/systems/packet_validator.hpp index 989bdeb..107c9f1 100644 --- a/src/systems/packet_validator.hpp +++ b/src/systems/packet_validator.hpp @@ -50,6 +50,8 @@ class PacketValidator { return 13; // type (1) + entity_id (4) + position_x (4) + position_y (4) case PACKET_TYPE::ENTITY_SPAWN: return 19; // type (1) + entity_id (4) + position_x (4) + position_y (4) + team_id (1) + type_string_length (4) + type_string_data (variable) + case PACKET_TYPE::ENTITY_STATS: + return 25; // type (1) + entity_id (4) + health (4) + max_health (4) + mana (4) + max_mana (4) + level (4) case PACKET_TYPE::GAME_START: case PACKET_TYPE::GAME_STATE: case PACKET_TYPE::PLAYER_DISCONNECT: diff --git a/src/systems/serialization_system.cpp b/src/systems/serialization_system.cpp index 50f9867..3a20918 100644 --- a/src/systems/serialization_system.cpp +++ b/src/systems/serialization_system.cpp @@ -1,4 +1,5 @@ #include "serialization_system.hpp" +#include "components/stats.hpp" std::vector SerializationSystem::serialize_packet(PACKET_TYPE packet_type) { std::vector packet_data; @@ -85,3 +86,28 @@ void SerializationSystem::serialize_float(float value, std::vector& out uint32_t int_value = reinterpret_cast(value); serialize_uint32(int_value, output); } + +std::vector SerializationSystem::serialize_entity_stats(uint32_t entity_id, const Stats& stats) { + std::vector packet_data; + packet_data.push_back(static_cast(PACKET_TYPE::ENTITY_STATS)); + + // Entity ID (4 bytes, little-endian) + serialize_uint32(entity_id, packet_data); + + // Health (4 bytes float, little-endian) + serialize_float(stats.health, packet_data); + + // Max Health (4 bytes float, little-endian) + serialize_float(stats.max_health, packet_data); + + // Mana (4 bytes float, little-endian) + serialize_float(stats.mana, packet_data); + + // Max Mana (4 bytes float, little-endian) + serialize_float(stats.max_mana, packet_data); + + // Level (4 bytes int, little-endian as uint32_t) + serialize_uint32(static_cast(stats.level), packet_data); + + return packet_data; +} diff --git a/src/systems/serialization_system.hpp b/src/systems/serialization_system.hpp index c586617..19967ba 100644 --- a/src/systems/serialization_system.hpp +++ b/src/systems/serialization_system.hpp @@ -7,6 +7,9 @@ #include #include +// Forward declarations +struct Stats; + /** * Handles serialization of game packets into byte arrays. * All methods are static and return packets as std::vector. @@ -47,6 +50,14 @@ class SerializationSystem { */ static std::vector serialize_entity_spawn(uint32_t entity_id, const Vec2& position, uint8_t team_id, const std::string& entity_type); + /** + * Serialize an entity stats update packet (health, mana, level). + * @param entity_id The ID of the entity + * @param stats The Stats component containing health, mana, and level + * @return Packet data as a vector of bytes + */ + static std::vector serialize_entity_stats(uint32_t entity_id, const struct Stats& stats); + private: /** * Helper function to serialize a 32-bit unsigned integer in little-endian format From ccf872350acc12c81f371b6f96eac3feb7e5177f Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 08:33:45 -0500 Subject: [PATCH 21/79] Add a few stats for debugging --- data/entities/champions/champion.xml | 2 +- data/entities/minions/cannon_minion.xml | 12 ++++++++---- data/entities/minions/magic_minon.xml | 13 ++++++++----- data/entities/minions/melee_minion.xml | 13 ++++--------- data/entities/minions/ranged_minion.xml | 8 ++++++-- 5 files changed, 27 insertions(+), 21 deletions(-) diff --git a/data/entities/champions/champion.xml b/data/entities/champions/champion.xml index 844d334..19a57aa 100644 --- a/data/entities/champions/champion.xml +++ b/data/entities/champions/champion.xml @@ -22,4 +22,4 @@ - + \ No newline at end of file diff --git a/data/entities/minions/cannon_minion.xml b/data/entities/minions/cannon_minion.xml index 9227f00..02d0f91 100644 --- a/data/entities/minions/cannon_minion.xml +++ b/data/entities/minions/cannon_minion.xml @@ -8,9 +8,13 @@ > - + \ No newline at end of file diff --git a/data/entities/minions/magic_minon.xml b/data/entities/minions/magic_minon.xml index fe96500..5dc6bb6 100644 --- a/data/entities/minions/magic_minon.xml +++ b/data/entities/minions/magic_minon.xml @@ -8,11 +8,14 @@ > - - - \ No newline at end of file + \ No newline at end of file diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml index 071a818..4d82362 100644 --- a/data/entities/minions/melee_minion.xml +++ b/data/entities/minions/melee_minion.xml @@ -11,15 +11,10 @@ max_health="100" health="100" move_speed="4.0" + physical_power="10" + armor="5" + attack_range="1.5" + attack_speed="1.0" /> - \ No newline at end of file diff --git a/data/entities/minions/ranged_minion.xml b/data/entities/minions/ranged_minion.xml index 175284d..127f4fa 100644 --- a/data/entities/minions/ranged_minion.xml +++ b/data/entities/minions/ranged_minion.xml @@ -8,9 +8,13 @@ > \ No newline at end of file From c2318e6b343adc16b089c496fcc7a64a1ec0f32c Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 08:39:47 -0500 Subject: [PATCH 22/79] Revert hashing --- src/components/network_entity.hpp | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/src/components/network_entity.hpp b/src/components/network_entity.hpp index a1c726f..3aac8f2 100644 --- a/src/components/network_entity.hpp +++ b/src/components/network_entity.hpp @@ -3,7 +3,9 @@ #include "component.hpp" #include "movement.hpp" #include "entity_state.hpp" +#include "stats.hpp" #include +#include /** * NetworkEntityComponent - Tracks network synchronization state @@ -38,7 +40,7 @@ struct NetworkEntityComponent : public Component { // === Last Known State (for delta detection) === Vec2 last_synced_position = Vec2(0.0f, 0.0f); // Position at last sync EntityState last_synced_state = EntityState::SPAWNED; // State at last sync - uint32_t last_synced_stats_hash = 0; // Hash of stats at last sync (for any stats component) + std::optional last_synced_stats; // Stats at last sync (for change detection) // === Bandwidth Optimization === static constexpr uint32_t MIN_POSITION_CHANGE = 1; // Only sync if moved 1 unit @@ -67,25 +69,35 @@ struct NetworkEntityComponent : public Component { /** * Check if any stats have changed since last sync. - * Uses a simple hash of critical stats values for efficient comparison. - * @param stats_hash Hash of current stats (health, mana, level combined) + * Directly compares current stats against cached version. + * @param current_stats Current stats component * @return true if stats have changed */ - bool has_stats_changed(uint32_t stats_hash) const { - return stats_hash != last_synced_stats_hash; + bool has_stats_changed(const Stats& current_stats) const { + if (!last_synced_stats) { + return true; // No cached stats, so it's a change + } + // Simple field-by-field comparison of critical fields + return current_stats.health != last_synced_stats->health || + current_stats.max_health != last_synced_stats->max_health || + current_stats.mana != last_synced_stats->mana || + current_stats.max_mana != last_synced_stats->max_mana || + current_stats.level != last_synced_stats->level; } /** * Mark this entity as fully synced with the given state. * @param position Current position * @param state Current state - * @param stats_hash Hash of current stats for change detection + * @param stats Current stats (for change detection) * @param current_frame Frame number */ - void mark_synced(const Vec2& position, EntityState state, uint32_t stats_hash, uint32_t current_frame) { + void mark_synced(const Vec2& position, EntityState state, const Stats* stats, uint32_t current_frame) { last_synced_position = position; last_synced_state = state; - last_synced_stats_hash = stats_hash; + if (stats) { + last_synced_stats = *stats; + } last_sync_frame = current_frame; force_full_sync_next_frame = false; } From 19b9cc4718d6c33063f80ed3f8e479751890558a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 08:40:09 -0500 Subject: [PATCH 23/79] add proper entity cleanup with state sync logic --- src/systems/gameplay_coordinator.cpp | 53 +++++++++++++++++++++++++++- src/systems/gameplay_coordinator.hpp | 19 ++++++++++ 2 files changed, 71 insertions(+), 1 deletion(-) diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index 55cf471..b0d5674 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -1,4 +1,6 @@ #include "gameplay_coordinator.hpp" +#include +#include GameplayCoordinator::GameplayCoordinator() : wave_system_(nullptr) { @@ -29,6 +31,55 @@ void GameplayCoordinator::update(const SystemContext& ctx) { combat_system_.update(ctx); // PLAYER SYSTEMS - // 6. Synchronize to clients + // Synchronize to clients network_sync_system_.update(ctx); + + // Cleanup dead entities (after network sync so death state reaches clients first) + cleanup_dead_entities(ctx.entity_manager); +} + +void GameplayCoordinator::mark_for_cleanup(EntityID entity_id) { + // Check if already marked + auto it = std::find(entities_marked_for_cleanup_.begin(), + entities_marked_for_cleanup_.end(), + entity_id); + if (it == entities_marked_for_cleanup_.end()) { + entities_marked_for_cleanup_.push_back(entity_id); + LOG_DEBUG("Entity %u marked for cleanup", entity_id); + } +} + +void GameplayCoordinator::cleanup_dead_entities(EntityManager& entity_manager) { + // Actually remove entities that were marked last frame + // Allows Client Sync before removal + std::vector to_remove = entities_marked_for_cleanup_; + entities_marked_for_cleanup_.clear(); + + for (EntityID entity_id : to_remove) { + if (entity_manager.destroy_entity(entity_id)) { + LOG_INFO("Cleaned up dead entity %u", entity_id); + } else { + LOG_WARN("Failed to cleanup entity %u (already removed?)", entity_id); + } + } + + // Check for newly dead entities and mark them for cleanup next frame + auto entities_with_state = entity_manager.get_entities_with_component(); + for (auto* entity : entities_with_state) { + if (!entity) continue; + + auto* state = entity->get_component(); + if (!state || state->current_state != EntityState::DEAD) { + continue; + } + + // Cleanup entity next frame + EntityID entity_id = entity->get_id(); + auto it = std::find(entities_marked_for_cleanup_.begin(), + entities_marked_for_cleanup_.end(), + entity_id); + if (it == entities_marked_for_cleanup_.end()) { + mark_for_cleanup(entity_id); + } + } } diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index 46db4ba..d9de490 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -66,11 +66,27 @@ class GameplayCoordinator { * 2. MovementSystem::update() - Move entities * 3. CombatSystem::update() - Auto-attacks and damage * 4. NetworkSyncSystem::update() - Broadcast state + * 5. cleanup_dead_entities() - Remove entities marked for deletion * * @param ctx System context containing entity manager and services */ void update(const SystemContext& ctx); + /** + * Clean up dead entities that have been synced to clients. + * Removes entities that have been in DEAD state for one frame, + * allowing clients to receive and process the death state before removal. + * @param entity_manager Reference to entity manager + */ + void cleanup_dead_entities(EntityManager& entity_manager); + + /** + * Mark an entity for cleanup (removal after next network sync). + * Called when entity reaches DEAD state. + * @param entity_id ID of entity to mark for cleanup + */ + void mark_for_cleanup(EntityID entity_id); + /** * Get reference to input system. * @return Reference to InputSystem @@ -114,4 +130,7 @@ class GameplayCoordinator { MovementSystem movement_system_; NetworkSyncSystem network_sync_system_; CombatSystem combat_system_; + + // Entity cleanup tracking + std::vector entities_marked_for_cleanup_; // Entities to remove next frame }; From 2cf800ee54d1f3e70ca7e430088ad716ddb4b1b8 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 08:40:38 -0500 Subject: [PATCH 24/79] Add input validation (so player doesn't walk out of bounds) --- src/systems/input_system.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/systems/input_system.cpp b/src/systems/input_system.cpp index 1221dec..4a5ef66 100644 --- a/src/systems/input_system.cpp +++ b/src/systems/input_system.cpp @@ -47,6 +47,24 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi return false; } + // Validate target position is within map bounds + if (ctx.map) { + float half_width = ctx.map->size.x / 2.0f; + float half_height = ctx.map->size.y / 2.0f; + float min_x = ctx.map->offset.x - half_width; + float max_x = ctx.map->offset.x + half_width; + float min_y = ctx.map->offset.y - half_height; + float max_y = ctx.map->offset.y + half_height; + + if (target_position.x < min_x || target_position.x > max_x || + target_position.y < min_y || target_position.y > max_y) { + LOG_WARN("Entity %u movement target (%.2f, %.2f) is out of bounds [%.1f-%.1f, %.1f-%.1f]", + entity.get_id(), target_position.x, target_position.y, + min_x, max_x, min_y, max_y); + return false; + } + } + // Attempt to use pathfinding if NavigationService and Map are available if (ctx.navigation_service && ctx.map) { // Ensure entity has PathfindingComponent From 8d0b381d83d56dd13664fefb760a24f911cd5a2f Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 08:41:28 -0500 Subject: [PATCH 25/79] Add stat packets --- src/systems/network_sync_system.cpp | 89 ++++++++++++++++++----------- 1 file changed, 56 insertions(+), 33 deletions(-) diff --git a/src/systems/network_sync_system.cpp b/src/systems/network_sync_system.cpp index 555fe0d..0cd7394 100644 --- a/src/systems/network_sync_system.cpp +++ b/src/systems/network_sync_system.cpp @@ -5,29 +5,36 @@ #include "components/network_entity.hpp" #include "components/stats.hpp" #include +#include +#include -// Helper function to compute a simple hash of stats for change detection -static uint32_t compute_stats_hash(const Stats& stats) { - // Simple hash combining critical stats - // Using bit shifts and XOR to mix the values - uint32_t hash = 0; - - // Hash health and max_health (important for gameplay) - uint32_t health_bits = static_cast(stats.health * 100.0f); - uint32_t max_health_bits = static_cast(stats.max_health * 100.0f); - hash ^= health_bits; - hash ^= (max_health_bits << 8); - - // Hash mana and max_mana - uint32_t mana_bits = static_cast(stats.mana * 100.0f); - uint32_t max_mana_bits = static_cast(stats.max_mana * 100.0f); - hash ^= (mana_bits << 16); - hash ^= (max_mana_bits << 24); - - // Hash level - hash ^= stats.level; - - return hash; +// Helper function to create stat change packets only for changed fields +static std::vector> create_stat_change_packets(uint32_t entity_id, const Stats& current_stats, const Stats& last_synced_stats) { + std::vector> packets; + + // Helper lambda to create a stat packet if value changed + auto add_if_changed = [&](const std::string& stat_name, float current_val, float last_val) { + if (current_val != last_val) { + std::ostringstream oss; + oss << std::fixed << std::setprecision(6) << current_val; + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, stat_name, oss.str())); + } + }; + + auto add_if_changed_int = [&](const std::string& stat_name, int current_val, int last_val) { + if (current_val != last_val) { + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, stat_name, std::to_string(current_val))); + } + }; + + // Check each stat and only send packets for changed values + add_if_changed("health", current_stats.health, last_synced_stats.health); + add_if_changed("max_health", current_stats.max_health, last_synced_stats.max_health); + add_if_changed("mana", current_stats.mana, last_synced_stats.mana); + add_if_changed("max_mana", current_stats.max_mana, last_synced_stats.max_mana); + add_if_changed_int("level", current_stats.level, last_synced_stats.level); + + return packets; } void NetworkSyncSystem::update(const SystemContext& ctx) { @@ -105,9 +112,8 @@ void NetworkSyncSystem::update(const SystemContext& ctx) { Vec2 pos = move ? move->position : Vec2(0, 0); EntityState state_val = state ? state->current_state : EntityState::SPAWNED; - uint32_t stats_hash = stats ? compute_stats_hash(*stats) : 0; - net_comp->mark_synced(pos, state_val, stats_hash, current_frame_); + net_comp->mark_synced(pos, state_val, stats, current_frame_); LOG_DEBUG("Synced entity %u (is_first_sync=%s) at position (%.1f, %.1f), state=%d, packets=%zu", entity->get_id(), is_first_sync ? "true" : "false", pos.x, pos.y, (int)state_val, packets.size()); } else { @@ -197,18 +203,35 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent } // ======================================================================== - // Stats Update Packet (Health, Mana, Level) + // Stats Update Packets (Each stat sent individually) // ======================================================================== if (stats) { if (send_full_state || !net_comp) { - // Full state sync - send health/mana/level - packets.push_back(SerializationSystem::serialize_entity_stats(entity_id, *stats)); - } else { - // Delta sync - check if stats changed using generic hash comparison - uint32_t current_stats_hash = compute_stats_hash(*stats); - if (net_comp->has_stats_changed(current_stats_hash)) { - packets.push_back(SerializationSystem::serialize_entity_stats(entity_id, *stats)); - } + // Full state sync - send each stat as individual packet + std::ostringstream oss; + oss << std::fixed << std::setprecision(6) << stats->health; + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "health", oss.str())); + + oss.str(""); + oss.clear(); + oss << std::fixed << std::setprecision(6) << stats->max_health; + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "max_health", oss.str())); + + oss.str(""); + oss.clear(); + oss << std::fixed << std::setprecision(6) << stats->mana; + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "mana", oss.str())); + + oss.str(""); + oss.clear(); + oss << std::fixed << std::setprecision(6) << stats->max_mana; + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "max_mana", oss.str())); + + packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "level", std::to_string(stats->level))); + } else if (net_comp->has_stats_changed(*stats)) { + // Delta sync - only send packets for stats that changed + auto stat_packets = create_stat_change_packets(entity_id, *stats, *net_comp->last_synced_stats); + packets.insert(packets.end(), stat_packets.begin(), stat_packets.end()); } } From 75ffe4bc20d68caf7b3089da4643db204a3aedf1 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 18 Nov 2025 08:44:30 -0500 Subject: [PATCH 26/79] Entity Serialization --- src/systems/movement_system.cpp | 9 +++++++++ src/systems/serialization_system.cpp | 28 ++++++++++++++++++++++++++++ src/systems/serialization_system.hpp | 13 ++++++++++++- 3 files changed, 49 insertions(+), 1 deletion(-) diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index 2bdaac6..7253120 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -101,6 +101,7 @@ void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& en } // Update pathfinding entities (minions following waypoints) + // TODO: Differentiate between minions and other pathfinding entities (AI Component?) -- cmkrist 18/11/2025 if (pathfinding) { update_stuck_detection(ctx, entity, *movement, *pathfinding, state_comp); update_waypoint_movement(ctx, entity, *movement, *stats, *pathfinding, state_comp); @@ -117,6 +118,14 @@ void MovementSystem::update_direct_movement(const SystemContext& ctx, Entity& en // Check if reached target if (distance < TARGET_THRESHOLD) { state_comp.target_positions.erase(state_comp.target_positions.begin()); + + // Transition to IDLE when all targets are reached + // Separate system? -- cmkrist 18/11/2025 + if (state_comp.target_positions.empty()) { + state_comp.current_state = EntityState::IDLE; + state_comp.state_duration_ms = 0.0f; + LOG_DEBUG("Entity %u reached destination, transitioning to IDLE", entity.get_id()); + } return; } diff --git a/src/systems/serialization_system.cpp b/src/systems/serialization_system.cpp index 3a20918..09baa6c 100644 --- a/src/systems/serialization_system.cpp +++ b/src/systems/serialization_system.cpp @@ -111,3 +111,31 @@ std::vector SerializationSystem::serialize_entity_stats(uint32_t entity return packet_data; } + +std::vector SerializationSystem::serialize_entity_stat_change(uint32_t entity_id, const std::string& stat_name, const std::string& stat_value) { + std::vector packet_data; + packet_data.push_back(static_cast(PACKET_TYPE::ENTITY_STATS)); + + // Entity ID (4 bytes, little-endian) + serialize_uint32(entity_id, packet_data); + + // Stat name length (4 bytes, little-endian) + uint32_t name_length = static_cast(stat_name.length()); + serialize_uint32(name_length, packet_data); + + // Stat name string + for (char c : stat_name) { + packet_data.push_back(static_cast(c)); + } + + // Stat value length (4 bytes, little-endian) + uint32_t value_length = static_cast(stat_value.length()); + serialize_uint32(value_length, packet_data); + + // Stat value string + for (char c : stat_value) { + packet_data.push_back(static_cast(c)); + } + + return packet_data; +} diff --git a/src/systems/serialization_system.hpp b/src/systems/serialization_system.hpp index 19967ba..17dcbc6 100644 --- a/src/systems/serialization_system.hpp +++ b/src/systems/serialization_system.hpp @@ -51,13 +51,24 @@ class SerializationSystem { static std::vector serialize_entity_spawn(uint32_t entity_id, const Vec2& position, uint8_t team_id, const std::string& entity_type); /** - * Serialize an entity stats update packet (health, mana, level). + * Serialize an entity stats update packet. * @param entity_id The ID of the entity * @param stats The Stats component containing health, mana, and level * @return Packet data as a vector of bytes */ static std::vector serialize_entity_stats(uint32_t entity_id, const struct Stats& stats); + /** + * Serialize a single stat change packet. + * Efficient for syncing individual stat changes without full stats sync. + * Format: type(1) + entity_id(4) + stat_name_length(4) + stat_name + stat_value(4/8) + * @param entity_id The ID of the entity + * @param stat_name The name of the stat being changed (e.g., "health", "mana", "level") + * @param stat_value The new value as a string representation + * @return Packet data as a vector of bytes + */ + static std::vector serialize_entity_stat_change(uint32_t entity_id, const std::string& stat_name, const std::string& stat_value); + private: /** * Helper function to serialize a 32-bit unsigned integer in little-endian format From 09d415d8ef0f470ade5123d417713bb0ecfd74aa Mon Sep 17 00:00:00 2001 From: ploinky Date: Wed, 19 Nov 2025 13:59:41 +0100 Subject: [PATCH 27/79] Use maths library functions instead of utility helpers --- .vscode/settings.json | 78 +++++++++++++++++++++++++++++++++ src/systems/movement_system.cpp | 25 +---------- src/systems/movement_system.hpp | 23 ---------- 3 files changed, 80 insertions(+), 46 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..f786995 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,78 @@ +{ + "files.associations": { + "algorithm": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "charconv": "cpp", + "chrono": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "compare": "cpp", + "concepts": "cpp", + "condition_variable": "cpp", + "csignal": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "deque": "cpp", + "exception": "cpp", + "filesystem": "cpp", + "format": "cpp", + "forward_list": "cpp", + "fstream": "cpp", + "functional": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "list": "cpp", + "locale": "cpp", + "map": "cpp", + "memory": "cpp", + "mutex": "cpp", + "new": "cpp", + "optional": "cpp", + "ostream": "cpp", + "queue": "cpp", + "random": "cpp", + "ratio": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "string": "cpp", + "system_error": "cpp", + "thread": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "unordered_map": "cpp", + "utility": "cpp", + "vector": "cpp", + "xfacet": "cpp", + "xhash": "cpp", + "xiosbase": "cpp", + "xlocale": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xstring": "cpp", + "xtr1common": "cpp", + "xtree": "cpp", + "xutility": "cpp" + } +} \ No newline at end of file diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index 7253120..9a5b1f7 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -143,7 +143,7 @@ void MovementSystem::update_direct_movement(const SystemContext& ctx, Entity& en void MovementSystem::update_stuck_detection(const SystemContext& ctx, Entity& entity, Movement& movement, PathfindingComponent& pathfinding, EntityStateComponent* entity_state) { - float movement_distance = distance(movement.position, pathfinding.last_position); + float movement_distance = (movement.position - pathfinding.last_position).length(); if (movement_distance < STUCK_DETECTION_THRESHOLD) { // Entity hasn't moved - accumulate stuck time @@ -263,7 +263,7 @@ bool MovementSystem::has_collision(const Entity& entity, const Vec2& proposed_po float other_radius = other_move->collision_radius; float min_distance = entity_radius + other_radius; - float actual_distance = distance(proposed_position, other_move->position); + float actual_distance = (proposed_position - other_move->position).length(); if (actual_distance < min_distance) { return true; // Collision detected @@ -273,27 +273,6 @@ bool MovementSystem::has_collision(const Entity& entity, const Vec2& proposed_po return false; // No collision } -float MovementSystem::distance(const Vec2& a, const Vec2& b) { - float dx = a.x - b.x; - float dy = a.y - b.y; - return std::sqrt(dx * dx + dy * dy); -} - -float MovementSystem::distance(const Vec3& a, const Vec3& b) { - float dx = a.x - b.x; - float dy = a.y - b.y; - float dz = a.z - b.z; - return std::sqrt(dx * dx + dy * dy + dz * dz); -} - -Vec3 MovementSystem::normalize(const Vec3& v) { - float len = distance(Vec3(0, 0, 0), v); - if (len < 0.0001f) { - return v; - } - return Vec3(v.x / len, v.y / len, v.z / len); -} - void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint_id, NavigationService* navigation_service, const Map* map) { if (!navigation_service || !map || target_spawnpoint_id >= map->spawnpoints.size()) { return; diff --git a/src/systems/movement_system.hpp b/src/systems/movement_system.hpp index c15684e..de5ba19 100644 --- a/src/systems/movement_system.hpp +++ b/src/systems/movement_system.hpp @@ -77,21 +77,6 @@ class MovementSystem { // Utility functions // ======================================================================== - /** - * Calculate distance between two 3D points. - * @param a First point - * @param b Second point - * @return Euclidean distance - */ - static float distance(const Vec3& a, const Vec3& b); - - /** - * Normalize a vector (make it unit length). - * @param v Vector to normalize - * @return Normalized vector - */ - static Vec3 normalize(const Vec3& v); - /** * Request a new path for an entity to a target spawnpoint. * @param entity The entity requesting a path @@ -109,13 +94,5 @@ class MovementSystem { * @return true if collision detected, false if path is clear */ static bool has_collision(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager); - - /** - * Calculate distance between two points. - * @param a First point - * @param b Second point - * @return Distance - */ - static float distance(const Vec2& a, const Vec2& b); }; From 19eb32f32832032885821124018e4b896f23a0b1 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Wed, 19 Nov 2025 11:21:34 -0500 Subject: [PATCH 28/79] fix minor linux compilation error --- src/systems/packet_validator.hpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/systems/packet_validator.hpp b/src/systems/packet_validator.hpp index 107c9f1..2f29c06 100644 --- a/src/systems/packet_validator.hpp +++ b/src/systems/packet_validator.hpp @@ -2,7 +2,9 @@ #include #include +#include #include +#include /** * Packet type enumeration for network communication. @@ -125,8 +127,8 @@ class PacketValidator { } Vec2 vec{}; - std::memcpy(&vec.x, packet_data + 1, 4); // offset 1 (after packet type) - std::memcpy(&vec.y, packet_data + 5, 4); + memcpy(&vec.x, packet_data + 1, 4); // offset 1 (after packet type) + memcpy(&vec.y, packet_data + 5, 4); return std::make_optional(vec); } From e1ff9c2511709064bd69e5d57407b8ce1b202320 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Wed, 19 Nov 2025 11:22:05 -0500 Subject: [PATCH 29/79] 1s delay between minion spawns --- src/systems/wave_system.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/systems/wave_system.hpp b/src/systems/wave_system.hpp index 159dba0..aeece0d 100644 --- a/src/systems/wave_system.hpp +++ b/src/systems/wave_system.hpp @@ -60,7 +60,7 @@ class WaveSystem { const Map* map_ = nullptr; SpawningSystem spawning_system_; float wave_interval_ms = 30000.0f; // 30 seconds between waves - float wave_delay_ms = 10000.0f; // 1 second delay between minions in a wave + float wave_delay_ms = 1000.0f; // 1 second delay between minions in a wave float elapsed_time_ms; float last_spawn_timestamp; int minion_index; From c007253baf7cb26c3187eaa6b39e130fbcb5e88a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Wed, 19 Nov 2025 11:27:54 -0500 Subject: [PATCH 30/79] Remove unused demo code --- src/systems/navmesh_system.cpp | 38 ---------------------------------- src/systems/navmesh_system.hpp | 26 ----------------------- 2 files changed, 64 deletions(-) delete mode 100644 src/systems/navmesh_system.cpp delete mode 100644 src/systems/navmesh_system.hpp diff --git a/src/systems/navmesh_system.cpp b/src/systems/navmesh_system.cpp deleted file mode 100644 index c58d060..0000000 --- a/src/systems/navmesh_system.cpp +++ /dev/null @@ -1,38 +0,0 @@ -#include "navmesh_system.hpp" -#include "components/navmesh.hpp" -#include "components/component.hpp" -#include - -EntityID NavMeshSystem::map_entity_id_ = INVALID_ENTITY_ID; - -Entity& NavMeshSystem::initialize_map(EntityManager& entity_manager) { - LOG_INFO("Initializing NavMesh system"); - - // Create map entity - Entity& map_entity = entity_manager.create_entity(); - map_entity_id_ = map_entity.get_id(); - - // Create and attach navmesh component - auto navmesh = std::make_unique(); - navmesh->width = 100.0f; - navmesh->height = 20.0f; - navmesh->y_level = 0.0f; - - // Set up two spawnpoints at opposite ends of the navmesh - // Spawnpoint 0: at x=0 (left side) - navmesh->spawnpoints.push_back(Vec3(0.0f, 0.0f, 10.0f)); - - // Spawnpoint 1: at x=100 (right side) - navmesh->spawnpoints.push_back(Vec3(100.0f, 0.0f, 10.0f)); - - map_entity.add_component(std::move(navmesh)); - - LOG_INFO("Map entity created with ID %u", map_entity_id_); - LOG_INFO("NavMesh: 100x20, Spawnpoint 0: (0, 0, 10), Spawnpoint 1: (100, 0, 10)"); - - return map_entity; -} - -EntityID NavMeshSystem::get_map_entity_id() { - return map_entity_id_; -} diff --git a/src/systems/navmesh_system.hpp b/src/systems/navmesh_system.hpp deleted file mode 100644 index bcda608..0000000 --- a/src/systems/navmesh_system.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include "entity_manager.hpp" - -/** - * System to initialize and manage the map and its navmesh. - * Creates a map entity with a NavMesh component and sets up spawnpoints. - */ -class NavMeshSystem { -public: - /** - * Initialize the navmesh system and create the map entity. - * @param entity_manager Reference to the entity manager - * @return Reference to the created map entity - */ - static Entity& initialize_map(EntityManager& entity_manager); - - /** - * Get the map entity ID if it exists. - * @return Map entity ID, or INVALID_ENTITY_ID if not initialized - */ - static EntityID get_map_entity_id(); - -private: - static EntityID map_entity_id_; -}; From 392719305dc8f685dd7c15782daacd71f2b732f4 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Wed, 19 Nov 2025 11:35:52 -0500 Subject: [PATCH 31/79] fix cmake, remove unnecesary comments --- CMakeLists.txt | 1 - src/services/astar_pathfinding.cpp | 2 +- src/services/network_service.cpp | 5 +---- src/systems/movement_system.cpp | 1 - src/systems/network_sync_system.cpp | 2 -- src/systems/wave_system.cpp | 1 - 6 files changed, 2 insertions(+), 10 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 12a4d2a..126bd33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -83,7 +83,6 @@ set(GAMESERVER_HEADERS src/components/stats.hpp src/systems/math.hpp src/components/map.hpp - src/components/navmesh.hpp src/services/navigation_service.hpp src/services/astar_pathfinding.hpp src/services/network_service.hpp diff --git a/src/services/astar_pathfinding.cpp b/src/services/astar_pathfinding.cpp index 238788c..852673a 100644 --- a/src/services/astar_pathfinding.cpp +++ b/src/services/astar_pathfinding.cpp @@ -52,7 +52,7 @@ std::vector AStarPathfinder::FindPath( } } - LOG_INFO("A*: start_polygon=%d, goal_polygon=%d for path (%.1f, %.1f) -> (%.1f, %.1f)", + LOG_DEBUG("A*: start_polygon=%d, goal_polygon=%d for path (%.1f, %.1f) -> (%.1f, %.1f)", start_polygon, goal_polygon, start_pos.x, start_pos.y, goal_pos.x, goal_pos.y); // If either position is not in a polygon, try to find the closest polygon diff --git a/src/services/network_service.cpp b/src/services/network_service.cpp index 04fa991..6b2e113 100644 --- a/src/services/network_service.cpp +++ b/src/services/network_service.cpp @@ -33,9 +33,7 @@ NetworkService::~NetworkService() { ERROR_CODE NetworkService::start_server() { LOG_INFO("Initializing GameServer on port %d with max %d clients", port_, max_clients_); // Initialize ENet - int enet_init_result = enet_initialize(); - LOG_INFO("enet_initialize() returned: %d", enet_init_result); - + int enet_init_result = enet_initialize(); if (enet_init_result != 0) { LOG_ERROR("Failed to initialize ENet"); return ERROR_CODE::ERROR_ENET_INIT_FAILED; @@ -300,7 +298,6 @@ void NetworkService::broadcast_packet(const PACKET_TYPE& packet_type) { // Broadcast to all connected peers if (backend_->enet_server_) { enet_host_broadcast(backend_->enet_server_, 0, packet); - LOG_DEBUG("Broadcasted packet type %d to all clients", (int)packet_type); } else { enet_packet_destroy(packet); } diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index 9a5b1f7..8b4d01f 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -60,7 +60,6 @@ void MovementSystem::process_completed_paths(const SystemContext& ctx) { if (result->path.empty()) { LOG_WARN("Entity %u received EMPTY path!", entity->get_id()); } else { - LOG_INFO("Entity %u received path with %zu waypoints", entity->get_id(), result->path.size()); if (entity_state) { entity_state->current_state = EntityState::MOVING; entity_state->state_duration_ms = 0.0f; diff --git a/src/systems/network_sync_system.cpp b/src/systems/network_sync_system.cpp index 0cd7394..5677bdc 100644 --- a/src/systems/network_sync_system.cpp +++ b/src/systems/network_sync_system.cpp @@ -116,8 +116,6 @@ void NetworkSyncSystem::update(const SystemContext& ctx) { net_comp->mark_synced(pos, state_val, stats, current_frame_); LOG_DEBUG("Synced entity %u (is_first_sync=%s) at position (%.1f, %.1f), state=%d, packets=%zu", entity->get_id(), is_first_sync ? "true" : "false", pos.x, pos.y, (int)state_val, packets.size()); - } else { - LOG_WARN("No data serialized for entity %u during sync", entity->get_id()); } } diff --git a/src/systems/wave_system.cpp b/src/systems/wave_system.cpp index 8a13c90..1652a19 100644 --- a/src/systems/wave_system.cpp +++ b/src/systems/wave_system.cpp @@ -54,7 +54,6 @@ void WaveSystem::update(const SystemContext& ctx) { // Minion Spawning if(minion_index > 0) { if (elapsed_time_ms - last_spawn_timestamp >= wave_delay_ms) { - LOG_INFO("Spawning new minion from wave %d, index %d", wave_index, minion_index); for(uint8_t team_id = 1; team_id < 3; team_id++) { create_minion( ctx, From 76e7d2f53f449623f6c7353035404302ae24e2f8 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Wed, 19 Nov 2025 12:57:13 -0500 Subject: [PATCH 32/79] Add Visualizer to server for debugging (--visualize) --- CMakeLists.txt | 2 + src/main.cpp | 26 +- src/services/visualizer_service.cpp | 408 ++++++++++++++++++++++++++++ src/services/visualizer_service.hpp | 98 +++++++ src/systems/gameserver.cpp | 15 + src/systems/gameserver.hpp | 8 + 6 files changed, 556 insertions(+), 1 deletion(-) create mode 100644 src/services/visualizer_service.cpp create mode 100644 src/services/visualizer_service.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 126bd33..08adfa9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -51,6 +51,7 @@ set(GAMESERVER_SOURCES # Services src/services/navigation_service.cpp src/services/astar_pathfinding.cpp + src/services/visualizer_service.cpp # Systems src/systems/combat_system.cpp src/services/network_service.cpp @@ -109,6 +110,7 @@ set(GAMESERVER_HEADERS src/components/attack.hpp src/components/target.hpp src/components/auto_attack.hpp + src/services/visualizer_service.hpp ) set(LIBRARY_SOURCES diff --git a/src/main.cpp b/src/main.cpp index 39362f4..57cf152 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -47,10 +47,29 @@ void signal_handler(int signal) { } // === Main Entry Point === // -int main() { +int main(int argc, char* argv[]) { LOG_INFO("OpenChamp GameServer Starting"); LOG_INFO("=============================="); + // Parse command-line arguments + bool enable_visualizer = false; + uint16_t visualizer_port = 8080; + + for (int i = 1; i < argc; ++i) { + std::string arg(argv[i]); + if (arg == "--visualize") { + enable_visualizer = true; + LOG_INFO("Visualizer enabled (will run on port %u)", visualizer_port); + } else if (arg == "--visualize-port" && i + 1 < argc) { + try { + visualizer_port = std::stoi(argv[++i]); + LOG_INFO("Visualizer port set to %u", visualizer_port); + } catch (...) { + LOG_ERROR("Invalid visualizer port, using default %u", visualizer_port); + } + } + } + // Parse port from environment int env_port = DEFAULT_PORT; const char* port_env = std::getenv("SERVER_PORT"); @@ -100,6 +119,11 @@ int main() { return (int)(init_result); } + // Start visualizer if requested + if (enable_visualizer) { + server.start_visualizer(visualizer_port); + } + // Register signal handler for graceful shutdown g_server_instance = &server; std::signal(SIGINT, signal_handler); diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp new file mode 100644 index 0000000..00ee69c --- /dev/null +++ b/src/services/visualizer_service.cpp @@ -0,0 +1,408 @@ +#include "visualizer_service.hpp" +#include "entity_manager.hpp" +#include "components/map.hpp" +#include "components/movement.hpp" +#include "components/stats.hpp" +#include "components/entity_state.hpp" +#include +#include +#include +#include +#include +#include + +// Windows socket headers +#ifdef _WIN32 + #include + #include + #pragma comment(lib, "ws2_32.lib") + #define SHUT_RDWR SD_BOTH +#endif + +VisualizerService::VisualizerService(uint16_t port) + : port_(port) { +} + +VisualizerService::~VisualizerService() { + stop(); +} + +void VisualizerService::initialize(EntityManager* entity_manager, Map* map) { + entity_manager_ = entity_manager; + map_ = map; + LOG_INFO("VisualizerService initialized on port %u", port_); +} + +bool VisualizerService::start() { + if (running_) { + LOG_WARN("VisualizerService already running"); + return false; + } + + running_ = true; + server_thread_ = std::make_unique(&VisualizerService::run_server, this); + return true; +} + +void VisualizerService::stop() { + if (!running_) { + return; + } + + running_ = false; + if (server_thread_ && server_thread_->joinable()) { + server_thread_->join(); + } + + LOG_INFO("VisualizerService stopped"); +} + +void VisualizerService::run_server() { +#ifdef _WIN32 + // Initialize Winsock + WSADATA wsa_data; + if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) { + LOG_ERROR("WSAStartup failed"); + running_ = false; + return; + } + + // Create listening socket + SOCKET listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (listen_socket == INVALID_SOCKET) { + LOG_ERROR("socket() failed: %d", WSAGetLastError()); + WSACleanup(); + running_ = false; + return; + } + + // Set socket to reuse address + int reuse = 1; + if (setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)) < 0) { + LOG_WARN("setsockopt(SO_REUSEADDR) failed"); + } + + // Bind to port + struct sockaddr_in server_addr; + server_addr.sin_family = AF_INET; + server_addr.sin_addr.s_addr = htonl(INADDR_ANY); + server_addr.sin_port = htons(port_); + + if (bind(listen_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) { + LOG_ERROR("bind() failed: %d", WSAGetLastError()); + closesocket(listen_socket); + WSACleanup(); + running_ = false; + return; + } + + // Listen for connections + if (listen(listen_socket, SOMAXCONN) == SOCKET_ERROR) { + LOG_ERROR("listen() failed: %d", WSAGetLastError()); + closesocket(listen_socket); + WSACleanup(); + running_ = false; + return; + } + + LOG_INFO("HTTP server listening on port %u", port_); + + // Accept connections loop + while (running_) { + // Set a timeout for accept so we can check running_ flag periodically + fd_set read_fds; + FD_ZERO(&read_fds); + FD_SET(listen_socket, &read_fds); + + struct timeval tv; + tv.tv_sec = 1; // 1 second timeout + tv.tv_usec = 0; + + int select_result = select((int)listen_socket + 1, &read_fds, nullptr, nullptr, &tv); + if (select_result < 0) { + LOG_ERROR("select() failed: %d", WSAGetLastError()); + break; + } + + if (select_result == 0) { + // Timeout - check if we should continue + continue; + } + + // Accept connection + struct sockaddr_in client_addr; + int client_addr_len = sizeof(client_addr); + SOCKET client_socket = accept(listen_socket, (struct sockaddr*)&client_addr, &client_addr_len); + + if (client_socket == INVALID_SOCKET) { + LOG_ERROR("accept() failed: %d", WSAGetLastError()); + continue; + } + + // Read HTTP request + char buffer[4096]; + int recv_len = recv(client_socket, buffer, sizeof(buffer) - 1, 0); + if (recv_len > 0) { + buffer[recv_len] = '\0'; + + // Parse request + std::string request(buffer); + std::string response; + + if (request.find("GET /api/gamestate") != std::string::npos) { + // Return JSON game state + std::string json = get_game_state_json(); + response = "HTTP/1.1 200 OK\r\n"; + response += "Content-Type: application/json\r\n"; + response += "Content-Length: " + std::to_string(json.length()) + "\r\n"; + response += "Access-Control-Allow-Origin: *\r\n"; + response += "Connection: close\r\n"; + response += "\r\n"; + response += json; + } else if (request.find("GET /") != std::string::npos || request.find("GET") != std::string::npos) { + // Return HTML page + std::string html = get_html_page(); + response = "HTTP/1.1 200 OK\r\n"; + response += "Content-Type: text/html\r\n"; + response += "Content-Length: " + std::to_string(html.length()) + "\r\n"; + response += "Connection: close\r\n"; + response += "\r\n"; + response += html; + } else { + // 404 Not Found + response = "HTTP/1.1 404 Not Found\r\n"; + response += "Content-Type: text/plain\r\n"; + response += "Content-Length: 9\r\n"; + response += "Connection: close\r\n"; + response += "\r\n"; + response += "Not Found"; + } + + // Send response + send(client_socket, response.c_str(), (int)response.length(), 0); + } + + // Close client socket + shutdown(client_socket, SHUT_RDWR); + closesocket(client_socket); + } + + // Cleanup + closesocket(listen_socket); + WSACleanup(); + LOG_INFO("HTTP server stopped"); +#else + LOG_WARN("VisualizerService HTTP server not implemented for non-Windows platforms"); +#endif + running_ = false; +} + +std::string VisualizerService::get_html_page() const { + return R"( + + + + GameServer Debugger + + + +

GameServer Debugger

+

Map View

+ + +

Game State

+
+ +

Entities

+
+ + + + + )"; +} + +std::string VisualizerService::get_game_state_json() const { + std::ostringstream json; + json << std::fixed << std::setprecision(2); + + json << "{"; + + // Map data + json << "\"map\":{"; + if (map_) { + json << "\"name\":\"" << map_->name << "\","; + json << "\"size\":{\"x\":" << map_->size.x << ",\"y\":" << map_->size.y << "},"; + json << "\"offset\":{\"x\":" << map_->offset.x << ",\"y\":" << map_->offset.y << "},"; + + // Vertices + json << "\"vertices\":["; + for (size_t i = 0; i < map_->vertices.size(); i++) { + if (i > 0) json << ","; + json << "{\"x\":" << map_->vertices[i].x << ",\"z\":" << map_->vertices[i].y << "}"; + } + json << "],"; + + // Spawnpoints + json << "\"spawnpoints\":["; + for (size_t i = 0; i < map_->spawnpoints.size(); i++) { + if (i > 0) json << ","; + json << "{\"x\":" << map_->spawnpoints[i].x << ",\"z\":" << map_->spawnpoints[i].y << "}"; + } + json << "]"; + } + json << "},"; + + // Entities + json << "\"entities\":["; + if (entity_manager_) { + auto all_entities = entity_manager_->get_entities_with_component(); + bool first = true; + for (auto* entity : all_entities) { + if (!first) json << ","; + first = false; + + auto* move = entity->get_component(); + auto* stats = entity->get_component(); + auto* state = entity->get_component(); + + json << "{"; + json << "\"id\":" << entity->get_id() << ","; + json << "\"position\":{\"x\":" << move->position.x << ",\"z\":" << move->position.y << "},"; + json << "\"team_id\":" << (int)(stats ? stats->team_id : 0) << ","; + json << "\"state\":\"" << (state ? std::to_string((int)state->current_state) : "UNKNOWN") << "\""; + json << "}"; + } + } + json << "],"; + + // State + json << "\"state\":{\"message\":\"Visualizer active\"}"; + + json << "}"; + return json.str(); +} diff --git a/src/services/visualizer_service.hpp b/src/services/visualizer_service.hpp new file mode 100644 index 0000000..8b22fe6 --- /dev/null +++ b/src/services/visualizer_service.hpp @@ -0,0 +1,98 @@ +#pragma once + +#include +#include +#include +#include +#include + +// Forward declarations +class EntityManager; +struct SystemContext; + +/** + * VisualizerService - Optional web-based visualization of game state + * + * RESPONSIBILITIES: + * - Serve a web page for visualizing map and entities + * - Provide JSON API endpoints for game state + * - Run HTTP server in background thread + * - Display real-time entity positions and states + * + * USAGE (optional, debug only): + * VisualizerService visualizer(8080); // Port 8080 + * visualizer.initialize(&entity_manager, map_pointer_.get()); + * visualizer.start(); + * // Open http://localhost:8080 in browser + * + * NOTE: This is entirely optional and only for development debugging. + * Disable with VISUALIZER_ENABLED = false or by not initializing. + */ +class VisualizerService { +public: + VisualizerService(uint16_t port = 8080); + ~VisualizerService(); + + // Prevent copying + VisualizerService(const VisualizerService&) = delete; + VisualizerService& operator=(const VisualizerService&) = delete; + + // Allow moving + VisualizerService(VisualizerService&&) = default; + VisualizerService& operator=(VisualizerService&&) = default; + + /** + * Initialize visualizer with entity manager and map. + * Must be called before start(). + * @param entity_manager Pointer to entity manager + * @param map Map data for visualization + */ + void initialize(EntityManager* entity_manager, struct Map* map); + + /** + * Start the HTTP server in background thread. + * @return true if server started successfully + */ + bool start(); + + /** + * Stop the HTTP server and wait for thread to finish. + */ + void stop(); + + /** + * Check if server is running. + * @return true if HTTP server is active + */ + bool is_running() const { return running_; } + + /** + * Get the port the server is listening on. + * @return Port number + */ + uint16_t get_port() const { return port_; } + +private: + uint16_t port_; + std::atomic running_{false}; + std::unique_ptr server_thread_; + EntityManager* entity_manager_ = nullptr; + struct Map* map_ = nullptr; + + /** + * Run the HTTP server (called in background thread). + */ + void run_server(); + + /** + * Get HTML page content. + * @return HTML string for visualization + */ + std::string get_html_page() const; + + /** + * Get current game state as JSON. + * @return JSON string with map, entities, and state + */ + std::string get_game_state_json() const; +}; diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index e41d2d3..7658704 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -229,3 +229,18 @@ bool GameServer::is_valid_state_transition(GAME_STATE from, GAME_STATE to) const return false; } } + +void GameServer::start_visualizer(uint16_t port) { + if (!map_pointer_) { + LOG_ERROR("Cannot start visualizer: map not initialized"); + return; + } + + debug_visualizer_ = std::make_unique(port); + debug_visualizer_->initialize(&entity_manager_, map_pointer_.get()); + if (debug_visualizer_->start()) { + LOG_INFO("Debug visualizer started on port %u", port); + } else { + LOG_ERROR("Failed to start debug visualizer"); + } +} diff --git a/src/systems/gameserver.hpp b/src/systems/gameserver.hpp index e683947..5dbcf24 100644 --- a/src/systems/gameserver.hpp +++ b/src/systems/gameserver.hpp @@ -20,6 +20,7 @@ // Services #include "services/navigation_service.hpp" #include "services/network_service.hpp" +#include "services/visualizer_service.hpp" /** * Central GameServer class encapsulating all server state and logic. * Replaces global state management with proper OOP encapsulation. @@ -104,6 +105,12 @@ class GameServer { */ bool is_lobby_full() const; + /** + * Start the debug visualizer web server. + * @param port Port to listen on (default 8080) + */ + void start_visualizer(uint16_t port = 8080); + private: // Network configuration int max_clients_; @@ -133,6 +140,7 @@ class GameServer { // Services (Separate thread) std::unique_ptr navigation_service_; + std::unique_ptr debug_visualizer_; // ECS systems EntityManager entity_manager_; From a230335cd715cbbb1f8a0c826f187d57b2c55429 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Wed, 19 Nov 2025 13:24:10 -0500 Subject: [PATCH 33/79] Add launch options for vizualizer --- .vscode/launch.json | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index 13e4ab8..15ae99c 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -1,12 +1,44 @@ { "version": "0.2.0", "configurations": [ - { - "name": "Win(x64) Debug", + "name": "Win(D) Visual", "type": "cppvsdbg", "request": "launch", "program": "${workspaceFolder}/build/_output/windows_x64/Debug/gameserver.exe", + "args": ["--visualize"], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "console": "externalTerminal" + }, + { + "name": "Win(D) Debug", + "type": "cppvsdbg", + "request": "launch", + "program": "${workspaceFolder}/build/_output/windows_x64/Debug/gameserver.exe", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "console": "externalTerminal" + }, + { + "name": "Win(R) Visual", + "type": "cppvsdbg", + "request": "launch", + "program": "${workspaceFolder}/build/_output/windows_x64/Release/gameserver.exe --visualize", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "console": "externalTerminal" + }, + { + "name": "Win(R) Debug", + "type": "cppvsdbg", + "request": "launch", + "program": "${workspaceFolder}/build/_output/windows_x64/Release/gameserver.exe", "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", From b806aa36bd5a5879f7e41c0ddc9ae0f4472f9db8 Mon Sep 17 00:00:00 2001 From: ploinky Date: Fri, 21 Nov 2025 08:35:14 +0100 Subject: [PATCH 34/79] NPC system implementation --- CMakeLists.txt | 2 + src/systems/gameplay_coordinator.cpp | 1 + src/systems/gameplay_coordinator.hpp | 2 + src/systems/npc_system.cpp | 49 ++++++++++++++++++++++++ src/systems/npc_system.hpp | 57 ++++++++++++++++++++++++++++ 5 files changed, 111 insertions(+) create mode 100644 src/systems/npc_system.cpp create mode 100644 src/systems/npc_system.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 08adfa9..5352ac1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,6 +63,7 @@ set(GAMESERVER_SOURCES src/systems/combat_system.cpp src/systems/movement_system.cpp src/systems/network_sync_system.cpp + src/systems/npc_system.cpp src/systems/serialization_system.cpp src/systems/spawning_system.cpp src/systems/wave_system.cpp @@ -95,6 +96,7 @@ set(GAMESERVER_HEADERS src/systems/spawning_system.hpp src/systems/wave_system.hpp src/systems/network_sync_system.hpp + src/systems/npc_system.hpp src/systems/player_manager.hpp src/systems/input_system.hpp src/systems/collision_system.hpp diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index b0d5674..5bafc3c 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -19,6 +19,7 @@ void GameplayCoordinator::update(const SystemContext& ctx) { // INPUT SYSTEMS input_system_.update(ctx); + npc_system_.update(ctx); // ENGINE SYSTEMS wave_system_->update(ctx); diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index d9de490..b686f39 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -7,6 +7,7 @@ #include "movement_system.hpp" #include "network_sync_system.hpp" #include "combat_system.hpp" +#include "npc_system.hpp" /** * GameplayCoordinator - Orchestrates all game systems @@ -130,6 +131,7 @@ class GameplayCoordinator { MovementSystem movement_system_; NetworkSyncSystem network_sync_system_; CombatSystem combat_system_; + NPCSystem npc_system_; // Entity cleanup tracking std::vector entities_marked_for_cleanup_; // Entities to remove next frame diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp new file mode 100644 index 0000000..1110918 --- /dev/null +++ b/src/systems/npc_system.cpp @@ -0,0 +1,49 @@ +#include "npc_system.hpp" + +#include "components/entity_state.hpp" + +void NPCSystem::update(const SystemContext& ctx) { + // TODO properly pick npc entities only - ploinky 20/11/2025 + for(auto npc_entity : ctx.entity_manager.get_entities_with_component()) { + update_entity(ctx, npc_entity); + } +} + +void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { + Movement* npc_movement = npc_entity->get_component(); + Stats* npc_stats = npc_entity->get_component(); + EntityStateComponent* npc_state = npc_entity->get_component(); + + if(!npc_movement || !npc_stats) { + LOG_WARN("NPCSystem attempted to update pathfinding entity %d without movement component", npc_entity->get_id()); + return; + } + + if(npc_state->current_state == EntityState::ATTACKING) { + // TODO check if we're too far off our lane and need to return + } + + if(npc_state->current_state == EntityState::MOVING || npc_state->current_state == EntityState::PATHFINDING_WAITING) { + // TODO how do I find all entities in my general area that are attackable? - ploinky 20/11/2025 + for(auto other_entity : ctx.entity_manager.get_entities_with_component()) { + if(other_entity == npc_entity) { + continue; + } + + Movement* other_movement = other_entity->get_component(); + if(!other_movement) { + continue; // continue checking other entities in range + } + + // TODO this check needs to be in an attack component, + // and it needs a second fields "acquisition_range" or something similar - ploinky 20/11/2025 + if(std::abs((npc_movement->position - other_movement->position).length()) <= npc_stats->attack_range) { + npc_state->current_state = EntityState::ATTACKING; + npc_state->target_entity_id = other_entity->get_id(); + npc_state->state_duration_ms = 0.0f; + LOG_INFO("Entity %d is attacking entity %d", npc_entity->get_id(), other_entity->get_id()); + return; // done updating this entity + } + } + } +} \ No newline at end of file diff --git a/src/systems/npc_system.hpp b/src/systems/npc_system.hpp new file mode 100644 index 0000000..e34464b --- /dev/null +++ b/src/systems/npc_system.hpp @@ -0,0 +1,57 @@ +#pragma once + +#include "system_context.hpp" +/** + * NPC System - Handles entities that need to act on the map + * but do not have a player controlling them. + * + * RESPONSIBILITIES: + * - Make NPC entities do things + * + * FEATURES: + * - Checks what the entity is thinking + * - Checks what the entity is doing + * - If the entitiy isn't doing what the system thinks it + * should be doing, makes the entity do that thing + * + * USAGE: + * NPCSystem npc_system; + * // In game loop: + * npc_system.update(ctx); + * + * SYSTEM INTERACTION: + * - Runs before all other systems (except input) because this is kind of + * like "npc input" + * - Can be used independently or as part of GameplayCoordinator + */ +class NPCSystem { +public: + NPCSystem() = default; + ~NPCSystem() = default; + + // Prevent copying + NPCSystem(const NPCSystem&) = delete; + NPCSystem& operator=(const NPCSystem&) = delete; + + // Allow moving + NPCSystem(NPCSystem&&) = default; + NPCSystem& operator=(NPCSystem&&) = default; + + /** + * Update npc entity actions. + * + * @param ctx System context with entity manager and network service + */ + void update(const SystemContext& ctx); + +private: + /** + * Update a single entity. + * This allows us to return at any point the entity is done thinking, + * which we could not do inside a loop in the main update function. + * + * @param System System context with entity manager and network service + * @param npc_entity The entity that is currently thinking + */ + void update_entity(const SystemContext& ctx, Entity* npc_entity); +}; \ No newline at end of file From 1c7f78ee95ab4c06f96a5e31baeecf87cf86bc97 Mon Sep 17 00:00:00 2001 From: ploinky Date: Fri, 21 Nov 2025 08:52:21 +0100 Subject: [PATCH 35/79] Return minion to path when chasing too far --- src/systems/npc_system.cpp | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index 1110918..498cb76 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -13,14 +13,26 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { Movement* npc_movement = npc_entity->get_component(); Stats* npc_stats = npc_entity->get_component(); EntityStateComponent* npc_state = npc_entity->get_component(); + PathfindingComponent* npc_path = npc_entity->get_component(); - if(!npc_movement || !npc_stats) { - LOG_WARN("NPCSystem attempted to update pathfinding entity %d without movement component", npc_entity->get_id()); + if(!npc_movement || !npc_stats || !npc_state || !npc_path) { + LOG_WARN("NPCSystem attempted to update entity %d but it's missing (a) relevant component(s)", npc_entity->get_id()); return; } if(npc_state->current_state == EntityState::ATTACKING) { - // TODO check if we're too far off our lane and need to return + // TODO if we're "flattening the navmesh" then this should really be a Vec2 - ploinky 21/11/2025 + Vec3 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; + Vec3 current_position = Vec3(npc_movement->position.x, 0, npc_movement->position.y); + + // TODO Having this "stay aggrod" distance in code is a bad idea. + // This should be in data, because you may want different chasing distances per map. - ploinky 21/11/2025 + if(std::abs((current_waypoint - current_position).length()) > 30.0f) { + npc_state->current_state = EntityState::MOVING; + npc_state->target_entity_id = INVALID_ENTITY_ID; + npc_state->state_duration_ms = 0.0f; + return; // done updating this entity + } } if(npc_state->current_state == EntityState::MOVING || npc_state->current_state == EntityState::PATHFINDING_WAITING) { @@ -35,8 +47,8 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { continue; // continue checking other entities in range } - // TODO this check needs to be in an attack component, - // and it needs a second fields "acquisition_range" or something similar - ploinky 20/11/2025 + // TODO This check needs to be against a different field in an attack component, + // "acquisition_range" or something similar - ploinky 20/11/2025 if(std::abs((npc_movement->position - other_movement->position).length()) <= npc_stats->attack_range) { npc_state->current_state = EntityState::ATTACKING; npc_state->target_entity_id = other_entity->get_id(); From 8517678762c3ca010e0191597ec5b198478b3b04 Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 24 Nov 2025 17:48:13 +0100 Subject: [PATCH 36/79] Add npc component with npc type --- data/entities/_entity.xsd | 7 +++ data/entities/minions/cannon_minion.xml | 1 + data/entities/minions/magic_minon.xml | 1 + data/entities/minions/melee_minion.xml | 1 + data/entities/minions/ranged_minion.xml | 1 + src/components/component_registry.hpp | 1 + src/components/npc_component.hpp | 14 +++++ src/systems/data_loader.cpp | 21 ++++++++ src/systems/npc_system.cpp | 68 +++++++++++++------------ 9 files changed, 83 insertions(+), 32 deletions(-) create mode 100644 src/components/npc_component.hpp diff --git a/data/entities/_entity.xsd b/data/entities/_entity.xsd index f100b77..0bab8fc 100644 --- a/data/entities/_entity.xsd +++ b/data/entities/_entity.xsd @@ -25,6 +25,13 @@ + + + + + + + diff --git a/data/entities/minions/cannon_minion.xml b/data/entities/minions/cannon_minion.xml index 02d0f91..0570f2c 100644 --- a/data/entities/minions/cannon_minion.xml +++ b/data/entities/minions/cannon_minion.xml @@ -17,4 +17,5 @@ attack_speed="1.2" /> + \ No newline at end of file diff --git a/data/entities/minions/magic_minon.xml b/data/entities/minions/magic_minon.xml index 5dc6bb6..9a09f0f 100644 --- a/data/entities/minions/magic_minon.xml +++ b/data/entities/minions/magic_minon.xml @@ -18,4 +18,5 @@ attack_speed="0.8" /> + \ No newline at end of file diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml index 4d82362..c702309 100644 --- a/data/entities/minions/melee_minion.xml +++ b/data/entities/minions/melee_minion.xml @@ -17,4 +17,5 @@ attack_speed="1.0" /> + \ No newline at end of file diff --git a/data/entities/minions/ranged_minion.xml b/data/entities/minions/ranged_minion.xml index 127f4fa..fa6461b 100644 --- a/data/entities/minions/ranged_minion.xml +++ b/data/entities/minions/ranged_minion.xml @@ -17,4 +17,5 @@ attack_speed="0.9" /> + \ No newline at end of file diff --git a/src/components/component_registry.hpp b/src/components/component_registry.hpp index 99ad783..05dd5b5 100644 --- a/src/components/component_registry.hpp +++ b/src/components/component_registry.hpp @@ -17,6 +17,7 @@ namespace ComponentTypes { // === Core Gameplay (2000-2099) === constexpr uint32_t MOVEMENT = 2001; constexpr uint32_t STATS = 2002; + constexpr uint32_t NPC = 2003; // === State Management (2010-2099) === constexpr uint32_t ENTITY_STATE = 2010; diff --git a/src/components/npc_component.hpp b/src/components/npc_component.hpp new file mode 100644 index 0000000..8952db9 --- /dev/null +++ b/src/components/npc_component.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include "component.hpp" +#include "component_registry.hpp" + +enum class NPCType { + MINION +}; + +struct NPCComponent : public Component { + NPCType npc_type; + + COMPONENT_TYPE_ID(NPCComponent, ComponentTypes::NPC) +}; \ No newline at end of file diff --git a/src/systems/data_loader.cpp b/src/systems/data_loader.cpp index 72c04a5..02eb2ad 100644 --- a/src/systems/data_loader.cpp +++ b/src/systems/data_loader.cpp @@ -7,6 +7,7 @@ #include #include #include +#include /** * Convert string to DamageType enum. @@ -23,6 +24,19 @@ static DamageType string_to_damage_type(const std::string& str) { return DamageType::PHYSICAL; } +/** + * Convert string to NPCType enum. + * @param str The string to convert (case-insensitive) + * @return NPCType enum value, defaults to MINION if unrecognized + */ +static NPCType string_to_npc_type(const std::string& str) { + if (str == "minion") { + return NPCType::MINION; + } + // Default to MINION for unrecognized or empty strings + return NPCType::MINION; +} + /** * Convenience macro. Loads the attribute from the node if the node has it, and sets it in the component. * @param node A pugi::xml_node which (maybe) has the attribute @@ -106,6 +120,13 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { temp.component_templates.push_back(state); } + pugi::xml_node npc_node = rootNode.child("npc"); + if(npc_node != NULL) { + std::shared_ptr npc = std::make_shared(); + LOAD_ENUM_ATTRIBUTE(npc_node, npc, npc_type, string_to_npc_type) + temp.component_templates.push_back(npc); + } + pugi::xml_node statsNode = rootNode.child("stats"); if(statsNode != NULL) { std::shared_ptr stats = std::make_shared(); diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index 498cb76..fb77e74 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -1,6 +1,7 @@ #include "npc_system.hpp" #include "components/entity_state.hpp" +#include "components/npc_component.hpp" void NPCSystem::update(const SystemContext& ctx) { // TODO properly pick npc entities only - ploinky 20/11/2025 @@ -14,47 +15,50 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { Stats* npc_stats = npc_entity->get_component(); EntityStateComponent* npc_state = npc_entity->get_component(); PathfindingComponent* npc_path = npc_entity->get_component(); + NPCComponent* npc_comp = npc_entity->get_component(); - if(!npc_movement || !npc_stats || !npc_state || !npc_path) { + if(!npc_movement || !npc_stats || !npc_state || !npc_path || !npc_comp) { LOG_WARN("NPCSystem attempted to update entity %d but it's missing (a) relevant component(s)", npc_entity->get_id()); return; } - if(npc_state->current_state == EntityState::ATTACKING) { - // TODO if we're "flattening the navmesh" then this should really be a Vec2 - ploinky 21/11/2025 - Vec3 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; - Vec3 current_position = Vec3(npc_movement->position.x, 0, npc_movement->position.y); - - // TODO Having this "stay aggrod" distance in code is a bad idea. - // This should be in data, because you may want different chasing distances per map. - ploinky 21/11/2025 - if(std::abs((current_waypoint - current_position).length()) > 30.0f) { - npc_state->current_state = EntityState::MOVING; - npc_state->target_entity_id = INVALID_ENTITY_ID; - npc_state->state_duration_ms = 0.0f; - return; // done updating this entity - } - } + if(npc_comp->npc_type == NPCType::MINION) { + if(npc_state->current_state == EntityState::ATTACKING) { + // TODO if we're "flattening the navmesh" then this should really be a Vec2 - ploinky 21/11/2025 + Vec3 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; + Vec3 current_position = Vec3(npc_movement->position.x, 0, npc_movement->position.y); - if(npc_state->current_state == EntityState::MOVING || npc_state->current_state == EntityState::PATHFINDING_WAITING) { - // TODO how do I find all entities in my general area that are attackable? - ploinky 20/11/2025 - for(auto other_entity : ctx.entity_manager.get_entities_with_component()) { - if(other_entity == npc_entity) { - continue; + // TODO Having this "stay aggrod" distance in code is a bad idea. + // This should be in data, because you may want different chasing distances per map. - ploinky 21/11/2025 + if(std::abs((current_waypoint - current_position).length()) > 30.0f) { + npc_state->current_state = EntityState::MOVING; + npc_state->target_entity_id = INVALID_ENTITY_ID; + npc_state->state_duration_ms = 0.0f; + return; // done updating this entity } + } - Movement* other_movement = other_entity->get_component(); - if(!other_movement) { - continue; // continue checking other entities in range - } + if(npc_state->current_state == EntityState::MOVING || npc_state->current_state == EntityState::PATHFINDING_WAITING) { + // TODO how do I find all entities in my general area that are attackable? - ploinky 20/11/2025 + for(auto other_entity : ctx.entity_manager.get_entities_with_component()) { + if(other_entity == npc_entity) { + continue; + } - // TODO This check needs to be against a different field in an attack component, - // "acquisition_range" or something similar - ploinky 20/11/2025 - if(std::abs((npc_movement->position - other_movement->position).length()) <= npc_stats->attack_range) { - npc_state->current_state = EntityState::ATTACKING; - npc_state->target_entity_id = other_entity->get_id(); - npc_state->state_duration_ms = 0.0f; - LOG_INFO("Entity %d is attacking entity %d", npc_entity->get_id(), other_entity->get_id()); - return; // done updating this entity + Movement* other_movement = other_entity->get_component(); + if(!other_movement) { + continue; // continue checking other entities in range + } + + // TODO This check needs to be against a different field in an attack component, + // "acquisition_range" or something similar - ploinky 20/11/2025 + if(std::abs((npc_movement->position - other_movement->position).length()) <= npc_stats->attack_range) { + npc_state->current_state = EntityState::ATTACKING; + npc_state->target_entity_id = other_entity->get_id(); + npc_state->state_duration_ms = 0.0f; + LOG_INFO("Entity %d is attacking entity %d", npc_entity->get_id(), other_entity->get_id()); + return; // done updating this entity + } } } } From cdc0d3fd4b712d6831252e3f9475e1def03d5d13 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 16:13:19 -0500 Subject: [PATCH 37/79] add chase_distance to xml and integrate --- data/entities/_entity.xsd | 2 ++ data/entities/minions/melee_minion.xml | 5 ++++- src/components/npc_component.hpp | 2 ++ src/systems/data_loader.cpp | 1 + src/systems/npc_system.cpp | 4 +--- 5 files changed, 10 insertions(+), 4 deletions(-) diff --git a/data/entities/_entity.xsd b/data/entities/_entity.xsd index 0bab8fc..695caa5 100644 --- a/data/entities/_entity.xsd +++ b/data/entities/_entity.xsd @@ -29,6 +29,8 @@ + + diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml index c702309..831dcd4 100644 --- a/data/entities/minions/melee_minion.xml +++ b/data/entities/minions/melee_minion.xml @@ -17,5 +17,8 @@ attack_speed="1.0" /> - + \ No newline at end of file diff --git a/src/components/npc_component.hpp b/src/components/npc_component.hpp index 8952db9..9109ffd 100644 --- a/src/components/npc_component.hpp +++ b/src/components/npc_component.hpp @@ -9,6 +9,8 @@ enum class NPCType { struct NPCComponent : public Component { NPCType npc_type; + float chase_distance = 30.0f; + float chase_timeout_ms = 5000.0f; // How long to keep chasing without hitting the target (not implemented)-- cmkrist 24/11/2025 COMPONENT_TYPE_ID(NPCComponent, ComponentTypes::NPC) }; \ No newline at end of file diff --git a/src/systems/data_loader.cpp b/src/systems/data_loader.cpp index 02eb2ad..8ab869b 100644 --- a/src/systems/data_loader.cpp +++ b/src/systems/data_loader.cpp @@ -124,6 +124,7 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { if(npc_node != NULL) { std::shared_ptr npc = std::make_shared(); LOAD_ENUM_ATTRIBUTE(npc_node, npc, npc_type, string_to_npc_type) + LOAD_ATTRIBUTE(npc_node, npc, chase_distance, float) temp.component_templates.push_back(npc); } diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index fb77e74..4a69ac9 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -28,9 +28,7 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { Vec3 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; Vec3 current_position = Vec3(npc_movement->position.x, 0, npc_movement->position.y); - // TODO Having this "stay aggrod" distance in code is a bad idea. - // This should be in data, because you may want different chasing distances per map. - ploinky 21/11/2025 - if(std::abs((current_waypoint - current_position).length()) > 30.0f) { + if(std::abs((current_waypoint - current_position).length()) > npc_comp->chase_distance) { npc_state->current_state = EntityState::MOVING; npc_state->target_entity_id = INVALID_ENTITY_ID; npc_state->state_duration_ms = 0.0f; From 98720309fe9d8feed7b7b0559a0d833629b1fcf3 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 16:28:43 -0500 Subject: [PATCH 38/79] Move vectors to 2D --- src/systems/npc_system.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index 4a69ac9..e7224ab 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -24,11 +24,10 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { if(npc_comp->npc_type == NPCType::MINION) { if(npc_state->current_state == EntityState::ATTACKING) { - // TODO if we're "flattening the navmesh" then this should really be a Vec2 - ploinky 21/11/2025 Vec3 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; - Vec3 current_position = Vec3(npc_movement->position.x, 0, npc_movement->position.y); + Vec2 waypoint_2d = Vec2(current_waypoint.x, current_waypoint.z); - if(std::abs((current_waypoint - current_position).length()) > npc_comp->chase_distance) { + if((waypoint_2d - npc_movement->position).length() > npc_comp->chase_distance) { npc_state->current_state = EntityState::MOVING; npc_state->target_entity_id = INVALID_ENTITY_ID; npc_state->state_duration_ms = 0.0f; @@ -50,7 +49,7 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { // TODO This check needs to be against a different field in an attack component, // "acquisition_range" or something similar - ploinky 20/11/2025 - if(std::abs((npc_movement->position - other_movement->position).length()) <= npc_stats->attack_range) { + if((npc_movement->position - other_movement->position).length() <= npc_stats->attack_range) { npc_state->current_state = EntityState::ATTACKING; npc_state->target_entity_id = other_entity->get_id(); npc_state->state_duration_ms = 0.0f; From 16848a7c9650d3ec5b1f3a6a75933351cb0d1e42 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 16:36:39 -0500 Subject: [PATCH 39/79] Move moment logic to all 2d --- src/components/pathfinding.hpp | 4 ++-- src/services/navigation_service.cpp | 7 ++----- src/services/navigation_service.hpp | 2 +- src/systems/movement_system.cpp | 7 +++---- src/systems/npc_system.cpp | 5 ++--- 5 files changed, 10 insertions(+), 15 deletions(-) diff --git a/src/components/pathfinding.hpp b/src/components/pathfinding.hpp index d4dbb51..e640b85 100644 --- a/src/components/pathfinding.hpp +++ b/src/components/pathfinding.hpp @@ -11,8 +11,8 @@ * Entity state is tracked in EntityStateComponent (PATHFINDING_WAITING, MOVING, STUCK). */ struct PathfindingComponent : public Component { - // Current path waypoints (3D positions) - std::vector waypoints; + // Current path waypoints (2D positions) + std::vector waypoints; // Index of the next waypoint to move toward int current_waypoint_index = 0; diff --git a/src/services/navigation_service.cpp b/src/services/navigation_service.cpp index 193770b..66e7666 100644 --- a/src/services/navigation_service.cpp +++ b/src/services/navigation_service.cpp @@ -80,13 +80,10 @@ struct NavigationService::NavServiceBackend { req.entity_pathing_radius ); - // Convert the 2D path back to 3D (keeping Y from destination for now) + // Store the 2D path directly PathResult res = PathResult(); res.entity_id = req.entity_id; - res.path.reserve(path_2d.size()); - for (const auto& waypoint_2d : path_2d) { - res.path.push_back(Vec3(waypoint_2d.x, req.destination.y, waypoint_2d.y)); - } + res.path = path_2d; if (res.path.empty()) { LOG_WARN("Navigation: Entity %u path from (%.1f, %.1f) to (%.1f, %.1f) returned EMPTY PATH", diff --git a/src/services/navigation_service.hpp b/src/services/navigation_service.hpp index cdab217..8bad7e2 100644 --- a/src/services/navigation_service.hpp +++ b/src/services/navigation_service.hpp @@ -18,7 +18,7 @@ class PathRequest { class PathResult { public: uint32_t entity_id; - std::vector path; + std::vector path; }; class NavigationService { diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index 8b4d01f..3d559ff 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -190,10 +190,9 @@ void MovementSystem::update_waypoint_movement(const SystemContext& ctx, Entity& } // Move toward current waypoint - Vec3 current_waypoint = pathfinding.waypoints[pathfinding.current_waypoint_index]; - Vec2 waypoint_2d = Vec2(current_waypoint.x, current_waypoint.z); + Vec2 current_waypoint = pathfinding.waypoints[pathfinding.current_waypoint_index]; Vec2 current_pos = movement.position; - Vec2 direction = waypoint_2d - current_pos; + Vec2 direction = current_waypoint - current_pos; float distance = direction.length(); // Check if reached waypoint @@ -207,7 +206,7 @@ void MovementSystem::update_waypoint_movement(const SystemContext& ctx, Entity& float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); Vec2 new_position = (distance_to_move >= distance) - ? waypoint_2d + ? current_waypoint : current_pos + (direction.normalized() * distance_to_move); movement.position = new_position; diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index e7224ab..041e971 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -24,10 +24,9 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { if(npc_comp->npc_type == NPCType::MINION) { if(npc_state->current_state == EntityState::ATTACKING) { - Vec3 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; - Vec2 waypoint_2d = Vec2(current_waypoint.x, current_waypoint.z); + Vec2 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; - if((waypoint_2d - npc_movement->position).length() > npc_comp->chase_distance) { + if((current_waypoint - npc_movement->position).length() > npc_comp->chase_distance) { npc_state->current_state = EntityState::MOVING; npc_state->target_entity_id = INVALID_ENTITY_ID; npc_state->state_duration_ms = 0.0f; From 8b0190ce64da9458f9ee6d7e9463822d13647de5 Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 24 Nov 2025 22:49:33 +0100 Subject: [PATCH 40/79] Properly pick npc entities by npc component --- src/systems/npc_system.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index 041e971..3ba9f71 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -4,8 +4,7 @@ #include "components/npc_component.hpp" void NPCSystem::update(const SystemContext& ctx) { - // TODO properly pick npc entities only - ploinky 20/11/2025 - for(auto npc_entity : ctx.entity_manager.get_entities_with_component()) { + for(auto npc_entity : ctx.entity_manager.get_entities_with_component()) { update_entity(ctx, npc_entity); } } From d65666fdc8cbc3245640d6a9877c885e846bbaba Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 24 Nov 2025 22:55:07 +0100 Subject: [PATCH 41/79] Avoid invalid vector access --- src/systems/npc_system.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index 3ba9f71..37ee26e 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -22,7 +22,9 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { } if(npc_comp->npc_type == NPCType::MINION) { - if(npc_state->current_state == EntityState::ATTACKING) { + + // Stop attacking if the minion is too far away from its path + if(npc_state->current_state == EntityState::ATTACKING && npc_path->waypoints.size() > 0) { Vec2 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; if((current_waypoint - npc_movement->position).length() > npc_comp->chase_distance) { @@ -33,6 +35,7 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { } } + // If the minion is running down its path, stop pathing and attack any enemy entities within aggro range if(npc_state->current_state == EntityState::MOVING || npc_state->current_state == EntityState::PATHFINDING_WAITING) { // TODO how do I find all entities in my general area that are attackable? - ploinky 20/11/2025 for(auto other_entity : ctx.entity_manager.get_entities_with_component()) { From e212548ccedfc7372c136332ebe37db7862bfba6 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:50:04 -0500 Subject: [PATCH 42/79] XML AI Updates --- data/entities/_entity.xsd | 30 +++++++++++++++++++ data/entities/minions/cannon_minion.xml | 13 ++++++++ .../{magic_minon.xml => magic_minion.xml} | 20 +++++++++++-- data/entities/minions/melee_minion.xml | 13 ++++++++ data/entities/minions/ranged_minion.xml | 13 ++++++++ data/entities/player.xml | 12 ++++++++ 6 files changed, 99 insertions(+), 2 deletions(-) rename data/entities/minions/{magic_minon.xml => magic_minion.xml} (50%) create mode 100644 data/entities/player.xml diff --git a/data/entities/_entity.xsd b/data/entities/_entity.xsd index 695caa5..c9ddee0 100644 --- a/data/entities/_entity.xsd +++ b/data/entities/_entity.xsd @@ -34,6 +34,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/data/entities/minions/cannon_minion.xml b/data/entities/minions/cannon_minion.xml index 0570f2c..8f8f9eb 100644 --- a/data/entities/minions/cannon_minion.xml +++ b/data/entities/minions/cannon_minion.xml @@ -18,4 +18,17 @@ /> + + + \ No newline at end of file diff --git a/data/entities/minions/magic_minon.xml b/data/entities/minions/magic_minion.xml similarity index 50% rename from data/entities/minions/magic_minon.xml rename to data/entities/minions/magic_minion.xml index 9a09f0f..0cb0e56 100644 --- a/data/entities/minions/magic_minon.xml +++ b/data/entities/minions/magic_minion.xml @@ -11,12 +11,28 @@ max_health="80" health="80" move_speed="4.0" - magical_power="10" + magic_power="10" armor="2" magic_resist="5" attack_range="5.5" attack_speed="0.8" /> - + + + + \ No newline at end of file diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml index 831dcd4..7191582 100644 --- a/data/entities/minions/melee_minion.xml +++ b/data/entities/minions/melee_minion.xml @@ -21,4 +21,17 @@ type="minion" chase_distance="10.0" /> + + + \ No newline at end of file diff --git a/data/entities/minions/ranged_minion.xml b/data/entities/minions/ranged_minion.xml index fa6461b..8054234 100644 --- a/data/entities/minions/ranged_minion.xml +++ b/data/entities/minions/ranged_minion.xml @@ -18,4 +18,17 @@ /> + + + \ No newline at end of file diff --git a/data/entities/player.xml b/data/entities/player.xml new file mode 100644 index 0000000..2faf7d2 --- /dev/null +++ b/data/entities/player.xml @@ -0,0 +1,12 @@ + + + + + + + From fdc1bc22d5e97ee22289c7623685958a4e63ec5b Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:51:12 -0500 Subject: [PATCH 43/79] remove entity duplication, 5s first wave --- src/systems/wave_system.cpp | 11 +++-------- src/systems/wave_system.hpp | 5 +++-- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/src/systems/wave_system.cpp b/src/systems/wave_system.cpp index 1652a19..14f9f37 100644 --- a/src/systems/wave_system.cpp +++ b/src/systems/wave_system.cpp @@ -72,7 +72,7 @@ void WaveSystem::update(const SystemContext& ctx) { } } // Wave Spawning - if (elapsed_time_ms >= wave_interval_ms) { + if (elapsed_time_ms >= (wave_index == 0 ? first_wave_delay_ms : wave_interval_ms)) { LOG_INFO("Spawning new wave"); minion_index = 1; wave_index++; @@ -90,13 +90,8 @@ bool WaveSystem::create_minion(const SystemContext& ctx, const std::string& mini // Find spawn position Vec2 spawn_pos = map_->spawnpoints[spawn_point_id]; - // Get collision radius from template entity if available - Entity& temp = ctx.entity_manager.create_entity_from_template(minion_template); - float collision_radius = 0.5f; // Default - if (auto* move = temp.get_component()) { - collision_radius = move->collision_radius; - } - ctx.entity_manager.destroy_entity(temp.get_id()); + // Get collision radius from template without creating an entity + float collision_radius = ctx.entity_manager.get_template_collision_radius(minion_template); // Find free spawn position spawn_pos = find_free_spawn_position(spawn_point_id, collision_radius); diff --git a/src/systems/wave_system.hpp b/src/systems/wave_system.hpp index aeece0d..bcc33e8 100644 --- a/src/systems/wave_system.hpp +++ b/src/systems/wave_system.hpp @@ -59,8 +59,9 @@ class WaveSystem { NavigationService* navigation_service_ = nullptr; const Map* map_ = nullptr; SpawningSystem spawning_system_; - float wave_interval_ms = 30000.0f; // 30 seconds between waves - float wave_delay_ms = 1000.0f; // 1 second delay between minions in a wave + float wave_interval_ms = 30000.0f; // 30 seconds between waves (debug timing) + float first_wave_delay_ms = 1000.0f; // 1 second before first wave spawns (debug timing - reduced for testing) + float wave_delay_ms = 100.0f; // 100ms delay between minions in a wave (debug timing - reduced for testing) float elapsed_time_ms; float last_spawn_timestamp; int minion_index; From a4ca854bfca549995addc6355453d06ee7817bbf Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:51:50 -0500 Subject: [PATCH 44/79] Targeting System --- src/systems/targeting_system.cpp | 331 +++++++++++++++++++++++++++++++ src/systems/targeting_system.hpp | 190 ++++++++++++++++++ 2 files changed, 521 insertions(+) create mode 100644 src/systems/targeting_system.cpp create mode 100644 src/systems/targeting_system.hpp diff --git a/src/systems/targeting_system.cpp b/src/systems/targeting_system.cpp new file mode 100644 index 0000000..a203d3c --- /dev/null +++ b/src/systems/targeting_system.cpp @@ -0,0 +1,331 @@ +#include "targeting_system.hpp" +#include +#include +#include +#include + +std::vector TargetingSystem::update( + EntityManager& entity_manager, + float delta_time) +{ + std::vector events; + + // Get all entities in the manager + const auto& all_entities = entity_manager.get_all_entities(); + + // Process each entity that has AutoAttack component + for (const auto& entity_pair : all_entities) { + Entity* entity = entity_pair.second.get(); + if (!entity || !entity->has_component()) { + continue; + } + + // Process auto-attack for this entity + auto entity_events = process_auto_attack(entity_manager, entity->get_id(), delta_time); + events.insert(events.end(), entity_events.begin(), entity_events.end()); + } + + return events; +} + +std::vector TargetingSystem::get_targets_in_range( + EntityManager& entity_manager, + EntityID entity_id, + bool include_allies) const +{ + std::vector targets; + + Entity* observer = entity_manager.get_entity(entity_id); + if (!observer || !observer->has_component() || !observer->has_component()) { + return targets; + } + + Movement* observer_movement = observer->get_component(); + Stats* observer_stats = observer->get_component(); + + const auto& all_entities = entity_manager.get_all_entities(); + + for (const auto& entity_pair : all_entities) { + Entity* potential_target = entity_pair.second.get(); + + // Skip self + if (potential_target->get_id() == entity_id) { + continue; + } + + // Skip entities without movement or stats + if (!potential_target->has_component() || !potential_target->has_component()) { + continue; + } + + // Skip if not in vision range + Movement* target_movement = potential_target->get_component(); + if (!is_in_vision_range(observer_movement->position, target_movement->position, observer_stats->vision_range)) { + continue; + } + + // Skip if not eligible for combat + if (!can_engage_in_combat(entity_manager, entity_id, potential_target->get_id())) { + continue; + } + + targets.push_back(potential_target->get_id()); + } + + return targets; +} + +bool TargetingSystem::is_in_attack_range( + const Vec3& attacker_position, + const Vec3& target_position, + float attack_range) const +{ + float distance = calculate_distance(attacker_position, target_position); + return distance <= attack_range; +} + +bool TargetingSystem::is_in_vision_range( + const Vec3& observer_position, + const Vec3& target_position, + float vision_range) const +{ + float distance = calculate_distance(observer_position, target_position); + return distance <= vision_range; +} + +bool TargetingSystem::acquire_target( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id) +{ + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity || !entity->has_component()) { + return false; + } + + // Validate target exists + Entity* target = entity_manager.get_entity(target_id); + if (!target) { + return false; + } + + // Validate can engage in combat + if (!can_engage_in_combat(entity_manager, entity_id, target_id)) { + return false; + } + + AutoAttack* auto_attack = entity->get_component(); + auto_attack->target_id = target_id; + auto_attack->is_attacking = true; + + LOG_INFO("Targeting: Entity (ID %u) acquired target (ID %u)", entity_id, target_id); + return true; +} + +bool TargetingSystem::release_target( + EntityManager& entity_manager, + EntityID entity_id) +{ + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity || !entity->has_component()) { + return false; + } + + AutoAttack* auto_attack = entity->get_component(); + if (auto_attack->target_id == INVALID_TARGET_ID) { + return false; + } + + EntityID old_target = auto_attack->target_id; + auto_attack->target_id = INVALID_TARGET_ID; + auto_attack->is_attacking = false; + + LOG_INFO("Targeting: Entity (ID %u) released target (ID %u)", entity_id, old_target); + return true; +} + +bool TargetingSystem::can_engage_in_combat( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id) const +{ + Entity* entity = entity_manager.get_entity(entity_id); + Entity* target = entity_manager.get_entity(target_id); + + if (!entity || !target) { + return false; + } + + // Both must have Stats and Movement for combat + if (!entity->has_component() || !target->has_component()) { + return false; + } + + if (!entity->has_component() || !target->has_component()) { + return false; + } + + // Check if target is alive + Stats* target_stats = target->get_component(); + if (target_stats->health <= 0.0f) { + return false; + } + + // Check if attacker is alive + Stats* entity_stats = entity->get_component(); + if (entity_stats->health <= 0.0f) { + return false; + } + + // TODO: Add team/faction checks here when team system is implemented + // For now, all minions can attack each other + + return true; +} + +bool TargetingSystem::is_target_valid( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id) const +{ + // Validate entity still exists + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity || !entity->has_component()) { + return false; + } + + // Check if we can still engage in combat + if (!can_engage_in_combat(entity_manager, entity_id, target_id)) { + return false; + } + + // Check if target is still in vision range + Entity* target = entity_manager.get_entity(target_id); + if (!target || !target->has_component()) { + return false; + } + + Movement* entity_movement = entity->get_component(); + Movement* target_movement = target->get_component(); + Stats* entity_stats = entity->get_component(); + + if (!is_in_vision_range(entity_movement->position, target_movement->position, entity_stats->vision_range)) { + return false; + } + + return true; +} + +EntityID TargetingSystem::get_closest_target( + EntityManager& entity_manager, + EntityID entity_id) const +{ + std::vector targets = get_targets_in_range(entity_manager, entity_id); + + if (targets.empty()) { + return INVALID_ENTITY_ID; + } + + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity || !entity->has_component()) { + return INVALID_ENTITY_ID; + } + + Movement* entity_movement = entity->get_component(); + + EntityID closest_id = targets[0]; + float closest_distance = std::numeric_limits::max(); + + for (EntityID target_id : targets) { + Entity* target = entity_manager.get_entity(target_id); + if (!target || !target->has_component()) { + continue; + } + + Movement* target_movement = target->get_component(); + float distance = calculate_distance(entity_movement->position, target_movement->position); + + if (distance < closest_distance) { + closest_distance = distance; + closest_id = target_id; + } + } + + return closest_id; +} + +float TargetingSystem::calculate_distance(const Vec3& pos1, const Vec3& pos2) const +{ + Vec3 delta = pos1 - pos2; + return std::sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z); +} + +std::vector TargetingSystem::process_auto_attack( + EntityManager& entity_manager, + EntityID entity_id, + float delta_time) +{ + std::vector events; + + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity) { + return events; + } + + AutoAttack* auto_attack = entity->get_component(); + if (!auto_attack || !auto_attack->auto_attack_enabled) { + return events; + } + + // Update attack cooldown + if (auto_attack->attack_cooldown > 0.0f) { + auto_attack->attack_cooldown -= delta_time; + } + + // Check current target validity + if (auto_attack->target_id != INVALID_TARGET_ID) { + if (!is_target_valid(entity_manager, entity_id, auto_attack->target_id)) { + // Target became invalid, release it + release_target(entity_manager, entity_id); + TargetingEvent event; + event.entity_id = entity_id; + event.target_id = INVALID_TARGET_ID; + event.acquired = false; + events.push_back(event); + } + } + + // If no valid target, try to find one + if (auto_attack->target_id == INVALID_TARGET_ID && auto_attack->auto_attack_enabled) { + EntityID new_target = find_new_target(entity_manager, entity_id); + if (new_target != INVALID_ENTITY_ID) { + acquire_target(entity_manager, entity_id, new_target); + TargetingEvent event; + event.entity_id = entity_id; + event.target_id = new_target; + event.acquired = true; + events.push_back(event); + } + } + + return events; +} + +EntityID TargetingSystem::find_new_target( + EntityManager& entity_manager, + EntityID entity_id) +{ + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity) { + return INVALID_ENTITY_ID; + } + + // Get closest target within vision range + EntityID closest_target = get_closest_target(entity_manager, entity_id); + + if (closest_target != INVALID_ENTITY_ID) { + LOG_DEBUG("Targeting: Entity (ID %u) found new target (ID %u)", entity_id, closest_target); + } + + return closest_target; +} diff --git a/src/systems/targeting_system.hpp b/src/systems/targeting_system.hpp new file mode 100644 index 0000000..33b9852 --- /dev/null +++ b/src/systems/targeting_system.hpp @@ -0,0 +1,190 @@ +#pragma once + +#include "entity_manager.hpp" +#include "components/auto_attack.hpp" +#include "components/movement.hpp" +#include "components/stats.hpp" +#include "systems/math.hpp" +#include +#include + +/** + * Targeting and Combat Detection System + * + * Responsible for: + * - Detecting potential targets within entity vision ranges + * - Validating target eligibility (team, state, distance) + * - Managing auto-attack target acquisition and retention + * - Triggering attacks when targets enter attack range + * - Coordinating with CombatSystem for actual damage application + */ +class TargetingSystem { +public: + /** + * Targeting event for when an entity acquires or loses a target + */ + struct TargetingEvent { + EntityID entity_id; // Entity that acquired/lost target + EntityID target_id; // The target entity (0 if lost target) + bool acquired; // true if acquired, false if lost + }; + + /** + * Combat detection event for when an entity enters attack range + */ + struct CombatDetectionEvent { + EntityID attacker_id; // Entity initiating combat + EntityID target_id; // Target entity + float distance; // Current distance to target + float attack_range; // Attack range of attacker + }; + + TargetingSystem() = default; + virtual ~TargetingSystem() = default; + + /** + * Update targeting system - detect targets and manage auto-attacks + * Should be called once per frame/tick from the main game loop + * @param entity_manager Reference to the entity manager + * @param delta_time Time elapsed since last update (in seconds) + * @return Vector of targeting events that occurred during this update + */ + std::vector update( + EntityManager& entity_manager, + float delta_time + ); + + /** + * Get all targets within an entity's vision range + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity searching for targets + * @param include_allies Whether to include allies in results (default: false) + * @return Vector of entity IDs within vision range + */ + std::vector get_targets_in_range( + EntityManager& entity_manager, + EntityID entity_id, + bool include_allies = false + ) const; + + /** + * Check if a target is within attack range of an attacker + * @param attacker_position Position of the attacking entity + * @param target_position Position of the target entity + * @param attack_range Attack range in world units + * @return true if target is within attack range + */ + bool is_in_attack_range( + const Vec3& attacker_position, + const Vec3& target_position, + float attack_range + ) const; + + /** + * Check if a target is within vision range of an observer + * @param observer_position Position of the observing entity + * @param target_position Position of the target entity + * @param vision_range Vision range in world units + * @return true if target is within vision range + */ + bool is_in_vision_range( + const Vec3& observer_position, + const Vec3& target_position, + float vision_range + ) const; + + /** + * Acquire a target for an entity + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity acquiring the target + * @param target_id ID of the target to acquire + * @return true if target was acquired successfully + */ + bool acquire_target( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id + ); + + /** + * Release the current target of an entity + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity releasing its target + * @return true if target was released (entity had a target) + */ + bool release_target( + EntityManager& entity_manager, + EntityID entity_id + ); + + /** + * Check if two entities are on opposing teams/can attack each other + * For now, this checks if both have Movement components (minions can attack each other) + * @param entity_manager Reference to the entity manager + * @param entity_id Entity to check + * @param target_id Potential target to check + * @return true if entities can engage in combat + */ + bool can_engage_in_combat( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id + ) const; + + /** + * Check if a target is still valid (alive, in range, can engage) + * @param entity_manager Reference to the entity manager + * @param entity_id Entity that has the target + * @param target_id Current target ID to validate + * @return true if target is still valid + */ + bool is_target_valid( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id + ) const; + + /** + * Get the closest enemy target within vision range + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity searching for targets + * @return ID of closest enemy, or INVALID_ENTITY_ID if none found + */ + EntityID get_closest_target( + EntityManager& entity_manager, + EntityID entity_id + ) const; + +private: + /** + * Calculate distance between two entities + * @param pos1 First position + * @param pos2 Second position + * @return Distance between positions + */ + float calculate_distance(const Vec3& pos1, const Vec3& pos2) const; + + /** + * Process auto-attack logic for an entity + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity to process + * @param delta_time Time elapsed since last update + * @return TargetingEvent if a targeting change occurred, nullptr otherwise + */ + std::vector process_auto_attack( + EntityManager& entity_manager, + EntityID entity_id, + float delta_time + ); + + /** + * Attempt to find a new target for an entity + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity searching for a target + * @return ID of new target, or INVALID_ENTITY_ID if none found + */ + EntityID find_new_target( + EntityManager& entity_manager, + EntityID entity_id + ); +}; From 46b27863addda5183d7e8c0776cd7fa632a1f31f Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:52:02 -0500 Subject: [PATCH 45/79] Attack Execution System --- src/systems/attack_execution_system.cpp | 101 ++++++++++++++++++++++++ src/systems/attack_execution_system.hpp | 70 ++++++++++++++++ 2 files changed, 171 insertions(+) create mode 100644 src/systems/attack_execution_system.cpp create mode 100644 src/systems/attack_execution_system.hpp diff --git a/src/systems/attack_execution_system.cpp b/src/systems/attack_execution_system.cpp new file mode 100644 index 0000000..53c8d8e --- /dev/null +++ b/src/systems/attack_execution_system.cpp @@ -0,0 +1,101 @@ +#include "attack_execution_system.hpp" +#include "components/auto_attack.hpp" +#include "components/entity_state.hpp" +#include "serialization_system.hpp" +#include "services/network_service.hpp" +#include + +void AttackExecutionSystem::update(const SystemContext& ctx) { + if (!combat_system_) { + LOG_WARN("AttackExecutionSystem: combat_system not set!"); + return; + } + + // Process all entities with pending attacks + auto attacking_entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : attacking_entities) { + if (entity) { + auto* attack = entity->get_component(); + if (attack && attack->attack_in_progress) { + execute_attack(ctx, *entity, *attack, ctx.delta_time_ms); + } + } + } +} + +bool AttackExecutionSystem::execute_attack(const SystemContext& ctx, Entity& entity, + AttackComponent& attack, float delta_time_ms) { + // Get auto-attack component for hit timing + auto* auto_attack = entity.get_component(); + if (!auto_attack) { + auto_attack = nullptr; // Optional component + } + + float hit_timing_percent = auto_attack ? auto_attack->hit_timing_percent : 0.5f; + float animation_duration = attack.attack_animation_duration_ms > 0.0f + ? attack.attack_animation_duration_ms + : 300.0f; + + // Store old progress to detect threshold crossing + float old_progress = attack.attack_animation_progress; + + // Update animation progress + attack.attack_animation_progress += delta_time_ms / animation_duration; + + // Check if we should apply damage (crossed the hit timing threshold) + bool damage_applied = false; + if (old_progress < hit_timing_percent && attack.attack_animation_progress >= hit_timing_percent) { + // It's time to apply damage! + // First check if attacker is still alive + auto* attacker_stats = entity.get_component(); + if (attacker_stats && attacker_stats->health > 0.0f && attack.pending_target != INVALID_ENTITY_ID) { + auto damage_events = combat_system_->apply_damage( + ctx.entity_manager, + entity.get_id(), + attack.pending_target, + attack.pending_damage, + attack.pending_damage_type + ); + + if (!damage_events.empty()) { + LOG_INFO("Attack executed: entity %u dealt %.1f damage to entity %u", + entity.get_id(), damage_events[0].damage_dealt, attack.pending_target); + + // Broadcast combat event to all clients -- might need to be moved later -- cmkrist 24/11/2025 + if (ctx.network_service) { + const auto& event = damage_events[0]; + auto combat_packet = SerializationSystem::serialize_combat_event( + entity.get_id(), + attack.pending_target, + event.damage_dealt, + static_cast(event.damage_type), + event.was_critical_hit + ); + ctx.network_service->broadcast_packet(combat_packet); + } + + damage_applied = true; + } + } else if (attacker_stats && attacker_stats->health <= 0.0f) { + LOG_DEBUG("Cancelling attack: attacker %u is dead", entity.get_id()); + } + } + + // Check if animation is complete + if (attack.attack_animation_progress >= 1.0f) { + attack.attack_animation_progress = 1.0f; + attack.attack_in_progress = false; + + // Clear pending attack data + attack.pending_damage = 0.0f; + attack.pending_target = INVALID_ENTITY_ID; + attack.pending_damage_type = DamageType::PHYSICAL; + } + + return damage_applied; +} + +bool AttackExecutionSystem::is_damage_apply_time(float attack_progress, float hit_timing_percent) const { + // Damage applies when we reach or pass the hit timing threshold + return attack_progress >= hit_timing_percent; +} diff --git a/src/systems/attack_execution_system.hpp b/src/systems/attack_execution_system.hpp new file mode 100644 index 0000000..7ddc2cf --- /dev/null +++ b/src/systems/attack_execution_system.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include "entity_manager.hpp" +#include "system_context.hpp" +#include "combat_system.hpp" +#include "components/attack.hpp" + +/** + * AttackExecutionSystem - Executes pending attacks and applies damage + * + * RESPONSIBILITIES: + * - Update attack animation progress each frame + * - Detect when damage should be applied based on animation timing + * - Call CombatSystem.apply_damage() at the right moment + * - Clean up completed attacks + * - Reset attack state after animations complete + * + * COMPONENTS USED: + * - AttackComponent (attack state and pending attack data) + * - AutoAttackComponent (animation timing parameters) + * - Stats (for damage calculation) + * + * SYSTEM INTERACTION: + * - Runs AFTER AutoAttackSystem (which queues attacks) + * - Runs AFTER CombatSystem (separate pass for execution) + * - Calls CombatSystem.apply_damage() to process damage + * + * DATA-DRIVEN DESIGN: + * Attacks are queued with pending data (damage, target, animation duration). + * This system executes those attacks based on the configured animation timing. + */ +class AttackExecutionSystem { +public: + /** + * Set reference to combat system for applying damage. + * Must be called before update(). + * @param combat_system Reference to CombatSystem + */ + void set_combat_system(CombatSystem* combat_system) { + combat_system_ = combat_system; + } + + /** + * Update all pending attacks for this frame. + * Processes attack animations and applies damage at the correct time. + * @param ctx System context with entity manager, services, and delta time + */ + void update(const SystemContext& ctx); + +private: + CombatSystem* combat_system_ = nullptr; + + /** + * Process a single entity's pending attack. + * @param ctx System context + * @param entity Entity with attack in progress + * @param attack Attack component with pending data + * @param delta_time_ms Time elapsed this frame + * @return true if damage was applied this frame + */ + bool execute_attack(const SystemContext& ctx, Entity& entity, AttackComponent& attack, float delta_time_ms); + + /** + * Check if it's time to apply damage based on animation progress and hit timing. + * @param attack_progress Current animation progress (0.0-1.0) + * @param hit_timing_percent When damage should occur (0.0-1.0) + * @return true if we just crossed the hit timing threshold + */ + bool is_damage_apply_time(float attack_progress, float hit_timing_percent) const; +}; From 5610b4722254d3abb86b12b0b6c7293b9a021a5e Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:52:20 -0500 Subject: [PATCH 46/79] Auto Attack System --- src/components/attack.hpp | 6 + src/systems/auto_attack_system.cpp | 320 +++++++++++++++++++++++++++++ src/systems/auto_attack_system.hpp | 122 +++++++++++ 3 files changed, 448 insertions(+) create mode 100644 src/systems/auto_attack_system.cpp create mode 100644 src/systems/auto_attack_system.hpp diff --git a/src/components/attack.hpp b/src/components/attack.hpp index 0b80e0f..d526c10 100644 --- a/src/components/attack.hpp +++ b/src/components/attack.hpp @@ -30,6 +30,12 @@ struct AttackComponent : public Component { // === Current Attack === bool attack_in_progress = false; // Currently executing attack animation/projectile float attack_animation_progress = 0.0f; // 0.0 to 1.0, used for timing hit/effects + float attack_animation_duration_ms = 300.0f; // Total duration of attack animation + + // === Pending Attack Data (set by AutoAttackSystem) === + float pending_damage = 0.0f; // Damage to apply when animation completes + EntityID pending_target = INVALID_ENTITY_ID; // Target of pending attack + DamageType pending_damage_type = DamageType::PHYSICAL; // Type of pending damage // === Attack Counters === uint32_t total_attacks = 0; // Total attacks landed (for stats/quests) diff --git a/src/systems/auto_attack_system.cpp b/src/systems/auto_attack_system.cpp new file mode 100644 index 0000000..968004b --- /dev/null +++ b/src/systems/auto_attack_system.cpp @@ -0,0 +1,320 @@ +#include "auto_attack_system.hpp" +#include "components/movement.hpp" +#include "components/entity_state.hpp" +#include "components/network_entity.hpp" +#include +#include +#include +#include + +void AutoAttackSystem::update(const SystemContext& ctx) { + // Process all entities with auto-attack behavior + auto attacking_entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : attacking_entities) { + if (entity) { + update_auto_attack(ctx, *entity, ctx.delta_time_ms); + } + } +} + +void AutoAttackSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms) { + auto* auto_attack = entity.get_component(); + auto* attack = entity.get_component(); + auto* target = entity.get_component(); + auto* stats = entity.get_component(); + auto* entity_state = entity.get_component(); + + if (!auto_attack || !attack || !target || !stats) { + return; // Missing required components + } + + // Don't process if entity is dead + if (is_dead(entity)) { + if (target->is_target_valid()) { + target->clear_target(); + } + return; + } + + // Update combat timer + auto_attack->update_combat_timer(delta_time_ms); + + // Update attack cooldown + update_attack_cooldown(*attack, delta_time_ms); + + // Don't process if auto-attacking disabled + if (!auto_attack->should_auto_attack()) { + // If we had a target but auto-attack is disabled, clear it + if (target->is_target_valid()) { + target->clear_target(); + } + return; + } + + // Search for new target if needed + if (!target->is_target_valid() && auto_attack->should_search_targets()) { + // Search for target on first search (last_target_search_ms == 0) or after interval has passed + if (target->last_target_search_ms == 0.0f || (auto_attack->time_since_attack_ms >= target->target_search_interval_ms)) { + EntityID new_target = find_best_target(ctx, entity, *auto_attack, *target); + if (new_target != INVALID_ENTITY_ID) { + target->set_target(new_target); + // Tell entity_state who to move toward via target_entity_id + if (entity_state) { + entity_state->target_entity_id = new_target; + } + LOG_INFO("Entity (ID %u) acquired new target: %u", entity.get_id(), new_target); + + // Update distance immediately so target validation works + Entity* target_entity = ctx.entity_manager.get_entity(new_target); + if (target_entity) { + auto* target_move = target_entity->get_component(); + auto* my_move = entity.get_component(); + if (target_move && my_move) { + float dx = target_move->position.x - my_move->position.x; + float dy = target_move->position.y - my_move->position.y; + float distance = std::sqrt(dx * dx + dy * dy); + target->update_target_distance(distance, stats->attack_range); + } + } + } + // Mark search as done - reset timer + target->last_target_search_ms = auto_attack->time_since_attack_ms; + } + } + + // Process valid targets + if (target->is_target_valid()) { + Entity* target_entity = ctx.entity_manager.get_entity(target->current_target); + + if (target_entity && !is_dead(*target_entity)) { + // Calculate distance to target + auto* target_move = target_entity->get_component(); + auto* my_move = entity.get_component(); + + if (target_move && my_move) { + float dx = target_move->position.x - my_move->position.x; + float dy = target_move->position.y - my_move->position.y; + float distance = std::sqrt(dx * dx + dy * dy); + + target->update_target_distance(distance, stats->attack_range); + + // Attack if in range and ready + if (target->target_in_range && is_attack_ready(*attack)) { + // Begin attack animation + begin_attack_animation(*attack); + + // Transition to ATTACKING state - movement system will handle kiting + if (entity_state && entity_state->current_state != EntityState::ATTACKING) { + entity_state->current_state = EntityState::ATTACKING; + entity_state->state_duration_ms = 0.0f; + } + + // Calculate damage + float base_damage = stats->physical_power + auto_attack->bonus_damage; + base_damage *= auto_attack->base_damage_multiplier; + + // Store attack data for CombatSystem to process + // (CombatSystem will call apply_damage when appropriate) + attack->pending_damage = base_damage; + attack->pending_damage_type = auto_attack->damage_type; + attack->pending_target = target->current_target; + attack->attack_animation_duration_ms = auto_attack->attack_animation_duration_ms; + + // Start cooldown + start_attack_cooldown(*attack, stats->attack_speed); + auto_attack->on_attack(); + + LOG_INFO("Entity (ID %u) initiated auto-attack on target (ID %u)", + entity.get_id(), target->current_target); + } else if (!target->target_in_range) { + // Out of range - MovementSystem will handle approaching via HOLDING_FOR_TARGET + // Just update the target_entity_id so it knows who to move toward + if (entity_state) { + entity_state->target_entity_id = target->current_target; + } + } + } + } else { + // Target is dead or invalid, clear it + // MovementSystem will handle state transitions based on pathfinding + target->clear_target(); + } + } +} + +EntityID AutoAttackSystem::find_best_target(const SystemContext& ctx, const Entity& attacker, + const AutoAttackComponent& auto_attack_comp, + TargetComponent& target_comp) const { + if (!attacker.has_component() || !attacker.has_component()) { + return INVALID_ENTITY_ID; + } + + const auto* attacker_move = attacker.get_component(); + // attacker_stats not needed for find_best_target - only for target validation + + EntityID best_target = INVALID_ENTITY_ID; + float best_score = -1e9f; + + // Get all entities with Movement (potential targets) + auto all_entities = ctx.entity_manager.get_entities_with_component(); + + for (auto* potential_target : all_entities) { + if (!potential_target || potential_target->get_id() == attacker.get_id()) { + continue; // Skip self + } + + // Check if valid target + if (!is_valid_target(ctx, attacker, *potential_target)) { + continue; + } + + // Calculate distance + auto* target_move = potential_target->get_component(); + if (!target_move) continue; + + float dx = target_move->position.x - attacker_move->position.x; + float dy = target_move->position.y - attacker_move->position.y; + float distance = std::sqrt(dx * dx + dy * dy); + + // Skip if out of aggro range + if (distance > auto_attack_comp.aggression_range) { + continue; + } + + // Calculate target score based on targeting mode + float score = 0.0f; + + auto* target_stats = potential_target->get_component(); + + switch (target_comp.targeting_mode) { + case TargetComponent::TargetPriority::NEAREST: + score = -distance; // Negative distance = higher score for closer + break; + + case TargetComponent::TargetPriority::LOWEST_HEALTH: + if (target_stats) { + score = -(target_stats->health); // Negative health = target low HP + } + break; + + case TargetComponent::TargetPriority::HIGHEST_THREAT: + if (target_stats) { + score = target_stats->physical_power + target_stats->magic_power; + } + break; + + case TargetComponent::TargetPriority::HIGHEST_DAMAGE: + if (target_stats) { + score = target_stats->physical_power; + } + break; + + default: + score = -distance; + break; + } + + // Prefer closer targets as tiebreaker + if (auto_attack_comp.prioritize_closest) { + score -= (distance * 0.1f); + } + + if (score > best_score) { + best_score = score; + best_target = potential_target->get_id(); + } + } + + return best_target; +} + +bool AutoAttackSystem::is_valid_target(const SystemContext& /*ctx*/, const Entity& attacker, + const Entity& potential_target) const { + // Must have stats + if (!potential_target.has_component()) { + return false; + } + + const auto* attacker_stats = attacker.get_component(); + const auto* target_stats = potential_target.get_component(); + + if (!attacker_stats || !target_stats) { + return false; + } + + // Can't target dead units + if (target_stats->health <= 0.0f) { + return false; + } + + // Can't target neutral observers + if (target_stats->team_id == 255) { + return false; + } + + // Can't target same team (unless friendly fire enabled) + if (attacker_stats->team_id != 0 && target_stats->team_id == attacker_stats->team_id) { + return false; + } + + // Target must be on opposite team or attacker neutral + if (attacker_stats->team_id == 0 && target_stats->team_id == 0) { + return false; // Can't target neutrals as neutral + } + + return true; +} + +bool AutoAttackSystem::is_dead(const Entity& entity) const { + if (!entity.has_component()) { + return true; + } + + const Stats* stats = entity.get_component(); + return stats->health <= 0.0f; +} + +void AutoAttackSystem::update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const { + if (attack.attack_cooldown_ms > 0.0f) { + attack.attack_cooldown_ms -= delta_time_ms; + if (attack.attack_cooldown_ms < 0.0f) { + attack.attack_cooldown_ms = 0.0f; + attack.can_attack = true; + } + } +} + +void AutoAttackSystem::start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const { + if (attack_speed_stat > 0.0f) { + attack.attack_cooldown_ms = (1000.0f / attack_speed_stat); // Convert to milliseconds + } else { + attack.attack_cooldown_ms = 1000.0f; // Default 1 second + } + attack.can_attack = false; + attack.attacks_this_frame = 0; +} + +bool AutoAttackSystem::is_attack_ready(const AttackComponent& attack) const { + return attack.attack_cooldown_ms <= 0.0f && attack.can_attack; +} + +void AutoAttackSystem::begin_attack_animation(AttackComponent& attack) const { + attack.attack_in_progress = true; + attack.attack_animation_progress = 0.0f; + attack.attacks_this_frame++; + attack.total_attacks++; +} + +bool AutoAttackSystem::update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const { + if (!attack.attack_in_progress) return false; + + attack.attack_animation_progress += delta_time_ms / animation_duration_ms; + + if (attack.attack_animation_progress >= 1.0f) { + attack.attack_animation_progress = 1.0f; + attack.attack_in_progress = false; + return true; // Attack complete + } + + return false; +} diff --git a/src/systems/auto_attack_system.hpp b/src/systems/auto_attack_system.hpp new file mode 100644 index 0000000..2378c97 --- /dev/null +++ b/src/systems/auto_attack_system.hpp @@ -0,0 +1,122 @@ +#pragma once + +#include "entity_manager.hpp" +#include "system_context.hpp" +#include "components/auto_attack.hpp" +#include "components/attack.hpp" +#include "components/target.hpp" +#include "components/stats.hpp" + +/** + * AutoAttackSystem - Handles auto-attack AI and cooldown mechanics + * + * RESPONSIBILITIES: + * - Automatic target acquisition and searching + * - Attack cooldown and readiness tracking + * - Combat timeout management + * - Target validation and prioritization + * - Attack animation management + * - Auto-attack execution coordination + * + * COMPONENTS USED: + * - AutoAttackComponent (AI behavior settings) + * - AttackComponent (attack state and cooldown) + * - TargetComponent (target tracking) + * - Stats (attack speed, health, damage stats) + * - Movement (position for range calculations) + * - EntityStateComponent (for state tracking) + * + * SYSTEM INTERACTION: + * - Works with CombatSystem which applies actual damage + * - Manages when and how attacks are initiated + * - Feeds attack information to network sync + * + * DATA-DRIVEN DESIGN: + * All auto-attack behavior is configured through AutoAttackComponent properties. + * This system reads those properties and executes accordingly without hardcoded logic. + */ +class AutoAttackSystem { +public: + /** + * Update all auto-attack behavior for this frame. + * Handles target search, cooldowns, and attack execution for all entities with AutoAttackComponent. + * @param ctx System context with entity manager, services, and delta time + */ + void update(const SystemContext& ctx); + +private: + /** + * Update and process auto-attacks for an entity. + * Handles cooldowns, target selection, and attack execution. + * @param ctx System context + * @param entity Entity to update + * @param delta_time_ms Time since last frame in milliseconds + */ + void update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms); + + /** + * Find best target for an entity based on targeting mode and auto-attack settings. + * @param ctx System context + * @param attacker Entity looking for target + * @param auto_attack_comp AutoAttackComponent for settings + * @param target_comp TargetComponent to update + * @return EntityID of best target, or INVALID_ENTITY_ID if none found + */ + EntityID find_best_target(const SystemContext& ctx, const Entity& attacker, + const AutoAttackComponent& auto_attack_comp, + TargetComponent& target_comp) const; + + /** + * Check if a potential target is valid (not dead, correct team, etc). + * @param ctx System context + * @param attacker Entity doing attacking + * @param potential_target Entity to validate + * @return true if valid target + */ + bool is_valid_target(const SystemContext& ctx, const Entity& attacker, + const Entity& potential_target) const; + + /** + * Check if an entity is dead (health <= 0). + * @param entity Entity to check + * @return true if entity is dead + */ + bool is_dead(const Entity& entity) const; + + /** + * Update attack cooldown for an entity. + * Called each frame to reduce the cooldown timer. + * @param attack Attack component to update + * @param delta_time_ms Time elapsed since last frame + */ + void update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const; + + /** + * Start attack cooldown based on attack speed stat. + * @param attack Attack component to update + * @param attack_speed_stat Attack speed from Stats component (attacks per second) + */ + void start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const; + + /** + * Check if an entity is ready to attack. + * @param attack Attack component to check + * @return true if cooldown is finished and entity can attack + */ + bool is_attack_ready(const AttackComponent& attack) const; + + /** + * Begin attack animation. + * @param attack Attack component to update + */ + void begin_attack_animation(AttackComponent& attack) const; + + /** + * Update attack animation progress. + * @param attack Attack component to update + * @param delta_time_ms Time elapsed + * @param animation_duration_ms Total animation duration + * @return true if animation is complete + */ + bool update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const; +}; From 5d625661affe1734a3743c9ce0686f4660bd08af Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:53:01 -0500 Subject: [PATCH 47/79] Update gamplay systems for combat --- src/systems/gameplay_coordinator.cpp | 6 ++++- src/systems/gameplay_coordinator.hpp | 33 ++++++++++++++++++++++------ 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index 5bafc3c..739b2a3 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -6,6 +6,9 @@ GameplayCoordinator::GameplayCoordinator() : wave_system_(nullptr) { // Systems initialized with default constructors // WaveSystem will be initialized via initialize_wave_system() before use + + // Link systems that depend on each other + attack_execution_system_.set_combat_system(&combat_system_); } void GameplayCoordinator::initialize_wave_system(EntityManager* entity_manager, NetworkService* network_service, @@ -29,7 +32,8 @@ void GameplayCoordinator::update(const SystemContext& ctx) { collision_system_.update(ctx); // COMBAT SYSTEMS - combat_system_.update(ctx); + auto_attack_system_.update(ctx); // Must run before CombatSystem and AttackExecutionSystem + attack_execution_system_.update(ctx); // Must run after CombatSystem // PLAYER SYSTEMS // Synchronize to clients diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index b686f39..91daf6e 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -6,7 +6,8 @@ #include "wave_system.hpp" #include "movement_system.hpp" #include "network_sync_system.hpp" -#include "combat_system.hpp" +#include "auto_attack_system.hpp" +#include "attack_execution_system.hpp" #include "npc_system.hpp" /** @@ -26,8 +27,10 @@ * 1. WaveSystem - Spawns new entities for this frame * 2. MovementSystem - Updates entity positions based on paths * 3. CollisionSystem - Resolves overlaps and pushes entities apart - * 4. CombatSystem - Resolves damage and effects - * 5. NetworkSyncSystem - Sends state updates to clients + * 4. AutoAttackSystem - Executes auto-attacks and manages cooldowns + * 5. CombatSystem - Applies damage (data-driven by AutoAttackSystem) + * 6. AttackExecutionSystem - Executes pending attacks with animation timing + * 7. NetworkSyncSystem - Sends state updates to clients * * USAGE: * GameplayCoordinator gameplay; @@ -65,9 +68,12 @@ class GameplayCoordinator { * Order: * 1. WaveSystem::update() - Spawn new minions * 2. MovementSystem::update() - Move entities - * 3. CombatSystem::update() - Auto-attacks and damage - * 4. NetworkSyncSystem::update() - Broadcast state - * 5. cleanup_dead_entities() - Remove entities marked for deletion + * 3. CollisionSystem::update() - Resolve collisions + * 4. AutoAttackSystem::update() - Manage auto-attacks and cooldowns + * 5. CombatSystem::update() - Apply damage (data-driven) + * 6. AttackExecutionSystem::update() - Execute pending attacks + * 7. NetworkSyncSystem::update() - Broadcast state + * 8. cleanup_dead_entities() - Remove entities marked for deletion * * @param ctx System context containing entity manager and services */ @@ -118,19 +124,32 @@ class GameplayCoordinator { */ NetworkSyncSystem& get_network_sync_system() { return network_sync_system_; } + /** + * Get reference to auto-attack system. + * @return Reference to AutoAttackSystem + */ + AutoAttackSystem& get_auto_attack_system() { return auto_attack_system_; } + + /** + * Get reference to attack execution system. + * @return Reference to AttackExecutionSystem + */ + AttackExecutionSystem& get_attack_execution_system() { return attack_execution_system_; } + /** * Get reference to combat system. * @return Reference to CombatSystem */ - CombatSystem& get_combat_system() { return combat_system_; } private: InputSystem input_system_; std::unique_ptr wave_system_; CollisionSystem collision_system_; MovementSystem movement_system_; + AutoAttackSystem auto_attack_system_; NetworkSyncSystem network_sync_system_; CombatSystem combat_system_; + AttackExecutionSystem attack_execution_system_; NPCSystem npc_system_; // Entity cleanup tracking From 33417fecb7d639c6e0c98e59383416d4c452faf1 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:53:13 -0500 Subject: [PATCH 48/79] build fix --- CMakeLists.txt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5352ac1..50ec0d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -54,13 +54,14 @@ set(GAMESERVER_SOURCES src/services/visualizer_service.cpp # Systems src/systems/combat_system.cpp + src/systems/auto_attack_system.cpp + src/systems/attack_execution_system.cpp src/services/network_service.cpp src/systems/data_loader.cpp src/systems/gameserver.cpp src/systems/input_system.cpp src/systems/collision_system.cpp src/systems/map_system.cpp - src/systems/combat_system.cpp src/systems/movement_system.cpp src/systems/network_sync_system.cpp src/systems/npc_system.cpp @@ -91,6 +92,8 @@ set(GAMESERVER_HEADERS src/systems/data_loader.hpp src/systems/map_system.hpp src/systems/combat_system.hpp + src/systems/auto_attack_system.hpp + src/systems/attack_execution_system.hpp src/systems/movement_system.hpp src/systems/serialization_system.hpp src/systems/spawning_system.hpp From 8fe8e2c54401e1c4f244e759ea8f252f61e44b1b Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:54:11 -0500 Subject: [PATCH 49/79] Combat System Decoupling, data loader updates for combat attributes --- src/systems/combat_system.cpp | 278 ++-------------------------------- src/systems/combat_system.hpp | 107 ++----------- src/systems/data_loader.cpp | 85 ++++++++++- 3 files changed, 104 insertions(+), 366 deletions(-) diff --git a/src/systems/combat_system.cpp b/src/systems/combat_system.cpp index db7c67d..d9b98b4 100644 --- a/src/systems/combat_system.cpp +++ b/src/systems/combat_system.cpp @@ -1,5 +1,4 @@ #include "combat_system.hpp" -#include "components/movement.hpp" #include "components/entity_state.hpp" #include "components/network_entity.hpp" #include @@ -7,16 +6,6 @@ #include #include -void CombatSystem::update(const SystemContext& ctx) { - // Process all entities with auto-attack behavior - auto attacking_entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : attacking_entities) { - if (entity) { - update_auto_attack(ctx, *entity, ctx.delta_time_ms); - } - } -} - std::vector CombatSystem::apply_damage( EntityManager& entity_manager, EntityID attacker_id, @@ -35,6 +24,12 @@ std::vector CombatSystem::apply_damage( Stats* target_stats = target_entity->get_component(); + // Prevent overkill damage on already-dead entities + if (target_stats->health <= 0.0f) { + LOG_DEBUG("Combat: Attempting to damage already-dead entity %u, ignoring", target_id); + return events; + } + // Get attacker entity and stats (for lifesteal/spell vamp) Entity* attacker_entity = entity_manager.get_entity(attacker_id); Stats* attacker_stats = nullptr; @@ -78,6 +73,11 @@ std::vector CombatSystem::apply_damage( float actual_damage = reduced_damage; target_stats->health -= actual_damage; + // Clamp health to never go below 0 + if (target_stats->health < 0.0f) { + target_stats->health = 0.0f; + } + // Update entity state if dead if (target_stats->health <= 0.0f) { if (auto* entity_state = target_entity->get_component()) { @@ -178,19 +178,6 @@ bool CombatSystem::restore_mana( return true; } -bool CombatSystem::is_dead( - EntityManager& entity_manager, - EntityID entity_id) const -{ - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity || !entity->has_component()) { - return true; - } - - const Stats* stats = entity->get_component(); - return stats->health <= 0.0f; -} - float CombatSystem::calculate_damage_reduction(float base_damage, int resistance) const { // Damage reduction formula: damage * (100 / (100 + resistance)) @@ -215,246 +202,3 @@ float CombatSystem::calculate_critical_hit(const Stats& attacker) return 1.0f; } - -void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms) { - auto* auto_attack = entity.get_component(); - auto* attack = entity.get_component(); - auto* target = entity.get_component(); - auto* stats = entity.get_component(); - - if (!auto_attack || !attack || !target || !stats) { - return; // Missing required components - } - - // Update combat timer - auto_attack->update_combat_timer(delta_time_ms); - - // Update attack cooldown - update_attack_cooldown(*attack, delta_time_ms); - - // Don't process if auto-attacking disabled - if (!auto_attack->should_auto_attack()) { - return; - } - - // Search for new target if needed - if (!target->is_target_valid() && auto_attack->should_search_targets()) { - if (target->should_search_for_target(0.0f)) { // TODO: Pass actual game time - EntityID new_target = find_best_target(ctx, entity, *auto_attack, *target); - if (new_target != INVALID_ENTITY_ID) { - target->set_target(new_target); - LOG_INFO("Entity (ID %u) acquired new target: %u", entity.get_id(), new_target); - } - target->mark_target_searched(0.0f); - } - } - - // If we have a valid target and are ready to attack - if (target->is_target_valid() && is_attack_ready(*attack)) { - Entity* target_entity = ctx.entity_manager.get_entity(target->current_target); - - if (target_entity && !is_dead(ctx.entity_manager, target->current_target)) { - // Calculate distance to target - auto* target_move = target_entity->get_component(); - auto* my_move = entity.get_component(); - - if (target_move && my_move) { - float dx = target_move->position.x - my_move->position.x; - float dy = target_move->position.y - my_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - - target->update_target_distance(distance, stats->attack_range); - - // Attack if in range - if (target->target_in_range) { - // Begin attack animation - begin_attack_animation(*attack); - - // Calculate damage - float base_damage = stats->physical_power + auto_attack->bonus_damage; - base_damage *= auto_attack->base_damage_multiplier; - - // Apply damage - auto damage_events = apply_damage(ctx.entity_manager, entity.get_id(), - target->current_target, base_damage, - auto_attack->damage_type); - - if (!damage_events.empty()) { - // Start cooldown - start_attack_cooldown(*attack, stats->attack_speed); - auto_attack->on_attack(); - - LOG_INFO("Entity (ID %u) auto-attacked target (ID %u) for %.1f damage", - entity.get_id(), target->current_target, damage_events[0].damage_dealt); - } - } - } - } else { - // Target is dead or invalid, clear it - target->clear_target(); - } - } -} - -EntityID CombatSystem::find_best_target(const SystemContext& ctx, const Entity& attacker, - const AutoAttackComponent& auto_attack_comp, - TargetComponent& target_comp) const { - if (!attacker.has_component() || !attacker.has_component()) { - return INVALID_ENTITY_ID; - } - - const auto* attacker_move = attacker.get_component(); - const auto* attacker_stats = attacker.get_component(); - - EntityID best_target = INVALID_ENTITY_ID; - float best_score = -1e9f; - - // Get all entities with Movement (potential targets) - auto all_entities = ctx.entity_manager.get_entities_with_component(); - - for (auto* potential_target : all_entities) { - if (!potential_target || potential_target->get_id() == attacker.get_id()) { - continue; // Skip self - } - - // Check if valid target - if (!is_valid_target(ctx, attacker, *potential_target)) { - continue; - } - - // Calculate distance - auto* target_move = potential_target->get_component(); - if (!target_move) continue; - - float dx = target_move->position.x - attacker_move->position.x; - float dy = target_move->position.y - attacker_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - - // Skip if out of aggro range - if (distance > auto_attack_comp.aggression_range) { - continue; - } - - // Calculate target score based on targeting mode - float score = 0.0f; - - auto* target_stats = potential_target->get_component(); - - switch (target_comp.targeting_mode) { - case TargetComponent::TargetPriority::NEAREST: - score = -distance; // Negative distance = higher score for closer - break; - - case TargetComponent::TargetPriority::LOWEST_HEALTH: - if (target_stats) { - score = -(target_stats->health); // Negative health = target low HP - } - break; - - case TargetComponent::TargetPriority::HIGHEST_THREAT: - if (target_stats) { - score = target_stats->physical_power + target_stats->magic_power; - } - break; - - case TargetComponent::TargetPriority::HIGHEST_DAMAGE: - if (target_stats) { - score = target_stats->physical_power; - } - break; - - default: - score = -distance; - break; - } - - // Prefer closer targets as tiebreaker - if (auto_attack_comp.prioritize_closest) { - score -= (distance * 0.1f); - } - - if (score > best_score) { - best_score = score; - best_target = potential_target->get_id(); - } - } - - return best_target; -} - -bool CombatSystem::is_valid_target(const SystemContext& ctx, const Entity& attacker, - const Entity& potential_target) const { - // Must have stats - if (!potential_target.has_component()) { - return false; - } - - const auto* attacker_stats = attacker.get_component(); - const auto* target_stats = potential_target.get_component(); - - if (!attacker_stats || !target_stats) { - return false; - } - - // Can't target dead units - if (target_stats->health <= 0.0f) { - return false; - } - - // Can't target same team (unless friendly fire enabled) - if (attacker_stats->team_id != 0 && target_stats->team_id == attacker_stats->team_id) { - return false; - } - - // Target must be on opposite team or attacker neutral - if (attacker_stats->team_id == 0 && target_stats->team_id == 0) { - return false; // Can't target neutrals as neutral - } - - return true; -} - -void CombatSystem::update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const { - if (attack.attack_cooldown_ms > 0.0f) { - attack.attack_cooldown_ms -= delta_time_ms; - if (attack.attack_cooldown_ms < 0.0f) { - attack.attack_cooldown_ms = 0.0f; - attack.can_attack = true; - } - } -} - -void CombatSystem::start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const { - if (attack_speed_stat > 0.0f) { - attack.attack_cooldown_ms = (1000.0f / attack_speed_stat); // Convert to milliseconds - } else { - attack.attack_cooldown_ms = 1000.0f; // Default 1 second - } - attack.can_attack = false; - attack.attacks_this_frame = 0; -} - -bool CombatSystem::is_attack_ready(const AttackComponent& attack) const { - return attack.attack_cooldown_ms <= 0.0f && attack.can_attack; -} - -void CombatSystem::begin_attack_animation(AttackComponent& attack) const { - attack.attack_in_progress = true; - attack.attack_animation_progress = 0.0f; - attack.attacks_this_frame++; - attack.total_attacks++; -} - -bool CombatSystem::update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const { - if (!attack.attack_in_progress) return false; - - attack.attack_animation_progress += delta_time_ms / animation_duration_ms; - - if (attack.attack_animation_progress >= 1.0f) { - attack.attack_animation_progress = 1.0f; - attack.attack_in_progress = false; - return true; // Attack complete - } - - return false; -} diff --git a/src/systems/combat_system.hpp b/src/systems/combat_system.hpp index c2d4e18..c6f7a62 100644 --- a/src/systems/combat_system.hpp +++ b/src/systems/combat_system.hpp @@ -3,42 +3,42 @@ #include "entity_manager.hpp" #include "system_context.hpp" #include "components/stats.hpp" -#include "components/attack.hpp" -#include "components/auto_attack.hpp" -#include "components/target.hpp" #include /** - * CombatSystem - Handles all combat mechanics + * CombatSystem - Handles damage calculation and application * * RESPONSIBILITIES: * - Damage calculation and application - * - Auto-attack execution and cooldown management - * - Target selection and validation - * - Combat state management (in-combat, cooldowns, etc.) * - Critical hit calculation * - Armor/resist/mitigation calculations + * - Lifesteal and spell vamp application + * - Entity death state management + * + * DATA-DRIVEN DESIGN: + * This system is purely data-driven. It only applies damage, healing, and + * mana restoration based on external input (from skills, auto-attacks, etc). + * Auto-attack behavior, cooldown management, and target selection are handled + * by the AutoAttackSystem. * * COMPONENTS USED: * - Stats (base damage, armor, resist, health) - * - AttackComponent (attack cooldown, state) - * - AutoAttackComponent (AI behavior) - * - TargetComponent (target tracking) - * - Movement (for distance calculations) + * - EntityStateComponent (entity state tracking) + * - NetworkEntityComponent (for syncing death state) * * SYSTEM INTERACTION: * - Works with NetworkSyncSystem to broadcast combat effects - * - Integrates with MovementSystem for approach distance + * - AutoAttackSystem calls apply_damage to execute attacks + * - Triggered by other systems for damage/healing events * - Coordinates with GameplayCoordinator for execution order */ class CombatSystem { public: /** * Update all combat for this frame. - * Processes auto-attacks, cooldowns, and combat state for all entities. + * The combat system is data-driven - actual combat is triggered externally. * @param ctx System context with entity manager, services, and delta time */ - void update(const SystemContext& ctx); /** * Structure representing damage information for combat events. @@ -97,85 +97,6 @@ class CombatSystem { float mana_amount ); - /** - * Check if an entity is dead (health <= 0). - * @param entity_manager Reference to entity manager - * @param entity_id Entity ID to check - * @return true if entity is dead or doesn't exist, false otherwise - */ - bool is_dead( - EntityManager& entity_manager, - EntityID entity_id - ) const; - - /** - * Update and process auto-attacks for an entity. - * Handles cooldowns, target selection, and attack execution for entities with AutoAttackComponent. - * @param ctx System context - * @param entity Entity to update - * @param delta_time_ms Time since last frame in milliseconds - */ - void update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms); - - /** - * Find best target for an entity based on targeting mode. - * @param ctx System context - * @param attacker Entity looking for target - * @param auto_attack_comp AutoAttackComponent for settings - * @param target_comp TargetComponent to update - * @return EntityID of best target, or INVALID_ENTITY_ID if none found - */ - EntityID find_best_target(const SystemContext& ctx, const Entity& attacker, - const AutoAttackComponent& auto_attack_comp, - TargetComponent& target_comp) const; - - /** - * Check if a potential target is valid (not dead, correct team, etc). - * @param ctx System context - * @param attacker Entity doing attacking - * @param potential_target Entity to validate - * @return true if valid target - */ - bool is_valid_target(const SystemContext& ctx, const Entity& attacker, - const Entity& potential_target) const; - - /** - * Update attack cooldown for an entity. - * Called each frame to reduce the cooldown timer. - * @param attack Attack component to update - * @param delta_time_ms Time elapsed since last frame - */ - void update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const; - - /** - * Start attack cooldown based on attack speed stat. - * @param attack Attack component to update - * @param attack_speed_stat Attack speed from Stats component (attacks per second) - */ - void start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const; - - /** - * Check if an entity is ready to attack. - * @param attack Attack component to check - * @return true if cooldown is finished and entity can attack - */ - bool is_attack_ready(const AttackComponent& attack) const; - - /** - * Begin attack animation. - * @param attack Attack component to update - */ - void begin_attack_animation(AttackComponent& attack) const; - - /** - * Update attack animation progress. - * @param attack Attack component to update - * @param delta_time_ms Time elapsed - * @param animation_duration_ms Total animation duration - * @return true if animation is complete - */ - bool update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const; - private: /** * Calculate damage reduction based on armor or magic resist. diff --git a/src/systems/data_loader.cpp b/src/systems/data_loader.cpp index 8ab869b..506c927 100644 --- a/src/systems/data_loader.cpp +++ b/src/systems/data_loader.cpp @@ -8,6 +8,9 @@ #include #include #include +#include +#include +#include /** * Convert string to DamageType enum. @@ -37,6 +40,42 @@ static NPCType string_to_npc_type(const std::string& str) { return NPCType::MINION; } +/** + * Convert string to AIPersonality enum. + * @param str The string to convert (case-insensitive) + * @return AIPersonality enum value, defaults to BALANCED if unrecognized + */ +static AutoAttackComponent::AIPersonality string_to_ai_personality(const std::string& str) { + if (str == "passive") { + return AutoAttackComponent::AIPersonality::PASSIVE; + } else if (str == "defensive") { + return AutoAttackComponent::AIPersonality::DEFENSIVE; + } else if (str == "aggressive") { + return AutoAttackComponent::AIPersonality::AGGRESSIVE; + } else if (str == "zealous") { + return AutoAttackComponent::AIPersonality::ZEALOUS; + } + // Default to BALANCED for unrecognized or empty strings + return AutoAttackComponent::AIPersonality::BALANCED; +} + +/** + * Convert string to TargetPriority enum. + * @param str The string to convert (case-insensitive) + * @return TargetPriority enum value, defaults to NEAREST if unrecognized + */ +static TargetComponent::TargetPriority string_to_target_priority(const std::string& str) { + if (str == "lowest_health") { + return TargetComponent::TargetPriority::LOWEST_HEALTH; + } else if (str == "highest_threat") { + return TargetComponent::TargetPriority::HIGHEST_THREAT; + } else if (str == "highest_damage") { + return TargetComponent::TargetPriority::HIGHEST_DAMAGE; + } + // Default to NEAREST for unrecognized or empty strings + return TargetComponent::TargetPriority::NEAREST; +} + /** * Convenience macro. Loads the attribute from the node if the node has it, and sets it in the component. * @param node A pugi::xml_node which (maybe) has the attribute @@ -96,40 +135,72 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { temp.id = id; pugi::xml_node movementNode = rootNode.child("movement"); - if(movementNode != NULL) { + if(!movementNode.empty()) { std::shared_ptr movement = std::make_shared(); temp.component_templates.push_back(movement); } pugi::xml_node pathfindingNode = rootNode.child("pathfinding"); - if(pathfindingNode != NULL) { + if(!pathfindingNode.empty()) { std::shared_ptr pathfinding = std::make_shared(); temp.component_templates.push_back(pathfinding); } pugi::xml_node networkNode = rootNode.child("network"); - if(networkNode != NULL) { + if(!networkNode.empty()) { std::shared_ptr network = std::make_shared(); network->force_full_sync_next_frame = true; temp.component_templates.push_back(network); } pugi::xml_node stateNode = rootNode.child("state"); - if(stateNode != NULL) { + if(!stateNode.empty()) { std::shared_ptr state = std::make_shared(); temp.component_templates.push_back(state); } pugi::xml_node npc_node = rootNode.child("npc"); - if(npc_node != NULL) { + if(!npc_node.empty()) { std::shared_ptr npc = std::make_shared(); LOAD_ENUM_ATTRIBUTE(npc_node, npc, npc_type, string_to_npc_type) LOAD_ATTRIBUTE(npc_node, npc, chase_distance, float) temp.component_templates.push_back(npc); } + pugi::xml_node auto_attack_node = rootNode.child("auto_attack"); + if(!auto_attack_node.empty()) { + std::shared_ptr auto_attack = std::make_shared(); + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, enabled, bool) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, aggressive, bool) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, retaliate_only, bool) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, aggression_range, float) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, retreat_range, float) + LOAD_ENUM_ATTRIBUTE(auto_attack_node, auto_attack, personality, string_to_ai_personality) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, combat_timeout_ms, float) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, base_damage_multiplier, float) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, bonus_damage, float) + LOAD_ENUM_ATTRIBUTE(auto_attack_node, auto_attack, damage_type, string_to_damage_type) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, attack_animation_duration_ms, float) + LOAD_ATTRIBUTE(auto_attack_node, auto_attack, hit_timing_percent, float) + temp.component_templates.push_back(auto_attack); + } + + pugi::xml_node target_node = rootNode.child("target"); + if(!target_node.empty()) { + std::shared_ptr target = std::make_shared(); + LOAD_ENUM_ATTRIBUTE(target_node, target, targeting_mode, string_to_target_priority) + LOAD_ATTRIBUTE(target_node, target, target_search_interval_ms, float) + temp.component_templates.push_back(target); + } + + pugi::xml_node attack_node = rootNode.child("attack"); + if(!attack_node.empty()) { + std::shared_ptr attack = std::make_shared(); + temp.component_templates.push_back(attack); + } + pugi::xml_node statsNode = rootNode.child("stats"); - if(statsNode != NULL) { + if(!statsNode.empty()) { std::shared_ptr stats = std::make_shared(); LOAD_ATTRIBUTE(statsNode, stats, max_health, float) @@ -164,6 +235,8 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { LOAD_ATTRIBUTE(statsNode, stats, leech, float) LOAD_ATTRIBUTE(statsNode, stats, vision_range, float) + LOG_DEBUG("Loaded Stats component: health=%f, max_health=%f, move_speed=%f", + stats->health, stats->max_health, stats->move_speed); temp.component_templates.push_back(stats); } From 1954bdd7925f69e983be3836dc717b31b27c0f6a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:54:45 -0500 Subject: [PATCH 50/79] New packets --- src/systems/packet_validator.hpp | 7 ++++++ src/systems/serialization_system.cpp | 37 ++++++++++++++++++++++++++++ src/systems/serialization_system.hpp | 23 +++++++++++++++++ 3 files changed, 67 insertions(+) diff --git a/src/systems/packet_validator.hpp b/src/systems/packet_validator.hpp index 2f29c06..bebd525 100644 --- a/src/systems/packet_validator.hpp +++ b/src/systems/packet_validator.hpp @@ -24,6 +24,9 @@ enum class PACKET_TYPE : uint8_t { // Update packets ENTITY_POSITION, ENTITY_STATS, + ENTITY_STATE, + // Combat packets + COMBAT_EVENT, // Player related packets PLAYER_READY, PLAYER_DISCONNECT, @@ -54,6 +57,10 @@ class PacketValidator { return 19; // type (1) + entity_id (4) + position_x (4) + position_y (4) + team_id (1) + type_string_length (4) + type_string_data (variable) case PACKET_TYPE::ENTITY_STATS: return 25; // type (1) + entity_id (4) + health (4) + max_health (4) + mana (4) + max_mana (4) + level (4) + case PACKET_TYPE::ENTITY_STATE: + return 6; // type (1) + entity_id (4) + state_value (1) + case PACKET_TYPE::COMBAT_EVENT: + return 18; // type (1) + attacker_id (4) + target_id (4) + damage (4) + damage_type (1) + was_critical (1) + padding (2) case PACKET_TYPE::GAME_START: case PACKET_TYPE::GAME_STATE: case PACKET_TYPE::PLAYER_DISCONNECT: diff --git a/src/systems/serialization_system.cpp b/src/systems/serialization_system.cpp index 09baa6c..92bb134 100644 --- a/src/systems/serialization_system.cpp +++ b/src/systems/serialization_system.cpp @@ -139,3 +139,40 @@ std::vector SerializationSystem::serialize_entity_stat_change(uint32_t return packet_data; } + +std::vector SerializationSystem::serialize_entity_state(uint32_t entity_id, uint8_t state_value) { + std::vector packet_data; + packet_data.push_back(static_cast(PACKET_TYPE::ENTITY_STATE)); + + // Entity ID (4 bytes, little-endian) + serialize_uint32(entity_id, packet_data); + + // State value (1 byte) + packet_data.push_back(state_value); + + return packet_data; +} + +std::vector SerializationSystem::serialize_combat_event(uint32_t attacker_id, uint32_t target_id, + float damage_dealt, uint8_t damage_type, bool was_critical) { + std::vector packet_data; + packet_data.push_back(static_cast(PACKET_TYPE::COMBAT_EVENT)); + + // Attacker ID (4 bytes, little-endian) + serialize_uint32(attacker_id, packet_data); + + // Target ID (4 bytes, little-endian) + serialize_uint32(target_id, packet_data); + + // Damage (4 bytes float, little-endian) + serialize_float(damage_dealt, packet_data); + + // Damage Type (1 byte) + packet_data.push_back(damage_type); + + // Was Critical (1 byte: 0 or 1) + packet_data.push_back(was_critical ? 1 : 0); + + return packet_data; +} + diff --git a/src/systems/serialization_system.hpp b/src/systems/serialization_system.hpp index 17dcbc6..6de44d2 100644 --- a/src/systems/serialization_system.hpp +++ b/src/systems/serialization_system.hpp @@ -69,6 +69,29 @@ class SerializationSystem { */ static std::vector serialize_entity_stat_change(uint32_t entity_id, const std::string& stat_name, const std::string& stat_value); + /** + * Serialize an entity state change packet. + * Used to sync entity state changes (e.g., SPAWNED, DEAD, MOVING). + * @param entity_id The ID of the entity + * @param state_value The new entity state as a uint8_t (see EntityState enum) + * @return Packet data as a vector of bytes + */ + static std::vector serialize_entity_state(uint32_t entity_id, uint8_t state_value); + + /** + * Serialize a combat event packet. + * Broadcasts damage, critical hits, and other combat interactions. + * Format: type(1) + attacker_id(4) + target_id(4) + damage(4) + damage_type(1) + was_critical(1) + reserved(2) + * @param attacker_id The ID of the attacking entity + * @param target_id The ID of the target entity + * @param damage_dealt The amount of damage dealt (as float) + * @param damage_type The type of damage (0=PHYSICAL, 1=MAGICAL, 2=TRUE) + * @param was_critical Whether the attack was a critical hit + * @return Packet data as a vector of bytes + */ + static std::vector serialize_combat_event(uint32_t attacker_id, uint32_t target_id, + float damage_dealt, uint8_t damage_type, bool was_critical); + private: /** * Helper function to serialize a 32-bit unsigned integer in little-endian format From c2b6b76f464c7f960295f52bb030ffe9d06b9012 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:55:14 -0500 Subject: [PATCH 51/79] collision fix --- src/systems/entity_manager.hpp | 39 ++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/systems/entity_manager.hpp b/src/systems/entity_manager.hpp index 9700cad..48d815a 100644 --- a/src/systems/entity_manager.hpp +++ b/src/systems/entity_manager.hpp @@ -7,6 +7,7 @@ #include "components/component.hpp" #include "components/template.hpp" +#include "components/movement.hpp" #include /** @@ -258,6 +259,44 @@ class EntityManager { std::unordered_map& get_all_entities() { return entities_; } + + /** + * Get entity template by ID without creating an entity. + * Useful for querying template data (e.g., collision radius) without consuming an entity ID. + * @param template_id The ID of the template to retrieve + * @return Const pointer to the template, or nullptr if not found + */ + const EntityTemplate* get_template(const std::string& template_id) const { + auto it = entity_template_cache.find(template_id); + if (it == entity_template_cache.end()) { + return nullptr; + } + return &it->second; + } + + /** + * Get collision radius for a template without creating an entity. + * Used for pathfinding and collision queries during spawn phase. + * @param template_id The ID of the template + * @return Collision radius (default 0.5f if not found) + */ + float get_template_collision_radius(const std::string& template_id) const { + const EntityTemplate* template_data = get_template(template_id); + if (!template_data) { + return 0.5f; // Default + } + + // Search for Movement component in template (TYPE_ID = 2001) + for (const auto& comp : template_data->component_templates) { + if (comp->get_type_id() == 2001) { // Movement component type ID + const Movement* move_template = static_cast(comp.get()); + if (move_template) { + return move_template->collision_radius; + } + } + } + return 0.5f; // Default + } private: std::unordered_map entities_; From dfbc7bbee494155f1aa7213b0020e8d1e8f8e6e6 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:55:40 -0500 Subject: [PATCH 52/79] divert attak-moving to movement system --- src/systems/movement_system.cpp | 51 +++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/src/systems/movement_system.cpp b/src/systems/movement_system.cpp index 3d559ff..2c5fdff 100644 --- a/src/systems/movement_system.cpp +++ b/src/systems/movement_system.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include @@ -92,6 +93,56 @@ void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& en if (!movement || !stats) return; + // If holding for target, move toward the target entity + if (state_comp && state_comp->current_state == EntityState::HOLDING_FOR_TARGET && + state_comp->target_entity_id != INVALID_ENTITY_ID) { + Entity* target = ctx.entity_manager.get_entity(state_comp->target_entity_id); + if (target) { + Movement* target_movement = target->get_component(); + if (target_movement) { + // Move toward target + Vec2 direction = target_movement->position - movement->position; + float distance = direction.length(); + + if (distance > 0.1f) { + Vec2 normalized_dir = direction.normalized(); + float move_speed = stats->move_speed; + float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); + movement->position = movement->position + (normalized_dir * distance_to_move); + } + } + } + return; // Don't process other movement + } + + // Handle movement during ATTACKING state (kiting) + if (state_comp && state_comp->current_state == EntityState::ATTACKING) { + // Check if entity has AutoAttackComponent and kiting is enabled + auto* auto_attack = entity.get_component(); + if (auto_attack && auto_attack->allow_kiting && auto_attack->kite_while_attacking) { + // Move toward target with reduced speed + if (state_comp->target_entity_id != INVALID_ENTITY_ID) { + Entity* target = ctx.entity_manager.get_entity(state_comp->target_entity_id); + if (target) { + Movement* target_movement = target->get_component(); + if (target_movement) { + // Move toward target at reduced speed + Vec2 direction = target_movement->position - movement->position; + float distance = direction.length(); + + if (distance > 0.1f) { + Vec2 normalized_dir = direction.normalized(); + float base_move_speed = stats->move_speed * auto_attack->movement_during_attack; + float distance_to_move = base_move_speed * (ctx.delta_time_ms / 1000.0f); + movement->position = movement->position + (normalized_dir * distance_to_move); + } + } + } + } + } + return; // Stop other movement processing during attack + } + // Update direct movement targets (players, point-based movement) if (state_comp && state_comp->current_state == EntityState::MOVING && !state_comp->target_positions.empty()) { From 420ed66c1ab3d9408b606e8d71ef7e8009c43187 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Mon, 24 Nov 2025 23:57:43 -0500 Subject: [PATCH 53/79] NPC Brain, debugging for minions with 1hp --- src/components/npc_component.hpp | 31 ++++++++++++++++++++ src/systems/network_sync_system.cpp | 28 ++++++++++++++++-- src/systems/npc_system.cpp | 44 ++++++++++------------------- src/systems/player_manager.cpp | 6 ++++ src/systems/spawning_system.cpp | 2 ++ 5 files changed, 79 insertions(+), 32 deletions(-) diff --git a/src/components/npc_component.hpp b/src/components/npc_component.hpp index 9109ffd..5c42c3f 100644 --- a/src/components/npc_component.hpp +++ b/src/components/npc_component.hpp @@ -11,6 +11,37 @@ struct NPCComponent : public Component { NPCType npc_type; float chase_distance = 30.0f; float chase_timeout_ms = 5000.0f; // How long to keep chasing without hitting the target (not implemented)-- cmkrist 24/11/2025 + + // === State Cooldown === + float state_change_cooldown_ms = 250.0f; // Minimum time between state changes (prevents rapid flip-flopping) + float time_since_last_state_change_ms = 0.0f; // Tracks time since last state change + + /** + * Check if enough time has passed to allow a state change. + * Prevents rapid state transitions that cause minions to get stuck. + * @return true if state change is allowed + */ + bool can_change_state() const { + return time_since_last_state_change_ms >= state_change_cooldown_ms; + } + + /** + * Mark that a state change just occurred. + * Resets the cooldown timer. + */ + void on_state_changed() { + time_since_last_state_change_ms = 0.0f; + } + + /** + * Update the state change cooldown timer. + * @param delta_time_ms Time elapsed since last update + */ + void update_state_cooldown(float delta_time_ms) { + if (time_since_last_state_change_ms < state_change_cooldown_ms) { + time_since_last_state_change_ms += delta_time_ms; + } + } COMPONENT_TYPE_ID(NPCComponent, ComponentTypes::NPC) }; \ No newline at end of file diff --git a/src/systems/network_sync_system.cpp b/src/systems/network_sync_system.cpp index 5677bdc..d736a13 100644 --- a/src/systems/network_sync_system.cpp +++ b/src/systems/network_sync_system.cpp @@ -131,6 +131,7 @@ bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t curren auto* state = entity.get_component(); auto* move = entity.get_component(); + auto* stats = entity.get_component(); // Always sync entities in MOVING state if (state && state->current_state == EntityState::MOVING) { @@ -147,6 +148,11 @@ bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t curren return true; } + // Check for stat changes (health, mana, level, etc.) + if (stats && net_comp->has_stats_changed(*stats)) { + return true; + } + // Force sync if requested if (net_comp->force_full_sync_next_frame) { return true; @@ -155,11 +161,12 @@ bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t curren // Debug: log why entity isn't changing (first 50 frames only) static uint32_t logged_frames = 0; if (logged_frames < 50 && state) { - LOG_INFO("Frame %u: Entity %u state=%d, sync_check: moving=%s, pos_changed=%s, state_changed=%s, force=%s", + LOG_INFO("Frame %u: Entity %u state=%d, sync_check: moving=%s, pos_changed=%s, state_changed=%s, stats_changed=%s, force=%s", current_frame, entity.get_id(), (int)state->current_state, (state->current_state == EntityState::MOVING) ? "yes" : "no", move && net_comp->has_position_changed(move->position) ? "yes" : "no", state && net_comp->has_state_changed(state->current_state) ? "yes" : "no", + stats && net_comp->has_stats_changed(*stats) ? "yes" : "no", net_comp->force_full_sync_next_frame ? "yes" : "no"); logged_frames++; } @@ -179,10 +186,10 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent if (!move || !state) { if (!move) { - LOG_WARN("Entity %u missing Movement component", entity_id); + LOG_DEBUG("Entity %u missing Movement component", entity_id); } if (!state) { - LOG_WARN("Entity %u missing EntityStateComponent", entity_id); + LOG_DEBUG("Entity %u missing EntityStateComponent", entity_id); } return packets; // Return empty vector } @@ -209,6 +216,7 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent std::ostringstream oss; oss << std::fixed << std::setprecision(6) << stats->health; packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "health", oss.str())); + LOG_DEBUG("Entity %u: Syncing health = %s", entity_id, oss.str().c_str()); oss.str(""); oss.clear(); @@ -229,9 +237,23 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent } else if (net_comp->has_stats_changed(*stats)) { // Delta sync - only send packets for stats that changed auto stat_packets = create_stat_change_packets(entity_id, *stats, *net_comp->last_synced_stats); + if (!stat_packets.empty()) { + LOG_DEBUG("Entity %u: Syncing %zu stat changes (health: %.1f)", entity_id, stat_packets.size(), stats->health); + } packets.insert(packets.end(), stat_packets.begin(), stat_packets.end()); } } + // ======================================================================== + // Entity State Update Packet + // ======================================================================== + if (send_full_state || !net_comp) { + // Full state sync - always send state + packets.push_back(SerializationSystem::serialize_entity_state(entity_id, static_cast(state->current_state))); + } else if (net_comp->has_state_changed(state->current_state)) { + // Delta sync - only send state if it changed + packets.push_back(SerializationSystem::serialize_entity_state(entity_id, static_cast(state->current_state))); + } + return packets; } diff --git a/src/systems/npc_system.cpp b/src/systems/npc_system.cpp index 37ee26e..788ccdf 100644 --- a/src/systems/npc_system.cpp +++ b/src/systems/npc_system.cpp @@ -2,14 +2,21 @@ #include "components/entity_state.hpp" #include "components/npc_component.hpp" +#include "components/auto_attack.hpp" +#include void NPCSystem::update(const SystemContext& ctx) { for(auto npc_entity : ctx.entity_manager.get_entities_with_component()) { + // Update state cooldown timers for all NPCs + NPCComponent* npc_comp = npc_entity->get_component(); + if (npc_comp) { + npc_comp->update_state_cooldown(ctx.delta_time_ms); + } update_entity(ctx, npc_entity); } } -void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { +void NPCSystem::update_entity(const SystemContext& /*ctx*/, Entity* npc_entity) { Movement* npc_movement = npc_entity->get_component(); Stats* npc_stats = npc_entity->get_component(); EntityStateComponent* npc_state = npc_entity->get_component(); @@ -22,40 +29,19 @@ void NPCSystem::update_entity(const SystemContext& ctx, Entity* npc_entity) { } if(npc_comp->npc_type == NPCType::MINION) { - // Stop attacking if the minion is too far away from its path + // This enforces map-boundary behavior - minions don't chase forever if(npc_state->current_state == EntityState::ATTACKING && npc_path->waypoints.size() > 0) { Vec2 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; if((current_waypoint - npc_movement->position).length() > npc_comp->chase_distance) { - npc_state->current_state = EntityState::MOVING; - npc_state->target_entity_id = INVALID_ENTITY_ID; - npc_state->state_duration_ms = 0.0f; - return; // done updating this entity - } - } - - // If the minion is running down its path, stop pathing and attack any enemy entities within aggro range - if(npc_state->current_state == EntityState::MOVING || npc_state->current_state == EntityState::PATHFINDING_WAITING) { - // TODO how do I find all entities in my general area that are attackable? - ploinky 20/11/2025 - for(auto other_entity : ctx.entity_manager.get_entities_with_component()) { - if(other_entity == npc_entity) { - continue; - } - - Movement* other_movement = other_entity->get_component(); - if(!other_movement) { - continue; // continue checking other entities in range - } - - // TODO This check needs to be against a different field in an attack component, - // "acquisition_range" or something similar - ploinky 20/11/2025 - if((npc_movement->position - other_movement->position).length() <= npc_stats->attack_range) { - npc_state->current_state = EntityState::ATTACKING; - npc_state->target_entity_id = other_entity->get_id(); + // Only change state if cooldown allows it + if (npc_comp->can_change_state()) { + npc_state->current_state = EntityState::MOVING; + npc_state->target_entity_id = INVALID_ENTITY_ID; npc_state->state_duration_ms = 0.0f; - LOG_INFO("Entity %d is attacking entity %d", npc_entity->get_id(), other_entity->get_id()); - return; // done updating this entity + npc_comp->on_state_changed(); + LOG_DEBUG("Entity %d returning to MOVING (too far from waypoint)", npc_entity->get_id()); } } } diff --git a/src/systems/player_manager.cpp b/src/systems/player_manager.cpp index 9471712..519877c 100644 --- a/src/systems/player_manager.cpp +++ b/src/systems/player_manager.cpp @@ -212,6 +212,12 @@ EntityID PlayerManager::create_player_entity(const std::string& client_id, Entit player_owned_comp->owning_player_id = player_id; champion_entity.add_component(std::move(player_owned_comp)); + // Set champion team ID so minions don't target it (use 255 = neutral observer) + auto* champion_stats = champion_entity.get_component(); + if (champion_stats) { + champion_stats->team_id = 255; // Neutral observer - not a valid combat target + } + LOG_INFO("Created player (ID %u) with champion (ID %u) for client %s", player_id, champion_id, client_id.c_str()); diff --git a/src/systems/spawning_system.cpp b/src/systems/spawning_system.cpp index 0265a59..d7361bf 100644 --- a/src/systems/spawning_system.cpp +++ b/src/systems/spawning_system.cpp @@ -30,6 +30,8 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, auto* stats = entity.get_component(); if (stats) { stats->team_id = team_id; + LOG_INFO("Spawned minion (ID %u) with health=%f, max_health=%f, team=%u", + entity_id, stats->health, stats->max_health, team_id); } // Add network entity component for syncing From 778a55e1fd2525b6f30580b2a97763f44712ceb7 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 25 Nov 2025 12:26:26 -0500 Subject: [PATCH 54/79] move files into new folders for better readability --- src/{systems => libs}/math.hpp | 0 src/systems/{ => core}/attack_execution_system.cpp | 0 src/systems/{ => core}/attack_execution_system.hpp | 0 src/systems/{ => core}/auto_attack_system.cpp | 0 src/systems/{ => core}/auto_attack_system.hpp | 0 src/systems/{ => core}/collision_system.cpp | 0 src/systems/{ => core}/collision_system.hpp | 0 src/systems/{ => core}/input_system.cpp | 0 src/systems/{ => core}/input_system.hpp | 0 src/systems/{ => core}/movement_system.cpp | 0 src/systems/{ => core}/movement_system.hpp | 0 src/systems/{ => core}/network_sync_system.cpp | 0 src/systems/{ => core}/network_sync_system.hpp | 0 src/systems/{ => core}/npc_system.cpp | 0 src/systems/{ => core}/npc_system.hpp | 0 src/systems/{ => core}/spawning_system.cpp | 0 src/systems/{ => core}/spawning_system.hpp | 0 src/systems/{ => core}/targeting_system.cpp | 0 src/systems/{ => core}/targeting_system.hpp | 0 src/systems/{ => core}/wave_system.cpp | 0 src/systems/{ => core}/wave_system.hpp | 0 src/systems/entity_manager.hpp | 2 +- src/systems/{ => util}/combat_system.cpp | 2 +- src/systems/{ => util}/combat_system.hpp | 0 src/systems/{ => util}/data_loader.cpp | 0 src/systems/{ => util}/data_loader.hpp | 0 src/systems/{ => util}/map_system.cpp | 0 src/systems/{ => util}/map_system.hpp | 0 src/systems/{ => util}/packet_handler.cpp | 0 src/systems/{ => util}/packet_handler.hpp | 0 src/systems/{ => util}/packet_validator.hpp | 0 src/systems/{ => util}/player_manager.cpp | 0 src/systems/{ => util}/player_manager.hpp | 0 src/systems/{ => util}/serialization_system.cpp | 0 src/systems/{ => util}/serialization_system.hpp | 0 35 files changed, 2 insertions(+), 2 deletions(-) rename src/{systems => libs}/math.hpp (100%) rename src/systems/{ => core}/attack_execution_system.cpp (100%) rename src/systems/{ => core}/attack_execution_system.hpp (100%) rename src/systems/{ => core}/auto_attack_system.cpp (100%) rename src/systems/{ => core}/auto_attack_system.hpp (100%) rename src/systems/{ => core}/collision_system.cpp (100%) rename src/systems/{ => core}/collision_system.hpp (100%) rename src/systems/{ => core}/input_system.cpp (100%) rename src/systems/{ => core}/input_system.hpp (100%) rename src/systems/{ => core}/movement_system.cpp (100%) rename src/systems/{ => core}/movement_system.hpp (100%) rename src/systems/{ => core}/network_sync_system.cpp (100%) rename src/systems/{ => core}/network_sync_system.hpp (100%) rename src/systems/{ => core}/npc_system.cpp (100%) rename src/systems/{ => core}/npc_system.hpp (100%) rename src/systems/{ => core}/spawning_system.cpp (100%) rename src/systems/{ => core}/spawning_system.hpp (100%) rename src/systems/{ => core}/targeting_system.cpp (100%) rename src/systems/{ => core}/targeting_system.hpp (100%) rename src/systems/{ => core}/wave_system.cpp (100%) rename src/systems/{ => core}/wave_system.hpp (100%) rename src/systems/{ => util}/combat_system.cpp (99%) rename src/systems/{ => util}/combat_system.hpp (100%) rename src/systems/{ => util}/data_loader.cpp (100%) rename src/systems/{ => util}/data_loader.hpp (100%) rename src/systems/{ => util}/map_system.cpp (100%) rename src/systems/{ => util}/map_system.hpp (100%) rename src/systems/{ => util}/packet_handler.cpp (100%) rename src/systems/{ => util}/packet_handler.hpp (100%) rename src/systems/{ => util}/packet_validator.hpp (100%) rename src/systems/{ => util}/player_manager.cpp (100%) rename src/systems/{ => util}/player_manager.hpp (100%) rename src/systems/{ => util}/serialization_system.cpp (100%) rename src/systems/{ => util}/serialization_system.hpp (100%) diff --git a/src/systems/math.hpp b/src/libs/math.hpp similarity index 100% rename from src/systems/math.hpp rename to src/libs/math.hpp diff --git a/src/systems/attack_execution_system.cpp b/src/systems/core/attack_execution_system.cpp similarity index 100% rename from src/systems/attack_execution_system.cpp rename to src/systems/core/attack_execution_system.cpp diff --git a/src/systems/attack_execution_system.hpp b/src/systems/core/attack_execution_system.hpp similarity index 100% rename from src/systems/attack_execution_system.hpp rename to src/systems/core/attack_execution_system.hpp diff --git a/src/systems/auto_attack_system.cpp b/src/systems/core/auto_attack_system.cpp similarity index 100% rename from src/systems/auto_attack_system.cpp rename to src/systems/core/auto_attack_system.cpp diff --git a/src/systems/auto_attack_system.hpp b/src/systems/core/auto_attack_system.hpp similarity index 100% rename from src/systems/auto_attack_system.hpp rename to src/systems/core/auto_attack_system.hpp diff --git a/src/systems/collision_system.cpp b/src/systems/core/collision_system.cpp similarity index 100% rename from src/systems/collision_system.cpp rename to src/systems/core/collision_system.cpp diff --git a/src/systems/collision_system.hpp b/src/systems/core/collision_system.hpp similarity index 100% rename from src/systems/collision_system.hpp rename to src/systems/core/collision_system.hpp diff --git a/src/systems/input_system.cpp b/src/systems/core/input_system.cpp similarity index 100% rename from src/systems/input_system.cpp rename to src/systems/core/input_system.cpp diff --git a/src/systems/input_system.hpp b/src/systems/core/input_system.hpp similarity index 100% rename from src/systems/input_system.hpp rename to src/systems/core/input_system.hpp diff --git a/src/systems/movement_system.cpp b/src/systems/core/movement_system.cpp similarity index 100% rename from src/systems/movement_system.cpp rename to src/systems/core/movement_system.cpp diff --git a/src/systems/movement_system.hpp b/src/systems/core/movement_system.hpp similarity index 100% rename from src/systems/movement_system.hpp rename to src/systems/core/movement_system.hpp diff --git a/src/systems/network_sync_system.cpp b/src/systems/core/network_sync_system.cpp similarity index 100% rename from src/systems/network_sync_system.cpp rename to src/systems/core/network_sync_system.cpp diff --git a/src/systems/network_sync_system.hpp b/src/systems/core/network_sync_system.hpp similarity index 100% rename from src/systems/network_sync_system.hpp rename to src/systems/core/network_sync_system.hpp diff --git a/src/systems/npc_system.cpp b/src/systems/core/npc_system.cpp similarity index 100% rename from src/systems/npc_system.cpp rename to src/systems/core/npc_system.cpp diff --git a/src/systems/npc_system.hpp b/src/systems/core/npc_system.hpp similarity index 100% rename from src/systems/npc_system.hpp rename to src/systems/core/npc_system.hpp diff --git a/src/systems/spawning_system.cpp b/src/systems/core/spawning_system.cpp similarity index 100% rename from src/systems/spawning_system.cpp rename to src/systems/core/spawning_system.cpp diff --git a/src/systems/spawning_system.hpp b/src/systems/core/spawning_system.hpp similarity index 100% rename from src/systems/spawning_system.hpp rename to src/systems/core/spawning_system.hpp diff --git a/src/systems/targeting_system.cpp b/src/systems/core/targeting_system.cpp similarity index 100% rename from src/systems/targeting_system.cpp rename to src/systems/core/targeting_system.cpp diff --git a/src/systems/targeting_system.hpp b/src/systems/core/targeting_system.hpp similarity index 100% rename from src/systems/targeting_system.hpp rename to src/systems/core/targeting_system.hpp diff --git a/src/systems/wave_system.cpp b/src/systems/core/wave_system.cpp similarity index 100% rename from src/systems/wave_system.cpp rename to src/systems/core/wave_system.cpp diff --git a/src/systems/wave_system.hpp b/src/systems/core/wave_system.hpp similarity index 100% rename from src/systems/wave_system.hpp rename to src/systems/core/wave_system.hpp diff --git a/src/systems/entity_manager.hpp b/src/systems/entity_manager.hpp index 48d815a..cd017b7 100644 --- a/src/systems/entity_manager.hpp +++ b/src/systems/entity_manager.hpp @@ -8,7 +8,7 @@ #include "components/component.hpp" #include "components/template.hpp" #include "components/movement.hpp" -#include +#include /** * Represents a unique entity ID in the ECS system. diff --git a/src/systems/combat_system.cpp b/src/systems/util/combat_system.cpp similarity index 99% rename from src/systems/combat_system.cpp rename to src/systems/util/combat_system.cpp index d9b98b4..7b9ce7e 100644 --- a/src/systems/combat_system.cpp +++ b/src/systems/util/combat_system.cpp @@ -1,4 +1,4 @@ -#include "combat_system.hpp" +#include #include "components/entity_state.hpp" #include "components/network_entity.hpp" #include diff --git a/src/systems/combat_system.hpp b/src/systems/util/combat_system.hpp similarity index 100% rename from src/systems/combat_system.hpp rename to src/systems/util/combat_system.hpp diff --git a/src/systems/data_loader.cpp b/src/systems/util/data_loader.cpp similarity index 100% rename from src/systems/data_loader.cpp rename to src/systems/util/data_loader.cpp diff --git a/src/systems/data_loader.hpp b/src/systems/util/data_loader.hpp similarity index 100% rename from src/systems/data_loader.hpp rename to src/systems/util/data_loader.hpp diff --git a/src/systems/map_system.cpp b/src/systems/util/map_system.cpp similarity index 100% rename from src/systems/map_system.cpp rename to src/systems/util/map_system.cpp diff --git a/src/systems/map_system.hpp b/src/systems/util/map_system.hpp similarity index 100% rename from src/systems/map_system.hpp rename to src/systems/util/map_system.hpp diff --git a/src/systems/packet_handler.cpp b/src/systems/util/packet_handler.cpp similarity index 100% rename from src/systems/packet_handler.cpp rename to src/systems/util/packet_handler.cpp diff --git a/src/systems/packet_handler.hpp b/src/systems/util/packet_handler.hpp similarity index 100% rename from src/systems/packet_handler.hpp rename to src/systems/util/packet_handler.hpp diff --git a/src/systems/packet_validator.hpp b/src/systems/util/packet_validator.hpp similarity index 100% rename from src/systems/packet_validator.hpp rename to src/systems/util/packet_validator.hpp diff --git a/src/systems/player_manager.cpp b/src/systems/util/player_manager.cpp similarity index 100% rename from src/systems/player_manager.cpp rename to src/systems/util/player_manager.cpp diff --git a/src/systems/player_manager.hpp b/src/systems/util/player_manager.hpp similarity index 100% rename from src/systems/player_manager.hpp rename to src/systems/util/player_manager.hpp diff --git a/src/systems/serialization_system.cpp b/src/systems/util/serialization_system.cpp similarity index 100% rename from src/systems/serialization_system.cpp rename to src/systems/util/serialization_system.cpp diff --git a/src/systems/serialization_system.hpp b/src/systems/util/serialization_system.hpp similarity index 100% rename from src/systems/serialization_system.hpp rename to src/systems/util/serialization_system.hpp From 113ac446b96b5d1cf717dbc8da60f80351de5f76 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 25 Nov 2025 12:58:35 -0500 Subject: [PATCH 55/79] fix headers --- CMakeLists.txt | 88 ++++++------------- src/components/component_registry.hpp | 3 +- .../{errors.hpp => engine_errors.hpp} | 0 src/components/experience.hpp | 4 +- src/components/intent.hpp | 85 ++++++++++++++++++ src/components/map.hpp | 4 +- src/components/movement.hpp | 4 +- src/components/navmesh.hpp | 4 +- src/components/pathfinding.hpp | 4 +- src/main.cpp | 2 +- src/services/astar_pathfinding.cpp | 2 +- src/services/astar_pathfinding.hpp | 2 +- src/services/navigation_service.hpp | 2 +- src/services/network_service.cpp | 6 +- src/services/network_service.hpp | 6 +- src/services/visualizer_service.cpp | 14 +-- src/systems/core/attack_execution_system.cpp | 15 ++-- src/systems/core/attack_execution_system.hpp | 8 +- src/systems/core/auto_attack_system.cpp | 10 +-- src/systems/core/collision_system.cpp | 8 +- src/systems/core/input_system.cpp | 14 +-- src/systems/core/movement_system.cpp | 10 +-- src/systems/core/network_sync_system.cpp | 14 +-- src/systems/core/network_sync_system.hpp | 6 +- src/systems/core/npc_system.cpp | 8 +- src/systems/core/spawning_system.cpp | 16 ++-- src/systems/core/targeting_system.cpp | 2 +- src/systems/core/targeting_system.hpp | 10 +-- src/systems/core/wave_system.cpp | 14 +-- src/systems/core/wave_system.hpp | 8 +- src/systems/entity_manager.hpp | 7 +- src/systems/gameplay_coordinator.cpp | 4 +- src/systems/gameplay_coordinator.hpp | 25 ++++-- src/systems/gameserver.cpp | 12 +-- src/systems/gameserver.hpp | 28 +++--- src/systems/util/combat_system.cpp | 6 +- src/systems/util/data_loader.cpp | 4 +- src/systems/util/map_system.cpp | 8 +- src/systems/util/packet_handler.cpp | 20 ++--- src/systems/util/player_manager.cpp | 12 +-- src/systems/util/player_manager.hpp | 2 +- src/systems/util/serialization_system.cpp | 4 +- src/systems/util/serialization_system.hpp | 4 +- tests/tests.cpp | 10 +-- 44 files changed, 293 insertions(+), 226 deletions(-) rename src/components/{errors.hpp => engine_errors.hpp} (100%) create mode 100644 src/components/intent.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 50ec0d2..b892378 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,77 +52,41 @@ set(GAMESERVER_SOURCES src/services/navigation_service.cpp src/services/astar_pathfinding.cpp src/services/visualizer_service.cpp - # Systems - src/systems/combat_system.cpp - src/systems/auto_attack_system.cpp - src/systems/attack_execution_system.cpp src/services/network_service.cpp - src/systems/data_loader.cpp + # Systems - Core src/systems/gameserver.cpp - src/systems/input_system.cpp - src/systems/collision_system.cpp - src/systems/map_system.cpp - src/systems/movement_system.cpp - src/systems/network_sync_system.cpp - src/systems/npc_system.cpp - src/systems/serialization_system.cpp - src/systems/spawning_system.cpp - src/systems/wave_system.cpp - src/systems/player_manager.cpp - src/systems/packet_handler.cpp src/systems/gameplay_coordinator.cpp + # Systems - Core Game Logic + src/systems/core/attack_execution_system.cpp + src/systems/core/auto_attack_system.cpp + src/systems/core/collision_system.cpp + src/systems/core/input_system.cpp + src/systems/core/movement_system.cpp + src/systems/core/network_sync_system.cpp + src/systems/core/npc_system.cpp + src/systems/core/spawning_system.cpp + src/systems/core/targeting_system.cpp + src/systems/core/wave_system.cpp + # Systems - Utilities + src/systems/util/combat_system.cpp + src/systems/util/data_loader.cpp + src/systems/util/map_system.cpp + src/systems/util/packet_handler.cpp + src/systems/util/player_manager.cpp + src/systems/util/serialization_system.cpp ) -# Header files (for IDE organization) -set(GAMESERVER_HEADERS - src/systems/gameserver.hpp - src/components/game_state.hpp - src/entities/player.hpp - src/systems/packet_validator.hpp - src/components/errors.hpp - src/systems/entity_manager.hpp - src/components/component.hpp - src/components/movement.hpp - src/components/stats.hpp - src/systems/math.hpp - src/components/map.hpp - src/services/navigation_service.hpp - src/services/astar_pathfinding.hpp - src/services/network_service.hpp - src/systems/data_loader.hpp - src/systems/map_system.hpp - src/systems/combat_system.hpp - src/systems/auto_attack_system.hpp - src/systems/attack_execution_system.hpp - src/systems/movement_system.hpp - src/systems/serialization_system.hpp - src/systems/spawning_system.hpp - src/systems/wave_system.hpp - src/systems/network_sync_system.hpp - src/systems/npc_system.hpp - src/systems/player_manager.hpp - src/systems/input_system.hpp - src/systems/collision_system.hpp - src/systems/system_context.hpp - src/systems/packet_handler.hpp - src/systems/gameplay_coordinator.hpp - src/components/client_info.hpp - src/components/readiness.hpp - src/components/network_metadata.hpp - src/components/wave_state.hpp - src/components/network_entity.hpp - src/components/player_owned.hpp - src/components/attack.hpp - src/components/target.hpp - src/components/auto_attack.hpp - src/services/visualizer_service.hpp -) +# Header files are now included via consolidated headers: +# - for all component types +# - for all system types +# - for all service types +# No individual header listing needed. set(LIBRARY_SOURCES src/libs/pugixml.cpp ) -add_executable(gameserver ${GAMESERVER_SOURCES} ${GAMESERVER_HEADERS} ${LIBRARY_SOURCES}) +add_executable(gameserver ${GAMESERVER_SOURCES} ${LIBRARY_SOURCES}) # Include directories target_include_directories(gameserver PRIVATE @@ -146,7 +110,7 @@ enable_testing() # Add test executable add_executable(gameserver_tests tests/tests.cpp - src/systems/data_loader.cpp + src/systems/util/data_loader.cpp src/libs/pugixml.cpp ) diff --git a/src/components/component_registry.hpp b/src/components/component_registry.hpp index 05dd5b5..9c13491 100644 --- a/src/components/component_registry.hpp +++ b/src/components/component_registry.hpp @@ -22,7 +22,8 @@ namespace ComponentTypes { // === State Management (2010-2099) === constexpr uint32_t ENTITY_STATE = 2010; constexpr uint32_t PATHFINDING = 2009; - constexpr uint32_t EXPERIENCE = 2011; + constexpr uint32_t INTENT = 2011; + constexpr uint32_t EXPERIENCE = 2012; // === Attack & Combat (2020-2099) === constexpr uint32_t ATTACK = 2020; diff --git a/src/components/errors.hpp b/src/components/engine_errors.hpp similarity index 100% rename from src/components/errors.hpp rename to src/components/engine_errors.hpp diff --git a/src/components/experience.hpp b/src/components/experience.hpp index d003d36..32a4db0 100644 --- a/src/components/experience.hpp +++ b/src/components/experience.hpp @@ -1,11 +1,11 @@ #pragma once -#include "component.hpp" +#include struct ExperienceComponent : public Component { float current_exp = 0.0f; // Current experience points float required_exp = 1.0f; // Experience required for next level float exp_growth_rate = 1.2f; // Growth rate for required experience per level - COMPONENT_TYPE_ID(ExperienceComponent, 2011) + COMPONENT_TYPE_ID(ExperienceComponent, 2012) }; \ No newline at end of file diff --git a/src/components/intent.hpp b/src/components/intent.hpp new file mode 100644 index 0000000..c775086 --- /dev/null +++ b/src/components/intent.hpp @@ -0,0 +1,85 @@ +#pragma once + +#include +#include +#include +#include +#include + +/** + * Intent types define the high-level goals/behaviors for NPCs. + * Intents are the "what" - the EntityState is the "how". + */ +enum class IntentType { + NONE, // No active intent + MOVE_TO_POSITION, // Move to a specific position + MOVE_TO_SPAWNPOINT, // Move along the path to a spawnpoint + ATTACK_TARGET, // Attack a specific entity + DEFEND_POSITION, // Defend an area around a position + CHASE_ENEMY, // Chase down a fleeing enemy + RETREAT, // Fall back to a safe position + PATROL, // Patrol a defined area +}; + +/** + * Intent priority levels determine which intent takes precedence when multiple are active. + * Higher values = higher priority. + */ +enum class IntentPriority { + LOWEST = 0, + LOW = 1, + NORMAL = 2, + HIGH = 3, + CRITICAL = 4 +}; + +/** + * Intent represents a high-level goal/behavior for an NPC. + * Intents are data-driven and can be queued, prioritized, and interrupted. + * (Logic for managing intents belongs in systems, not components) + */ +struct Intent { + IntentType type = IntentType::NONE; + IntentPriority priority = IntentPriority::NORMAL; + + // Time this intent has been active (milliseconds) + float elapsed_time_ms = 0.0f; + + // Maximum duration for this intent (0 = unlimited) + // If exceeded, intent is automatically cleared + float max_duration_ms = 0.0f; + + // Target data (usage depends on intent type) + uint32_t target_entity_id = INVALID_ENTITY_ID; // For ATTACK_TARGET, CHASE_ENEMY + Vec2 target_position = Vec2(0.0f, 0.0f); // For MOVE_TO_POSITION, DEFEND_POSITION + uint32_t target_spawnpoint_id = 0; // For MOVE_TO_SPAWNPOINT + + // Behavior parameters + float min_range = 0.0f; // Minimum distance to maintain from target + float max_range = 0.0f; // Maximum distance before intent is abandoned + float tolerance = 0.1f; // Distance tolerance for reaching waypoints/positions + + // Whether this intent can be interrupted by higher-priority intents + bool is_interruptible = true; +}; + +/** + * IntentComponent manages the NPC's intentions/goals. + * Uses a priority queue to determine which intent takes precedence. + * Works in conjunction with EntityStateComponent for state management. + * + * Logic for managing intents (setting, clearing, prioritizing) belongs in systems. + */ +struct IntentComponent : public Component { + + // Current active intent (highest priority) + std::unique_ptr current_intent; + + // Intent queue for managing multiple simultaneous intents + std::vector> queued_intents; + + // Maximum number of intents in the queue + static constexpr size_t MAX_INTENT_QUEUE_SIZE = 5; + + COMPONENT_TYPE_ID(IntentComponent, 2011) +}; diff --git a/src/components/map.hpp b/src/components/map.hpp index ed7ff3d..cf6500f 100644 --- a/src/components/map.hpp +++ b/src/components/map.hpp @@ -1,7 +1,7 @@ #pragma once -#include "component.hpp" -#include "../systems/math.hpp" +#include +#include #include #include diff --git a/src/components/movement.hpp b/src/components/movement.hpp index e394e72..4039426 100644 --- a/src/components/movement.hpp +++ b/src/components/movement.hpp @@ -1,7 +1,7 @@ #pragma once -#include "component.hpp" -#include "../systems/math.hpp" +#include +#include #include /** diff --git a/src/components/navmesh.hpp b/src/components/navmesh.hpp index a5a6fa5..f7f2999 100644 --- a/src/components/navmesh.hpp +++ b/src/components/navmesh.hpp @@ -1,7 +1,7 @@ #pragma once -#include "component.hpp" -#include "../systems/math.hpp" +#include +#include #include /** diff --git a/src/components/pathfinding.hpp b/src/components/pathfinding.hpp index e640b85..246cd56 100644 --- a/src/components/pathfinding.hpp +++ b/src/components/pathfinding.hpp @@ -1,7 +1,7 @@ #pragma once -#include "component.hpp" -#include "../systems/math.hpp" +#include +#include #include #include diff --git a/src/main.cpp b/src/main.cpp index 57cf152..4893d4d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -6,7 +6,7 @@ #include /* Project Headers */ -#include "gameserver.hpp" +#include // === Configuration Constants === constexpr int DEFAULT_PORT = 7000; diff --git a/src/services/astar_pathfinding.cpp b/src/services/astar_pathfinding.cpp index 852673a..94414ec 100644 --- a/src/services/astar_pathfinding.cpp +++ b/src/services/astar_pathfinding.cpp @@ -1,5 +1,5 @@ #include -#include +#include std::vector AStarPathfinder::FindPath( const Vec2& start_pos, diff --git a/src/services/astar_pathfinding.hpp b/src/services/astar_pathfinding.hpp index c328fc7..b43be68 100644 --- a/src/services/astar_pathfinding.hpp +++ b/src/services/astar_pathfinding.hpp @@ -9,7 +9,7 @@ #include #include -#include +#include /** * A* Pathfinding for 2D polygon-based navmeshes. diff --git a/src/services/navigation_service.hpp b/src/services/navigation_service.hpp index 8bad7e2..40b8b4e 100644 --- a/src/services/navigation_service.hpp +++ b/src/services/navigation_service.hpp @@ -5,7 +5,7 @@ #include #include -#include +#include class PathRequest { public: diff --git a/src/services/network_service.cpp b/src/services/network_service.cpp index 6b2e113..db209b0 100644 --- a/src/services/network_service.cpp +++ b/src/services/network_service.cpp @@ -1,7 +1,7 @@ -#include "network_service.hpp" +#include -#include "systems/math.hpp" -#include "libs/log.hpp" +#include +#include struct NetworkService::NetworkBackend { NetworkBackend() { diff --git a/src/services/network_service.hpp b/src/services/network_service.hpp index dd1bc52..2b54e75 100644 --- a/src/services/network_service.hpp +++ b/src/services/network_service.hpp @@ -7,9 +7,9 @@ #include -#include -#include -#include "components/errors.hpp" +#include +#include +#include /** * Manages low level networking so that consumers can simply exchange packets diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index 00ee69c..d71fb08 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -1,10 +1,10 @@ -#include "visualizer_service.hpp" -#include "entity_manager.hpp" -#include "components/map.hpp" -#include "components/movement.hpp" -#include "components/stats.hpp" -#include "components/entity_state.hpp" -#include +#include +#include +#include +#include +#include +#include +#include #include #include #include diff --git a/src/systems/core/attack_execution_system.cpp b/src/systems/core/attack_execution_system.cpp index 53c8d8e..30b61dd 100644 --- a/src/systems/core/attack_execution_system.cpp +++ b/src/systems/core/attack_execution_system.cpp @@ -1,9 +1,12 @@ -#include "attack_execution_system.hpp" -#include "components/auto_attack.hpp" -#include "components/entity_state.hpp" -#include "serialization_system.hpp" -#include "services/network_service.hpp" -#include +#include +#include + +#include + +#include +#include + +#include void AttackExecutionSystem::update(const SystemContext& ctx) { if (!combat_system_) { diff --git a/src/systems/core/attack_execution_system.hpp b/src/systems/core/attack_execution_system.hpp index 7ddc2cf..c6f08d6 100644 --- a/src/systems/core/attack_execution_system.hpp +++ b/src/systems/core/attack_execution_system.hpp @@ -1,9 +1,9 @@ #pragma once -#include "entity_manager.hpp" -#include "system_context.hpp" -#include "combat_system.hpp" -#include "components/attack.hpp" +#include +#include +#include +#include /** * AttackExecutionSystem - Executes pending attacks and applies damage diff --git a/src/systems/core/auto_attack_system.cpp b/src/systems/core/auto_attack_system.cpp index 968004b..cac389a 100644 --- a/src/systems/core/auto_attack_system.cpp +++ b/src/systems/core/auto_attack_system.cpp @@ -1,8 +1,8 @@ -#include "auto_attack_system.hpp" -#include "components/movement.hpp" -#include "components/entity_state.hpp" -#include "components/network_entity.hpp" -#include +#include +#include +#include +#include +#include #include #include #include diff --git a/src/systems/core/collision_system.cpp b/src/systems/core/collision_system.cpp index 3845d61..08e520a 100644 --- a/src/systems/core/collision_system.cpp +++ b/src/systems/core/collision_system.cpp @@ -1,7 +1,7 @@ -#include "collision_system.hpp" -#include "entity_manager.hpp" -#include "components/movement.hpp" -#include +#include +#include +#include +#include #include void CollisionSystem::update(const SystemContext& ctx) { diff --git a/src/systems/core/input_system.cpp b/src/systems/core/input_system.cpp index 4a5ef66..f1ee223 100644 --- a/src/systems/core/input_system.cpp +++ b/src/systems/core/input_system.cpp @@ -1,10 +1,10 @@ -#include "input_system.hpp" -#include "entity_manager.hpp" -#include "components/entity_state.hpp" -#include "components/movement.hpp" -#include "components/pathfinding.hpp" -#include "services/navigation_service.hpp" -#include +#include +#include +#include +#include +#include +#include +#include void InputSystem::queue_movement_input(EntityID entity_id, const Vec2& target_position) { movement_inputs_.push({entity_id, target_position}); diff --git a/src/systems/core/movement_system.cpp b/src/systems/core/movement_system.cpp index 2c5fdff..ce8d9de 100644 --- a/src/systems/core/movement_system.cpp +++ b/src/systems/core/movement_system.cpp @@ -1,12 +1,12 @@ -#include "movement_system.hpp" -#include "collision_system.hpp" -#include "entity_manager.hpp" -#include "services/navigation_service.hpp" +#include +#include +#include +#include #include #include #include #include -#include +#include #include // ============================================================================ diff --git a/src/systems/core/network_sync_system.cpp b/src/systems/core/network_sync_system.cpp index d736a13..e2da9e5 100644 --- a/src/systems/core/network_sync_system.cpp +++ b/src/systems/core/network_sync_system.cpp @@ -1,10 +1,10 @@ -#include "network_sync_system.hpp" -#include "serialization_system.hpp" -#include "components/movement.hpp" -#include "components/entity_state.hpp" -#include "components/network_entity.hpp" -#include "components/stats.hpp" -#include +#include +#include +#include +#include +#include +#include +#include #include #include diff --git a/src/systems/core/network_sync_system.hpp b/src/systems/core/network_sync_system.hpp index bd52bcc..5614234 100644 --- a/src/systems/core/network_sync_system.hpp +++ b/src/systems/core/network_sync_system.hpp @@ -1,8 +1,8 @@ #pragma once -#include "entity_manager.hpp" -#include "system_context.hpp" -#include "services/network_service.hpp" +#include +#include +#include #include #include diff --git a/src/systems/core/npc_system.cpp b/src/systems/core/npc_system.cpp index 788ccdf..85b2352 100644 --- a/src/systems/core/npc_system.cpp +++ b/src/systems/core/npc_system.cpp @@ -1,8 +1,8 @@ -#include "npc_system.hpp" +#include -#include "components/entity_state.hpp" -#include "components/npc_component.hpp" -#include "components/auto_attack.hpp" +#include +#include +#include #include void NPCSystem::update(const SystemContext& ctx) { diff --git a/src/systems/core/spawning_system.cpp b/src/systems/core/spawning_system.cpp index d7361bf..e89c64b 100644 --- a/src/systems/core/spawning_system.cpp +++ b/src/systems/core/spawning_system.cpp @@ -1,11 +1,11 @@ -#include "spawning_system.hpp" -#include "components/movement.hpp" -#include "components/stats.hpp" -#include "components/network_entity.hpp" -#include "components/entity_state.hpp" -#include "serialization_system.hpp" -#include "services/network_service.hpp" -#include +#include +#include +#include +#include +#include +#include +#include +#include EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, const std::string& template_id, diff --git a/src/systems/core/targeting_system.cpp b/src/systems/core/targeting_system.cpp index a203d3c..c38cff8 100644 --- a/src/systems/core/targeting_system.cpp +++ b/src/systems/core/targeting_system.cpp @@ -1,4 +1,4 @@ -#include "targeting_system.hpp" +#include #include #include #include diff --git a/src/systems/core/targeting_system.hpp b/src/systems/core/targeting_system.hpp index 33b9852..27b956f 100644 --- a/src/systems/core/targeting_system.hpp +++ b/src/systems/core/targeting_system.hpp @@ -1,10 +1,10 @@ #pragma once -#include "entity_manager.hpp" -#include "components/auto_attack.hpp" -#include "components/movement.hpp" -#include "components/stats.hpp" -#include "systems/math.hpp" +#include +#include +#include +#include +#include #include #include diff --git a/src/systems/core/wave_system.cpp b/src/systems/core/wave_system.cpp index 14f9f37..5538566 100644 --- a/src/systems/core/wave_system.cpp +++ b/src/systems/core/wave_system.cpp @@ -1,16 +1,16 @@ -#include -#include "wave_system.hpp" -#include "entity_manager.hpp" -#include "serialization_system.hpp" -#include "services/network_service.hpp" -#include "services/navigation_service.hpp" +#include +#include +#include +#include +#include +#include #include #include #include #include #include #include -#include +#include void WaveSystem::initialize(EntityManager* entity_manager, NetworkService* network_service, NavigationService* navigation_service, const Map* map) { diff --git a/src/systems/core/wave_system.hpp b/src/systems/core/wave_system.hpp index bcc33e8..478ef02 100644 --- a/src/systems/core/wave_system.hpp +++ b/src/systems/core/wave_system.hpp @@ -1,11 +1,11 @@ #pragma once +#include -#include -#include #include -#include -#include #include +#include +#include +#include #include /** diff --git a/src/systems/entity_manager.hpp b/src/systems/entity_manager.hpp index cd017b7..caf2f11 100644 --- a/src/systems/entity_manager.hpp +++ b/src/systems/entity_manager.hpp @@ -4,10 +4,11 @@ #include #include #include +// Components +#include +#include +#include -#include "components/component.hpp" -#include "components/template.hpp" -#include "components/movement.hpp" #include /** diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index 739b2a3..c35506e 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -1,6 +1,6 @@ -#include "gameplay_coordinator.hpp" +#include #include -#include +#include GameplayCoordinator::GameplayCoordinator() : wave_system_(nullptr) { diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index 91daf6e..ba309e5 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -1,14 +1,23 @@ #pragma once #include "system_context.hpp" -#include "input_system.hpp" -#include "collision_system.hpp" -#include "wave_system.hpp" -#include "movement_system.hpp" -#include "network_sync_system.hpp" -#include "auto_attack_system.hpp" -#include "attack_execution_system.hpp" -#include "npc_system.hpp" + +/* === Core Systems === */ +// Input +#include +#include + +// Physics & Movement +#include +#include + +// Combat +#include +#include + +// Networking +#include + /** * GameplayCoordinator - Orchestrates all game systems diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index 7658704..2a16b3a 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -1,8 +1,7 @@ -#include "gameserver.hpp" -#include "packet_validator.hpp" -#include "system_context.hpp" +#include +#include #include -#include +#include #include #include #include @@ -11,8 +10,9 @@ #include -#include -#include +#include +#include +#include GameServer::GameServer(int port, int max_clients, const std::string& map_path) : max_clients_(max_clients) diff --git a/src/systems/gameserver.hpp b/src/systems/gameserver.hpp index 5dbcf24..40ff518 100644 --- a/src/systems/gameserver.hpp +++ b/src/systems/gameserver.hpp @@ -6,21 +6,25 @@ #include #include #include -#include "components/errors.hpp" -#include "components/game_state.hpp" -#include "components/map.hpp" -#include "libs/frame_timer.h" -// Managers -#include "player_manager.hpp" -#include "packet_handler.hpp" -#include "gameplay_coordinator.hpp" +// Components +#include +#include +#include + +// Libraries +#include + +// Systems +#include +#include +#include // Systems -#include "entity_manager.hpp" +#include // Services -#include "services/navigation_service.hpp" -#include "services/network_service.hpp" -#include "services/visualizer_service.hpp" +#include +#include +#include /** * Central GameServer class encapsulating all server state and logic. * Replaces global state management with proper OOP encapsulation. diff --git a/src/systems/util/combat_system.cpp b/src/systems/util/combat_system.cpp index 7b9ce7e..c4b1d84 100644 --- a/src/systems/util/combat_system.cpp +++ b/src/systems/util/combat_system.cpp @@ -1,7 +1,7 @@ #include -#include "components/entity_state.hpp" -#include "components/network_entity.hpp" -#include +#include +#include +#include #include #include #include diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index 506c927..2be5b8c 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -1,9 +1,9 @@ -#include +#include #include #include -#include +#include #include #include #include diff --git a/src/systems/util/map_system.cpp b/src/systems/util/map_system.cpp index 76121ae..88f6bde 100644 --- a/src/systems/util/map_system.cpp +++ b/src/systems/util/map_system.cpp @@ -1,7 +1,7 @@ -#include "map_system.hpp" -#include "components/map.hpp" -#include "components/navmesh.hpp" -#include +#include +#include +#include +#include #include #include #include diff --git a/src/systems/util/packet_handler.cpp b/src/systems/util/packet_handler.cpp index 9e52469..c95ca1d 100644 --- a/src/systems/util/packet_handler.cpp +++ b/src/systems/util/packet_handler.cpp @@ -1,13 +1,13 @@ -#include "packet_handler.hpp" -#include "player_manager.hpp" -#include "entity_manager.hpp" -#include "input_system.hpp" -#include "services/network_service.hpp" -#include "systems/packet_validator.hpp" -#include "components/readiness.hpp" -#include "components/entity_state.hpp" -#include "components/network_metadata.hpp" -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include PacketHandler::PacketHandler(PlayerManager* player_manager, EntityManager* entity_manager, diff --git a/src/systems/util/player_manager.cpp b/src/systems/util/player_manager.cpp index 519877c..a4ddb48 100644 --- a/src/systems/util/player_manager.cpp +++ b/src/systems/util/player_manager.cpp @@ -1,9 +1,9 @@ -#include "player_manager.hpp" -#include "components/client_info.hpp" -#include "components/readiness.hpp" -#include "components/network_metadata.hpp" -#include "components/player_owned.hpp" -#include +#include +#include +#include +#include +#include +#include EntityID PlayerManager::on_client_connect(const std::string& client_id, EntityManager& entity_manager) { // Check if already connected diff --git a/src/systems/util/player_manager.hpp b/src/systems/util/player_manager.hpp index 46664d1..5b30431 100644 --- a/src/systems/util/player_manager.hpp +++ b/src/systems/util/player_manager.hpp @@ -4,7 +4,7 @@ #include #include #include -#include "entity_manager.hpp" +#include /** * PlayerManager - Manages all player entities and their lifecycle diff --git a/src/systems/util/serialization_system.cpp b/src/systems/util/serialization_system.cpp index 92bb134..a4bfa31 100644 --- a/src/systems/util/serialization_system.cpp +++ b/src/systems/util/serialization_system.cpp @@ -1,5 +1,5 @@ -#include "serialization_system.hpp" -#include "components/stats.hpp" +#include +#include std::vector SerializationSystem::serialize_packet(PACKET_TYPE packet_type) { std::vector packet_data; diff --git a/src/systems/util/serialization_system.hpp b/src/systems/util/serialization_system.hpp index 6de44d2..7237f1b 100644 --- a/src/systems/util/serialization_system.hpp +++ b/src/systems/util/serialization_system.hpp @@ -4,8 +4,8 @@ #include #include -#include -#include +#include +#include // Forward declarations struct Stats; diff --git a/tests/tests.cpp b/tests/tests.cpp index d1363a7..100b67f 100644 --- a/tests/tests.cpp +++ b/tests/tests.cpp @@ -8,11 +8,11 @@ #include #include -#include "../src/systems/entity_manager.hpp" -#include "../src/components/movement.hpp" -#include "../src/components/stats.hpp" -#include "../src/systems/packet_validator.hpp" -#include "../src/entities/player.hpp" +#include +#include +#include +#include +#include // Test utilities int tests_passed = 0; From af1e091dd4a6be6bcff6f40069a2779b2f0670d1 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 25 Nov 2025 18:47:02 -0500 Subject: [PATCH 56/79] Combat System Refactor --- CMakeLists.txt | 9 +- count.sh | 155 ++++++++ data/entities/minions/cannon_minion.xml | 3 + data/entities/minions/magic_minion.xml | 3 + data/entities/minions/melee_minion.xml | 3 + data/entities/minions/ranged_minion.xml | 3 + src/components/attack.hpp | 8 +- src/components/auto_attack.hpp | 139 +------- src/components/intent.hpp | 41 +-- src/components/network_entity.hpp | 56 --- src/components/network_metadata.hpp | 28 +- src/components/npc_component.hpp | 56 ++- src/components/pathfinding.hpp | 4 + src/components/target.hpp | 58 +-- src/main.cpp | 1 + src/services/navigation_service.cpp | 18 +- src/services/navigation_service.hpp | 4 +- src/services/visualizer_service.cpp | 100 +++++- src/systems/core/attack_execution_system.cpp | 104 ------ src/systems/core/attack_execution_system.hpp | 70 ---- src/systems/core/auto_attack_system.cpp | 320 ----------------- src/systems/core/brain_system.cpp | 149 ++++++++ src/systems/core/brain_system.hpp | 110 ++++++ src/systems/core/collision_system.cpp | 65 ++++ src/systems/core/collision_system.hpp | 11 + src/systems/core/combat_system.cpp | 189 ++++++++++ ...to_attack_system.hpp => combat_system.hpp} | 95 ++--- src/systems/core/input_system.cpp | 8 +- src/systems/core/input_system.hpp | 2 +- src/systems/core/movement_system.cpp | 118 ++++++- src/systems/core/network_sync_system.cpp | 21 +- src/systems/core/npc_system.cpp | 49 --- src/systems/core/npc_system.hpp | 57 --- src/systems/core/spawning_system.cpp | 47 ++- src/systems/core/spawning_system.hpp | 34 +- src/systems/core/targeting_system.cpp | 331 ------------------ src/systems/core/targeting_system.hpp | 190 ---------- src/systems/core/wave_system.cpp | 151 +------- src/systems/core/wave_system.hpp | 18 +- src/systems/gameplay_coordinator.cpp | 13 +- src/systems/gameplay_coordinator.hpp | 59 ++-- ...ombat_system.cpp => combat_calculator.cpp} | 12 +- ...ombat_system.hpp => combat_calculator.hpp} | 10 +- src/systems/util/component_utility.hpp | 192 ++++++++++ src/systems/util/data_loader.cpp | 89 ++++- src/systems/util/packet_handler.cpp | 3 +- src/systems/util/player_manager.cpp | 3 +- src/systems/util/targeting_utility.cpp | 307 ++++++++++++++++ src/systems/util/targeting_utility.hpp | 159 +++++++++ 49 files changed, 1872 insertions(+), 1803 deletions(-) create mode 100644 count.sh delete mode 100644 src/systems/core/attack_execution_system.cpp delete mode 100644 src/systems/core/attack_execution_system.hpp delete mode 100644 src/systems/core/auto_attack_system.cpp create mode 100644 src/systems/core/brain_system.cpp create mode 100644 src/systems/core/brain_system.hpp create mode 100644 src/systems/core/combat_system.cpp rename src/systems/core/{auto_attack_system.hpp => combat_system.hpp} (50%) delete mode 100644 src/systems/core/npc_system.cpp delete mode 100644 src/systems/core/npc_system.hpp delete mode 100644 src/systems/core/targeting_system.cpp delete mode 100644 src/systems/core/targeting_system.hpp rename src/systems/util/{combat_system.cpp => combat_calculator.cpp} (95%) rename src/systems/util/{combat_system.hpp => combat_calculator.hpp} (93%) create mode 100644 src/systems/util/component_utility.hpp create mode 100644 src/systems/util/targeting_utility.cpp create mode 100644 src/systems/util/targeting_utility.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index b892378..e19796f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,23 +57,22 @@ set(GAMESERVER_SOURCES src/systems/gameserver.cpp src/systems/gameplay_coordinator.cpp # Systems - Core Game Logic - src/systems/core/attack_execution_system.cpp - src/systems/core/auto_attack_system.cpp src/systems/core/collision_system.cpp + src/systems/core/combat_system.cpp + src/systems/core/brain_system.cpp src/systems/core/input_system.cpp src/systems/core/movement_system.cpp src/systems/core/network_sync_system.cpp - src/systems/core/npc_system.cpp src/systems/core/spawning_system.cpp - src/systems/core/targeting_system.cpp src/systems/core/wave_system.cpp # Systems - Utilities - src/systems/util/combat_system.cpp + src/systems/util/combat_calculator.cpp src/systems/util/data_loader.cpp src/systems/util/map_system.cpp src/systems/util/packet_handler.cpp src/systems/util/player_manager.cpp src/systems/util/serialization_system.cpp + src/systems/util/targeting_utility.cpp ) # Header files are now included via consolidated headers: diff --git a/count.sh b/count.sh new file mode 100644 index 0000000..95366c4 --- /dev/null +++ b/count.sh @@ -0,0 +1,155 @@ +#!/bin/bash + +# --- Configuration --- +OUTPUT_FILE="count.md" + +# Define common extensions for files to EXCLUDE from the main character/line count. +EXCLUDE_EXTENSIONS=("jpg" "jpeg" "png" "gif" "bmp" "ico" "mp3" "mp4" "mov" "avi" "zip" "rar" "gz" "tar" "bin" "exe" "dll" "so" "o" "class" "pdf" "doc" "docx" "xls" "xlsx") + +# Define common extensions for files you want to explicitly list in the breakdown table +# All other code/text files will be grouped under "Other Code/Text" +KNOWN_CODE_EXTENSIONS=("sh" "bash" "py" "js" "ts" "html" "css" "scss" "php" "c" "cpp" "h" "java" "go" "md" "txt" "yaml" "json" "xml") + + +# Convert the exclusion array to a regex pattern for use with 'find -not -regex' +EXCLUDE_PATTERN=$(printf "\.%s\\|" "${EXCLUDE_EXTENSIONS[@]}" | sed 's/|$/$/') +EXCLUDE_PATTERN="${EXCLUDE_PATTERN/\\|/\|}" +EXCLUDE_PATTERN=".*($EXCLUDE_PATTERN)" + +# Start by clearing the output file +echo "# 📁 Directory Content Analysis" > "$OUTPUT_FILE" +echo "" >> "$OUTPUT_FILE" +echo "Analysis started from: \`$(pwd)\`" >> "$OUTPUT_FILE" +echo "" >> "$OUTPUT_FILE" + +# --- 1. Total Code/Text Lines and Characters Count (Unchanged) --- + +echo "## 💻 Code/Text Lines & Characters" >> "$OUTPUT_FILE" +echo "*(Excluding files with extensions: ${EXCLUDE_EXTENSIONS[*]::$(( ${#EXCLUDE_EXTENSIONS[@]} > 5 ? 5 : ${#EXCLUDE_EXTENSIONS[@]} ))}[...] for brevity)*" >> "$OUTPUT_FILE" +echo "" >> "$OUTPUT_FILE" + +find . -type f -not -regex "$EXCLUDE_PATTERN" -print0 | xargs -0 wc -lcm | awk ' +BEGIN { + lines = 0; + chars = 0; +} +END { + if (NF >= 3) { + lines = $1; + chars = $2; + } + print "| Metric | Count |" + print "| :--- | :--- |" + print "| **Total Lines** | " lines " |" + print "| **Total Characters** | " chars " |" +}' >> "$OUTPUT_FILE" + +echo "" >> "$OUTPUT_FILE" + +# --- 2. File Classification and Summary Count (Updated Logic) --- + +declare -A EXTENSION_COUNTS +CODE_COUNT=0 +BINARY_COUNT=0 +TOTAL_FILES=0 +OTHER_CODE_COUNT=0 + +# Loop through all regular files to classify and count them +while IFS= read -r FILE; do + # Get the file's extension, defaulting to "None" if no extension is found + EXTENSION=$(echo "$FILE" | awk -F'.' '{if (NF>1) {print $NF} else {print "None"}}' | tr '[:upper:]' '[:lower:]') + + # Check if the extension is considered Binary/Media + IS_BINARY=0 + for EXT in "${EXCLUDE_EXTENSIONS[@]}"; do + if [[ "$EXTENSION" == "$EXT" ]]; then + IS_BINARY=1 + break + fi + done + + # Count based on classification for the top-level summary + if [[ $IS_BINARY -eq 1 ]]; then + ((BINARY_COUNT++)) + # Log binary files by their extension + EXTENSION_COUNTS["**Binary/Media**"]=$((${EXTENSION_COUNTS["**Binary/Media**"]:-0} + 1)) + else + ((CODE_COUNT++)) + + # Check if the code/text extension is one we want to explicitly list + IS_KNOWN_CODE=0 + for EXT in "${KNOWN_CODE_EXTENSIONS[@]}"; do + if [[ "$EXTENSION" == "$EXT" ]]; then + IS_KNOWN_CODE=1 + break + fi + done + + # Group Code/Text files: if known, list extension; if not, group as "Other Code/Text" + if [[ $IS_KNOWN_CODE -eq 1 ]]; then + EXTENSION_COUNTS["$EXTENSION"]=$((${EXTENSION_COUNTS["$EXTENSION"]:-0} + 1)) + elif [[ "$EXTENSION" == "None" ]]; then + # Files with no extension are still tracked under "None" + EXTENSION_COUNTS["None"]=$((${EXTENSION_COUNTS["None"]:-0} + 1)) + else + # All other (less common) code/text files are grouped here + ((OTHER_CODE_COUNT++)) + fi + fi + + ((TOTAL_FILES++)) + +done < <(find . -type f) + +# Add the cumulative "Other Code/Text" count to the tracking array if greater than zero +if [[ $OTHER_CODE_COUNT -gt 0 ]]; then + EXTENSION_COUNTS["**Other Code/Text**"]=$OTHER_CODE_COUNT +fi + + +# --- 3. Output Top-Level Summary Table (Unchanged) --- + +echo "## 📊 File Type Summary" >> "$OUTPUT_FILE" +echo "| File Type | Count | Percentage |" >> "$OUTPUT_FILE" +echo "| :--- | :--- | :--- |" >> "$OUTPUT_FILE" + +# Calculate percentages +if [[ $TOTAL_FILES -gt 0 ]]; then + CODE_PERCENT=$(awk "BEGIN {printf \"%.1f\", ($CODE_COUNT/$TOTAL_FILES)*100}") + BINARY_PERCENT=$(awk "BEGIN {printf \"%.1f\", ($BINARY_COUNT/$TOTAL_FILES)*100}") +else + CODE_PERCENT=0.0 + BINARY_PERCENT=0.0 +fi + +echo "| **Code/Text Files** | $CODE_COUNT | $CODE_PERCENT% |" >> "$OUTPUT_FILE" +echo "| Binary/Media Files | $BINARY_COUNT | $BINARY_PERCENT% |" >> "$OUTPUT_FILE" +echo "| **TOTAL** | **$TOTAL_FILES** | **100.0%** |" >> "$OUTPUT_FILE" + +echo "" >> "$OUTPUT_FILE" + +# --- 4. Output Extension Breakdown Table (Updated Logic) --- + +echo "## 🔍 File Count by Extension Breakdown" >> "$OUTPUT_FILE" +echo "| Extension | Count | Percentage |" >> "$OUTPUT_FILE" +echo "| :--- | :--- | :--- |" >> "$OUTPUT_FILE" + +# Sort the extensions by count in descending order +for EXTENSION in "${!EXTENSION_COUNTS[@]}"; do + echo "$EXTENSION ${EXTENSION_COUNTS[$EXTENSION]}" +done | sort -nr -k2 | while read EXTENSION COUNT; do + PERCENTAGE=$(awk "BEGIN {printf \"%.1f\", ($COUNT/$TOTAL_FILES)*100}") + + # Custom display logic for grouping headers + if [[ "$EXTENSION" == "**Binary/Media**" || "$EXTENSION" == "**Other Code/Text**" ]]; then + echo "| $EXTENSION | $COUNT | $PERCENTAGE% |" >> "$OUTPUT_FILE" + elif [[ "$EXTENSION" == "None" ]]; then + echo "| **$EXTENSION** | $COUNT | $PERCENTAGE% |" >> "$OUTPUT_FILE" + else + echo "| .$EXTENSION | $COUNT | $PERCENTAGE% |" >> "$OUTPUT_FILE" + fi +done + +echo "" >> "$OUTPUT_FILE" +echo "---" >> "$OUTPUT_FILE" +echo "Analysis complete. Output saved to \`$OUTPUT_FILE\`." \ No newline at end of file diff --git a/data/entities/minions/cannon_minion.xml b/data/entities/minions/cannon_minion.xml index 8f8f9eb..04d2e56 100644 --- a/data/entities/minions/cannon_minion.xml +++ b/data/entities/minions/cannon_minion.xml @@ -17,6 +17,7 @@ attack_speed="1.2" /> + + + \ No newline at end of file diff --git a/data/entities/minions/magic_minion.xml b/data/entities/minions/magic_minion.xml index 0cb0e56..effeb9b 100644 --- a/data/entities/minions/magic_minion.xml +++ b/data/entities/minions/magic_minion.xml @@ -18,6 +18,7 @@ attack_speed="0.8" /> + + + \ No newline at end of file diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml index 7191582..c43fd91 100644 --- a/data/entities/minions/melee_minion.xml +++ b/data/entities/minions/melee_minion.xml @@ -17,6 +17,7 @@ attack_speed="1.0" /> + + + \ No newline at end of file diff --git a/data/entities/minions/ranged_minion.xml b/data/entities/minions/ranged_minion.xml index 8054234..640511f 100644 --- a/data/entities/minions/ranged_minion.xml +++ b/data/entities/minions/ranged_minion.xml @@ -17,6 +17,7 @@ attack_speed="0.9" /> + + + \ No newline at end of file diff --git a/src/components/attack.hpp b/src/components/attack.hpp index d526c10..bc95d2b 100644 --- a/src/components/attack.hpp +++ b/src/components/attack.hpp @@ -6,7 +6,7 @@ /** * AttackComponent - Tracks current attack state and cooldown (DATA ONLY) * - * USAGE: Add to any entity that can attack (champions, minions, towers) + * USAGE: Add to any entity that can attack (champions, minions, towers) and projectiles * SYSTEMS: CombatSystem (for all update logic) * COMPANIONS: Stats (for attack_speed, attack_range), TargetComponent * @@ -24,7 +24,9 @@ struct AttackComponent : public Component { bool can_attack = true; // Can attack this frame // === Cooldown Tracking === - float attack_cooldown_ms = 0.0f; // Time until next attack available (0 = ready) + const float attack_cooldown_ms = 1000.0f; // Amount of ms to wait after attacking before being able to attack again (set once) + float cooldown_timer_ms = 0.0f; // Tracks remaining cooldown time + float cast_time_ms = 0.0f; // Time spent in current attack animation float last_attack_time_ms = 0.0f; // Timestamp of last attack // === Current Attack === @@ -32,7 +34,7 @@ struct AttackComponent : public Component { float attack_animation_progress = 0.0f; // 0.0 to 1.0, used for timing hit/effects float attack_animation_duration_ms = 300.0f; // Total duration of attack animation - // === Pending Attack Data (set by AutoAttackSystem) === + // === Pending Attack Data (set by CombatSystem) === float pending_damage = 0.0f; // Damage to apply when animation completes EntityID pending_target = INVALID_ENTITY_ID; // Target of pending attack DamageType pending_damage_type = DamageType::PHYSICAL; // Type of pending damage diff --git a/src/components/auto_attack.hpp b/src/components/auto_attack.hpp index d209cfd..6748a43 100644 --- a/src/components/auto_attack.hpp +++ b/src/components/auto_attack.hpp @@ -5,58 +5,30 @@ #include /** - * AutoAttackComponent - AI behavior for automatic attacking + * AutoAttackComponent - Pure data for auto-attack mechanics * - * USAGE: Add to minions and other AI entities that should auto-attack - * SYSTEMS: CombatSystem, AutoAttackSystem + * USAGE: Add to entities that can perform auto-attacks + * SYSTEMS: CombatSystem * COMPANIONS: AttackComponent, TargetComponent, Stats, Movement * * PURPOSE: - * - Enable AI entities to automatically search for and attack targets - * - Separate auto-attack behavior from manual attack mechanics - * - Support different AI personalities and aggression levels - * - Control when auto-attacking is enabled/disabled + * - Store auto-attack configuration and state + * - Track attack cooldown and animation state + * - Define attack damage and timing parameters + * - Store current combat state * * DESIGN: - * - Acts as a behavior modifier on top of AttackComponent - * - Stores AI-specific parameters - * - Integrates with TargetComponent for target selection - * - Works with CombatSystem for actual damage resolution + * - Pure data component (no functions) + * - CombatSystem reads and updates this data + * - BrainSystem controls when auto-attacking is enabled + * - No behavior logic - only mechanics * - * EXAMPLES: - * - Minions: Simple aggro, attack nearest enemy in range - * - Neutral units: No aggro, attack only if attacked - * - Champions (AI): Behavior-driven, target highest threat - * - Towers: Aggro-range based, attack closest in range + * NOTE: Behavior like aggression, target search, and AI personality + * belong in NPCComponent and are handled by BrainSystem */ struct AutoAttackComponent : public Component { - // === Auto-Attack Control === + // === Auto-Attack State === bool enabled = true; // Can auto-attack - bool aggressive = true; // Search for targets actively - bool retaliate_only = false; // Only attack if attacked first - - // === Auto-Attack Parameters === - float aggression_range = 10.0f; // How far to search for enemies to attack - float retreat_range = 8.0f; // How far to retreat if outnumbered - - // === Behavior Control === - enum class AIPersonality { - PASSIVE, // No aggression, only retaliate - DEFENSIVE, // Attack if threatened, otherwise passive - BALANCED, // Normal minion behavior - AGGRESSIVE, // Actively seek targets - ZEALOUS // Very aggressive, ignore retreat - }; - - AIPersonality personality = AIPersonality::BALANCED; - - // === Target Preference === - bool prioritize_enemies = true; // Attack enemies over neutrals - bool prioritize_wounded = true; // Focus low-health targets - bool prioritize_attackers = false; // Focus entities attacking me - bool prioritize_closest = true; // Among valid targets, choose closest - - // === State Management === bool in_combat = false; // Currently engaged in combat float combat_timeout_ms = 5000.0f; // How long before leaving combat (5 seconds) float time_since_attack_ms = 0.0f; // Time since last attack landed @@ -75,88 +47,5 @@ struct AutoAttackComponent : public Component { bool kite_while_attacking = false; // Actively move during auto-attacks float movement_during_attack = 0.3f; // Movement speed multiplier during attack (0.0-1.0) - /** - * Enable auto-attacking. - */ - void enable() { - enabled = true; - } - - /** - * Disable auto-attacking. - */ - void disable() { - enabled = false; - in_combat = false; - } - - /** - * Enter combat mode. - * Used by CombatSystem when combat starts. - */ - void enter_combat() { - in_combat = true; - time_since_attack_ms = 0.0f; - } - - /** - * Exit combat mode. - * Called when combat timeout expires. - */ - void exit_combat() { - in_combat = false; - } - - /** - * Update combat timer and potentially exit combat. - * @param delta_time_ms Time since last frame - * @return true if just exited combat - */ - bool update_combat_timer(float delta_time_ms) { - if (in_combat) { - time_since_attack_ms += delta_time_ms; - if (time_since_attack_ms > combat_timeout_ms) { - exit_combat(); - return true; // Just exited combat - } - } - return false; - } - - /** - * Mark that an attack occurred. - */ - void on_attack() { - time_since_attack_ms = 0.0f; - enter_combat(); - } - - /** - * Check if should be searching for targets. - * @return true if enabled and either not in combat or just exited combat - */ - bool should_search_targets() const { - return enabled && aggressive && !retaliate_only; - } - - /** - * Check if should auto-attack if target is available. - * @return true if auto-attacking is active - */ - bool should_auto_attack() const { - return enabled && (aggressive || in_combat); - } - - /** - * Get current movement speed modifier based on state. - * @return Movement speed multiplier (0.0-1.0) - */ - float get_movement_speed_modifier() const { - if (in_combat && kite_while_attacking) { - return movement_during_attack; - } - return 1.0f; - } - COMPONENT_TYPE_ID(AutoAttackComponent, 2022) }; diff --git a/src/components/intent.hpp b/src/components/intent.hpp index c775086..89c83ae 100644 --- a/src/components/intent.hpp +++ b/src/components/intent.hpp @@ -3,8 +3,6 @@ #include #include #include -#include -#include /** * Intent types define the high-level goals/behaviors for NPCs. @@ -12,7 +10,8 @@ */ enum class IntentType { NONE, // No active intent - MOVE_TO_POSITION, // Move to a specific position + MOVE_TO_OBJECTIVE, // Move toward lane objective (minion primary goal) + MOVE_TO_POSITION, // Move to a specific position (one-time) MOVE_TO_SPAWNPOINT, // Move along the path to a spawnpoint ATTACK_TARGET, // Attack a specific entity DEFEND_POSITION, // Defend an area around a position @@ -34,11 +33,15 @@ enum class IntentPriority { }; /** - * Intent represents a high-level goal/behavior for an NPC. - * Intents are data-driven and can be queued, prioritized, and interrupted. - * (Logic for managing intents belongs in systems, not components) + * IntentComponent manages the NPC's intentions/goals. + * Stores the current intent state inline with all parameters. + * Works in conjunction with EntityStateComponent for state management. + * + * Logic for managing intents (setting, clearing, prioritizing) belongs in systems. */ -struct Intent { +struct IntentComponent : public Component { + + // === Current Intent State === IntentType type = IntentType::NONE; IntentPriority priority = IntentPriority::NORMAL; @@ -51,8 +54,9 @@ struct Intent { // Target data (usage depends on intent type) uint32_t target_entity_id = INVALID_ENTITY_ID; // For ATTACK_TARGET, CHASE_ENEMY - Vec2 target_position = Vec2(0.0f, 0.0f); // For MOVE_TO_POSITION, DEFEND_POSITION - uint32_t target_spawnpoint_id = 0; // For MOVE_TO_SPAWNPOINT + Vec2 target_position = Vec2(0.0f, 0.0f); // For MOVE_TO_POSITION, DEFEND_POSITION, MOVE_TO_OBJECTIVE + uint32_t target_spawnpoint_id = 0; // For MOVE_TO_SPAWNPOINT, MOVE_TO_OBJECTIVE (current lane objective) + uint32_t objective_index = 0; // For MOVE_TO_OBJECTIVE: which spawnpoint in the lane path (0 = next, 1 = after, etc.) // Behavior parameters float min_range = 0.0f; // Minimum distance to maintain from target @@ -61,25 +65,6 @@ struct Intent { // Whether this intent can be interrupted by higher-priority intents bool is_interruptible = true; -}; - -/** - * IntentComponent manages the NPC's intentions/goals. - * Uses a priority queue to determine which intent takes precedence. - * Works in conjunction with EntityStateComponent for state management. - * - * Logic for managing intents (setting, clearing, prioritizing) belongs in systems. - */ -struct IntentComponent : public Component { - - // Current active intent (highest priority) - std::unique_ptr current_intent; - - // Intent queue for managing multiple simultaneous intents - std::vector> queued_intents; - - // Maximum number of intents in the queue - static constexpr size_t MAX_INTENT_QUEUE_SIZE = 5; COMPONENT_TYPE_ID(IntentComponent, 2011) }; diff --git a/src/components/network_entity.hpp b/src/components/network_entity.hpp index 3aac8f2..60e6711 100644 --- a/src/components/network_entity.hpp +++ b/src/components/network_entity.hpp @@ -46,61 +46,5 @@ struct NetworkEntityComponent : public Component { static constexpr uint32_t MIN_POSITION_CHANGE = 1; // Only sync if moved 1 unit static constexpr uint32_t SYNC_FRAME_INTERVAL = 1; // Sync every frame - /** - * Check if entity position has changed significantly since last sync. - * @param current_position Current entity position - * @return true if position change is significant - */ - bool has_position_changed(const Vec2& current_position) const { - float dx = current_position.x - last_synced_position.x; - float dy = current_position.y - last_synced_position.y; - float dist_sq = dx * dx + dy * dy; - return dist_sq >= (MIN_POSITION_CHANGE * MIN_POSITION_CHANGE); - } - - /** - * Check if entity state has changed since last sync. - * @param current_state Current entity state - * @return true if state has changed - */ - bool has_state_changed(EntityState current_state) const { - return current_state != last_synced_state; - } - - /** - * Check if any stats have changed since last sync. - * Directly compares current stats against cached version. - * @param current_stats Current stats component - * @return true if stats have changed - */ - bool has_stats_changed(const Stats& current_stats) const { - if (!last_synced_stats) { - return true; // No cached stats, so it's a change - } - // Simple field-by-field comparison of critical fields - return current_stats.health != last_synced_stats->health || - current_stats.max_health != last_synced_stats->max_health || - current_stats.mana != last_synced_stats->mana || - current_stats.max_mana != last_synced_stats->max_mana || - current_stats.level != last_synced_stats->level; - } - - /** - * Mark this entity as fully synced with the given state. - * @param position Current position - * @param state Current state - * @param stats Current stats (for change detection) - * @param current_frame Frame number - */ - void mark_synced(const Vec2& position, EntityState state, const Stats* stats, uint32_t current_frame) { - last_synced_position = position; - last_synced_state = state; - if (stats) { - last_synced_stats = *stats; - } - last_sync_frame = current_frame; - force_full_sync_next_frame = false; - } - COMPONENT_TYPE_ID(NetworkEntityComponent, 3004) }; diff --git a/src/components/network_metadata.hpp b/src/components/network_metadata.hpp index b5a4420..4ac0aa7 100644 --- a/src/components/network_metadata.hpp +++ b/src/components/network_metadata.hpp @@ -13,34 +13,8 @@ * Provides methods to check connection staleness and update activity. */ struct NetworkMetadataComponent : public Component { - std::chrono::steady_clock::time_point last_activity; + std::chrono::steady_clock::time_point last_activity = std::chrono::steady_clock::now(); unsigned int latency_ms = 0; // Last measured ping in milliseconds - /** - * Constructor - initializes last_activity to current time - */ - NetworkMetadataComponent() - : last_activity(std::chrono::steady_clock::now()) {} - - /** - * Check if player connection is stale (no activity for timeout_ms). - * @param timeout_ms Timeout in milliseconds (default: 30 seconds) - * @return true if last activity exceeds timeout - */ - bool is_stale(unsigned int timeout_ms = 30000) const { - auto now = std::chrono::steady_clock::now(); - auto elapsed = std::chrono::duration_cast( - now - last_activity); - return elapsed.count() > timeout_ms; - } - - /** - * Update last activity timestamp to current time. - * Call this whenever the player sends a packet. - */ - void update_activity() { - last_activity = std::chrono::steady_clock::now(); - } - COMPONENT_TYPE_ID(NetworkMetadataComponent, 3003) }; diff --git a/src/components/npc_component.hpp b/src/components/npc_component.hpp index 5c42c3f..65d9923 100644 --- a/src/components/npc_component.hpp +++ b/src/components/npc_component.hpp @@ -7,41 +7,39 @@ enum class NPCType { MINION }; + + struct NPCComponent : public Component { NPCType npc_type; - float chase_distance = 30.0f; - float chase_timeout_ms = 5000.0f; // How long to keep chasing without hitting the target (not implemented)-- cmkrist 24/11/2025 - // === State Cooldown === - float state_change_cooldown_ms = 250.0f; // Minimum time between state changes (prevents rapid flip-flopping) - float time_since_last_state_change_ms = 0.0f; // Tracks time since last state change + enum class AIPersonality { + PASSIVE, // No aggression, only retaliate + DEFENSIVE, // Attack if threatened, otherwise passive + BALANCED, // Normal minion behavior + AGGRESSIVE, // Actively seek targets + ZEALOUS // Very aggressive, ignore retreat + }; - /** - * Check if enough time has passed to allow a state change. - * Prevents rapid state transitions that cause minions to get stuck. - * @return true if state change is allowed - */ - bool can_change_state() const { - return time_since_last_state_change_ms >= state_change_cooldown_ms; - } + // === Behavior Configuration === + AIPersonality personality = AIPersonality::BALANCED; + float aggression_range = 10.0f; // How far to search for enemies to attack + float retreat_range = 8.0f; // How far to retreat if outnumbered + bool aggressive = true; // Search for targets actively + bool retaliate_only = false; // Only attack if attacked first - /** - * Mark that a state change just occurred. - * Resets the cooldown timer. - */ - void on_state_changed() { - time_since_last_state_change_ms = 0.0f; - } + // === Target Preference === + bool prioritize_enemies = true; // Attack enemies over neutrals + bool prioritize_wounded = true; // Focus low-health targets + bool prioritize_attackers = false; // Focus entities attacking me + bool prioritize_closest = true; // Among valid targets, choose closest - /** - * Update the state change cooldown timer. - * @param delta_time_ms Time elapsed since last update - */ - void update_state_cooldown(float delta_time_ms) { - if (time_since_last_state_change_ms < state_change_cooldown_ms) { - time_since_last_state_change_ms += delta_time_ms; - } - } + // === Chase Behavior === + float chase_distance = 30.0f; + float chase_timeout_ms = 5000.0f; // How long to keep chasing without hitting the target + + // === State Cooldown === + float state_change_cooldown_ms = 250.0f; // Minimum time between state changes (prevents rapid flip-flopping) + float time_since_last_state_change_ms = 0.0f; // Tracks time since last state change COMPONENT_TYPE_ID(NPCComponent, ComponentTypes::NPC) }; \ No newline at end of file diff --git a/src/components/pathfinding.hpp b/src/components/pathfinding.hpp index 246cd56..2bf4ae6 100644 --- a/src/components/pathfinding.hpp +++ b/src/components/pathfinding.hpp @@ -32,5 +32,9 @@ struct PathfindingComponent : public Component { // Threshold for considering entity stuck (milliseconds) static constexpr float STUCK_THRESHOLD_MS = 2000.0f; + // Counter for failed pathfinding attempts (to prevent infinite retries) + uint32_t pathfinding_retry_count = 0; + static constexpr uint32_t MAX_PATHFINDING_RETRIES = 3; + COMPONENT_TYPE_ID(PathfindingComponent, 2009) }; \ No newline at end of file diff --git a/src/components/target.hpp b/src/components/target.hpp index 3f74ac9..329b5c8 100644 --- a/src/components/target.hpp +++ b/src/components/target.hpp @@ -8,7 +8,7 @@ * TargetComponent - Tracks current attack target * * USAGE: Add to entities that need target selection (minions, champions) - * SYSTEMS: CombatSystem, AutoAttackSystem, TargetingSystem + * SYSTEMS: CombatSystem * COMPANIONS: AttackComponent, Movement * * PURPOSE: @@ -56,61 +56,5 @@ struct TargetComponent : public Component { bool target_in_range = false; // Whether target is in attack range float distance_to_target = 0.0f; // Cached distance to current target - /** - * Set a specific target. - * @param target_id Entity ID to target - */ - void set_target(EntityID target_id) { - current_target = target_id; - has_target = (target_id != INVALID_ENTITY_ID); - last_target_search_ms = 0.0f; - } - - /** - * Clear current target. - */ - void clear_target() { - current_target = INVALID_ENTITY_ID; - has_target = false; - target_in_range = false; - distance_to_target = 0.0f; - } - - /** - * Check if should search for new target. - * @param current_time_ms Current game time - * @return true if enough time has passed since last search - */ - bool should_search_for_target(float current_time_ms) const { - return (current_time_ms - last_target_search_ms) >= target_search_interval_ms; - } - - /** - * Mark that target search was performed. - * @param current_time_ms Current game time - */ - void mark_target_searched(float current_time_ms) { - last_target_search_ms = current_time_ms; - } - - /** - * Check if current target is still valid. - * @return true if target exists and is in range - */ - bool is_target_valid() const { - return has_target && current_target != INVALID_ENTITY_ID && - distance_to_target <= target_loss_range; - } - - /** - * Update distance to target (usually called by CombatSystem). - * @param distance Current distance in game units - * @param attack_range Attack range threshold - */ - void update_target_distance(float distance, float attack_range) { - distance_to_target = distance; - target_in_range = (distance <= attack_range); - } - COMPONENT_TYPE_ID(TargetComponent, 2021) }; diff --git a/src/main.cpp b/src/main.cpp index 4893d4d..e265e4a 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,4 +1,5 @@ #define ENET_IMPLEMENTATION +#define _CRT_SECURE_NO_WARNINGS /* Standard Libraries */ #include #include diff --git a/src/services/navigation_service.cpp b/src/services/navigation_service.cpp index 66e7666..5c30838 100644 --- a/src/services/navigation_service.cpp +++ b/src/services/navigation_service.cpp @@ -15,7 +15,7 @@ struct NavigationService::NavServiceBackend { std::thread worker; Map map; - std::atomic running{true}; + std::atomic running{false}; std::queue requests; std::queue results; std::queue waitingResults; @@ -24,6 +24,11 @@ struct NavigationService::NavServiceBackend { FrameTimer frame_timer = FrameTimer(30); NavServiceBackend() { + // Don't start thread yet - wait for map to be assigned + } + + void start_worker() { + running = true; worker = std::thread([this]() { LOG_INFO("Spinning off NavigationService backend thread"); start_work(); @@ -64,17 +69,13 @@ struct NavigationService::NavServiceBackend { // the lock is unlocked, take your time // ================================================================= - // Perform A* pathfinding on the 2D navmesh - Vec2 start_2d(req.current_position.x, req.current_position.z); - Vec2 goal_2d(req.destination.x, req.destination.z); - // Create local copies of the navmesh data for thread-safe pathfinding std::vector navmesh_vertices = this->map.vertices; std::vector> navmesh_polygons = this->map.polygons; std::vector path_2d = AStarPathfinder::FindPath( - start_2d, - goal_2d, + req.current_position, + req.destination, navmesh_vertices, navmesh_polygons, req.entity_pathing_radius @@ -87,7 +88,7 @@ struct NavigationService::NavServiceBackend { if (res.path.empty()) { LOG_WARN("Navigation: Entity %u path from (%.1f, %.1f) to (%.1f, %.1f) returned EMPTY PATH", - req.entity_id, start_2d.x, start_2d.y, goal_2d.x, goal_2d.y); + req.entity_id, req.current_position.x, req.current_position.y, req.destination.x, req.destination.y); } else { LOG_DEBUG("Navigation: Entity %u path with %zu waypoints", req.entity_id, res.path.size()); } @@ -126,6 +127,7 @@ struct NavigationService::NavServiceBackend { NavigationService::NavigationService(Map map_object) { impl_ = std::make_unique(); impl_->map = std::move(map_object); + impl_->start_worker(); // Start thread after map is assigned } NavigationService::~NavigationService() = default; diff --git a/src/services/navigation_service.hpp b/src/services/navigation_service.hpp index 40b8b4e..ac54909 100644 --- a/src/services/navigation_service.hpp +++ b/src/services/navigation_service.hpp @@ -11,8 +11,8 @@ class PathRequest { public: uint32_t entity_id; float entity_pathing_radius; - Vec3 current_position; - Vec3 destination; + Vec2 current_position; + Vec2 destination; }; class PathResult { diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index d71fb08..b83bc4b 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -19,6 +20,37 @@ #define SHUT_RDWR SD_BOTH #endif +// Helper functions to convert enums to strings +static std::string entity_state_to_string(EntityState state) { + switch (state) { + case EntityState::SPAWNED: return "SPAWNED"; + case EntityState::IDLE: return "IDLE"; + case EntityState::PATHFINDING_WAITING: return "PATHFINDING_WAITING"; + case EntityState::HOLDING_FOR_TARGET: return "HOLDING_FOR_TARGET"; + case EntityState::MOVING: return "MOVING"; + case EntityState::STOPPING: return "STOPPING"; + case EntityState::STUCK: return "STUCK"; + case EntityState::ATTACKING: return "ATTACKING"; + case EntityState::DEAD: return "DEAD"; + default: return "UNKNOWN"; + } +} + +static std::string intent_type_to_string(IntentType type) { + switch (type) { + case IntentType::NONE: return "NONE"; + case IntentType::MOVE_TO_OBJECTIVE: return "MOVE_TO_OBJECTIVE"; + case IntentType::MOVE_TO_POSITION: return "MOVE_TO_POSITION"; + case IntentType::MOVE_TO_SPAWNPOINT: return "MOVE_TO_SPAWNPOINT"; + case IntentType::ATTACK_TARGET: return "ATTACK_TARGET"; + case IntentType::DEFEND_POSITION: return "DEFEND_POSITION"; + case IntentType::CHASE_ENEMY: return "CHASE_ENEMY"; + case IntentType::RETREAT: return "RETREAT"; + case IntentType::PATROL: return "PATROL"; + default: return "UNKNOWN"; + } +} + VisualizerService::VisualizerService(uint16_t port) : port_(port) { } @@ -302,6 +334,44 @@ std::string VisualizerService::get_html_page() const { function drawEntities(entities) { if (!entities) return; + // First pass: draw targeting lines + for (let entity of entities) { + if (entity.target_id !== undefined) { + const attacker_x = entity.position.x * 10 + 400; + const attacker_y = entity.position.z * 10 + 300; + + // Find target entity + const target = entities.find(e => e.id === entity.target_id); + if (target) { + const target_x = target.position.x * 10 + 400; + const target_y = target.position.z * 10 + 300; + + // Draw targeting line + ctx.strokeStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + ctx.lineWidth = 2; + ctx.setLineDash([5, 5]); + ctx.beginPath(); + ctx.moveTo(attacker_x, attacker_y); + ctx.lineTo(target_x, target_y); + ctx.stroke(); + ctx.setLineDash([]); + + // Draw arrowhead at target + const angle = Math.atan2(target_y - attacker_y, target_x - attacker_x); + const arrowSize = 8; + + ctx.fillStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + ctx.beginPath(); + ctx.moveTo(target_x, target_y); + ctx.lineTo(target_x - arrowSize * Math.cos(angle - Math.PI / 6), target_y - arrowSize * Math.sin(angle - Math.PI / 6)); + ctx.lineTo(target_x - arrowSize * Math.cos(angle + Math.PI / 6), target_y - arrowSize * Math.sin(angle + Math.PI / 6)); + ctx.closePath(); + ctx.fill(); + } + } + } + + // Second pass: draw entities for (let entity of entities) { const x = entity.position.x * 10 + 400; const y = entity.position.z * 10 + 300; @@ -316,6 +386,15 @@ std::string VisualizerService::get_html_page() const { ctx.fillStyle = '#ffffff'; ctx.font = '10px Arial'; ctx.fillText(entity.id, x - 10, y - 8); + + // Highlight if attacking + if (entity.state === 'ATTACKING') { + ctx.strokeStyle = '#ffff00'; + ctx.lineWidth = 2; + ctx.beginPath(); + ctx.arc(x, y, 6, 0, Math.PI * 2); + ctx.stroke(); + } } } @@ -332,7 +411,19 @@ std::string VisualizerService::get_html_page() const { for (let entity of entities) { const el = document.createElement('div'); el.className = 'entity'; - el.innerHTML = `Entity ${entity.id} | Team ${entity.team_id} | State: ${entity.state} | Pos: (${entity.position.x.toFixed(1)}, ${entity.position.z.toFixed(1)})`; + + let targetStr = ''; + if (entity.target_id !== undefined) { + const target = entities.find(e => e.id === entity.target_id); + const targetName = target ? `E${entity.target_id}` : `E${entity.target_id} (DEAD)`; + targetStr = ` → Targeting ${targetName}`; + } + + const stateColor = entity.state === 'ATTACKING' ? '#ffff00' : + entity.state === 'MOVING' ? '#4da6ff' : + entity.state === 'DEAD' ? '#ff0000' : '#ffb347'; + + el.innerHTML = `E${entity.id} [Team ${entity.team_id}] | Intent: ${entity.intent} | State: ${entity.state}${targetStr} | (${entity.position.x.toFixed(1)}, ${entity.position.z.toFixed(1)})`; div.appendChild(el); } } @@ -389,12 +480,17 @@ std::string VisualizerService::get_game_state_json() const { auto* move = entity->get_component(); auto* stats = entity->get_component(); auto* state = entity->get_component(); + auto* intent = entity->get_component(); json << "{"; json << "\"id\":" << entity->get_id() << ","; json << "\"position\":{\"x\":" << move->position.x << ",\"z\":" << move->position.y << "},"; json << "\"team_id\":" << (int)(stats ? stats->team_id : 0) << ","; - json << "\"state\":\"" << (state ? std::to_string((int)state->current_state) : "UNKNOWN") << "\""; + json << "\"state\":\"" << (state ? entity_state_to_string(state->current_state) : "UNKNOWN") << "\","; + json << "\"intent\":\"" << (intent ? intent_type_to_string(intent->type) : "UNKNOWN") << "\""; + if (intent && intent->target_entity_id != INVALID_ENTITY_ID) { + json << ",\"target_id\":" << intent->target_entity_id; + } json << "}"; } } diff --git a/src/systems/core/attack_execution_system.cpp b/src/systems/core/attack_execution_system.cpp deleted file mode 100644 index 30b61dd..0000000 --- a/src/systems/core/attack_execution_system.cpp +++ /dev/null @@ -1,104 +0,0 @@ -#include -#include - -#include - -#include -#include - -#include - -void AttackExecutionSystem::update(const SystemContext& ctx) { - if (!combat_system_) { - LOG_WARN("AttackExecutionSystem: combat_system not set!"); - return; - } - - // Process all entities with pending attacks - auto attacking_entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : attacking_entities) { - if (entity) { - auto* attack = entity->get_component(); - if (attack && attack->attack_in_progress) { - execute_attack(ctx, *entity, *attack, ctx.delta_time_ms); - } - } - } -} - -bool AttackExecutionSystem::execute_attack(const SystemContext& ctx, Entity& entity, - AttackComponent& attack, float delta_time_ms) { - // Get auto-attack component for hit timing - auto* auto_attack = entity.get_component(); - if (!auto_attack) { - auto_attack = nullptr; // Optional component - } - - float hit_timing_percent = auto_attack ? auto_attack->hit_timing_percent : 0.5f; - float animation_duration = attack.attack_animation_duration_ms > 0.0f - ? attack.attack_animation_duration_ms - : 300.0f; - - // Store old progress to detect threshold crossing - float old_progress = attack.attack_animation_progress; - - // Update animation progress - attack.attack_animation_progress += delta_time_ms / animation_duration; - - // Check if we should apply damage (crossed the hit timing threshold) - bool damage_applied = false; - if (old_progress < hit_timing_percent && attack.attack_animation_progress >= hit_timing_percent) { - // It's time to apply damage! - // First check if attacker is still alive - auto* attacker_stats = entity.get_component(); - if (attacker_stats && attacker_stats->health > 0.0f && attack.pending_target != INVALID_ENTITY_ID) { - auto damage_events = combat_system_->apply_damage( - ctx.entity_manager, - entity.get_id(), - attack.pending_target, - attack.pending_damage, - attack.pending_damage_type - ); - - if (!damage_events.empty()) { - LOG_INFO("Attack executed: entity %u dealt %.1f damage to entity %u", - entity.get_id(), damage_events[0].damage_dealt, attack.pending_target); - - // Broadcast combat event to all clients -- might need to be moved later -- cmkrist 24/11/2025 - if (ctx.network_service) { - const auto& event = damage_events[0]; - auto combat_packet = SerializationSystem::serialize_combat_event( - entity.get_id(), - attack.pending_target, - event.damage_dealt, - static_cast(event.damage_type), - event.was_critical_hit - ); - ctx.network_service->broadcast_packet(combat_packet); - } - - damage_applied = true; - } - } else if (attacker_stats && attacker_stats->health <= 0.0f) { - LOG_DEBUG("Cancelling attack: attacker %u is dead", entity.get_id()); - } - } - - // Check if animation is complete - if (attack.attack_animation_progress >= 1.0f) { - attack.attack_animation_progress = 1.0f; - attack.attack_in_progress = false; - - // Clear pending attack data - attack.pending_damage = 0.0f; - attack.pending_target = INVALID_ENTITY_ID; - attack.pending_damage_type = DamageType::PHYSICAL; - } - - return damage_applied; -} - -bool AttackExecutionSystem::is_damage_apply_time(float attack_progress, float hit_timing_percent) const { - // Damage applies when we reach or pass the hit timing threshold - return attack_progress >= hit_timing_percent; -} diff --git a/src/systems/core/attack_execution_system.hpp b/src/systems/core/attack_execution_system.hpp deleted file mode 100644 index c6f08d6..0000000 --- a/src/systems/core/attack_execution_system.hpp +++ /dev/null @@ -1,70 +0,0 @@ -#pragma once - -#include -#include -#include -#include - -/** - * AttackExecutionSystem - Executes pending attacks and applies damage - * - * RESPONSIBILITIES: - * - Update attack animation progress each frame - * - Detect when damage should be applied based on animation timing - * - Call CombatSystem.apply_damage() at the right moment - * - Clean up completed attacks - * - Reset attack state after animations complete - * - * COMPONENTS USED: - * - AttackComponent (attack state and pending attack data) - * - AutoAttackComponent (animation timing parameters) - * - Stats (for damage calculation) - * - * SYSTEM INTERACTION: - * - Runs AFTER AutoAttackSystem (which queues attacks) - * - Runs AFTER CombatSystem (separate pass for execution) - * - Calls CombatSystem.apply_damage() to process damage - * - * DATA-DRIVEN DESIGN: - * Attacks are queued with pending data (damage, target, animation duration). - * This system executes those attacks based on the configured animation timing. - */ -class AttackExecutionSystem { -public: - /** - * Set reference to combat system for applying damage. - * Must be called before update(). - * @param combat_system Reference to CombatSystem - */ - void set_combat_system(CombatSystem* combat_system) { - combat_system_ = combat_system; - } - - /** - * Update all pending attacks for this frame. - * Processes attack animations and applies damage at the correct time. - * @param ctx System context with entity manager, services, and delta time - */ - void update(const SystemContext& ctx); - -private: - CombatSystem* combat_system_ = nullptr; - - /** - * Process a single entity's pending attack. - * @param ctx System context - * @param entity Entity with attack in progress - * @param attack Attack component with pending data - * @param delta_time_ms Time elapsed this frame - * @return true if damage was applied this frame - */ - bool execute_attack(const SystemContext& ctx, Entity& entity, AttackComponent& attack, float delta_time_ms); - - /** - * Check if it's time to apply damage based on animation progress and hit timing. - * @param attack_progress Current animation progress (0.0-1.0) - * @param hit_timing_percent When damage should occur (0.0-1.0) - * @return true if we just crossed the hit timing threshold - */ - bool is_damage_apply_time(float attack_progress, float hit_timing_percent) const; -}; diff --git a/src/systems/core/auto_attack_system.cpp b/src/systems/core/auto_attack_system.cpp deleted file mode 100644 index cac389a..0000000 --- a/src/systems/core/auto_attack_system.cpp +++ /dev/null @@ -1,320 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include - -void AutoAttackSystem::update(const SystemContext& ctx) { - // Process all entities with auto-attack behavior - auto attacking_entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : attacking_entities) { - if (entity) { - update_auto_attack(ctx, *entity, ctx.delta_time_ms); - } - } -} - -void AutoAttackSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms) { - auto* auto_attack = entity.get_component(); - auto* attack = entity.get_component(); - auto* target = entity.get_component(); - auto* stats = entity.get_component(); - auto* entity_state = entity.get_component(); - - if (!auto_attack || !attack || !target || !stats) { - return; // Missing required components - } - - // Don't process if entity is dead - if (is_dead(entity)) { - if (target->is_target_valid()) { - target->clear_target(); - } - return; - } - - // Update combat timer - auto_attack->update_combat_timer(delta_time_ms); - - // Update attack cooldown - update_attack_cooldown(*attack, delta_time_ms); - - // Don't process if auto-attacking disabled - if (!auto_attack->should_auto_attack()) { - // If we had a target but auto-attack is disabled, clear it - if (target->is_target_valid()) { - target->clear_target(); - } - return; - } - - // Search for new target if needed - if (!target->is_target_valid() && auto_attack->should_search_targets()) { - // Search for target on first search (last_target_search_ms == 0) or after interval has passed - if (target->last_target_search_ms == 0.0f || (auto_attack->time_since_attack_ms >= target->target_search_interval_ms)) { - EntityID new_target = find_best_target(ctx, entity, *auto_attack, *target); - if (new_target != INVALID_ENTITY_ID) { - target->set_target(new_target); - // Tell entity_state who to move toward via target_entity_id - if (entity_state) { - entity_state->target_entity_id = new_target; - } - LOG_INFO("Entity (ID %u) acquired new target: %u", entity.get_id(), new_target); - - // Update distance immediately so target validation works - Entity* target_entity = ctx.entity_manager.get_entity(new_target); - if (target_entity) { - auto* target_move = target_entity->get_component(); - auto* my_move = entity.get_component(); - if (target_move && my_move) { - float dx = target_move->position.x - my_move->position.x; - float dy = target_move->position.y - my_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - target->update_target_distance(distance, stats->attack_range); - } - } - } - // Mark search as done - reset timer - target->last_target_search_ms = auto_attack->time_since_attack_ms; - } - } - - // Process valid targets - if (target->is_target_valid()) { - Entity* target_entity = ctx.entity_manager.get_entity(target->current_target); - - if (target_entity && !is_dead(*target_entity)) { - // Calculate distance to target - auto* target_move = target_entity->get_component(); - auto* my_move = entity.get_component(); - - if (target_move && my_move) { - float dx = target_move->position.x - my_move->position.x; - float dy = target_move->position.y - my_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - - target->update_target_distance(distance, stats->attack_range); - - // Attack if in range and ready - if (target->target_in_range && is_attack_ready(*attack)) { - // Begin attack animation - begin_attack_animation(*attack); - - // Transition to ATTACKING state - movement system will handle kiting - if (entity_state && entity_state->current_state != EntityState::ATTACKING) { - entity_state->current_state = EntityState::ATTACKING; - entity_state->state_duration_ms = 0.0f; - } - - // Calculate damage - float base_damage = stats->physical_power + auto_attack->bonus_damage; - base_damage *= auto_attack->base_damage_multiplier; - - // Store attack data for CombatSystem to process - // (CombatSystem will call apply_damage when appropriate) - attack->pending_damage = base_damage; - attack->pending_damage_type = auto_attack->damage_type; - attack->pending_target = target->current_target; - attack->attack_animation_duration_ms = auto_attack->attack_animation_duration_ms; - - // Start cooldown - start_attack_cooldown(*attack, stats->attack_speed); - auto_attack->on_attack(); - - LOG_INFO("Entity (ID %u) initiated auto-attack on target (ID %u)", - entity.get_id(), target->current_target); - } else if (!target->target_in_range) { - // Out of range - MovementSystem will handle approaching via HOLDING_FOR_TARGET - // Just update the target_entity_id so it knows who to move toward - if (entity_state) { - entity_state->target_entity_id = target->current_target; - } - } - } - } else { - // Target is dead or invalid, clear it - // MovementSystem will handle state transitions based on pathfinding - target->clear_target(); - } - } -} - -EntityID AutoAttackSystem::find_best_target(const SystemContext& ctx, const Entity& attacker, - const AutoAttackComponent& auto_attack_comp, - TargetComponent& target_comp) const { - if (!attacker.has_component() || !attacker.has_component()) { - return INVALID_ENTITY_ID; - } - - const auto* attacker_move = attacker.get_component(); - // attacker_stats not needed for find_best_target - only for target validation - - EntityID best_target = INVALID_ENTITY_ID; - float best_score = -1e9f; - - // Get all entities with Movement (potential targets) - auto all_entities = ctx.entity_manager.get_entities_with_component(); - - for (auto* potential_target : all_entities) { - if (!potential_target || potential_target->get_id() == attacker.get_id()) { - continue; // Skip self - } - - // Check if valid target - if (!is_valid_target(ctx, attacker, *potential_target)) { - continue; - } - - // Calculate distance - auto* target_move = potential_target->get_component(); - if (!target_move) continue; - - float dx = target_move->position.x - attacker_move->position.x; - float dy = target_move->position.y - attacker_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - - // Skip if out of aggro range - if (distance > auto_attack_comp.aggression_range) { - continue; - } - - // Calculate target score based on targeting mode - float score = 0.0f; - - auto* target_stats = potential_target->get_component(); - - switch (target_comp.targeting_mode) { - case TargetComponent::TargetPriority::NEAREST: - score = -distance; // Negative distance = higher score for closer - break; - - case TargetComponent::TargetPriority::LOWEST_HEALTH: - if (target_stats) { - score = -(target_stats->health); // Negative health = target low HP - } - break; - - case TargetComponent::TargetPriority::HIGHEST_THREAT: - if (target_stats) { - score = target_stats->physical_power + target_stats->magic_power; - } - break; - - case TargetComponent::TargetPriority::HIGHEST_DAMAGE: - if (target_stats) { - score = target_stats->physical_power; - } - break; - - default: - score = -distance; - break; - } - - // Prefer closer targets as tiebreaker - if (auto_attack_comp.prioritize_closest) { - score -= (distance * 0.1f); - } - - if (score > best_score) { - best_score = score; - best_target = potential_target->get_id(); - } - } - - return best_target; -} - -bool AutoAttackSystem::is_valid_target(const SystemContext& /*ctx*/, const Entity& attacker, - const Entity& potential_target) const { - // Must have stats - if (!potential_target.has_component()) { - return false; - } - - const auto* attacker_stats = attacker.get_component(); - const auto* target_stats = potential_target.get_component(); - - if (!attacker_stats || !target_stats) { - return false; - } - - // Can't target dead units - if (target_stats->health <= 0.0f) { - return false; - } - - // Can't target neutral observers - if (target_stats->team_id == 255) { - return false; - } - - // Can't target same team (unless friendly fire enabled) - if (attacker_stats->team_id != 0 && target_stats->team_id == attacker_stats->team_id) { - return false; - } - - // Target must be on opposite team or attacker neutral - if (attacker_stats->team_id == 0 && target_stats->team_id == 0) { - return false; // Can't target neutrals as neutral - } - - return true; -} - -bool AutoAttackSystem::is_dead(const Entity& entity) const { - if (!entity.has_component()) { - return true; - } - - const Stats* stats = entity.get_component(); - return stats->health <= 0.0f; -} - -void AutoAttackSystem::update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const { - if (attack.attack_cooldown_ms > 0.0f) { - attack.attack_cooldown_ms -= delta_time_ms; - if (attack.attack_cooldown_ms < 0.0f) { - attack.attack_cooldown_ms = 0.0f; - attack.can_attack = true; - } - } -} - -void AutoAttackSystem::start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const { - if (attack_speed_stat > 0.0f) { - attack.attack_cooldown_ms = (1000.0f / attack_speed_stat); // Convert to milliseconds - } else { - attack.attack_cooldown_ms = 1000.0f; // Default 1 second - } - attack.can_attack = false; - attack.attacks_this_frame = 0; -} - -bool AutoAttackSystem::is_attack_ready(const AttackComponent& attack) const { - return attack.attack_cooldown_ms <= 0.0f && attack.can_attack; -} - -void AutoAttackSystem::begin_attack_animation(AttackComponent& attack) const { - attack.attack_in_progress = true; - attack.attack_animation_progress = 0.0f; - attack.attacks_this_frame++; - attack.total_attacks++; -} - -bool AutoAttackSystem::update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const { - if (!attack.attack_in_progress) return false; - - attack.attack_animation_progress += delta_time_ms / animation_duration_ms; - - if (attack.attack_animation_progress >= 1.0f) { - attack.attack_animation_progress = 1.0f; - attack.attack_in_progress = false; - return true; // Attack complete - } - - return false; -} diff --git a/src/systems/core/brain_system.cpp b/src/systems/core/brain_system.cpp new file mode 100644 index 0000000..eaf8911 --- /dev/null +++ b/src/systems/core/brain_system.cpp @@ -0,0 +1,149 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void BrainSystem::update(const SystemContext& ctx) { + // Get all entities with IntentComponent + auto entities_with_intent = ctx.entity_manager.get_entities_with_component(); + + for (auto* entity : entities_with_intent) { + if (!entity) continue; + + process_entity_intent(ctx, entity); + } +} + +void BrainSystem::process_entity_intent(const SystemContext& ctx, Entity* entity) { + auto* intent_comp = entity->get_component(); + auto* stats = entity->get_component(); + auto* entity_state = entity->get_component(); + auto* npc_comp = entity->get_component(); + auto* attack = entity->get_component(); + + if (!intent_comp || !stats || !entity_state) { + return; + } + + // Handle attack cooldown logic for ATTACK_TARGET intent + if (attack && intent_comp->type == IntentType::ATTACK_TARGET) { + // If attack is not ready, update cooldown timer + if (!attack->can_attack) { + if (attack->cooldown_timer_ms > 0.0f) { + attack->cooldown_timer_ms -= ctx.delta_time_ms; + if (attack->cooldown_timer_ms < 0.0f) { + attack->cooldown_timer_ms = 0.0f; + } + } + if (attack->cooldown_timer_ms == 0.0f) { + attack->can_attack = true; + } + } + // If attack was just used, set cooldown timer + if (attack->can_attack && attack->attack_in_progress) { + attack->cooldown_timer_ms = attack->attack_cooldown_ms; + attack->can_attack = false; + } + } + + // Check current intent + switch (intent_comp->type) { + // MOVEMENT LOGIC + case IntentType::MOVE_TO_OBJECTIVE: + case IntentType::MOVE_TO_POSITION: + case IntentType::MOVE_TO_SPAWNPOINT: { + // Check entity profile for aggression + if (npc_comp) { + using Personality = decltype(npc_comp->personality); + if (npc_comp->personality == Personality::AGGRESSIVE || + npc_comp->personality == Personality::ZEALOUS || + npc_comp->personality == Personality::BALANCED) + { + // Look for nearby enemies to attack + EntityID target = TargetingUtility::find_best_target( + ctx.entity_manager, + entity->get_id(), + npc_comp->aggression_range, + TargetComponent::TargetPriority::NEAREST, + true // prioritize_closest + ); + + if (target != INVALID_ENTITY_ID) { + // Switch to ATTACK_TARGET intent + intent_comp->type = IntentType::ATTACK_TARGET; + intent_comp->target_entity_id = target; + LOG_DEBUG("Entity %u: Switching to ATTACK_TARGET intent (target %u)", + entity->get_id(), target); + // Don't return - fall through to process ATTACK_TARGET case immediately + } + } + } + + // Only set MOVING state if we didn't find a target to attack + if (intent_comp->type != IntentType::ATTACK_TARGET) { + entity_state->current_state = EntityState::MOVING; + } + break; + } + case IntentType::ATTACK_TARGET: + default: + break; + } + + // Process ATTACK_TARGET intent (separate from movement intents) + if (intent_comp->type == IntentType::ATTACK_TARGET) { + // Check if target is valid and still alive + bool target_valid = false; + if (intent_comp->target_entity_id != INVALID_ENTITY_ID) { + // Check if target entity exists + Entity* target_entity = ctx.entity_manager.get_entity(intent_comp->target_entity_id); + if (target_entity) { + // Check if target is still alive + Stats* target_stats = target_entity->get_component(); + if (target_stats && target_stats->health > 0.0f) { + target_valid = true; + } + } + } + + if (target_valid) { + // Target is alive, proceed with attack logic + float distance = TargetingUtility::calculate_distance(entity->get_component()->position, intent_comp->target_entity_id, ctx.entity_manager); + if (distance >= stats->attack_range) { + // Out of range - move closer + entity_state->current_state = EntityState::MOVING; + } else { + // In range - attack + // BrainSystem only manages the state and intent + // CombatSystem will read ATTACKING state + ATTACK_TARGET intent to initiate actual attacks + entity_state->current_state = EntityState::ATTACKING; + entity_state->target_entity_id = intent_comp->target_entity_id; + LOG_DEBUG("Entity %u: Transitioned to ATTACKING state for target %u", + entity->get_id(), intent_comp->target_entity_id); + } + } else { + // Target is dead or invalid - revert to moving toward objective + intent_comp->type = IntentType::MOVE_TO_OBJECTIVE; + intent_comp->target_entity_id = INVALID_ENTITY_ID; + entity_state->current_state = EntityState::MOVING; + + // Clear any pending pathfinding waypoints from the attack path + auto* pathfinding = entity->get_component(); + if (pathfinding) { + pathfinding->waypoints.clear(); + pathfinding->current_waypoint_index = 0; + } + + LOG_DEBUG("Entity %u: Attack target is dead or invalid, reverting to MOVE_TO_OBJECTIVE", + entity->get_id()); + } + } +} \ No newline at end of file diff --git a/src/systems/core/brain_system.hpp b/src/systems/core/brain_system.hpp new file mode 100644 index 0000000..29dfd46 --- /dev/null +++ b/src/systems/core/brain_system.hpp @@ -0,0 +1,110 @@ +#pragma once + +#include "system_context.hpp" +#include +#include +#include +#include + +/** + * BrainSystem - NPC decision-making and intent management + * + * RESPONSIBILITIES: + * - Read IntentComponent to understand what the NPC wants to do + * - Translate high-level intents into low-level component state + * - Manage target acquisition based on intents + * - Handle cooldowns and combat timeouts + * - Set up CombatComponent and MovementComponent based on intents + * + * ARCHITECTURE: + * This system implements the Intent-based architecture: + * - IntentComponent = What the NPC thinks it should do (ATTACK_TARGET, MOVE_TO_POSITION, etc.) + * - BrainSystem = How to translate intent into lower-level components + * - CombatSystem = Reads CombatComponent and executes combat logic + * - MovementSystem = Reads MovementComponent and executes movement + * + * FLOW: + * 1. Read IntentComponent.current_intent + * 2. Based on intent type, update CombatComponent and MovementComponent + * 3. CombatSystem will read CombatComponent and handle combat + * 4. MovementSystem will read MovementComponent and handle movement + * 5. BrainSystem manages cooldowns and decides when to clear/change intents + * + * USAGE: + * BrainSystem brain_system; + * // In game loop: + * brain_system.update(ctx); + * + * SYSTEM INTERACTION: + * - Runs early in the loop (like NPC input) + * - Reads: IntentComponent, Stats, Movement, EntityStateComponent, CombatComponent + * - Writes: CombatComponent, MovementComponent, EntityStateComponent + * - Read by: CombatSystem, MovementSystem + */ +class BrainSystem { +public: + BrainSystem() = default; + ~BrainSystem() = default; + + // Prevent copying + BrainSystem(const BrainSystem&) = delete; + BrainSystem& operator=(const BrainSystem&) = delete; + + // Allow moving + BrainSystem(BrainSystem&&) = default; + BrainSystem& operator=(BrainSystem&&) = default; + + /** + * Update NPC decision-making and intent management. + * Translates intents into component state for other systems to execute. + * + * @param ctx System context with entity manager and network service + */ + void update(const SystemContext& ctx); + +private: + /** + * Process a single entity's intent. + * + * @param ctx System context + * @param entity Entity with IntentComponent + */ + void process_entity_intent(const SystemContext& ctx, Entity* entity); + + /** + * Update minion AI intent (LoL-style minion behavior). + * Handles target acquisition and movement to objective. + * + * @param ctx System context + * @param entity Minion entity + * @param intent IntentComponent to update + * @param stats Stats component + * @param entity_state EntityStateComponent to update + * @param auto_attack AutoAttackComponent with aggression range + */ + void update_minion_intent(const SystemContext& ctx, Entity* entity, IntentComponent& intent, + Stats& stats, EntityStateComponent& entity_state, + AutoAttackComponent& auto_attack); + + /** + * Handle generic intent for non-minion entities. + * Ensures entity state reflects current intent. + * + * @param ctx System context + * @param entity Entity to update + * @param intent IntentComponent + * @param entity_state EntityStateComponent to update + */ + void handle_generic_intent(const SystemContext& ctx, Entity* entity, + IntentComponent& intent, EntityStateComponent& entity_state); + + /** + * Get the distance from entity to target. + * + * @param attacker Entity doing the attacking + * @param target_id ID of target entity + * @param ctx System context + * @return Distance in units, or -1 if target not found + */ + float get_distance_to_target(const Entity* attacker, uint32_t target_id, const SystemContext& ctx) const; +}; diff --git a/src/systems/core/collision_system.cpp b/src/systems/core/collision_system.cpp index 08e520a..237dd8d 100644 --- a/src/systems/core/collision_system.cpp +++ b/src/systems/core/collision_system.cpp @@ -172,6 +172,71 @@ void CollisionSystem::push_colliding_entities(const Entity& entity, const Vec2& } } +Vec2 CollisionSystem::find_free_space(const Vec2& position, float collision_radius, EntityManager& entity_manager) { + // Get all entities with movement components to check for collisions + auto moving_entities = entity_manager.get_entities_with_component(); + + // Check if base position is free + bool position_free = true; + for (auto* entity : moving_entities) { + const Movement* other_move = entity->get_component(); + if (other_move) { + float dx = position.x - other_move->position.x; + float dy = position.y - other_move->position.y; + float dist = std::sqrt(dx * dx + dy * dy); + float min_distance = collision_radius + other_move->collision_radius; + + if (dist < min_distance) { + position_free = false; + break; + } + } + } + + if (position_free) { + return position; + } + + // If base position is occupied, try to find a free spot nearby + // Use expanding circles to search for free space + constexpr float SEARCH_RADIUS = 5.0f; + constexpr int SEARCH_SAMPLES = 16; // Number of angles to check + constexpr float PI = 3.14159265f; + + for (float search_distance = collision_radius * 2.0f; search_distance <= SEARCH_RADIUS; search_distance += 0.5f) { + for (int i = 0; i < SEARCH_SAMPLES; ++i) { + float angle = (2.0f * PI * i) / SEARCH_SAMPLES; + Vec2 candidate = position + Vec2(std::cos(angle) * search_distance, std::sin(angle) * search_distance); + + // Check if this candidate position is free + bool candidate_free = true; + for (auto* entity : moving_entities) { + const Movement* other_move = entity->get_component(); + if (other_move) { + float dx = candidate.x - other_move->position.x; + float dy = candidate.y - other_move->position.y; + float dist = std::sqrt(dx * dx + dy * dy); + float min_distance = collision_radius + other_move->collision_radius; + + if (dist < min_distance) { + candidate_free = false; + break; + } + } + } + + if (candidate_free) { + return candidate; + } + } + } + + // If no free space found after search, return base position anyway + LOG_WARN("CollisionSystem: Could not find free space near (%.1f, %.1f) with radius %.1f, using base position", + position.x, position.y, collision_radius); + return position; +} + float CollisionSystem::distance(const Vec2& a, const Vec2& b) { float dx = a.x - b.x; float dy = a.y - b.y; diff --git a/src/systems/core/collision_system.hpp b/src/systems/core/collision_system.hpp index 8191e67..d8aa4e0 100644 --- a/src/systems/core/collision_system.hpp +++ b/src/systems/core/collision_system.hpp @@ -90,6 +90,17 @@ class CollisionSystem { * @param entity_manager Reference to entity manager for finding colliding entities */ static void push_colliding_entities(const Entity& entity, const Vec2& proposed_position, EntityManager& entity_manager); + + /** + * Find a free spawn position near a given location. + * Searches for a collision-free position using expanding circle pattern. + * + * @param position The desired spawn position + * @param collision_radius The collision radius of the entity to spawn (default 1.0) + * @param entity_manager Reference to entity manager to check existing entities + * @return A nearby collision-free position, or the original position if none found + */ + static Vec2 find_free_space(const Vec2& position, float collision_radius, EntityManager& entity_manager); private: /** diff --git a/src/systems/core/combat_system.cpp b/src/systems/core/combat_system.cpp new file mode 100644 index 0000000..c18fff9 --- /dev/null +++ b/src/systems/core/combat_system.cpp @@ -0,0 +1,189 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void CombatSystem::update(const SystemContext& ctx) { + // Process all entities with auto-attack behavior + auto attacking_entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : attacking_entities) { + if (entity) { + // Update auto-attack (target search, cooldown, attack initiation) + update_auto_attack(ctx, *entity, ctx.delta_time_ms); + } + } + + // Process all entities with pending attacks (execution phase) + attacking_entities = ctx.entity_manager.get_entities_with_component(); + for (auto* entity : attacking_entities) { + if (entity) { + auto* attack = entity->get_component(); + if (attack && attack->attack_in_progress) { + execute_attack(ctx, *entity, *attack, ctx.delta_time_ms); + } + } + } +} + +void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms) { + auto* auto_attack = entity.get_component(); + auto* attack = entity.get_component(); + auto* target = entity.get_component(); + auto* stats = entity.get_component(); + auto* entity_state = entity.get_component(); + auto* intent = entity.get_component(); + + if (!auto_attack || !attack || !target || !stats) { + return; // Missing required components + } + + // Don't process if entity is dead + if (is_dead(entity)) { + if (ComponentUtility::is_target_valid(*target)) { + ComponentUtility::clear_target(*target); + } + return; + } + + // Check if entity should initiate an attack + // Condition: In ATTACKING state, has ATTACK_TARGET intent, and attack is ready + if (entity_state && entity_state->current_state == EntityState::ATTACKING && + intent && intent->type == IntentType::ATTACK_TARGET && + attack->can_attack && !attack->attack_in_progress) { + + // Get the target entity + auto* target_entity = ctx.entity_manager.get_entity(intent->target_entity_id); + auto* target_stats = target_entity ? target_entity->get_component() : nullptr; + + if (target_stats && target_stats->health > 0.0f && intent->target_entity_id != INVALID_ENTITY_ID) { + // Calculate damage based on attacker's physical power + float damage = stats->physical_power * 1.0f; + + // Initiate attack + attack->pending_target = intent->target_entity_id; + attack->pending_damage = damage; + attack->pending_damage_type = DamageType::PHYSICAL; + attack->attack_in_progress = true; + attack->attack_animation_progress = 0.0f; + attack->can_attack = false; + + LOG_DEBUG("Entity %u: CombatSystem initiating attack on target %u with damage %.1f", + entity.get_id(), intent->target_entity_id, damage); + } + } + + float hit_timing_percent = auto_attack ? auto_attack->hit_timing_percent : 0.5f; + float animation_duration = attack->attack_animation_duration_ms > 0.0f + ? attack->attack_animation_duration_ms + : 300.0f; + + // Store old progress to detect threshold crossing + float old_progress = attack->attack_animation_progress; + + // Update animation progress + attack->attack_animation_progress += delta_time_ms / animation_duration; + + // Check if we should apply damage (crossed the hit timing threshold) + bool damage_applied = false; + if (old_progress < hit_timing_percent && attack->attack_animation_progress >= hit_timing_percent) { + // It's time to apply damage! + // First check if attacker is still alive + auto* attacker_stats = entity.get_component(); + if (attacker_stats && attacker_stats->health > 0.0f && attack->pending_target != INVALID_ENTITY_ID) { + auto damage_events = combat_calculator_.apply_damage( + ctx.entity_manager, + entity.get_id(), + attack->pending_target, + attack->pending_damage, + attack->pending_damage_type + ); + + if (!damage_events.empty()) { + // Broadcast combat event to all clients + if (ctx.network_service) { + const auto& event = damage_events[0]; + auto combat_packet = SerializationSystem::serialize_combat_event( + entity.get_id(), + attack->pending_target, + event.damage_dealt, + static_cast(event.damage_type), + event.was_critical_hit + ); + ctx.network_service->broadcast_packet(combat_packet); + } + damage_applied = true; + } + } else if (attacker_stats && attacker_stats->health <= 0.0f) { + LOG_DEBUG("Cancelling attack: attacker %u is dead", entity.get_id()); + } + } + + // Check if animation is complete + if (attack->attack_animation_progress >= 1.0f) { + attack->attack_animation_progress = 1.0f; + attack->attack_in_progress = false; + + // Clear pending attack data + attack->pending_damage = 0.0f; + attack->pending_target = INVALID_ENTITY_ID; + attack->pending_damage_type = DamageType::PHYSICAL; + } +} + +void CombatSystem::execute_attack(const SystemContext& ctx, Entity& entity, AttackComponent& attack, float delta_time_ms) { + // This method was consolidated into update_auto_attack + // Attack execution now happens in update_auto_attack where damage is applied at the correct animation timing +} + +bool CombatSystem::is_dead(const Entity& entity) const { + const Stats* stats = entity.get_component(); + return stats && stats->health <= 0.0f; +} + +bool CombatSystem::is_valid_target(const SystemContext& ctx, const Entity& attacker, + const Entity& potential_target) const { + return TargetingUtility::can_engage_in_combat( + const_cast(ctx.entity_manager), + attacker.get_id(), + potential_target.get_id() + ); +} + +void CombatSystem::update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const { + if (attack.cooldown_timer_ms > 0.0f) { + attack.cooldown_timer_ms -= delta_time_ms; + if (attack.cooldown_timer_ms < 0.0f) { + attack.cooldown_timer_ms = 0.0f; + } + } +} + +void CombatSystem::start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const { + // attack_speed_stat is attacks per second + if (attack_speed_stat > 0.0f) { + attack.cooldown_timer_ms = 1000.0f / attack_speed_stat; + } +} + +bool CombatSystem::is_attack_ready(const AttackComponent& attack) const { + return attack.can_attack && attack.cooldown_timer_ms <= 0.0f; +} + +void CombatSystem::begin_attack_animation(AttackComponent& attack) const { + attack.attack_in_progress = true; + attack.attack_animation_progress = 0.0f; +} + +bool CombatSystem::is_damage_apply_time(float attack_progress, float hit_timing_percent) const { + // This is now handled in update_auto_attack by comparing old_progress vs new_progress + return false; +} diff --git a/src/systems/core/auto_attack_system.hpp b/src/systems/core/combat_system.hpp similarity index 50% rename from src/systems/core/auto_attack_system.hpp rename to src/systems/core/combat_system.hpp index 2378c97..425789e 100644 --- a/src/systems/core/auto_attack_system.hpp +++ b/src/systems/core/combat_system.hpp @@ -1,22 +1,30 @@ #pragma once -#include "entity_manager.hpp" -#include "system_context.hpp" -#include "components/auto_attack.hpp" -#include "components/attack.hpp" -#include "components/target.hpp" -#include "components/stats.hpp" +#include +#include +#include +#include +#include +#include +#include +#include /** - * AutoAttackSystem - Handles auto-attack AI and cooldown mechanics + * CombatSystem - Unified combat management system * * RESPONSIBILITIES: - * - Automatic target acquisition and searching + * - Auto-attack AI and target acquisition * - Attack cooldown and readiness tracking * - Combat timeout management * - Target validation and prioritization * - Attack animation management - * - Auto-attack execution coordination + * - Attack execution and damage application + * - Coordinate between auto-attack logic and damage calculation + * + * REPLACES: + * - AutoAttackSystem (auto-attack AI and cooldowns) + * - AttackExecutionSystem (attack animation and execution) + * This unified system handles all aspects of combat from AI to execution * * COMPONENTS USED: * - AutoAttackComponent (AI behavior settings) @@ -26,63 +34,71 @@ * - Movement (position for range calculations) * - EntityStateComponent (for state tracking) * + * UTILITIES USED: + * - TargetingUtility: Pure utility functions for targeting calculations and validation + * * SYSTEM INTERACTION: - * - Works with CombatSystem which applies actual damage - * - Manages when and how attacks are initiated - * - Feeds attack information to network sync + * - Uses CombatCalculator for damage calculation and application + * - Uses TargetingUtility for range and eligibility checks + * - Works with NetworkSyncSystem to broadcast combat effects + * - Feeds attack information to entity state tracking * * DATA-DRIVEN DESIGN: - * All auto-attack behavior is configured through AutoAttackComponent properties. + * All combat behavior is configured through component properties. * This system reads those properties and executes accordingly without hardcoded logic. + * Targeting behavior is entirely data-driven via AutoAttackComponent and Stats properties. */ -class AutoAttackSystem { +class CombatSystem { public: /** - * Update all auto-attack behavior for this frame. - * Handles target search, cooldowns, and attack execution for all entities with AutoAttackComponent. + * Update all combat for this frame. + * Handles auto-attacks, cooldowns, target search, and attack execution. * @param ctx System context with entity manager, services, and delta time */ void update(const SystemContext& ctx); private: + CombatCalculator combat_calculator_; + /** * Update and process auto-attacks for an entity. - * Handles cooldowns, target selection, and attack execution. + * Handles cooldowns, target selection, and attack initiation. * @param ctx System context * @param entity Entity to update * @param delta_time_ms Time since last frame in milliseconds */ void update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms); - + /** - * Find best target for an entity based on targeting mode and auto-attack settings. + * Execute a pending attack for an entity. + * Processes attack animations and applies damage at the correct time. * @param ctx System context - * @param attacker Entity looking for target - * @param auto_attack_comp AutoAttackComponent for settings - * @param target_comp TargetComponent to update - * @return EntityID of best target, or INVALID_ENTITY_ID if none found + * @param entity Entity with attack in progress + * @param attack Attack component with pending data + * @param delta_time_ms Time elapsed this frame + * @return true if damage was applied this frame */ - EntityID find_best_target(const SystemContext& ctx, const Entity& attacker, - const AutoAttackComponent& auto_attack_comp, - TargetComponent& target_comp) const; - + void execute_attack(const SystemContext& ctx, Entity& entity, AttackComponent& attack, float delta_time_ms); + /** * Check if a potential target is valid (not dead, correct team, etc). + * NOTE: Use TargetingUtility validation functions instead - all targeting is now in utility! * @param ctx System context * @param attacker Entity doing attacking * @param potential_target Entity to validate * @return true if valid target + * @deprecated Use TargetingUtility::can_engage_in_combat() or is_target_valid() directly */ - bool is_valid_target(const SystemContext& ctx, const Entity& attacker, + bool is_valid_target(const SystemContext& /*ctx*/, const Entity& attacker, const Entity& potential_target) const; - + /** * Check if an entity is dead (health <= 0). * @param entity Entity to check * @return true if entity is dead */ bool is_dead(const Entity& entity) const; - + /** * Update attack cooldown for an entity. * Called each frame to reduce the cooldown timer. @@ -90,33 +106,32 @@ class AutoAttackSystem { * @param delta_time_ms Time elapsed since last frame */ void update_attack_cooldown(AttackComponent& attack, float delta_time_ms) const; - + /** * Start attack cooldown based on attack speed stat. * @param attack Attack component to update * @param attack_speed_stat Attack speed from Stats component (attacks per second) */ void start_attack_cooldown(AttackComponent& attack, float attack_speed_stat) const; - + /** * Check if an entity is ready to attack. * @param attack Attack component to check * @return true if cooldown is finished and entity can attack */ bool is_attack_ready(const AttackComponent& attack) const; - + /** * Begin attack animation. * @param attack Attack component to update */ void begin_attack_animation(AttackComponent& attack) const; - + /** - * Update attack animation progress. - * @param attack Attack component to update - * @param delta_time_ms Time elapsed - * @param animation_duration_ms Total animation duration - * @return true if animation is complete + * Check if it's time to apply damage based on animation progress and hit timing. + * @param attack_progress Current animation progress (0.0-1.0) + * @param hit_timing_percent When damage should occur (0.0-1.0) + * @return true if we just crossed the hit timing threshold */ - bool update_attack_animation(AttackComponent& attack, float delta_time_ms, float animation_duration_ms) const; + bool is_damage_apply_time(float attack_progress, float hit_timing_percent) const; }; diff --git a/src/systems/core/input_system.cpp b/src/systems/core/input_system.cpp index f1ee223..de20cd5 100644 --- a/src/systems/core/input_system.cpp +++ b/src/systems/core/input_system.cpp @@ -75,14 +75,10 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi pathfinding = entity.get_component(); } - // Request pathfinding path - Vec3 start = Vec3(movement->position.x, 0.0f, movement->position.y); - Vec3 goal = Vec3(target_position.x, 0.0f, target_position.y); - PathRequest request; request.entity_id = entity.get_id(); - request.current_position = start; - request.destination = goal; + request.current_position = movement->position; + request.destination = target_position; request.entity_pathing_radius = 0.5f; if (ctx.navigation_service->MakeRequest(request)) { diff --git a/src/systems/core/input_system.hpp b/src/systems/core/input_system.hpp index 9848c90..9fc6a8d 100644 --- a/src/systems/core/input_system.hpp +++ b/src/systems/core/input_system.hpp @@ -5,7 +5,7 @@ #include #include -struct Entity; +class Entity; typedef uint32_t EntityID; /** diff --git a/src/systems/core/movement_system.cpp b/src/systems/core/movement_system.cpp index ce8d9de..f815d4d 100644 --- a/src/systems/core/movement_system.cpp +++ b/src/systems/core/movement_system.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include @@ -59,8 +60,20 @@ void MovementSystem::process_completed_paths(const SystemContext& ctx) { pathfinding->current_waypoint_index = 0; if (result->path.empty()) { - LOG_WARN("Entity %u received EMPTY path!", entity->get_id()); + LOG_WARN("Entity %u received EMPTY path! Retry count: %u", + entity->get_id(), pathfinding->pathfinding_retry_count); + + // Increment retry counter + pathfinding->pathfinding_retry_count++; + + // On empty path, mark as stuck so it can be retried + if (entity_state) { + entity_state->current_state = EntityState::PATHFINDING_WAITING; + } } else { + // Successful path received, reset retry counter + pathfinding->pathfinding_retry_count = 0; + if (entity_state) { entity_state->current_state = EntityState::MOVING; entity_state->state_duration_ms = 0.0f; @@ -76,11 +89,31 @@ void MovementSystem::retry_stuck_entities(const SystemContext& ctx) { for (auto* entity : entities) { PathfindingComponent* pathfinding = entity->get_component(); EntityStateComponent* entity_state = entity->get_component(); + IntentComponent* intent = entity->get_component(); + Movement* movement = entity->get_component(); + + if (!pathfinding || !entity_state || !movement) continue; - if (pathfinding && entity_state && - entity_state->current_state == EntityState::PATHFINDING_WAITING && + if (entity_state->current_state == EntityState::PATHFINDING_WAITING && pathfinding->waypoints.empty()) { - request_new_path(*entity, pathfinding->target_spawnpoint_id, ctx.navigation_service, ctx.map); + + // Only retry up to max retries, don't apply fallback + if (pathfinding->pathfinding_retry_count < PathfindingComponent::MAX_PATHFINDING_RETRIES) { + // Retry pathfinding request + if (intent && intent->type == IntentType::MOVE_TO_OBJECTIVE && + intent->target_spawnpoint_id < ctx.map->spawnpoints.size()) { + request_new_path(*entity, intent->target_spawnpoint_id, ctx.navigation_service, ctx.map); + } else if (intent && intent->type == IntentType::ATTACK_TARGET && ctx.navigation_service) { + PathRequest request; + request.entity_id = entity->get_id(); + request.current_position = movement->position; + request.destination = intent->target_position; + request.entity_pathing_radius = 0.5f; + ctx.navigation_service->MakeRequest(request); + } + } else { + LOG_WARN("Entity %u exceeded max pathfinding retries and will remain stuck on navmesh", entity->get_id()); + } } } } @@ -90,9 +123,56 @@ void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& en PathfindingComponent* pathfinding = entity.get_component(); Stats* stats = entity.get_component(); EntityStateComponent* state_comp = entity.get_component(); + IntentComponent* intent = entity.get_component(); if (!movement || !stats) return; + // Handle MOVE_TO_OBJECTIVE intent - set up pathfinding to target spawnpoint + if (intent && intent->type == IntentType::MOVE_TO_OBJECTIVE && pathfinding && + pathfinding->waypoints.empty() && intent->target_spawnpoint_id < ctx.map->spawnpoints.size()) { + request_new_path(entity, intent->target_spawnpoint_id, ctx.navigation_service, ctx.map); + return; // Path request submitted, will process next frame + } + + // Handle ATTACK_TARGET intent - request pathfinding to move toward target entity + if (intent && + intent->type == IntentType::ATTACK_TARGET && + intent->target_entity_id != INVALID_ENTITY_ID && + pathfinding && + pathfinding->waypoints.empty() + ) { + // Get the target entity's current position and check distance + Entity* target_entity = ctx.entity_manager.get_entity(intent->target_entity_id); + if (target_entity) { + Movement* target_movement = target_entity->get_component(); + if (target_movement && ctx.navigation_service && ctx.map && movement) { + // Check if already within attack range + float distance_to_target = (target_movement->position - movement->position).length(); + if (distance_to_target < stats->attack_range) { + // Already in range, no pathfinding needed + LOG_DEBUG("Entity %u: Already in attack range of target %u (distance=%.1f, range=%.1f)", + entity.get_id(), intent->target_entity_id, distance_to_target, stats->attack_range); + return; + } + + PathRequest request; + request.entity_id = entity.get_id(); + request.current_position = movement->position; + request.destination = target_movement->position; + request.entity_pathing_radius = 0.5f; + + if (ctx.navigation_service->MakeRequest(request)) { + if (state_comp) { + state_comp->current_state = EntityState::PATHFINDING_WAITING; + } + LOG_DEBUG("Entity %u: Requested pathfinding to attack target %u at (%.1f, %.1f)", + entity.get_id(), intent->target_entity_id, target_movement->position.x, target_movement->position.y); + } + } + } + return; // Path request submitted, will process next frame + } + // If holding for target, move toward the target entity if (state_comp && state_comp->current_state == EntityState::HOLDING_FOR_TARGET && state_comp->target_entity_id != INVALID_ENTITY_ID) { @@ -152,7 +232,7 @@ void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& en // Update pathfinding entities (minions following waypoints) // TODO: Differentiate between minions and other pathfinding entities (AI Component?) -- cmkrist 18/11/2025 - if (pathfinding) { + if (pathfinding && state_comp && state_comp->current_state == EntityState::MOVING) { update_stuck_detection(ctx, entity, *movement, *pathfinding, state_comp); update_waypoint_movement(ctx, entity, *movement, *stats, *pathfinding, state_comp); } @@ -228,12 +308,32 @@ void MovementSystem::update_waypoint_movement(const SystemContext& ctx, Entity& Movement& movement, Stats& stats, PathfindingComponent& pathfinding, EntityStateComponent* entity_state) { - // Skip if waiting for pathfinding or no waypoints + // Skip if waiting for pathfinding or not in MOVING state if (!pathfinding.waypoints.size() || !entity_state || entity_state->current_state != EntityState::MOVING) { return; } + // If we have ATTACK_TARGET intent and are in MOVING state, check if we should stop due to attack range + auto* intent = entity.get_component(); + if (intent && intent->type == IntentType::ATTACK_TARGET && intent->target_entity_id != INVALID_ENTITY_ID) { + Entity* target_entity = ctx.entity_manager.get_entity(intent->target_entity_id); + if (target_entity) { + Movement* target_movement = target_entity->get_component(); + if (target_movement) { + float distance_to_target = (target_movement->position - movement.position).length(); + if (distance_to_target < stats.attack_range) { + // We're now in attack range - clear waypoints and stop moving + pathfinding.waypoints.clear(); + pathfinding.current_waypoint_index = 0; + LOG_DEBUG("Entity %u: Reached attack range of target %u, stopping movement", + entity.get_id(), intent->target_entity_id); + return; + } + } + } + } + // Check if reached end of path if (pathfinding.current_waypoint_index >= pathfinding.waypoints.size()) { request_path_to_next_spawnpoint(ctx, entity, pathfinding, entity_state); @@ -334,14 +434,12 @@ void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint return; } - Vec3 start = Vec3(movement->position.x, 0.0f, movement->position.y); Vec2 goal_2d = map->spawnpoints[target_spawnpoint_id]; - Vec3 goal = Vec3(goal_2d.x, 0.0f, goal_2d.y); PathRequest request; request.entity_id = entity.get_id(); - request.current_position = start; - request.destination = goal; + request.current_position = movement->position; + request.destination = goal_2d; request.entity_pathing_radius = 0.5f; if (navigation_service->MakeRequest(request)) { diff --git a/src/systems/core/network_sync_system.cpp b/src/systems/core/network_sync_system.cpp index e2da9e5..79fd304 100644 --- a/src/systems/core/network_sync_system.cpp +++ b/src/systems/core/network_sync_system.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -113,7 +114,7 @@ void NetworkSyncSystem::update(const SystemContext& ctx) { Vec2 pos = move ? move->position : Vec2(0, 0); EntityState state_val = state ? state->current_state : EntityState::SPAWNED; - net_comp->mark_synced(pos, state_val, stats, current_frame_); + ComponentUtility::mark_network_entity_synced(*net_comp, pos, state_val, stats, current_frame_); LOG_DEBUG("Synced entity %u (is_first_sync=%s) at position (%.1f, %.1f), state=%d, packets=%zu", entity->get_id(), is_first_sync ? "true" : "false", pos.x, pos.y, (int)state_val, packets.size()); } @@ -139,17 +140,17 @@ bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t curren } // Check position change - if (move && net_comp->has_position_changed(move->position)) { + if (move && ComponentUtility::has_network_position_changed(*net_comp, move->position)) { return true; } // Check state change (for state transitions) - if (state && net_comp->has_state_changed(state->current_state)) { + if (state && ComponentUtility::has_network_state_changed(*net_comp, state->current_state)) { return true; } // Check for stat changes (health, mana, level, etc.) - if (stats && net_comp->has_stats_changed(*stats)) { + if (stats && ComponentUtility::has_network_stats_changed(*net_comp, *stats)) { return true; } @@ -164,9 +165,9 @@ bool NetworkSyncSystem::has_entity_changed(const Entity& entity, uint32_t curren LOG_INFO("Frame %u: Entity %u state=%d, sync_check: moving=%s, pos_changed=%s, state_changed=%s, stats_changed=%s, force=%s", current_frame, entity.get_id(), (int)state->current_state, (state->current_state == EntityState::MOVING) ? "yes" : "no", - move && net_comp->has_position_changed(move->position) ? "yes" : "no", - state && net_comp->has_state_changed(state->current_state) ? "yes" : "no", - stats && net_comp->has_stats_changed(*stats) ? "yes" : "no", + move && ComponentUtility::has_network_position_changed(*net_comp, move->position) ? "yes" : "no", + state && ComponentUtility::has_network_state_changed(*net_comp, state->current_state) ? "yes" : "no", + stats && ComponentUtility::has_network_stats_changed(*net_comp, *stats) ? "yes" : "no", net_comp->force_full_sync_next_frame ? "yes" : "no"); logged_frames++; } @@ -202,7 +203,7 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent packets.push_back(SerializationSystem::serialize_entity_position(entity_id, move->position)); } else { // Delta sync - only if position changed - if (net_comp->has_position_changed(move->position)) { + if (ComponentUtility::has_network_position_changed(*net_comp, move->position)) { packets.push_back(SerializationSystem::serialize_entity_position(entity_id, move->position)); } } @@ -234,7 +235,7 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "max_mana", oss.str())); packets.push_back(SerializationSystem::serialize_entity_stat_change(entity_id, "level", std::to_string(stats->level))); - } else if (net_comp->has_stats_changed(*stats)) { + } else if (ComponentUtility::has_network_stats_changed(*net_comp, *stats)) { // Delta sync - only send packets for stats that changed auto stat_packets = create_stat_change_packets(entity_id, *stats, *net_comp->last_synced_stats); if (!stat_packets.empty()) { @@ -250,7 +251,7 @@ std::vector> NetworkSyncSystem::serialize_entity_update(Ent if (send_full_state || !net_comp) { // Full state sync - always send state packets.push_back(SerializationSystem::serialize_entity_state(entity_id, static_cast(state->current_state))); - } else if (net_comp->has_state_changed(state->current_state)) { + } else if (ComponentUtility::has_network_state_changed(*net_comp, state->current_state)) { // Delta sync - only send state if it changed packets.push_back(SerializationSystem::serialize_entity_state(entity_id, static_cast(state->current_state))); } diff --git a/src/systems/core/npc_system.cpp b/src/systems/core/npc_system.cpp deleted file mode 100644 index 85b2352..0000000 --- a/src/systems/core/npc_system.cpp +++ /dev/null @@ -1,49 +0,0 @@ -#include - -#include -#include -#include -#include - -void NPCSystem::update(const SystemContext& ctx) { - for(auto npc_entity : ctx.entity_manager.get_entities_with_component()) { - // Update state cooldown timers for all NPCs - NPCComponent* npc_comp = npc_entity->get_component(); - if (npc_comp) { - npc_comp->update_state_cooldown(ctx.delta_time_ms); - } - update_entity(ctx, npc_entity); - } -} - -void NPCSystem::update_entity(const SystemContext& /*ctx*/, Entity* npc_entity) { - Movement* npc_movement = npc_entity->get_component(); - Stats* npc_stats = npc_entity->get_component(); - EntityStateComponent* npc_state = npc_entity->get_component(); - PathfindingComponent* npc_path = npc_entity->get_component(); - NPCComponent* npc_comp = npc_entity->get_component(); - - if(!npc_movement || !npc_stats || !npc_state || !npc_path || !npc_comp) { - LOG_WARN("NPCSystem attempted to update entity %d but it's missing (a) relevant component(s)", npc_entity->get_id()); - return; - } - - if(npc_comp->npc_type == NPCType::MINION) { - // Stop attacking if the minion is too far away from its path - // This enforces map-boundary behavior - minions don't chase forever - if(npc_state->current_state == EntityState::ATTACKING && npc_path->waypoints.size() > 0) { - Vec2 current_waypoint = npc_path->waypoints[npc_path->current_waypoint_index]; - - if((current_waypoint - npc_movement->position).length() > npc_comp->chase_distance) { - // Only change state if cooldown allows it - if (npc_comp->can_change_state()) { - npc_state->current_state = EntityState::MOVING; - npc_state->target_entity_id = INVALID_ENTITY_ID; - npc_state->state_duration_ms = 0.0f; - npc_comp->on_state_changed(); - LOG_DEBUG("Entity %d returning to MOVING (too far from waypoint)", npc_entity->get_id()); - } - } - } - } -} \ No newline at end of file diff --git a/src/systems/core/npc_system.hpp b/src/systems/core/npc_system.hpp deleted file mode 100644 index e34464b..0000000 --- a/src/systems/core/npc_system.hpp +++ /dev/null @@ -1,57 +0,0 @@ -#pragma once - -#include "system_context.hpp" -/** - * NPC System - Handles entities that need to act on the map - * but do not have a player controlling them. - * - * RESPONSIBILITIES: - * - Make NPC entities do things - * - * FEATURES: - * - Checks what the entity is thinking - * - Checks what the entity is doing - * - If the entitiy isn't doing what the system thinks it - * should be doing, makes the entity do that thing - * - * USAGE: - * NPCSystem npc_system; - * // In game loop: - * npc_system.update(ctx); - * - * SYSTEM INTERACTION: - * - Runs before all other systems (except input) because this is kind of - * like "npc input" - * - Can be used independently or as part of GameplayCoordinator - */ -class NPCSystem { -public: - NPCSystem() = default; - ~NPCSystem() = default; - - // Prevent copying - NPCSystem(const NPCSystem&) = delete; - NPCSystem& operator=(const NPCSystem&) = delete; - - // Allow moving - NPCSystem(NPCSystem&&) = default; - NPCSystem& operator=(NPCSystem&&) = default; - - /** - * Update npc entity actions. - * - * @param ctx System context with entity manager and network service - */ - void update(const SystemContext& ctx); - -private: - /** - * Update a single entity. - * This allows us to return at any point the entity is done thinking, - * which we could not do inside a loop in the main update function. - * - * @param System System context with entity manager and network service - * @param npc_entity The entity that is currently thinking - */ - void update_entity(const SystemContext& ctx, Entity* npc_entity); -}; \ No newline at end of file diff --git a/src/systems/core/spawning_system.cpp b/src/systems/core/spawning_system.cpp index e89c64b..aa4c574 100644 --- a/src/systems/core/spawning_system.cpp +++ b/src/systems/core/spawning_system.cpp @@ -1,16 +1,22 @@ #include +#include #include #include #include #include -#include -#include +#include #include EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, const std::string& template_id, const Vec2& position, uint8_t team_id) { + // Get collision radius from template to find free space + float collision_radius = ctx.entity_manager.get_template_collision_radius(template_id); + + // Find collision-free spawn position + Vec2 spawn_position = CollisionSystem::find_free_space(position, collision_radius, const_cast(ctx.entity_manager)); + // Create entity from template Entity& entity = ctx.entity_manager.create_entity_from_template(template_id); EntityID entity_id = entity.get_id(); @@ -20,10 +26,10 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, return INVALID_ENTITY_ID; } - // Set position + // Set position (collision-checked position) auto* move = entity.get_component(); if (move) { - move->position = position; + move->position = spawn_position; } // Set team ID @@ -34,6 +40,15 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, entity_id, stats->health, stats->max_health, team_id); } + // Adjust intent objective target based on team + // Team 1 moves toward spawnpoint 1, Team 2 moves toward spawnpoint 0 (opposite direction) + auto* intent = entity.get_component(); + if (intent && intent->type == IntentType::MOVE_TO_OBJECTIVE) { + intent->target_spawnpoint_id = (team_id == 1) ? 1 : 0; + LOG_DEBUG("Entity %u (team %u): Set objective target to spawnpoint %u", + entity_id, team_id, intent->target_spawnpoint_id); + } + // Add network entity component for syncing if (!entity.has_component()) { auto net_comp = std::make_unique(); @@ -48,28 +63,12 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, entity.add_component(std::move(entity_state)); } - // Broadcast spawn to clients - NOTE: NetworkSyncSystem will handle first sync - // The entity position will be sent in the same frame via NetworkSyncSystem - broadcast_entity_spawn(ctx, entity_id, position, team_id, template_id); - LOG_INFO("Spawned entity (ID %u) from template '%s' at (%.1f, %.1f), team %u", - entity_id, template_id.c_str(), position.x, position.y, team_id); + entity_id, template_id.c_str(), spawn_position.x, spawn_position.y, team_id); + + // NetworkSyncSystem will broadcast spawn to clients on first sync (when last_sync_frame == 0) + // This centralizes all network communication through the SyncManager return entity_id; } -void SpawningSystem::broadcast_entity_spawn(const SystemContext& ctx, - EntityID entity_id, - const Vec2& position, - uint8_t team_id, - const std::string& template_id) const { - if (!ctx.network_service) { - return; - } - - // Serialize and broadcast entity spawn packet - std::vector packet = SerializationSystem::serialize_entity_spawn(entity_id, position, team_id, template_id); - if (!packet.empty()) { - ctx.network_service->broadcast_packet(packet); - } -} diff --git a/src/systems/core/spawning_system.hpp b/src/systems/core/spawning_system.hpp index b48724a..54d5ab0 100644 --- a/src/systems/core/spawning_system.hpp +++ b/src/systems/core/spawning_system.hpp @@ -10,19 +10,29 @@ * RESPONSIBILITIES: * - Spawn entities from templates * - Initialize entity components + * - Find collision-free spawn positions * - Link spawned entities to their controllers (players, waves, etc.) - * - Broadcast spawn events to clients * * COMPONENTS USED: * - Movement (position tracking) - * - NetworkEntityComponent (for broadcasting to clients) + * - NetworkEntityComponent (for network synchronization) * - PlayerOwnedComponent (for linking champions to players) * - Stats (for entity attributes) * * SYSTEM INTERACTION: * - Called by WaveSystem, other spawning sources - * - Works with NetworkService to broadcast spawns + * - Works with CollisionSystem to find free space * - Integrates with EntityManager for entity creation + * - NetworkSyncSystem handles broadcasting spawned entities to clients + * + * NETWORK COMMUNICATION: + * SpawningSystem does NOT directly broadcast to clients. Instead: + * 1. SpawningSystem creates entity and adds NetworkEntityComponent + * 2. Sets force_full_sync_next_frame = true on NetworkEntityComponent + * 3. NetworkSyncSystem detects new entity (last_sync_frame == 0) + * 4. NetworkSyncSystem broadcasts spawn packet to all clients + * + * This centralizes all client communication through NetworkSyncSystem. * * USAGE: * SpawningSystem spawning_system; @@ -34,6 +44,10 @@ class SpawningSystem { public: /** * Spawn an entity from a template at a specific position. + * Automatically finds a collision-free position if the requested position is occupied. + * The spawned entity will be automatically synchronized to clients by NetworkSyncSystem + * on the next frame. + * * @param ctx System context with entity manager and network service * @param template_id Template name (e.g., "melee_minion", "champion") * @param position Starting position for the entity @@ -44,18 +58,4 @@ class SpawningSystem { const std::string& template_id, const Vec2& position, uint8_t team_id); - - /** - * Broadcast entity spawn to all connected clients. - * @param ctx System context with network service - * @param entity_id ID of entity that was spawned - * @param position Spawn position - * @param team_id Team of the entity - * @param template_id Template used for spawning - */ - void broadcast_entity_spawn(const SystemContext& ctx, - EntityID entity_id, - const Vec2& position, - uint8_t team_id, - const std::string& template_id) const; }; diff --git a/src/systems/core/targeting_system.cpp b/src/systems/core/targeting_system.cpp deleted file mode 100644 index c38cff8..0000000 --- a/src/systems/core/targeting_system.cpp +++ /dev/null @@ -1,331 +0,0 @@ -#include -#include -#include -#include -#include - -std::vector TargetingSystem::update( - EntityManager& entity_manager, - float delta_time) -{ - std::vector events; - - // Get all entities in the manager - const auto& all_entities = entity_manager.get_all_entities(); - - // Process each entity that has AutoAttack component - for (const auto& entity_pair : all_entities) { - Entity* entity = entity_pair.second.get(); - if (!entity || !entity->has_component()) { - continue; - } - - // Process auto-attack for this entity - auto entity_events = process_auto_attack(entity_manager, entity->get_id(), delta_time); - events.insert(events.end(), entity_events.begin(), entity_events.end()); - } - - return events; -} - -std::vector TargetingSystem::get_targets_in_range( - EntityManager& entity_manager, - EntityID entity_id, - bool include_allies) const -{ - std::vector targets; - - Entity* observer = entity_manager.get_entity(entity_id); - if (!observer || !observer->has_component() || !observer->has_component()) { - return targets; - } - - Movement* observer_movement = observer->get_component(); - Stats* observer_stats = observer->get_component(); - - const auto& all_entities = entity_manager.get_all_entities(); - - for (const auto& entity_pair : all_entities) { - Entity* potential_target = entity_pair.second.get(); - - // Skip self - if (potential_target->get_id() == entity_id) { - continue; - } - - // Skip entities without movement or stats - if (!potential_target->has_component() || !potential_target->has_component()) { - continue; - } - - // Skip if not in vision range - Movement* target_movement = potential_target->get_component(); - if (!is_in_vision_range(observer_movement->position, target_movement->position, observer_stats->vision_range)) { - continue; - } - - // Skip if not eligible for combat - if (!can_engage_in_combat(entity_manager, entity_id, potential_target->get_id())) { - continue; - } - - targets.push_back(potential_target->get_id()); - } - - return targets; -} - -bool TargetingSystem::is_in_attack_range( - const Vec3& attacker_position, - const Vec3& target_position, - float attack_range) const -{ - float distance = calculate_distance(attacker_position, target_position); - return distance <= attack_range; -} - -bool TargetingSystem::is_in_vision_range( - const Vec3& observer_position, - const Vec3& target_position, - float vision_range) const -{ - float distance = calculate_distance(observer_position, target_position); - return distance <= vision_range; -} - -bool TargetingSystem::acquire_target( - EntityManager& entity_manager, - EntityID entity_id, - EntityID target_id) -{ - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity || !entity->has_component()) { - return false; - } - - // Validate target exists - Entity* target = entity_manager.get_entity(target_id); - if (!target) { - return false; - } - - // Validate can engage in combat - if (!can_engage_in_combat(entity_manager, entity_id, target_id)) { - return false; - } - - AutoAttack* auto_attack = entity->get_component(); - auto_attack->target_id = target_id; - auto_attack->is_attacking = true; - - LOG_INFO("Targeting: Entity (ID %u) acquired target (ID %u)", entity_id, target_id); - return true; -} - -bool TargetingSystem::release_target( - EntityManager& entity_manager, - EntityID entity_id) -{ - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity || !entity->has_component()) { - return false; - } - - AutoAttack* auto_attack = entity->get_component(); - if (auto_attack->target_id == INVALID_TARGET_ID) { - return false; - } - - EntityID old_target = auto_attack->target_id; - auto_attack->target_id = INVALID_TARGET_ID; - auto_attack->is_attacking = false; - - LOG_INFO("Targeting: Entity (ID %u) released target (ID %u)", entity_id, old_target); - return true; -} - -bool TargetingSystem::can_engage_in_combat( - EntityManager& entity_manager, - EntityID entity_id, - EntityID target_id) const -{ - Entity* entity = entity_manager.get_entity(entity_id); - Entity* target = entity_manager.get_entity(target_id); - - if (!entity || !target) { - return false; - } - - // Both must have Stats and Movement for combat - if (!entity->has_component() || !target->has_component()) { - return false; - } - - if (!entity->has_component() || !target->has_component()) { - return false; - } - - // Check if target is alive - Stats* target_stats = target->get_component(); - if (target_stats->health <= 0.0f) { - return false; - } - - // Check if attacker is alive - Stats* entity_stats = entity->get_component(); - if (entity_stats->health <= 0.0f) { - return false; - } - - // TODO: Add team/faction checks here when team system is implemented - // For now, all minions can attack each other - - return true; -} - -bool TargetingSystem::is_target_valid( - EntityManager& entity_manager, - EntityID entity_id, - EntityID target_id) const -{ - // Validate entity still exists - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity || !entity->has_component()) { - return false; - } - - // Check if we can still engage in combat - if (!can_engage_in_combat(entity_manager, entity_id, target_id)) { - return false; - } - - // Check if target is still in vision range - Entity* target = entity_manager.get_entity(target_id); - if (!target || !target->has_component()) { - return false; - } - - Movement* entity_movement = entity->get_component(); - Movement* target_movement = target->get_component(); - Stats* entity_stats = entity->get_component(); - - if (!is_in_vision_range(entity_movement->position, target_movement->position, entity_stats->vision_range)) { - return false; - } - - return true; -} - -EntityID TargetingSystem::get_closest_target( - EntityManager& entity_manager, - EntityID entity_id) const -{ - std::vector targets = get_targets_in_range(entity_manager, entity_id); - - if (targets.empty()) { - return INVALID_ENTITY_ID; - } - - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity || !entity->has_component()) { - return INVALID_ENTITY_ID; - } - - Movement* entity_movement = entity->get_component(); - - EntityID closest_id = targets[0]; - float closest_distance = std::numeric_limits::max(); - - for (EntityID target_id : targets) { - Entity* target = entity_manager.get_entity(target_id); - if (!target || !target->has_component()) { - continue; - } - - Movement* target_movement = target->get_component(); - float distance = calculate_distance(entity_movement->position, target_movement->position); - - if (distance < closest_distance) { - closest_distance = distance; - closest_id = target_id; - } - } - - return closest_id; -} - -float TargetingSystem::calculate_distance(const Vec3& pos1, const Vec3& pos2) const -{ - Vec3 delta = pos1 - pos2; - return std::sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z); -} - -std::vector TargetingSystem::process_auto_attack( - EntityManager& entity_manager, - EntityID entity_id, - float delta_time) -{ - std::vector events; - - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity) { - return events; - } - - AutoAttack* auto_attack = entity->get_component(); - if (!auto_attack || !auto_attack->auto_attack_enabled) { - return events; - } - - // Update attack cooldown - if (auto_attack->attack_cooldown > 0.0f) { - auto_attack->attack_cooldown -= delta_time; - } - - // Check current target validity - if (auto_attack->target_id != INVALID_TARGET_ID) { - if (!is_target_valid(entity_manager, entity_id, auto_attack->target_id)) { - // Target became invalid, release it - release_target(entity_manager, entity_id); - TargetingEvent event; - event.entity_id = entity_id; - event.target_id = INVALID_TARGET_ID; - event.acquired = false; - events.push_back(event); - } - } - - // If no valid target, try to find one - if (auto_attack->target_id == INVALID_TARGET_ID && auto_attack->auto_attack_enabled) { - EntityID new_target = find_new_target(entity_manager, entity_id); - if (new_target != INVALID_ENTITY_ID) { - acquire_target(entity_manager, entity_id, new_target); - TargetingEvent event; - event.entity_id = entity_id; - event.target_id = new_target; - event.acquired = true; - events.push_back(event); - } - } - - return events; -} - -EntityID TargetingSystem::find_new_target( - EntityManager& entity_manager, - EntityID entity_id) -{ - Entity* entity = entity_manager.get_entity(entity_id); - if (!entity) { - return INVALID_ENTITY_ID; - } - - // Get closest target within vision range - EntityID closest_target = get_closest_target(entity_manager, entity_id); - - if (closest_target != INVALID_ENTITY_ID) { - LOG_DEBUG("Targeting: Entity (ID %u) found new target (ID %u)", entity_id, closest_target); - } - - return closest_target; -} diff --git a/src/systems/core/targeting_system.hpp b/src/systems/core/targeting_system.hpp deleted file mode 100644 index 27b956f..0000000 --- a/src/systems/core/targeting_system.hpp +++ /dev/null @@ -1,190 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include -#include - -/** - * Targeting and Combat Detection System - * - * Responsible for: - * - Detecting potential targets within entity vision ranges - * - Validating target eligibility (team, state, distance) - * - Managing auto-attack target acquisition and retention - * - Triggering attacks when targets enter attack range - * - Coordinating with CombatSystem for actual damage application - */ -class TargetingSystem { -public: - /** - * Targeting event for when an entity acquires or loses a target - */ - struct TargetingEvent { - EntityID entity_id; // Entity that acquired/lost target - EntityID target_id; // The target entity (0 if lost target) - bool acquired; // true if acquired, false if lost - }; - - /** - * Combat detection event for when an entity enters attack range - */ - struct CombatDetectionEvent { - EntityID attacker_id; // Entity initiating combat - EntityID target_id; // Target entity - float distance; // Current distance to target - float attack_range; // Attack range of attacker - }; - - TargetingSystem() = default; - virtual ~TargetingSystem() = default; - - /** - * Update targeting system - detect targets and manage auto-attacks - * Should be called once per frame/tick from the main game loop - * @param entity_manager Reference to the entity manager - * @param delta_time Time elapsed since last update (in seconds) - * @return Vector of targeting events that occurred during this update - */ - std::vector update( - EntityManager& entity_manager, - float delta_time - ); - - /** - * Get all targets within an entity's vision range - * @param entity_manager Reference to the entity manager - * @param entity_id ID of the entity searching for targets - * @param include_allies Whether to include allies in results (default: false) - * @return Vector of entity IDs within vision range - */ - std::vector get_targets_in_range( - EntityManager& entity_manager, - EntityID entity_id, - bool include_allies = false - ) const; - - /** - * Check if a target is within attack range of an attacker - * @param attacker_position Position of the attacking entity - * @param target_position Position of the target entity - * @param attack_range Attack range in world units - * @return true if target is within attack range - */ - bool is_in_attack_range( - const Vec3& attacker_position, - const Vec3& target_position, - float attack_range - ) const; - - /** - * Check if a target is within vision range of an observer - * @param observer_position Position of the observing entity - * @param target_position Position of the target entity - * @param vision_range Vision range in world units - * @return true if target is within vision range - */ - bool is_in_vision_range( - const Vec3& observer_position, - const Vec3& target_position, - float vision_range - ) const; - - /** - * Acquire a target for an entity - * @param entity_manager Reference to the entity manager - * @param entity_id ID of the entity acquiring the target - * @param target_id ID of the target to acquire - * @return true if target was acquired successfully - */ - bool acquire_target( - EntityManager& entity_manager, - EntityID entity_id, - EntityID target_id - ); - - /** - * Release the current target of an entity - * @param entity_manager Reference to the entity manager - * @param entity_id ID of the entity releasing its target - * @return true if target was released (entity had a target) - */ - bool release_target( - EntityManager& entity_manager, - EntityID entity_id - ); - - /** - * Check if two entities are on opposing teams/can attack each other - * For now, this checks if both have Movement components (minions can attack each other) - * @param entity_manager Reference to the entity manager - * @param entity_id Entity to check - * @param target_id Potential target to check - * @return true if entities can engage in combat - */ - bool can_engage_in_combat( - EntityManager& entity_manager, - EntityID entity_id, - EntityID target_id - ) const; - - /** - * Check if a target is still valid (alive, in range, can engage) - * @param entity_manager Reference to the entity manager - * @param entity_id Entity that has the target - * @param target_id Current target ID to validate - * @return true if target is still valid - */ - bool is_target_valid( - EntityManager& entity_manager, - EntityID entity_id, - EntityID target_id - ) const; - - /** - * Get the closest enemy target within vision range - * @param entity_manager Reference to the entity manager - * @param entity_id ID of the entity searching for targets - * @return ID of closest enemy, or INVALID_ENTITY_ID if none found - */ - EntityID get_closest_target( - EntityManager& entity_manager, - EntityID entity_id - ) const; - -private: - /** - * Calculate distance between two entities - * @param pos1 First position - * @param pos2 Second position - * @return Distance between positions - */ - float calculate_distance(const Vec3& pos1, const Vec3& pos2) const; - - /** - * Process auto-attack logic for an entity - * @param entity_manager Reference to the entity manager - * @param entity_id ID of the entity to process - * @param delta_time Time elapsed since last update - * @return TargetingEvent if a targeting change occurred, nullptr otherwise - */ - std::vector process_auto_attack( - EntityManager& entity_manager, - EntityID entity_id, - float delta_time - ); - - /** - * Attempt to find a new target for an entity - * @param entity_manager Reference to the entity manager - * @param entity_id ID of the entity searching for a target - * @return ID of new target, or INVALID_ENTITY_ID if none found - */ - EntityID find_new_target( - EntityManager& entity_manager, - EntityID entity_id - ); -}; diff --git a/src/systems/core/wave_system.cpp b/src/systems/core/wave_system.cpp index 5538566..fe2247c 100644 --- a/src/systems/core/wave_system.cpp +++ b/src/systems/core/wave_system.cpp @@ -87,163 +87,16 @@ bool WaveSystem::create_minion(const SystemContext& ctx, const std::string& mini return false; } - // Find spawn position + // Get spawn position from map Vec2 spawn_pos = map_->spawnpoints[spawn_point_id]; - // Get collision radius from template without creating an entity - float collision_radius = ctx.entity_manager.get_template_collision_radius(minion_template); - - // Find free spawn position - spawn_pos = find_free_spawn_position(spawn_point_id, collision_radius); - // Spawn entity using SpawningSystem + // (SpawningSystem will handle collision checking and finding free space) EntityID minion_id = spawning_system_.spawn_entity_from_template(ctx, minion_template, spawn_pos, team_id); if (minion_id == INVALID_ENTITY_ID) { LOG_ERROR("Failed to spawn minion of type %s", minion_template.c_str()); return false; } - - Entity* minion = ctx.entity_manager.get_entity(minion_id); - if (!minion) { - return false; - } - - // Add pathfinding component if not already present - if (!minion->has_component()) { - auto pathfinding = std::make_unique(); - minion->add_component(std::move(pathfinding)); - } - - // Add entity state component if not already present - if (!minion->has_component()) { - auto entity_state = std::make_unique(); - entity_state->current_state = EntityState::SPAWNED; - minion->add_component(std::move(entity_state)); - } - - // Request initial path to next spawnpoint - uint32_t target_spawnpoint = (spawn_point_id + 1) % map_->spawnpoints.size(); - request_minion_path(*minion, target_spawnpoint); - return true; } -void WaveSystem::request_minion_path(Entity& entity, uint32_t target_spawnpoint_id) { - if (!navigation_service_ || !map_ || target_spawnpoint_id >= map_->spawnpoints.size()) { - LOG_WARN("Cannot request path: navigation_service=%p, map=%p, spawnpoint_id=%u", navigation_service_, map_, target_spawnpoint_id); - return; - } - - Movement* move = entity.get_component(); - PathfindingComponent* pathfinding = entity.get_component(); - - if (!move || !pathfinding) { - LOG_WARN("Minion %u missing Movement or PathfindingComponent", entity.get_id()); - return; - } - - Vec3 start = Vec3(move->position.x, 0.0f, move->position.y); - Vec2 goal_2d = map_->spawnpoints[target_spawnpoint_id]; - Vec3 goal = Vec3(goal_2d.x, 0.0f, goal_2d.y); - - LOG_DEBUG("Minion %u requesting path from (%.1f, %.1f) to spawnpoint %u (%.1f, %.1f)", - entity.get_id(), start.x, start.z, target_spawnpoint_id, goal.x, goal.z); - - PathRequest request; - request.entity_id = entity.get_id(); - request.current_position = start; - request.destination = goal; - request.entity_pathing_radius = 0.5f; - - EntityStateComponent* entity_state = entity.get_component(); - - if (navigation_service_->MakeRequest(request)) { - pathfinding->target_spawnpoint_id = target_spawnpoint_id; - // Transition to waiting state - if (entity_state) { - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - LOG_DEBUG("Path request queued for minion %u", entity.get_id()); - } else { - // Mark as waiting for path so we retry next tick - pathfinding->target_spawnpoint_id = target_spawnpoint_id; - if (entity_state) { - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - LOG_DEBUG("Pathfinding queue full, will retry for minion %u", entity.get_id()); - } -} - -Vec2 WaveSystem::find_free_spawn_position(uint32_t spawn_point_id, float collision_radius) { - if (!map_ || spawn_point_id >= map_->spawnpoints.size()) { - // Fallback to default spawnpoint if invalid - return Vec2(0.0f, 0.0f); - } - - Vec2 base_position = map_->spawnpoints[spawn_point_id]; - - // Get all entities with movement components to check for collisions - auto moving_entities = entity_manager_->get_entities_with_component(); - - // Check if base position is free - bool position_free = true; - for (auto* entity : moving_entities) { - const Movement* other_move = entity->get_component(); - if (other_move) { - float dx = base_position.x - other_move->position.x; - float dy = base_position.y - other_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - float min_distance = collision_radius + other_move->collision_radius; - - if (distance < min_distance) { - position_free = false; - break; - } - } - } - - if (position_free) { - return base_position; - } - - // If base position is occupied, try to find a free spot nearby - // Use expanding circles to search for free space - constexpr float SPAWN_SEARCH_RADIUS = 5.0f; - constexpr int SEARCH_SAMPLES = 16; // Number of angles to check - - for (float search_distance = collision_radius * 2.0f; search_distance <= SPAWN_SEARCH_RADIUS; search_distance += 0.5f) { - for (int i = 0; i < SEARCH_SAMPLES; ++i) { - float angle = (2.0f * 3.14159265f * i) / SEARCH_SAMPLES; - Vec2 candidate = base_position + Vec2(std::cos(angle) * search_distance, std::sin(angle) * search_distance); - - // Check if this candidate position is free - bool candidate_free = true; - for (auto* entity : moving_entities) { - const Movement* other_move = entity->get_component(); - if (other_move) { - float dx = candidate.x - other_move->position.x; - float dy = candidate.y - other_move->position.y; - float distance = std::sqrt(dx * dx + dy * dy); - float min_distance = collision_radius + other_move->collision_radius; - - if (distance < min_distance) { - candidate_free = false; - break; - } - } - } - - if (candidate_free) { - return candidate; - } - } - } - - // If no free space found after search, return base position anyway - // (let collision detection handle it later? push everyone back?(not-implemented(tm))) -- cmkrist 16/11/2025 - LOG_WARN("Could not find free spawn position for spawnpoint %u, using base position", spawn_point_id); - return base_position; -} - diff --git a/src/systems/core/wave_system.hpp b/src/systems/core/wave_system.hpp index 478ef02..4ad48da 100644 --- a/src/systems/core/wave_system.hpp +++ b/src/systems/core/wave_system.hpp @@ -79,20 +79,4 @@ class WaveSystem { * @return true if minion spawned successfully */ bool create_minion(const SystemContext& ctx, const std::string& minion_template, uint8_t team_id, uint32_t spawn_point_id); - - /** - * Request a path for a minion to its target spawnpoint. - * @param entity Entity with Movement and PathfindingComponent - * @param target_spawnpoint_id Target spawnpoint ID - */ - void request_minion_path(Entity& entity, uint32_t target_spawnpoint_id); - - /** - * Find a free spawn position near the given spawnpoint. - * Checks if there are other entities at the spawnpoint and offsets position if needed. - * @param spawn_point_id The spawnpoint index - * @param collision_radius The radius to check for collisions - * @return A free position near the spawnpoint - */ - Vec2 find_free_spawn_position(uint32_t spawn_point_id, float collision_radius); -}; +}; \ No newline at end of file diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index c35506e..6bda5cc 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -6,9 +6,6 @@ GameplayCoordinator::GameplayCoordinator() : wave_system_(nullptr) { // Systems initialized with default constructors // WaveSystem will be initialized via initialize_wave_system() before use - - // Link systems that depend on each other - attack_execution_system_.set_combat_system(&combat_system_); } void GameplayCoordinator::initialize_wave_system(EntityManager* entity_manager, NetworkService* network_service, @@ -20,9 +17,9 @@ void GameplayCoordinator::initialize_wave_system(EntityManager* entity_manager, void GameplayCoordinator::update(const SystemContext& ctx) { // Execute systems in dependency order - // INPUT SYSTEMS + // INPUT & AI SYSTEMS input_system_.update(ctx); - npc_system_.update(ctx); + brain_system_.update(ctx); // Process NPC intents // ENGINE SYSTEMS wave_system_->update(ctx); @@ -31,10 +28,8 @@ void GameplayCoordinator::update(const SystemContext& ctx) { movement_system_.update(ctx); collision_system_.update(ctx); - // COMBAT SYSTEMS - auto_attack_system_.update(ctx); // Must run before CombatSystem and AttackExecutionSystem - attack_execution_system_.update(ctx); // Must run after CombatSystem - // PLAYER SYSTEMS + // COMBAT SYSTEMS (unified) + combat_system_.update(ctx); // Synchronize to clients network_sync_system_.update(ctx); diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index ba309e5..750e227 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -3,17 +3,19 @@ #include "system_context.hpp" /* === Core Systems === */ -// Input +// Input & AI #include -#include +#include + +// Spawning +#include // Physics & Movement #include #include // Combat -#include -#include +#include // Networking #include @@ -33,13 +35,12 @@ * - Manage game state transitions (use GameServer) * * SYSTEM UPDATE ORDER (important for correctness): - * 1. WaveSystem - Spawns new entities for this frame - * 2. MovementSystem - Updates entity positions based on paths - * 3. CollisionSystem - Resolves overlaps and pushes entities apart - * 4. AutoAttackSystem - Executes auto-attacks and manages cooldowns - * 5. CombatSystem - Applies damage (data-driven by AutoAttackSystem) - * 6. AttackExecutionSystem - Executes pending attacks with animation timing - * 7. NetworkSyncSystem - Sends state updates to clients + * 1. WaveSystem - Creates entities in ECS + * 2. BrainSystem - NPC decision-making and intent management + * 3. MovementSystem - Updates entity positions based on paths + * 4. CollisionSystem - Resolves overlaps and pushes entities apart + * 5. CombatSystem - Handles all combat (auto-attacks, cooldowns, target search, attack execution) + * 6. NetworkSyncSystem - BROADCASTS ALL STATE CHANGES TO CLIENTS (spawns, updates, deaths) * * USAGE: * GameplayCoordinator gameplay; @@ -76,13 +77,12 @@ class GameplayCoordinator { * * Order: * 1. WaveSystem::update() - Spawn new minions - * 2. MovementSystem::update() - Move entities - * 3. CollisionSystem::update() - Resolve collisions - * 4. AutoAttackSystem::update() - Manage auto-attacks and cooldowns - * 5. CombatSystem::update() - Apply damage (data-driven) - * 6. AttackExecutionSystem::update() - Execute pending attacks - * 7. NetworkSyncSystem::update() - Broadcast state - * 8. cleanup_dead_entities() - Remove entities marked for deletion + * 2. BrainSystem::update() - Process NPC intents + * 3. MovementSystem::update() - Move entities + * 4. CollisionSystem::update() - Resolve collisions + * 5. CombatSystem::update() - Manage all combat + * 6. NetworkSyncSystem::update() - Broadcast state + * 7. cleanup_dead_entities() - Remove entities marked for deletion * * @param ctx System context containing entity manager and services */ @@ -103,6 +103,12 @@ class GameplayCoordinator { */ void mark_for_cleanup(EntityID entity_id); + /** + * Get reference to brain system. + * @return Reference to BrainSystem + */ + BrainSystem& get_brain_system() { return brain_system_; } + /** * Get reference to input system. * @return Reference to InputSystem @@ -133,33 +139,20 @@ class GameplayCoordinator { */ NetworkSyncSystem& get_network_sync_system() { return network_sync_system_; } - /** - * Get reference to auto-attack system. - * @return Reference to AutoAttackSystem - */ - AutoAttackSystem& get_auto_attack_system() { return auto_attack_system_; } - - /** - * Get reference to attack execution system. - * @return Reference to AttackExecutionSystem - */ - AttackExecutionSystem& get_attack_execution_system() { return attack_execution_system_; } - /** * Get reference to combat system. * @return Reference to CombatSystem */ + CombatSystem& get_combat_system() { return combat_system_; } private: InputSystem input_system_; std::unique_ptr wave_system_; + BrainSystem brain_system_; CollisionSystem collision_system_; MovementSystem movement_system_; - AutoAttackSystem auto_attack_system_; NetworkSyncSystem network_sync_system_; CombatSystem combat_system_; - AttackExecutionSystem attack_execution_system_; - NPCSystem npc_system_; // Entity cleanup tracking std::vector entities_marked_for_cleanup_; // Entities to remove next frame diff --git a/src/systems/util/combat_system.cpp b/src/systems/util/combat_calculator.cpp similarity index 95% rename from src/systems/util/combat_system.cpp rename to src/systems/util/combat_calculator.cpp index c4b1d84..ec6f923 100644 --- a/src/systems/util/combat_system.cpp +++ b/src/systems/util/combat_calculator.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -6,7 +6,7 @@ #include #include -std::vector CombatSystem::apply_damage( +std::vector CombatCalculator::apply_damage( EntityManager& entity_manager, EntityID attacker_id, EntityID target_id, @@ -136,7 +136,7 @@ std::vector CombatSystem::apply_damage( return events; } -bool CombatSystem::apply_heal( +bool CombatCalculator::apply_heal( EntityManager& entity_manager, EntityID target_id, float heal_amount) @@ -157,7 +157,7 @@ bool CombatSystem::apply_heal( return true; } -bool CombatSystem::restore_mana( +bool CombatCalculator::restore_mana( EntityManager& entity_manager, EntityID target_id, float mana_amount) @@ -178,7 +178,7 @@ bool CombatSystem::restore_mana( return true; } -float CombatSystem::calculate_damage_reduction(float base_damage, int resistance) const +float CombatCalculator::calculate_damage_reduction(float base_damage, int resistance) const { // Damage reduction formula: damage * (100 / (100 + resistance)) // This ensures that 100 resistance reduces damage by 50%, 200 resistance by 66%, etc. @@ -189,7 +189,7 @@ float CombatSystem::calculate_damage_reduction(float base_damage, int resistance return base_damage * (100.0f / (100.0f + resistance)); } -float CombatSystem::calculate_critical_hit(const Stats& attacker) +float CombatCalculator::calculate_critical_hit(const Stats& attacker) { // Random number between 0 and 99 int roll = std::rand() % 100; diff --git a/src/systems/util/combat_system.hpp b/src/systems/util/combat_calculator.hpp similarity index 93% rename from src/systems/util/combat_system.hpp rename to src/systems/util/combat_calculator.hpp index c6f7a62..50d95dc 100644 --- a/src/systems/util/combat_system.hpp +++ b/src/systems/util/combat_calculator.hpp @@ -6,7 +6,7 @@ #include /** - * CombatSystem - Handles damage calculation and application + * CombatCalculator - Handles damage calculation and application * * RESPONSIBILITIES: * - Damage calculation and application @@ -19,7 +19,7 @@ * This system is purely data-driven. It only applies damage, healing, and * mana restoration based on external input (from skills, auto-attacks, etc). * Auto-attack behavior, cooldown management, and target selection are handled - * by the AutoAttackSystem. + * by the CombatSystem. * * COMPONENTS USED: * - Stats (base damage, armor, resist, health) @@ -28,15 +28,15 @@ * * SYSTEM INTERACTION: * - Works with NetworkSyncSystem to broadcast combat effects - * - AutoAttackSystem calls apply_damage to execute attacks + * - CombatSystem calls apply_damage to execute attacks * - Triggered by other systems for damage/healing events * - Coordinates with GameplayCoordinator for execution order */ -class CombatSystem { +class CombatCalculator { public: /** * Update all combat for this frame. - * The combat system is data-driven - actual combat is triggered externally. + * The combat calculator is data-driven - actual combat is triggered externally. * @param ctx System context with entity manager, services, and delta time */ diff --git a/src/systems/util/component_utility.hpp b/src/systems/util/component_utility.hpp new file mode 100644 index 0000000..1e5d4da --- /dev/null +++ b/src/systems/util/component_utility.hpp @@ -0,0 +1,192 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * ComponentUtility - Pure utility functions for component logic. + * + * ECS PRINCIPLE: Components are pure data containers. + * Systems query and modify components, but the logic belongs in systems/utilities. + * + * This utility provides helper functions to replace methods that were + * previously on components, following ECS principles strictly. + */ +class ComponentUtility { +public: + // ======================================================================== + // NetworkMetadataComponent Utilities + // ======================================================================== + + /** + * Check if player connection is stale (no activity for timeout_ms). + * @param metadata NetworkMetadataComponent to check + * @param timeout_ms Timeout in milliseconds (default: 30 seconds) + * @return true if last activity exceeds timeout + */ + static bool is_metadata_stale(const NetworkMetadataComponent& metadata, + unsigned int timeout_ms = 30000) { + auto now = std::chrono::steady_clock::now(); + auto elapsed = std::chrono::duration_cast( + now - metadata.last_activity); + return elapsed.count() > (long long)timeout_ms; + } + + /** + * Update network metadata last activity timestamp to current time. + * Call this whenever the player sends a packet. + * @param metadata NetworkMetadataComponent to update + */ + static void update_metadata_activity(NetworkMetadataComponent& metadata) { + metadata.last_activity = std::chrono::steady_clock::now(); + } + + // ======================================================================== + // NetworkEntityComponent Utilities + // ======================================================================== + + /** + * Check if entity position has changed significantly since last sync. + * @param net_comp NetworkEntityComponent to check + * @param current_position Current entity position + * @return true if position change is significant + */ + static bool has_network_position_changed(const NetworkEntityComponent& net_comp, + const Vec2& current_position) { + float dx = current_position.x - net_comp.last_synced_position.x; + float dy = current_position.y - net_comp.last_synced_position.y; + float dist_sq = dx * dx + dy * dy; + return dist_sq >= (NetworkEntityComponent::MIN_POSITION_CHANGE * + NetworkEntityComponent::MIN_POSITION_CHANGE); + } + + /** + * Check if entity state has changed since last sync. + * @param net_comp NetworkEntityComponent to check + * @param current_state Current entity state + * @return true if state has changed + */ + static bool has_network_state_changed(const NetworkEntityComponent& net_comp, + EntityState current_state) { + return current_state != net_comp.last_synced_state; + } + + /** + * Check if any stats have changed since last sync. + * Directly compares current stats against cached version. + * @param net_comp NetworkEntityComponent to check + * @param current_stats Current stats component + * @return true if stats have changed + */ + static bool has_network_stats_changed(const NetworkEntityComponent& net_comp, + const Stats& current_stats) { + if (!net_comp.last_synced_stats) { + return true; // No cached stats, so it's a change + } + // Simple field-by-field comparison of critical fields + return current_stats.health != net_comp.last_synced_stats->health || + current_stats.max_health != net_comp.last_synced_stats->max_health || + current_stats.mana != net_comp.last_synced_stats->mana || + current_stats.max_mana != net_comp.last_synced_stats->max_mana || + current_stats.level != net_comp.last_synced_stats->level; + } + + /** + * Mark entity as synced with the given state (updates component data). + * @param net_comp NetworkEntityComponent to update + * @param position Current position + * @param state Current state + * @param stats Current stats (for change detection) + * @param current_frame Frame number + */ + static void mark_network_entity_synced(NetworkEntityComponent& net_comp, + const Vec2& position, + EntityState state, + const Stats* stats, + uint32_t current_frame) { + net_comp.last_synced_position = position; + net_comp.last_synced_state = state; + if (stats) { + net_comp.last_synced_stats = *stats; + } + net_comp.last_sync_frame = current_frame; + net_comp.force_full_sync_next_frame = false; + } + + // ======================================================================== + // TargetComponent Utilities + // ======================================================================== + + /** + * Set a specific target on the target component. + * @param target_comp TargetComponent to update + * @param target_id Entity ID to target + */ + static void set_target(TargetComponent& target_comp, EntityID target_id) { + target_comp.current_target = target_id; + target_comp.has_target = (target_id != INVALID_ENTITY_ID); + target_comp.last_target_search_ms = 0.0f; + } + + /** + * Clear current target from the target component. + * @param target_comp TargetComponent to update + */ + static void clear_target(TargetComponent& target_comp) { + target_comp.current_target = INVALID_ENTITY_ID; + target_comp.has_target = false; + target_comp.target_in_range = false; + target_comp.distance_to_target = 0.0f; + } + + /** + * Check if should search for new target. + * @param target_comp TargetComponent to check + * @param current_time_ms Current game time + * @return true if enough time has passed since last search + */ + static bool should_search_for_target(const TargetComponent& target_comp, + float current_time_ms) { + return (current_time_ms - target_comp.last_target_search_ms) >= + target_comp.target_search_interval_ms; + } + + /** + * Mark that target search was performed. + * @param target_comp TargetComponent to update + * @param current_time_ms Current game time + */ + static void mark_target_searched(TargetComponent& target_comp, float current_time_ms) { + target_comp.last_target_search_ms = current_time_ms; + } + + /** + * Check if current target is still valid. + * @param target_comp TargetComponent to check + * @return true if target exists and is in range + */ + static bool is_target_valid(const TargetComponent& target_comp) { + return target_comp.has_target && target_comp.current_target != INVALID_ENTITY_ID && + target_comp.distance_to_target <= target_comp.target_loss_range; + } + + /** + * Update distance to target (called by systems when calculating distance). + * @param target_comp TargetComponent to update + * @param distance Current distance in game units + * @param attack_range Attack range threshold + */ + static void update_target_distance(TargetComponent& target_comp, + float distance, + float attack_range) { + target_comp.distance_to_target = distance; + target_comp.target_in_range = (distance <= attack_range); + } +}; diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index 2be5b8c..41231ec 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -11,6 +11,7 @@ #include #include #include +#include /** * Convert string to DamageType enum. @@ -45,18 +46,18 @@ static NPCType string_to_npc_type(const std::string& str) { * @param str The string to convert (case-insensitive) * @return AIPersonality enum value, defaults to BALANCED if unrecognized */ -static AutoAttackComponent::AIPersonality string_to_ai_personality(const std::string& str) { +static NPCComponent::AIPersonality string_to_ai_personality(const std::string& str) { if (str == "passive") { - return AutoAttackComponent::AIPersonality::PASSIVE; + return NPCComponent::AIPersonality::PASSIVE; } else if (str == "defensive") { - return AutoAttackComponent::AIPersonality::DEFENSIVE; + return NPCComponent::AIPersonality::DEFENSIVE; } else if (str == "aggressive") { - return AutoAttackComponent::AIPersonality::AGGRESSIVE; + return NPCComponent::AIPersonality::AGGRESSIVE; } else if (str == "zealous") { - return AutoAttackComponent::AIPersonality::ZEALOUS; + return NPCComponent::AIPersonality::ZEALOUS; } // Default to BALANCED for unrecognized or empty strings - return AutoAttackComponent::AIPersonality::BALANCED; + return NPCComponent::AIPersonality::BALANCED; } /** @@ -76,6 +77,33 @@ static TargetComponent::TargetPriority string_to_target_priority(const std::stri return TargetComponent::TargetPriority::NEAREST; } +/** + * Convert string to IntentType enum. + * @param str The string to convert (case-insensitive) + * @return IntentType enum value, defaults to NONE if unrecognized + */ +static IntentType string_to_intent_type(const std::string& str) { + if (str == "move_to_objective") { + return IntentType::MOVE_TO_OBJECTIVE; + } else if (str == "move_to_position") { + return IntentType::MOVE_TO_POSITION; + } else if (str == "move_to_spawnpoint") { + return IntentType::MOVE_TO_SPAWNPOINT; + } else if (str == "attack_target") { + return IntentType::ATTACK_TARGET; + } else if (str == "defend_position") { + return IntentType::DEFEND_POSITION; + } else if (str == "chase_enemy") { + return IntentType::CHASE_ENEMY; + } else if (str == "retreat") { + return IntentType::RETREAT; + } else if (str == "patrol") { + return IntentType::PATROL; + } + // Default to NONE for unrecognized or empty strings + return IntentType::NONE; +} + /** * Convenience macro. Loads the attribute from the node if the node has it, and sets it in the component. * @param node A pugi::xml_node which (maybe) has the attribute @@ -163,6 +191,11 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { if(!npc_node.empty()) { std::shared_ptr npc = std::make_shared(); LOAD_ENUM_ATTRIBUTE(npc_node, npc, npc_type, string_to_npc_type) + LOAD_ATTRIBUTE(npc_node, npc, aggressive, bool) + LOAD_ATTRIBUTE(npc_node, npc, retaliate_only, bool) + LOAD_ATTRIBUTE(npc_node, npc, aggression_range, float) + LOAD_ATTRIBUTE(npc_node, npc, retreat_range, float) + LOAD_ENUM_ATTRIBUTE(npc_node, npc, personality, string_to_ai_personality) LOAD_ATTRIBUTE(npc_node, npc, chase_distance, float) temp.component_templates.push_back(npc); } @@ -171,11 +204,6 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { if(!auto_attack_node.empty()) { std::shared_ptr auto_attack = std::make_shared(); LOAD_ATTRIBUTE(auto_attack_node, auto_attack, enabled, bool) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, aggressive, bool) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, retaliate_only, bool) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, aggression_range, float) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, retreat_range, float) - LOAD_ENUM_ATTRIBUTE(auto_attack_node, auto_attack, personality, string_to_ai_personality) LOAD_ATTRIBUTE(auto_attack_node, auto_attack, combat_timeout_ms, float) LOAD_ATTRIBUTE(auto_attack_node, auto_attack, base_damage_multiplier, float) LOAD_ATTRIBUTE(auto_attack_node, auto_attack, bonus_damage, float) @@ -240,6 +268,45 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { temp.component_templates.push_back(stats); } + pugi::xml_node intent_node = rootNode.child("intent"); + if(!intent_node.empty()) { + std::shared_ptr intent = std::make_shared(); + // Parse the initial intent if one is defined + std::string intent_type_str = intent_node.attribute("type").as_string(""); + if (!intent_type_str.empty()) { + intent->type = string_to_intent_type(intent_type_str); + + // Load optional intent parameters + LOAD_ENUM_ATTRIBUTE(intent_node, intent, type, string_to_intent_type) + LOAD_ENUM_ATTRIBUTE(intent_node, intent, priority, [](const std::string& s) { + if (s == "lowest") return IntentPriority::LOWEST; + if (s == "low") return IntentPriority::LOW; + if (s == "high") return IntentPriority::HIGH; + if (s == "critical") return IntentPriority::CRITICAL; + return IntentPriority::NORMAL; + }) + LOAD_ATTRIBUTE(intent_node, intent, max_duration_ms, float) + LOAD_ATTRIBUTE(intent_node, intent, min_range, float) + LOAD_ATTRIBUTE(intent_node, intent, max_range, float) + LOAD_ATTRIBUTE(intent_node, intent, tolerance, float) + + // Load target_spawnpoint_id for MOVE_TO_OBJECTIVE and similar + pugi::xml_attribute target_sp = intent_node.attribute("target_spawnpoint_id"); + if(!target_sp.empty()) { + intent->target_spawnpoint_id = target_sp.as_uint(); + } + + // Load objective_index for lane progression + pugi::xml_attribute obj_idx = intent_node.attribute("objective_index"); + if(!obj_idx.empty()) { + intent->objective_index = obj_idx.as_uint(); + } + + LOG_DEBUG("Loaded Intent component: type=%d", static_cast(intent->type)); + } + temp.component_templates.push_back(intent); + } + LOG_INFO("Successfully loaded template entity \"%s\" from %s with %d components", temp.id.c_str(), file_name.c_str(), temp.component_templates.size()); return temp; } diff --git a/src/systems/util/packet_handler.cpp b/src/systems/util/packet_handler.cpp index c95ca1d..a03f178 100644 --- a/src/systems/util/packet_handler.cpp +++ b/src/systems/util/packet_handler.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -36,7 +37,7 @@ void PacketHandler::handle_packet(const std::string& client_id, const uint8_t* d if (player_entity) { auto* metadata = player_entity->get_component(); if (metadata) { - metadata->update_activity(); + ComponentUtility::update_metadata_activity(*metadata); } } } diff --git a/src/systems/util/player_manager.cpp b/src/systems/util/player_manager.cpp index a4ddb48..cb02441 100644 --- a/src/systems/util/player_manager.cpp +++ b/src/systems/util/player_manager.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -162,7 +163,7 @@ void PlayerManager::update_player_latency(const std::string& client_id, EntityMa auto* metadata = player_entity->get_component(); if (metadata) { metadata->latency_ms = latency_ms; - metadata->update_activity(); + ComponentUtility::update_metadata_activity(*metadata); } } diff --git a/src/systems/util/targeting_utility.cpp b/src/systems/util/targeting_utility.cpp new file mode 100644 index 0000000..6c01cbc --- /dev/null +++ b/src/systems/util/targeting_utility.cpp @@ -0,0 +1,307 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +std::vector TargetingUtility::get_targets_in_range( + EntityManager& entity_manager, + EntityID entity_id, + bool include_allies) +{ + std::vector targets; + + Entity* observer = entity_manager.get_entity(entity_id); + if (!observer || !observer->has_component() || !observer->has_component()) { + return targets; + } + + Movement* observer_movement = observer->get_component(); + Stats* observer_stats = observer->get_component(); + + const auto& all_entities = entity_manager.get_all_entities(); + + for (const auto& entity_pair : all_entities) { + Entity* potential_target = const_cast(&entity_pair.second); + + // Skip self + if (potential_target->get_id() == entity_id) { + continue; + } + + // Skip entities without movement or stats + if (!potential_target->has_component() || !potential_target->has_component()) { + continue; + } + + // Skip if not in vision range + Movement* target_movement = potential_target->get_component(); + if (!is_in_vision_range(observer_movement->position, target_movement->position, observer_stats->vision_range)) { + continue; + } + + // Skip if not eligible for combat + if (!can_engage_in_combat(entity_manager, entity_id, potential_target->get_id())) { + continue; + } + + targets.push_back(potential_target->get_id()); + } + + return targets; +} + +bool TargetingUtility::is_in_attack_range( + const Vec2& attacker_position, + const Vec2& target_position, + float attack_range) +{ + float distance = calculate_distance(attacker_position, target_position); + return distance <= attack_range; +} + +bool TargetingUtility::is_in_vision_range( + const Vec2& observer_position, + const Vec2& target_position, + float vision_range) +{ + float distance = calculate_distance(observer_position, target_position); + return distance <= vision_range; +} + +bool TargetingUtility::can_engage_in_combat( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id) +{ + Entity* entity = entity_manager.get_entity(entity_id); + Entity* target = entity_manager.get_entity(target_id); + + if (!entity || !target) { + return false; + } + + // Both must have Stats and Movement for combat + if (!entity->has_component() || !target->has_component()) { + return false; + } + + if (!entity->has_component() || !target->has_component()) { + return false; + } + + // Check if target is alive + Stats* target_stats = target->get_component(); + if (target_stats->health <= 0.0f) { + return false; + } + + // Check if attacker is alive + Stats* entity_stats = entity->get_component(); + if (entity_stats->health <= 0.0f) { + return false; + } + + // TODO: Add team/faction checks here when team system is implemented + // For now, all minions can attack each other (different team_id) + if (entity_stats->team_id == target_stats->team_id) { + return false; // Can't attack same team + } + + return true; +} + +bool TargetingUtility::is_target_valid( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id) +{ + // Validate entity still exists + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity) { + return false; + } + + // Check if we can still engage in combat + if (!can_engage_in_combat(entity_manager, entity_id, target_id)) { + return false; + } + + // Check if target is still in vision range + Entity* target = entity_manager.get_entity(target_id); + if (!target || !target->has_component()) { + return false; + } + + Movement* entity_movement = entity->get_component(); + Movement* target_movement = target->get_component(); + Stats* entity_stats = entity->get_component(); + + if (!is_in_vision_range(entity_movement->position, target_movement->position, entity_stats->vision_range)) { + return false; + } + + return true; +} + +EntityID TargetingUtility::get_closest_target( + EntityManager& entity_manager, + EntityID entity_id) +{ + std::vector targets = get_targets_in_range(entity_manager, entity_id); + + if (targets.empty()) { + return INVALID_ENTITY_ID; + } + + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity || !entity->has_component()) { + return INVALID_ENTITY_ID; + } + + Movement* entity_movement = entity->get_component(); + + EntityID closest_id = targets[0]; + float closest_distance = std::numeric_limits::max(); + + for (EntityID target_id : targets) { + Entity* target = entity_manager.get_entity(target_id); + if (!target || !target->has_component()) { + continue; + } + + Movement* target_movement = target->get_component(); + float distance = calculate_distance(entity_movement->position, target_movement->position); + + if (distance < closest_distance) { + closest_distance = distance; + closest_id = target_id; + } + } + + return closest_id; +} + +float TargetingUtility::calculate_distance(const Vec2& pos1, const Vec2& pos2) +{ + float dx = pos1.x - pos2.x; + float dy = pos1.y - pos2.y; + return std::sqrt(dx * dx + dy * dy); +} + +float TargetingUtility::calculate_distance(const Vec2& pos1, const EntityID& entity_id, EntityManager& entity_manager) +{ + Entity* entity = entity_manager.get_entity(entity_id); + if (!entity || !entity->has_component()) { + return std::numeric_limits::max(); + } + + Movement* entity_movement = entity->get_component(); + return calculate_distance(pos1, entity_movement->position); +} + +EntityID TargetingUtility::find_best_target( + EntityManager& entity_manager, + EntityID attacker_id, + float aggression_range, + TargetComponent::TargetPriority targeting_mode, + bool prioritize_closest) +{ + Entity* attacker = entity_manager.get_entity(attacker_id); + if (!attacker || !attacker->has_component() || !attacker->has_component()) { + return INVALID_ENTITY_ID; + } + + const auto* attacker_move = attacker->get_component(); + const auto* attacker_stats = attacker->get_component(); + + EntityID best_target = INVALID_ENTITY_ID; + float best_score = -1e9f; + + // Get all entities with Movement (potential targets) + auto all_entities = entity_manager.get_entities_with_component(); + + for (auto* potential_target : all_entities) { + if (!potential_target || potential_target->get_id() == attacker_id) { + continue; // Skip self + } + + // Check if valid target (alive, correct team, etc) + auto* target_stats = potential_target->get_component(); + if (!target_stats || target_stats->health <= 0.0f) { + continue; // Target must be alive + } + + // Can't target neutral observers (team_id == 255) + if (target_stats->team_id == 255) { + continue; + } + + // Team-based targeting validation + // Can't target same team + if (attacker_stats->team_id != 0 && target_stats->team_id == attacker_stats->team_id) { + continue; + } + + // Can't target neutrals as neutral + if (attacker_stats->team_id == 0 && target_stats->team_id == 0) { + continue; + } + + // Calculate distance + auto* target_move = potential_target->get_component(); + if (!target_move) continue; + + float distance = calculate_distance(attacker_move->position, target_move->position); + + // Skip if out of aggro range + if (distance > aggression_range) { + continue; + } + + // Calculate target score based on targeting mode + float score = 0.0f; + + switch (targeting_mode) { + case TargetComponent::TargetPriority::NEAREST: + score = -distance; // Negative distance = higher score for closer + break; + + case TargetComponent::TargetPriority::LOWEST_HEALTH: + score = -(target_stats->health); // Negative health = target low HP + break; + + case TargetComponent::TargetPriority::HIGHEST_THREAT: + score = target_stats->physical_power + target_stats->magic_power; + break; + + case TargetComponent::TargetPriority::HIGHEST_DAMAGE: + score = target_stats->physical_power; + break; + + case TargetComponent::TargetPriority::PRIORITY_TARGET: + // PRIORITY_TARGET handled elsewhere, default to nearest + score = -distance; + break; + + default: + score = -distance; + break; + } + + // Prefer closer targets as tiebreaker + if (prioritize_closest) { + score -= (distance * 0.1f); + } + + if (score > best_score) { + best_score = score; + best_target = potential_target->get_id(); + } + } + + return best_target; +} diff --git a/src/systems/util/targeting_utility.hpp b/src/systems/util/targeting_utility.hpp new file mode 100644 index 0000000..5c047ad --- /dev/null +++ b/src/systems/util/targeting_utility.hpp @@ -0,0 +1,159 @@ +#pragma once + +#include +#include +#include +#include +#include + +/** + * TargetingUtility - Data-driven targeting and vision utility functions + * + * Pure utility functions for targeting calculations and target validation. + * Used by CombatSystem and other systems that need targeting logic. + * + * RESPONSIBILITIES: + * - Range and distance calculations (vision, attack range) + * - Target eligibility validation (alive, can engage, in range) + * - Target discovery (find targets in range, get closest, etc.) + * - Team/faction checks for combat eligibility + * + * DATA-DRIVEN DESIGN: + * All behavior is configured through component properties: + * - AutoAttackComponent: personality, aggression_range, prioritization + * - Stats: vision_range, attack_range, health + * - TargetComponent: targeting_mode, current_target + * + * USAGE: + * // Find best target within vision range + * EntityID target = TargetingUtility::get_closest_target(entity_manager, entity_id); + * + * // Validate if target is still valid + * if (TargetingUtility::is_target_valid(entity_manager, attacker_id, target_id)) { + * // Can still attack target + * } + * + * NOTE: + * These are pure utility functions - they do NOT modify entity state. + * Only CombatSystem should call these functions in the main update loop. + */ +class TargetingUtility { +public: + /** + * Get all targets within an entity's vision range that can be engaged. + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity searching for targets + * @param include_allies Whether to include allies in results (default: false) + * @return Vector of entity IDs within vision range and eligible for combat + */ + static std::vector get_targets_in_range( + EntityManager& entity_manager, + EntityID entity_id, + bool include_allies = false + ); + + /** + * Check if a target is within attack range of an attacker (2D). + * @param attacker_position Position of the attacking entity + * @param target_position Position of the target entity + * @param attack_range Attack range in world units + * @return true if target is within attack range + */ + static bool is_in_attack_range( + const Vec2& attacker_position, + const Vec2& target_position, + float attack_range + ); + + /** + * Check if a target is within vision range of an observer (2D). + * @param observer_position Position of the observing entity + * @param target_position Position of the target entity + * @param vision_range Vision range in world units + * @return true if target is within vision range + */ + static bool is_in_vision_range( + const Vec2& observer_position, + const Vec2& target_position, + float vision_range + ); + + /** + * Check if two entities can engage in combat. + * Validates that both entities are alive and have required components. + * @param entity_manager Reference to the entity manager + * @param entity_id Entity that would be attacking + * @param target_id Entity that would be attacked + * @return true if entities can engage in combat + */ + static bool can_engage_in_combat( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id + ); + + /** + * Validate if a target is still valid for an attacker. + * Checks: alive, in vision range, can engage in combat. + * @param entity_manager Reference to the entity manager + * @param entity_id Entity that has the target + * @param target_id Current target ID to validate + * @return true if target is still valid and can be attacked + */ + static bool is_target_valid( + EntityManager& entity_manager, + EntityID entity_id, + EntityID target_id + ); + + /** + * Get the closest enemy target within vision range. + * @param entity_manager Reference to the entity manager + * @param entity_id ID of the entity searching for targets + * @return ID of closest valid target, or INVALID_ENTITY_ID if none found + */ + static EntityID get_closest_target( + EntityManager& entity_manager, + EntityID entity_id + ); + + /** + * Calculate distance between two positions (2D). + * @param pos1 First position + * @param pos2 Second position + * @return Distance between positions (Euclidean) + */ + static float calculate_distance(const Vec2& pos1, const Vec2& pos2); + + /** + * Calculate distance between two positions (2D). + * @param pos1 First position + * @param pos2 Second position + * @return Distance between positions (Euclidean) + */ + static float calculate_distance(const Vec2& pos1, const EntityID& entity_id, EntityManager& entity_manager); + + /** + * Find the best target for an entity based on targeting priority and auto-attack settings. + * Considers distance, health, threat level, and damage based on targeting mode. + * + * @param entity_manager Reference to the entity manager + * @param attacker_id ID of the entity looking for a target + * @param aggression_range Maximum distance to search for targets + * @param targeting_mode TargetComponent::TargetPriority mode for prioritization + * @param prioritize_closest If true, prefer closer targets as tiebreaker + * @return ID of best target, or INVALID_ENTITY_ID if none found + */ + static EntityID find_best_target( + EntityManager& entity_manager, + EntityID attacker_id, + float aggression_range, + TargetComponent::TargetPriority targeting_mode, + bool prioritize_closest = true + ); + +private: + // Private constructor - this is a utility class with only static methods + TargetingUtility() = delete; + ~TargetingUtility() = delete; +}; From e41ff197830bb24fb825440e5fa58eafdf339edd Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 25 Nov 2025 21:29:26 -0500 Subject: [PATCH 57/79] Update map navmesh to support rotation (godot core) --- src/systems/util/map_system.cpp | 214 +++++++++++++++++++++++++++++++- src/systems/util/map_system.hpp | 36 ++++++ 2 files changed, 247 insertions(+), 3 deletions(-) diff --git a/src/systems/util/map_system.cpp b/src/systems/util/map_system.cpp index 88f6bde..d77ed08 100644 --- a/src/systems/util/map_system.cpp +++ b/src/systems/util/map_system.cpp @@ -9,6 +9,9 @@ #include #include #include +#include +#include +#include std::optional MapSystem::load_map(const std::optional& file_path) { @@ -83,6 +86,20 @@ std::optional MapSystem::load_map(const std::optional& file_pa std::vector spawnpoints = parse_spawnpoints_from_tscn(file_content); LOG_INFO("Parsed %zu spawnpoints from map file", spawnpoints.size()); + // Extract spawnpoint positions for transformation + std::vector spawnpoint_positions; + for (const auto& sp : spawnpoints) { + spawnpoint_positions.push_back(sp.position); + } + + // Apply NavigationRegion3D transform to navmesh and spawnpoints + apply_navigation_region_transform(file_content, navmesh_data.vertices, spawnpoint_positions); + + // Update spawnpoints with transformed positions + for (size_t i = 0; i < spawnpoints.size() && i < spawnpoint_positions.size(); ++i) { + spawnpoints[i].position = spawnpoint_positions[i]; + } + // Add Map component Map map; size_t final_slash_index = actual_file_path.find_last_of("/\\"); @@ -96,9 +113,12 @@ std::optional MapSystem::load_map(const std::optional& file_pa map.spawnpoints.push_back(sp.position); LOG_INFO(" Spawnpoint: (%.1f, %.1f)", sp.position.x, sp.position.y); } - // Get 2d size and offset - map.size = MapSystem::calculate_size_from_vertices(navmesh_data.vertices); - map.offset = map.size / 2.0f; + + // Calculate map bounds and derived size/offset + MapBounds bounds = MapSystem::calculate_bounds_from_vertices(navmesh_data.vertices); + map.size = Vec2(bounds.max.x - bounds.min.x, bounds.max.y - bounds.min.y); + // Offset is the center point between min and max + map.offset = Vec2((bounds.min.x + bounds.max.x) / 2.0f, (bounds.min.y + bounds.max.y) / 2.0f); LOG_INFO("Loaded map '%s' with %zu vertices, %zu polygons, and %zu spawnpoints", map.name.c_str(), navmesh_data.vertices.size(), navmesh_data.polygons.size(), spawnpoints.size()); @@ -451,4 +471,192 @@ Vec2 MapSystem::calculate_size_from_vertices(const std::vector& vertices) } return Vec2(max_x - min_x, max_y - min_y); +} + +MapSystem::MapBounds MapSystem::calculate_bounds_from_vertices(const std::vector& vertices) { + MapBounds bounds; + + if (vertices.empty()) { + bounds.min = Vec2(0.0f, 0.0f); + bounds.max = Vec2(0.0f, 0.0f); + return bounds; + } + + bounds.min.x = vertices[0].x; + bounds.max.x = vertices[0].x; + bounds.min.y = vertices[0].y; + bounds.max.y = vertices[0].y; + + for (const auto& v : vertices) { + bounds.min.x = std::min(bounds.min.x, v.x); + bounds.max.x = std::max(bounds.max.x, v.x); + bounds.min.y = std::min(bounds.min.y, v.y); + bounds.max.y = std::max(bounds.max.y, v.y); + } + + return bounds; +} + +MapSystem::TransformData +MapSystem::parse_transform_3d(const std::string& transform_str) { + // Format: Transform3D(m00, m01, m02, m10, m11, m12, m20, m21, m22, x, y, z) + MapSystem::TransformData data; + data.has_rotation = false; + data.position.x = 0.0f; + data.position.y = 0.0f; + + // Initialize matrix to identity + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + data.matrix[i][j] = (i == j) ? 1.0f : 0.0f; + } + } + + std::vector values; + size_t pos = 0; + + // Parse all 12 floats from the transform string + while (pos < transform_str.length() && values.size() < 12) { + // Skip whitespace and commas + while (pos < transform_str.length() && (std::isspace(transform_str[pos]) || transform_str[pos] == ',')) { + pos++; + } + + if (pos >= transform_str.length()) break; + + // Parse number + size_t start = pos; + if (transform_str[pos] == '-') pos++; + + // Parse digits and decimal point + while (pos < transform_str.length() && (std::isdigit(transform_str[pos]) || transform_str[pos] == '.')) { + pos++; + } + + // Handle scientific notation (e or E) + if (pos < transform_str.length() && (transform_str[pos] == 'e' || transform_str[pos] == 'E')) { + pos++; + // Handle optional sign after e + if (pos < transform_str.length() && (transform_str[pos] == '+' || transform_str[pos] == '-')) { + pos++; + } + // Parse exponent digits + while (pos < transform_str.length() && std::isdigit(transform_str[pos])) { + pos++; + } + } + + if (pos > start) { + try { + values.push_back(std::stof(transform_str.substr(start, pos - start))); + } catch (...) { + LOG_WARN("Failed to parse transform value from '%s'", transform_str.substr(start, pos - start).c_str()); + } + } + } + + if (values.size() >= 12) { + // Extract 3x3 rotation matrix + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + data.matrix[i][j] = values[i * 3 + j]; + } + } + + // Extract position (last 3 values) + data.position.x = values[9]; + data.position.y = values[11]; // z coordinate becomes y + + // Check if there's any significant rotation (check if matrix is not identity) + const float eps = 0.0001f; + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + float expected = (i == j) ? 1.0f : 0.0f; + if (std::abs(data.matrix[i][j] - expected) > eps) { + data.has_rotation = true; + break; + } + } + if (data.has_rotation) break; + } + + if (data.has_rotation) { + LOG_INFO("Detected rotation in NavigationRegion3D: matrix=[[%.4f,%.4f,%.4f],[%.4f,%.4f,%.4f],[%.4f,%.4f,%.4f]]", + data.matrix[0][0], data.matrix[0][1], data.matrix[0][2], + data.matrix[1][0], data.matrix[1][1], data.matrix[1][2], + data.matrix[2][0], data.matrix[2][1], data.matrix[2][2]); + } + } else { + LOG_WARN("Failed to parse Transform3D - expected 12 values, got %zu", values.size()); + } + + return data; +} + +void MapSystem::apply_navigation_region_transform(const std::string& file_content, + std::vector& vertices, + std::vector& spawnpoints) { + // Find the NavigationRegion3D node and extract its transform + size_t nav_region_pos = file_content.find("[node name=\""); + if (nav_region_pos == std::string::npos) { + LOG_WARN("No node found in tscn file"); + return; + } + + // Find the first node's transform line (should be the root NavigationRegion3D) + size_t transform_pos = file_content.find("transform = Transform3D(", nav_region_pos); + if (transform_pos == std::string::npos) { + LOG_DEBUG("No transform found on NavigationRegion3D node (using default identity)"); + return; + } + + // Extract transform string + transform_pos += std::string("transform = Transform3D(").length(); + size_t transform_end = file_content.find(")", transform_pos); + if (transform_end == std::string::npos) { + LOG_WARN("Failed to find end of Transform3D string"); + return; + } + + std::string transform_str = file_content.substr(transform_pos, transform_end - transform_pos); + MapSystem::TransformData transform_data = parse_transform_3d(transform_str); + + if (!transform_data.has_rotation) { + LOG_DEBUG("NavigationRegion3D has identity rotation (no transformation needed)"); + return; + } + + // Apply rotation to vertices + // Transform is 3D: (X, Y, Z) -> applying 2D projection + // Godot uses X-right, Y-up, Z-back coordinate system + // We extract X and Z (converting Z to Y in 2D) + for (auto& v : vertices) { + float x3d = v.x; + float z3d = v.y; // Y in 2D is Z in 3D + float y3d = 0.0f; // Navmesh is flat on Y=0 plane + + // Apply rotation: result = matrix * [x, y, z] + float new_x = transform_data.matrix[0][0] * x3d + transform_data.matrix[0][1] * y3d + transform_data.matrix[0][2] * z3d; + float new_z = transform_data.matrix[2][0] * x3d + transform_data.matrix[2][1] * y3d + transform_data.matrix[2][2] * z3d; + + // Store back as 2D (X and Z become X and Y) + v.x = new_x; + v.y = new_z; + } + + // Apply rotation to spawnpoints + for (auto& sp : spawnpoints) { + float x3d = sp.x; + float z3d = sp.y; + float y3d = 0.0f; // Spawnpoints are on the ground plane + + float new_x = transform_data.matrix[0][0] * x3d + transform_data.matrix[0][1] * y3d + transform_data.matrix[0][2] * z3d; + float new_z = transform_data.matrix[2][0] * x3d + transform_data.matrix[2][1] * y3d + transform_data.matrix[2][2] * z3d; + + sp.x = new_x; + sp.y = new_z; + } + + LOG_INFO("Applied NavigationRegion3D transform to %zu vertices and %zu spawnpoints", + vertices.size(), spawnpoints.size()); } \ No newline at end of file diff --git a/src/systems/util/map_system.hpp b/src/systems/util/map_system.hpp index 5a1a2e5..2dc3d91 100644 --- a/src/systems/util/map_system.hpp +++ b/src/systems/util/map_system.hpp @@ -77,6 +77,41 @@ class MapSystem { */ static std::vector serialize_map(Entity* map_entity); private: + /** + * Structure to hold transformation matrix data. + */ + struct TransformData { + float matrix[3][3]; + Vec2 position; + bool has_rotation; + }; + + /** + * Structure to hold map bounds information (min/max coordinates). + */ + struct MapBounds { + Vec2 min; // Minimum (x, y) coordinates + Vec2 max; // Maximum (x, y) coordinates + }; + + /** + * Extract the Transform3D from the NavigationRegion3D node and apply it to navmesh vertices. + * @param file_content The TSCN file content + * @param vertices The vertices to transform (modified in-place) + * @param spawnpoints The spawnpoints to transform (modified in-place) + */ + static void apply_navigation_region_transform(const std::string& file_content, + std::vector& vertices, + std::vector& spawnpoints); + + /** + * Parse a Transform3D matrix string from Godot format. + * Format: Transform3D(m00, m01, m02, m10, m11, m12, m20, m21, m22, x, y, z) + * @param transform_str The transform string to parse + * @return TransformData containing rotation matrix and position + */ + static TransformData parse_transform_3d(const std::string& transform_str); + /** * Parse a Godot tscn file and extract navmesh data. * Looks for NavigationMesh subsection with vertices and polygons. @@ -88,4 +123,5 @@ class MapSystem { static std::vector parse_vertices_to_2D(const std::string& vertices_str); static std::vector> parse_polygons(const std::string& polygons_str); static Vec2 calculate_size_from_vertices(const std::vector& vertices); + static MapBounds calculate_bounds_from_vertices(const std::vector& vertices); }; From 45dbef1085f7cab3469917599dabc6061a07e23a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 25 Nov 2025 21:30:00 -0500 Subject: [PATCH 58/79] Add navmesh, bounds, and other QOL features to visualizer --- src/services/visualizer_service.cpp | 236 +++++++++++++++++++++++++--- 1 file changed, 213 insertions(+), 23 deletions(-) diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index b83bc4b..5344151 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -248,6 +248,21 @@ std::string VisualizerService::get_html_page() const {

Map View

+

Visualization Legend

+
+
█ Grid - Reference coordinate grid (10-unit spacing)
+
█ Map Bounds - Dashed line showing map boundary
+
█ Navmesh - Walkable area polygons
+
● Vertices - Navmesh vertex positions with indices
+
● Centroids - Polygon center points for pathfinding
+
★ Spawnpoints - Unit spawn locations
+
● Blue Entity - Team 1 entity
+
● Red Entity - Team 2 entity
+
⚫ Attacking Ring - Entity in ATTACKING state
+
⚫ Moving Ring - Entity in MOVING state
+
⚫ Pathfinding Ring - Entity in PATHFINDING_WAITING state
+
+

Game State

@@ -267,6 +282,12 @@ std::string VisualizerService::get_html_page() const { ctx.fillStyle = '#000'; ctx.fillRect(0, 0, canvas.width, canvas.height); + // Draw grid first (background) + drawGrid(data.map); + + // Draw map bounds + drawMapBounds(data.map); + // Draw navmesh drawNavmesh(data.map); @@ -286,48 +307,203 @@ std::string VisualizerService::get_html_page() const { } } + function screenToWorld(screenX, screenY) { + return { + x: (screenX - 400) / 10, + y: (screenY - 300) / 10 + }; + } + + function worldToScreen(worldX, worldY) { + return { + x: worldX * 10 + 400, + y: worldY * 10 + 300 + }; + } + + function drawGrid(mapData) { + const gridSize = 10; // Units per grid square + const gridScale = gridSize * 10; // Pixels per grid square (at 10px/unit) + + ctx.strokeStyle = '#1a3a1a'; + ctx.lineWidth = 0.5; + + // Vertical lines + for (let x = 0; x < canvas.width; x += gridScale) { + ctx.beginPath(); + ctx.moveTo(x, 0); + ctx.lineTo(x, canvas.height); + ctx.stroke(); + } + + // Horizontal lines + for (let y = 0; y < canvas.height; y += gridScale) { + ctx.beginPath(); + ctx.moveTo(0, y); + ctx.lineTo(canvas.width, y); + ctx.stroke(); + } + + // Draw grid labels every 50 units + ctx.fillStyle = '#2a4a2a'; + ctx.font = '10px monospace'; + ctx.textAlign = 'right'; + ctx.textBaseline = 'top'; + + for (let worldX = -100; worldX <= 100; worldX += 50) { + const screenX = worldToScreen(worldX, 0).x; + if (screenX >= 0 && screenX <= canvas.width) { + ctx.fillText(worldX.toString(), screenX - 3, 3); + } + } + + ctx.textAlign = 'left'; + for (let worldY = -100; worldY <= 100; worldY += 50) { + const screenY = worldToScreen(0, worldY).y; + if (screenY >= 0 && screenY <= canvas.height) { + ctx.fillText(worldY.toString(), 3, screenY); + } + } + } + + function drawMapBounds(mapData) { + if (!mapData) return; + + // Draw map boundary as a dashed line + ctx.strokeStyle = '#664040'; + ctx.lineWidth = 2; + ctx.setLineDash([10, 5]); + + const halfWidth = mapData.size.x / 2; + const halfHeight = mapData.size.y / 2; + + const minX = mapData.offset.x - halfWidth; + const maxX = mapData.offset.x + halfWidth; + const minY = mapData.offset.y - halfHeight; + const maxY = mapData.offset.y + halfHeight; + + const topLeft = worldToScreen(minX, minY); + const topRight = worldToScreen(maxX, minY); + const bottomLeft = worldToScreen(minX, maxY); + const bottomRight = worldToScreen(maxX, maxY); + + ctx.beginPath(); + ctx.moveTo(topLeft.x, topLeft.y); + ctx.lineTo(topRight.x, topRight.y); + ctx.lineTo(bottomRight.x, bottomRight.y); + ctx.lineTo(bottomLeft.x, bottomLeft.y); + ctx.closePath(); + ctx.stroke(); + + ctx.setLineDash([]); + } + function drawNavmesh(mapData) { if (!mapData || !mapData.vertices) return; const vertices = mapData.vertices; const polygons = mapData.polygons || []; + // Draw polygon faces ctx.strokeStyle = '#408040'; ctx.fillStyle = '#204020'; - ctx.lineWidth = 1; + ctx.lineWidth = 2; for (let poly of polygons) { if (poly.length < 3) continue; ctx.beginPath(); const v = vertices[poly[0]]; - ctx.moveTo(v.x * 10 + 400, v.z * 10 + 300); + const screen = worldToScreen(v.x, v.z); + ctx.moveTo(screen.x, screen.y); for (let i = 1; i < poly.length; i++) { const v = vertices[poly[i]]; - ctx.lineTo(v.x * 10 + 400, v.z * 10 + 300); + const screen = worldToScreen(v.x, v.z); + ctx.lineTo(screen.x, screen.y); } ctx.closePath(); ctx.fill(); ctx.stroke(); } + + // Draw vertices with labels + ctx.fillStyle = '#80ff80'; + ctx.strokeStyle = '#ffffff'; + ctx.lineWidth = 1; + ctx.font = 'bold 9px monospace'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + + for (let i = 0; i < vertices.length; i++) { + const v = vertices[i]; + const screen = worldToScreen(v.x, v.z); + + // Draw vertex circle + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 3, 0, Math.PI * 2); + ctx.fill(); + ctx.stroke(); + + // Draw vertex index + ctx.fillStyle = '#000000'; + ctx.fillText(i.toString(), screen.x, screen.y); + ctx.fillStyle = '#80ff80'; + } + + // Draw polygon centroids + ctx.fillStyle = '#ff6b6b'; + for (let i = 0; i < polygons.length; i++) { + const poly = polygons[i]; + if (poly.length < 3) continue; + + // Calculate centroid + let cx = 0, cy = 0; + for (let idx of poly) { + cx += vertices[idx].x; + cy += vertices[idx].z; + } + cx /= poly.length; + cy /= poly.length; + + const screen = worldToScreen(cx, cy); + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 2, 0, Math.PI * 2); + ctx.fill(); + } } function drawSpawnpoints(mapData) { if (!mapData || !mapData.spawnpoints) return; ctx.fillStyle = '#ffff00'; + ctx.strokeStyle = '#ffff00'; + ctx.lineWidth = 2; ctx.font = '12px Arial'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'bottom'; for (let i = 0; i < mapData.spawnpoints.length; i++) { const sp = mapData.spawnpoints[i]; - const x = sp.x * 10 + 400; - const y = sp.z * 10 + 300; + const screen = worldToScreen(sp.x, sp.z); + // Draw spawnpoint star ctx.beginPath(); - ctx.arc(x, y, 5, 0, Math.PI * 2); + for (let j = 0; j < 5; j++) { + const angle = (j * 4 * Math.PI) / 5 - Math.PI / 2; + const radius = j % 2 === 0 ? 8 : 4; + const x = screen.x + Math.cos(angle) * radius; + const y = screen.y + Math.sin(angle) * radius; + if (j === 0) ctx.moveTo(x, y); + else ctx.lineTo(x, y); + } + ctx.closePath(); ctx.fill(); - ctx.fillText('S' + i, x - 5, y - 10); + ctx.stroke(); + + // Draw label + ctx.fillStyle = '#ffff00'; + ctx.fillText('S' + i, screen.x, screen.y - 12); } } @@ -337,34 +513,32 @@ std::string VisualizerService::get_html_page() const { // First pass: draw targeting lines for (let entity of entities) { if (entity.target_id !== undefined) { - const attacker_x = entity.position.x * 10 + 400; - const attacker_y = entity.position.z * 10 + 300; + const attacker_screen = worldToScreen(entity.position.x, entity.position.z); // Find target entity const target = entities.find(e => e.id === entity.target_id); if (target) { - const target_x = target.position.x * 10 + 400; - const target_y = target.position.z * 10 + 300; + const target_screen = worldToScreen(target.position.x, target.position.z); // Draw targeting line ctx.strokeStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; ctx.lineWidth = 2; ctx.setLineDash([5, 5]); ctx.beginPath(); - ctx.moveTo(attacker_x, attacker_y); - ctx.lineTo(target_x, target_y); + ctx.moveTo(attacker_screen.x, attacker_screen.y); + ctx.lineTo(target_screen.x, target_screen.y); ctx.stroke(); ctx.setLineDash([]); // Draw arrowhead at target - const angle = Math.atan2(target_y - attacker_y, target_x - attacker_x); + const angle = Math.atan2(target_screen.y - attacker_screen.y, target_screen.x - attacker_screen.x); const arrowSize = 8; ctx.fillStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; ctx.beginPath(); - ctx.moveTo(target_x, target_y); - ctx.lineTo(target_x - arrowSize * Math.cos(angle - Math.PI / 6), target_y - arrowSize * Math.sin(angle - Math.PI / 6)); - ctx.lineTo(target_x - arrowSize * Math.cos(angle + Math.PI / 6), target_y - arrowSize * Math.sin(angle + Math.PI / 6)); + ctx.moveTo(target_screen.x, target_screen.y); + ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle - Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle - Math.PI / 6)); + ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle + Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle + Math.PI / 6)); ctx.closePath(); ctx.fill(); } @@ -373,28 +547,44 @@ std::string VisualizerService::get_html_page() const { // Second pass: draw entities for (let entity of entities) { - const x = entity.position.x * 10 + 400; - const y = entity.position.z * 10 + 300; + const screen = worldToScreen(entity.position.x, entity.position.z); // Color by team ctx.fillStyle = entity.team_id === 1 ? '#4040ff' : '#ff4040'; ctx.beginPath(); - ctx.arc(x, y, 4, 0, Math.PI * 2); + ctx.arc(screen.x, screen.y, 4, 0, Math.PI * 2); ctx.fill(); // Draw ID ctx.fillStyle = '#ffffff'; - ctx.font = '10px Arial'; - ctx.fillText(entity.id, x - 10, y - 8); + ctx.font = 'bold 10px Arial'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + ctx.fillText(entity.id.toString(), screen.x, screen.y); // Highlight if attacking if (entity.state === 'ATTACKING') { ctx.strokeStyle = '#ffff00'; ctx.lineWidth = 2; ctx.beginPath(); - ctx.arc(x, y, 6, 0, Math.PI * 2); + ctx.arc(screen.x, screen.y, 6, 0, Math.PI * 2); ctx.stroke(); } + + // Draw state indicator + let stateColor; + switch (entity.state) { + case 'ATTACKING': stateColor = '#ffff00'; break; + case 'MOVING': stateColor = '#4da6ff'; break; + case 'PATHFINDING_WAITING': stateColor = '#ffa500'; break; + case 'DEAD': stateColor = '#ff0000'; break; + default: stateColor = '#ffb347'; break; + } + ctx.strokeStyle = stateColor; + ctx.lineWidth = 1; + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 8, 0, Math.PI * 2); + ctx.stroke(); } } From 02fc3627c65a5e5dc86bd2ec17c31fbc74b4a28a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 25 Nov 2025 21:30:10 -0500 Subject: [PATCH 59/79] fix player input --- src/systems/core/input_system.cpp | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/src/systems/core/input_system.cpp b/src/systems/core/input_system.cpp index de20cd5..06ef787 100644 --- a/src/systems/core/input_system.cpp +++ b/src/systems/core/input_system.cpp @@ -47,22 +47,31 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi return false; } - // Validate target position is within map bounds + // Transform input coordinates from map space to entity space + // Input comes in as absolute map coordinates, needs to be adjusted to map-relative coordinates + Vec2 transformed_position = target_position; if (ctx.map) { float half_width = ctx.map->size.x / 2.0f; float half_height = ctx.map->size.y / 2.0f; - float min_x = ctx.map->offset.x - half_width; + + // Calculate map minimum (where the map starts) + float map_min_x = ctx.map->offset.x - half_width; + float map_min_y = ctx.map->offset.y - half_height; + + // Check bounds first float max_x = ctx.map->offset.x + half_width; - float min_y = ctx.map->offset.y - half_height; float max_y = ctx.map->offset.y + half_height; - if (target_position.x < min_x || target_position.x > max_x || - target_position.y < min_y || target_position.y > max_y) { + if (target_position.x < map_min_x || target_position.x > max_x || + target_position.y < map_min_y || target_position.y > max_y) { LOG_WARN("Entity %u movement target (%.2f, %.2f) is out of bounds [%.1f-%.1f, %.1f-%.1f]", entity.get_id(), target_position.x, target_position.y, - min_x, max_x, min_y, max_y); + map_min_x, max_x, map_min_y, max_y); return false; } + + // Transform to centered coordinates (offset from map center) + transformed_position = target_position - ctx.map->offset; } // Attempt to use pathfinding if NavigationService and Map are available @@ -78,7 +87,7 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi PathRequest request; request.entity_id = entity.get_id(); request.current_position = movement->position; - request.destination = target_position; + request.destination = transformed_position; request.entity_pathing_radius = 0.5f; if (ctx.navigation_service->MakeRequest(request)) { @@ -87,7 +96,7 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi ent_state->state_duration_ms = 0.0f; ent_state->target_positions.clear(); - LOG_INFO("Entity %u requested pathfinding to (%.2f, %.2f)", entity.get_id(), target_position.x, target_position.y); + LOG_INFO("Entity %u requested pathfinding to (%.2f, %.2f)", entity.get_id(), transformed_position.x, transformed_position.y); return true; } else { LOG_WARN("Entity %u failed to request pathfinding", entity.get_id()); @@ -97,10 +106,10 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi // Fallback: Use direct movement if pathfinding unavailable LOG_DEBUG("Entity %u using direct movement to (%.2f, %.2f) (pathfinding unavailable)", - entity.get_id(), target_position.x, target_position.y); + entity.get_id(), transformed_position.x, transformed_position.y); ent_state->current_state = EntityState::MOVING; ent_state->target_positions.clear(); - ent_state->target_positions.push_back(target_position); + ent_state->target_positions.push_back(transformed_position); return true; } From 459f39bf379b2e5a2ecac457a733ac3950ef7fe6 Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 1 Dec 2025 09:02:29 +0100 Subject: [PATCH 60/79] logic refactor 2 --- .vscode/launch.json | 2 +- .vscode/settings.json | 4 +- CMakeLists.txt | 1 + data/entities/champions/champion.xml | 1 + data/entities/minions/cannon_minion.xml | 14 +- data/entities/minions/magic_minion.xml | 13 +- data/entities/minions/melee_minion.xml | 13 +- data/entities/minions/ranged_minion.xml | 14 +- src/components/attack.hpp | 5 + src/components/auto_attack.hpp | 51 --- src/components/intent.hpp | 59 +--- src/components/movement.hpp | 4 + src/components/npc_component.hpp | 22 +- src/components/pathfinding.hpp | 26 +- src/services/visualizer_service.cpp | 6 - src/systems/core/brain_system.cpp | 162 +++------- src/systems/core/brain_system.hpp | 44 +-- src/systems/core/combat_system.cpp | 31 +- src/systems/core/combat_system.hpp | 23 -- src/systems/core/input_system.cpp | 43 +-- src/systems/core/movement_system.cpp | 398 ++++-------------------- src/systems/core/movement_system.hpp | 43 +-- src/systems/core/npc_system.cpp | 85 +++++ src/systems/core/npc_system.hpp | 28 ++ src/systems/core/spawning_system.cpp | 13 +- src/systems/gameplay_coordinator.cpp | 1 + src/systems/gameplay_coordinator.hpp | 2 + src/systems/util/data_loader.cpp | 92 +----- src/systems/util/targeting_utility.cpp | 1 - 29 files changed, 298 insertions(+), 903 deletions(-) delete mode 100644 src/components/auto_attack.hpp create mode 100644 src/systems/core/npc_system.cpp create mode 100644 src/systems/core/npc_system.hpp diff --git a/.vscode/launch.json b/.vscode/launch.json index 15ae99c..fde5ad2 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -21,7 +21,7 @@ "stopAtEntry": false, "cwd": "${workspaceFolder}", "environment": [], - "console": "externalTerminal" + "console": "integratedTerminal" }, { "name": "Win(R) Visual", diff --git a/.vscode/settings.json b/.vscode/settings.json index f786995..d3c4667 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -73,6 +73,8 @@ "xstring": "cpp", "xtr1common": "cpp", "xtree": "cpp", - "xutility": "cpp" + "xutility": "cpp", + "variant": "cpp", + "array": "cpp" } } \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index e19796f..03c6556 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,6 +63,7 @@ set(GAMESERVER_SOURCES src/systems/core/input_system.cpp src/systems/core/movement_system.cpp src/systems/core/network_sync_system.cpp + src/systems/core/npc_system.cpp src/systems/core/spawning_system.cpp src/systems/core/wave_system.cpp # Systems - Utilities diff --git a/data/entities/champions/champion.xml b/data/entities/champions/champion.xml index 19a57aa..2c3fcf0 100644 --- a/data/entities/champions/champion.xml +++ b/data/entities/champions/champion.xml @@ -22,4 +22,5 @@ + \ No newline at end of file diff --git a/data/entities/minions/cannon_minion.xml b/data/entities/minions/cannon_minion.xml index 04d2e56..e402fe1 100644 --- a/data/entities/minions/cannon_minion.xml +++ b/data/entities/minions/cannon_minion.xml @@ -18,17 +18,9 @@ /> - - diff --git a/data/entities/minions/magic_minion.xml b/data/entities/minions/magic_minion.xml index effeb9b..b5cf10b 100644 --- a/data/entities/minions/magic_minion.xml +++ b/data/entities/minions/magic_minion.xml @@ -21,19 +21,8 @@ - diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml index c43fd91..7739e6a 100644 --- a/data/entities/minions/melee_minion.xml +++ b/data/entities/minions/melee_minion.xml @@ -20,18 +20,7 @@ - diff --git a/data/entities/minions/ranged_minion.xml b/data/entities/minions/ranged_minion.xml index 640511f..de1ef44 100644 --- a/data/entities/minions/ranged_minion.xml +++ b/data/entities/minions/ranged_minion.xml @@ -18,17 +18,9 @@ /> - - diff --git a/src/components/attack.hpp b/src/components/attack.hpp index bc95d2b..b399e8d 100644 --- a/src/components/attack.hpp +++ b/src/components/attack.hpp @@ -2,6 +2,7 @@ #include "component.hpp" #include +#include /** * AttackComponent - Tracks current attack state and cooldown (DATA ONLY) @@ -20,6 +21,9 @@ * - Separates attack state from combat stats */ struct AttackComponent : public Component { + // The entity that this component currently wants to target + std::optional target; + // === Attack State === bool can_attack = true; // Can attack this frame @@ -28,6 +32,7 @@ struct AttackComponent : public Component { float cooldown_timer_ms = 0.0f; // Tracks remaining cooldown time float cast_time_ms = 0.0f; // Time spent in current attack animation float last_attack_time_ms = 0.0f; // Timestamp of last attack + float hit_timing_percent = 0.5f; // When in animation does damage occur (0.0-1.0) // === Current Attack === bool attack_in_progress = false; // Currently executing attack animation/projectile diff --git a/src/components/auto_attack.hpp b/src/components/auto_attack.hpp deleted file mode 100644 index 6748a43..0000000 --- a/src/components/auto_attack.hpp +++ /dev/null @@ -1,51 +0,0 @@ -#pragma once - -#include "component.hpp" -#include "stats.hpp" -#include - -/** - * AutoAttackComponent - Pure data for auto-attack mechanics - * - * USAGE: Add to entities that can perform auto-attacks - * SYSTEMS: CombatSystem - * COMPANIONS: AttackComponent, TargetComponent, Stats, Movement - * - * PURPOSE: - * - Store auto-attack configuration and state - * - Track attack cooldown and animation state - * - Define attack damage and timing parameters - * - Store current combat state - * - * DESIGN: - * - Pure data component (no functions) - * - CombatSystem reads and updates this data - * - BrainSystem controls when auto-attacking is enabled - * - No behavior logic - only mechanics - * - * NOTE: Behavior like aggression, target search, and AI personality - * belong in NPCComponent and are handled by BrainSystem - */ -struct AutoAttackComponent : public Component { - // === Auto-Attack State === - bool enabled = true; // Can auto-attack - bool in_combat = false; // Currently engaged in combat - float combat_timeout_ms = 5000.0f; // How long before leaving combat (5 seconds) - float time_since_attack_ms = 0.0f; // Time since last attack landed - - // === Auto-Attack Damage === - float base_damage_multiplier = 1.0f; // Damage multiplier from base stats - float bonus_damage = 0.0f; // Additional flat damage - DamageType damage_type = DamageType::PHYSICAL; // Damage type for resistances - - // === Attack Animation === - float attack_animation_duration_ms = 300.0f; // How long attack animation takes - float hit_timing_percent = 0.5f; // When in animation does damage occur (0.0-1.0) - - // === Kiting & Movement === - bool allow_kiting = true; // Can move while attacking - bool kite_while_attacking = false; // Actively move during auto-attacks - float movement_during_attack = 0.3f; // Movement speed multiplier during attack (0.0-1.0) - - COMPONENT_TYPE_ID(AutoAttackComponent, 2022) -}; diff --git a/src/components/intent.hpp b/src/components/intent.hpp index 89c83ae..f6aa0e8 100644 --- a/src/components/intent.hpp +++ b/src/components/intent.hpp @@ -5,66 +5,27 @@ #include /** - * Intent types define the high-level goals/behaviors for NPCs. - * Intents are the "what" - the EntityState is the "how". + * Intent types define what entities want to do. */ enum class IntentType { NONE, // No active intent - MOVE_TO_OBJECTIVE, // Move toward lane objective (minion primary goal) MOVE_TO_POSITION, // Move to a specific position (one-time) - MOVE_TO_SPAWNPOINT, // Move along the path to a spawnpoint ATTACK_TARGET, // Attack a specific entity - DEFEND_POSITION, // Defend an area around a position - CHASE_ENEMY, // Chase down a fleeing enemy - RETREAT, // Fall back to a safe position - PATROL, // Patrol a defined area }; /** - * Intent priority levels determine which intent takes precedence when multiple are active. - * Higher values = higher priority. - */ -enum class IntentPriority { - LOWEST = 0, - LOW = 1, - NORMAL = 2, - HIGH = 3, - CRITICAL = 4 -}; - -/** - * IntentComponent manages the NPC's intentions/goals. - * Stores the current intent state inline with all parameters. - * Works in conjunction with EntityStateComponent for state management. - * - * Logic for managing intents (setting, clearing, prioritizing) belongs in systems. + * IntentComponent indicates what an entity currently wants to do. + * The BrainSystem encodes this intention into lower level components + * such as movement or attack. + * The Intent is controlled by, for example, the InputSystem (player controlled entity) + * or the NPCSystem (npc entity). */ struct IntentComponent : public Component { - - // === Current Intent State === IntentType type = IntentType::NONE; - IntentPriority priority = IntentPriority::NORMAL; - - // Time this intent has been active (milliseconds) - float elapsed_time_ms = 0.0f; - - // Maximum duration for this intent (0 = unlimited) - // If exceeded, intent is automatically cleared - float max_duration_ms = 0.0f; - + // Target data (usage depends on intent type) - uint32_t target_entity_id = INVALID_ENTITY_ID; // For ATTACK_TARGET, CHASE_ENEMY - Vec2 target_position = Vec2(0.0f, 0.0f); // For MOVE_TO_POSITION, DEFEND_POSITION, MOVE_TO_OBJECTIVE - uint32_t target_spawnpoint_id = 0; // For MOVE_TO_SPAWNPOINT, MOVE_TO_OBJECTIVE (current lane objective) - uint32_t objective_index = 0; // For MOVE_TO_OBJECTIVE: which spawnpoint in the lane path (0 = next, 1 = after, etc.) - - // Behavior parameters - float min_range = 0.0f; // Minimum distance to maintain from target - float max_range = 0.0f; // Maximum distance before intent is abandoned - float tolerance = 0.1f; // Distance tolerance for reaching waypoints/positions - - // Whether this intent can be interrupted by higher-priority intents - bool is_interruptible = true; - + uint32_t target_entity_id = INVALID_ENTITY_ID; // For ATTACK_TARGET + Vec2 target_position = Vec2(0.0f, 0.0f); // For MOVE_TO_POSITION + COMPONENT_TYPE_ID(IntentComponent, 2011) }; diff --git a/src/components/movement.hpp b/src/components/movement.hpp index 4039426..a62b0b9 100644 --- a/src/components/movement.hpp +++ b/src/components/movement.hpp @@ -3,6 +3,7 @@ #include #include #include +#include /** * Movement component for entities. @@ -15,6 +16,9 @@ struct Movement : public Component { // Collision radius for entity-to-entity collision avoidance float collision_radius{0.5f}; + + // Position that the entity currently wants to move to + std::optional target = std::nullopt; COMPONENT_TYPE_ID(Movement, 2001) }; \ No newline at end of file diff --git a/src/components/npc_component.hpp b/src/components/npc_component.hpp index 65d9923..9b0aa26 100644 --- a/src/components/npc_component.hpp +++ b/src/components/npc_component.hpp @@ -11,28 +11,12 @@ enum class NPCType { struct NPCComponent : public Component { NPCType npc_type; - - enum class AIPersonality { - PASSIVE, // No aggression, only retaliate - DEFENSIVE, // Attack if threatened, otherwise passive - BALANCED, // Normal minion behavior - AGGRESSIVE, // Actively seek targets - ZEALOUS // Very aggressive, ignore retreat - }; + // === Behavior Configuration === - AIPersonality personality = AIPersonality::BALANCED; float aggression_range = 10.0f; // How far to search for enemies to attack - float retreat_range = 8.0f; // How far to retreat if outnumbered - bool aggressive = true; // Search for targets actively - bool retaliate_only = false; // Only attack if attacked first - - // === Target Preference === - bool prioritize_enemies = true; // Attack enemies over neutrals - bool prioritize_wounded = true; // Focus low-health targets - bool prioritize_attackers = false; // Focus entities attacking me - bool prioritize_closest = true; // Among valid targets, choose closest - + Vec2 objective; // Target position for minions to path towards + // === Chase Behavior === float chase_distance = 30.0f; float chase_timeout_ms = 5000.0f; // How long to keep chasing without hitting the target diff --git a/src/components/pathfinding.hpp b/src/components/pathfinding.hpp index 2bf4ae6..93e3cb6 100644 --- a/src/components/pathfinding.hpp +++ b/src/components/pathfinding.hpp @@ -13,28 +13,12 @@ struct PathfindingComponent : public Component { // Current path waypoints (2D positions) std::vector waypoints; - - // Index of the next waypoint to move toward - int current_waypoint_index = 0; - - // Target spawnpoint ID (the destination spawnpoint this path leads to) - uint32_t target_spawnpoint_id = 0; - + // Request ID for tracking async pathfinding requests uint32_t path_request_id = 0; - - // Track last position to detect if entity is stuck - Vec2 last_position = Vec2(0.0f, 0.0f); - - // Time spent stuck without progress (milliseconds) - float stuck_time_ms = 0.0f; - - // Threshold for considering entity stuck (milliseconds) - static constexpr float STUCK_THRESHOLD_MS = 2000.0f; - - // Counter for failed pathfinding attempts (to prevent infinite retries) - uint32_t pathfinding_retry_count = 0; - static constexpr uint32_t MAX_PATHFINDING_RETRIES = 3; - + + // True if the entity has requested a path and is currently waiting for it to be calculated + bool waiting_for_path; + COMPONENT_TYPE_ID(PathfindingComponent, 2009) }; \ No newline at end of file diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index 5344151..f0e1659 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -39,14 +39,8 @@ static std::string entity_state_to_string(EntityState state) { static std::string intent_type_to_string(IntentType type) { switch (type) { case IntentType::NONE: return "NONE"; - case IntentType::MOVE_TO_OBJECTIVE: return "MOVE_TO_OBJECTIVE"; case IntentType::MOVE_TO_POSITION: return "MOVE_TO_POSITION"; - case IntentType::MOVE_TO_SPAWNPOINT: return "MOVE_TO_SPAWNPOINT"; case IntentType::ATTACK_TARGET: return "ATTACK_TARGET"; - case IntentType::DEFEND_POSITION: return "DEFEND_POSITION"; - case IntentType::CHASE_ENEMY: return "CHASE_ENEMY"; - case IntentType::RETREAT: return "RETREAT"; - case IntentType::PATROL: return "PATROL"; default: return "UNKNOWN"; } } diff --git a/src/systems/core/brain_system.cpp b/src/systems/core/brain_system.cpp index eaf8911..f2648c7 100644 --- a/src/systems/core/brain_system.cpp +++ b/src/systems/core/brain_system.cpp @@ -4,7 +4,6 @@ #include #include #include -#include #include #include #include @@ -16,134 +15,63 @@ void BrainSystem::update(const SystemContext& ctx) { auto entities_with_intent = ctx.entity_manager.get_entities_with_component(); for (auto* entity : entities_with_intent) { - if (!entity) continue; - process_entity_intent(ctx, entity); } } void BrainSystem::process_entity_intent(const SystemContext& ctx, Entity* entity) { auto* intent_comp = entity->get_component(); - auto* stats = entity->get_component(); - auto* entity_state = entity->get_component(); - auto* npc_comp = entity->get_component(); - auto* attack = entity->get_component(); - if (!intent_comp || !stats || !entity_state) { - return; + if(intent_comp->type == IntentType::ATTACK_TARGET) { + handle_attack_intent(ctx, entity); } - - // Handle attack cooldown logic for ATTACK_TARGET intent - if (attack && intent_comp->type == IntentType::ATTACK_TARGET) { - // If attack is not ready, update cooldown timer - if (!attack->can_attack) { - if (attack->cooldown_timer_ms > 0.0f) { - attack->cooldown_timer_ms -= ctx.delta_time_ms; - if (attack->cooldown_timer_ms < 0.0f) { - attack->cooldown_timer_ms = 0.0f; - } - } - if (attack->cooldown_timer_ms == 0.0f) { - attack->can_attack = true; - } - } - // If attack was just used, set cooldown timer - if (attack->can_attack && attack->attack_in_progress) { - attack->cooldown_timer_ms = attack->attack_cooldown_ms; - attack->can_attack = false; - } + + if(intent_comp->type == IntentType::MOVE_TO_POSITION) { + handle_move_intent(ctx, entity); } +} - // Check current intent - switch (intent_comp->type) { - // MOVEMENT LOGIC - case IntentType::MOVE_TO_OBJECTIVE: - case IntentType::MOVE_TO_POSITION: - case IntentType::MOVE_TO_SPAWNPOINT: { - // Check entity profile for aggression - if (npc_comp) { - using Personality = decltype(npc_comp->personality); - if (npc_comp->personality == Personality::AGGRESSIVE || - npc_comp->personality == Personality::ZEALOUS || - npc_comp->personality == Personality::BALANCED) - { - // Look for nearby enemies to attack - EntityID target = TargetingUtility::find_best_target( - ctx.entity_manager, - entity->get_id(), - npc_comp->aggression_range, - TargetComponent::TargetPriority::NEAREST, - true // prioritize_closest - ); +void BrainSystem::handle_attack_intent(const SystemContext& ctx, Entity* entity) { + auto* intent = entity->get_component(); + auto* stats = entity->get_component(); + auto* attack = entity->get_component(); + auto* state = entity->get_component(); - if (target != INVALID_ENTITY_ID) { - // Switch to ATTACK_TARGET intent - intent_comp->type = IntentType::ATTACK_TARGET; - intent_comp->target_entity_id = target; - LOG_DEBUG("Entity %u: Switching to ATTACK_TARGET intent (target %u)", - entity->get_id(), target); - // Don't return - fall through to process ATTACK_TARGET case immediately - } - } - } - - // Only set MOVING state if we didn't find a target to attack - if (intent_comp->type != IntentType::ATTACK_TARGET) { - entity_state->current_state = EntityState::MOVING; - } - break; + // Continue attacking if entity is in the middle of an attack + if(attack->target.has_value()) { + if(attack->target.value() == intent->target_entity_id) { + // Already in the middle of an attack on the correct target + return; } - case IntentType::ATTACK_TARGET: - default: - break; + + // Attacking the wrong target, update attack target to new intent + LOG_DEBUG("Entity %d has changed target from %d to %d", entity->get_id(), state->target_entity_id, intent->target_entity_id); } - - // Process ATTACK_TARGET intent (separate from movement intents) - if (intent_comp->type == IntentType::ATTACK_TARGET) { - // Check if target is valid and still alive - bool target_valid = false; - if (intent_comp->target_entity_id != INVALID_ENTITY_ID) { - // Check if target entity exists - Entity* target_entity = ctx.entity_manager.get_entity(intent_comp->target_entity_id); - if (target_entity) { - // Check if target is still alive - Stats* target_stats = target_entity->get_component(); - if (target_stats && target_stats->health > 0.0f) { - target_valid = true; - } - } - } - - if (target_valid) { - // Target is alive, proceed with attack logic - float distance = TargetingUtility::calculate_distance(entity->get_component()->position, intent_comp->target_entity_id, ctx.entity_manager); - if (distance >= stats->attack_range) { - // Out of range - move closer - entity_state->current_state = EntityState::MOVING; - } else { - // In range - attack - // BrainSystem only manages the state and intent - // CombatSystem will read ATTACKING state + ATTACK_TARGET intent to initiate actual attacks - entity_state->current_state = EntityState::ATTACKING; - entity_state->target_entity_id = intent_comp->target_entity_id; - LOG_DEBUG("Entity %u: Transitioned to ATTACKING state for target %u", - entity->get_id(), intent_comp->target_entity_id); - } - } else { - // Target is dead or invalid - revert to moving toward objective - intent_comp->type = IntentType::MOVE_TO_OBJECTIVE; - intent_comp->target_entity_id = INVALID_ENTITY_ID; - entity_state->current_state = EntityState::MOVING; - - // Clear any pending pathfinding waypoints from the attack path - auto* pathfinding = entity->get_component(); - if (pathfinding) { - pathfinding->waypoints.clear(); - pathfinding->current_waypoint_index = 0; - } - - LOG_DEBUG("Entity %u: Attack target is dead or invalid, reverting to MOVE_TO_OBJECTIVE", - entity->get_id()); - } + + Entity* target = ctx.entity_manager.get_entity(intent->target_entity_id); + Movement* target_movement = target->get_component(); + Movement* entity_movement = entity->get_component(); + + // Move into range if too far away + if((target_movement->position - entity_movement->position).length() > stats->attack_range) { + attack->target = std::nullopt; // Cancel any ongoing attack + entity_movement->target = target_movement->position; + return; + } + + // Start attack if in range + if(!attack->target.has_value() || attack->target.value() != target->get_id()) { + entity_movement->target = std::nullopt; // Stop moving + attack->target = intent->target_entity_id; + } +} + +void BrainSystem::handle_move_intent(const SystemContext& ctx, Entity* entity) { + Movement* movement = entity->get_component(); + IntentComponent* intent = entity->get_component(); + + // Set the movement target if required + if(!movement->target.has_value() || movement->target.value() != intent->target_position) { + movement->target = intent->target_position; } } \ No newline at end of file diff --git a/src/systems/core/brain_system.hpp b/src/systems/core/brain_system.hpp index 29dfd46..e56bc4f 100644 --- a/src/systems/core/brain_system.hpp +++ b/src/systems/core/brain_system.hpp @@ -4,21 +4,18 @@ #include #include #include -#include /** - * BrainSystem - NPC decision-making and intent management + * BrainSystem - Intent management * * RESPONSIBILITIES: - * - Read IntentComponent to understand what the NPC wants to do + * - Read IntentComponent to understand what the entity wants to do * - Translate high-level intents into low-level component state - * - Manage target acquisition based on intents - * - Handle cooldowns and combat timeouts * - Set up CombatComponent and MovementComponent based on intents * * ARCHITECTURE: * This system implements the Intent-based architecture: - * - IntentComponent = What the NPC thinks it should do (ATTACK_TARGET, MOVE_TO_POSITION, etc.) + * - InputSystem/NPCSystem = What the entity thinks it should do (ATTACK_TARGET, MOVE_TO_POSITION, etc.) * - BrainSystem = How to translate intent into lower-level components * - CombatSystem = Reads CombatComponent and executes combat logic * - MovementSystem = Reads MovementComponent and executes movement @@ -39,7 +36,6 @@ * - Runs early in the loop (like NPC input) * - Reads: IntentComponent, Stats, Movement, EntityStateComponent, CombatComponent * - Writes: CombatComponent, MovementComponent, EntityStateComponent - * - Read by: CombatSystem, MovementSystem */ class BrainSystem { public: @@ -72,39 +68,17 @@ class BrainSystem { void process_entity_intent(const SystemContext& ctx, Entity* entity); /** - * Update minion AI intent (LoL-style minion behavior). - * Handles target acquisition and movement to objective. + * Process a single entity's attack intent. * * @param ctx System context - * @param entity Minion entity - * @param intent IntentComponent to update - * @param stats Stats component - * @param entity_state EntityStateComponent to update - * @param auto_attack AutoAttackComponent with aggression range + * @param entity Entity with IntentComponent that intends to attack */ - void update_minion_intent(const SystemContext& ctx, Entity* entity, IntentComponent& intent, - Stats& stats, EntityStateComponent& entity_state, - AutoAttackComponent& auto_attack); + void handle_attack_intent(const SystemContext& ctx, Entity* entity); /** - * Handle generic intent for non-minion entities. - * Ensures entity state reflects current intent. + * Process a single entity's move intent. * * @param ctx System context - * @param entity Entity to update - * @param intent IntentComponent - * @param entity_state EntityStateComponent to update + * @param entity Entity with intends to move */ - void handle_generic_intent(const SystemContext& ctx, Entity* entity, - IntentComponent& intent, EntityStateComponent& entity_state); - - /** - * Get the distance from entity to target. - * - * @param attacker Entity doing the attacking - * @param target_id ID of target entity - * @param ctx System context - * @return Distance in units, or -1 if target not found - */ - float get_distance_to_target(const Entity* attacker, uint32_t target_id, const SystemContext& ctx) const; -}; + void handle_move_intent(const SystemContext& ctx, Entity* entity);}; diff --git a/src/systems/core/combat_system.cpp b/src/systems/core/combat_system.cpp index c18fff9..1f9194b 100644 --- a/src/systems/core/combat_system.cpp +++ b/src/systems/core/combat_system.cpp @@ -14,35 +14,23 @@ void CombatSystem::update(const SystemContext& ctx) { // Process all entities with auto-attack behavior - auto attacking_entities = ctx.entity_manager.get_entities_with_component(); + auto attacking_entities = ctx.entity_manager.get_entities_with_component(); for (auto* entity : attacking_entities) { if (entity) { // Update auto-attack (target search, cooldown, attack initiation) update_auto_attack(ctx, *entity, ctx.delta_time_ms); } } - - // Process all entities with pending attacks (execution phase) - attacking_entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : attacking_entities) { - if (entity) { - auto* attack = entity->get_component(); - if (attack && attack->attack_in_progress) { - execute_attack(ctx, *entity, *attack, ctx.delta_time_ms); - } - } - } } void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms) { - auto* auto_attack = entity.get_component(); auto* attack = entity.get_component(); auto* target = entity.get_component(); auto* stats = entity.get_component(); auto* entity_state = entity.get_component(); auto* intent = entity.get_component(); - if (!auto_attack || !attack || !target || !stats) { + if (!attack || !target || !stats) { return; // Missing required components } @@ -55,10 +43,7 @@ void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, } // Check if entity should initiate an attack - // Condition: In ATTACKING state, has ATTACK_TARGET intent, and attack is ready - if (entity_state && entity_state->current_state == EntityState::ATTACKING && - intent && intent->type == IntentType::ATTACK_TARGET && - attack->can_attack && !attack->attack_in_progress) { + if (attack-> target.has_value() && attack->can_attack && !attack->attack_in_progress) { // Get the target entity auto* target_entity = ctx.entity_manager.get_entity(intent->target_entity_id); @@ -81,7 +66,7 @@ void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, } } - float hit_timing_percent = auto_attack ? auto_attack->hit_timing_percent : 0.5f; + float hit_timing_percent = attack ? attack->hit_timing_percent : 0.5f; float animation_duration = attack->attack_animation_duration_ms > 0.0f ? attack->attack_animation_duration_ms : 300.0f; @@ -129,8 +114,9 @@ void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, // Check if animation is complete if (attack->attack_animation_progress >= 1.0f) { - attack->attack_animation_progress = 1.0f; + attack->attack_animation_progress = 0.0f; attack->attack_in_progress = false; + attack->can_attack = true; // Clear pending attack data attack->pending_damage = 0.0f; @@ -139,11 +125,6 @@ void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, } } -void CombatSystem::execute_attack(const SystemContext& ctx, Entity& entity, AttackComponent& attack, float delta_time_ms) { - // This method was consolidated into update_auto_attack - // Attack execution now happens in update_auto_attack where damage is applied at the correct animation timing -} - bool CombatSystem::is_dead(const Entity& entity) const { const Stats* stats = entity.get_component(); return stats && stats->health <= 0.0f; diff --git a/src/systems/core/combat_system.hpp b/src/systems/core/combat_system.hpp index 425789e..bc08256 100644 --- a/src/systems/core/combat_system.hpp +++ b/src/systems/core/combat_system.hpp @@ -5,7 +5,6 @@ #include #include #include -#include #include #include @@ -13,26 +12,16 @@ * CombatSystem - Unified combat management system * * RESPONSIBILITIES: - * - Auto-attack AI and target acquisition * - Attack cooldown and readiness tracking * - Combat timeout management - * - Target validation and prioritization * - Attack animation management * - Attack execution and damage application * - Coordinate between auto-attack logic and damage calculation * - * REPLACES: - * - AutoAttackSystem (auto-attack AI and cooldowns) - * - AttackExecutionSystem (attack animation and execution) - * This unified system handles all aspects of combat from AI to execution - * * COMPONENTS USED: - * - AutoAttackComponent (AI behavior settings) * - AttackComponent (attack state and cooldown) - * - TargetComponent (target tracking) * - Stats (attack speed, health, damage stats) * - Movement (position for range calculations) - * - EntityStateComponent (for state tracking) * * UTILITIES USED: * - TargetingUtility: Pure utility functions for targeting calculations and validation @@ -44,7 +33,6 @@ * - Feeds attack information to entity state tracking * * DATA-DRIVEN DESIGN: - * All combat behavior is configured through component properties. * This system reads those properties and executes accordingly without hardcoded logic. * Targeting behavior is entirely data-driven via AutoAttackComponent and Stats properties. */ @@ -69,17 +57,6 @@ class CombatSystem { */ void update_auto_attack(const SystemContext& ctx, Entity& entity, float delta_time_ms); - /** - * Execute a pending attack for an entity. - * Processes attack animations and applies damage at the correct time. - * @param ctx System context - * @param entity Entity with attack in progress - * @param attack Attack component with pending data - * @param delta_time_ms Time elapsed this frame - * @return true if damage was applied this frame - */ - void execute_attack(const SystemContext& ctx, Entity& entity, AttackComponent& attack, float delta_time_ms); - /** * Check if a potential target is valid (not dead, correct team, etc). * NOTE: Use TargetingUtility validation functions instead - all targeting is now in utility! diff --git a/src/systems/core/input_system.cpp b/src/systems/core/input_system.cpp index 06ef787..1170dc4 100644 --- a/src/systems/core/input_system.cpp +++ b/src/systems/core/input_system.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -36,7 +37,8 @@ void InputSystem::update(const SystemContext& ctx) { bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_position, const SystemContext& ctx) { EntityStateComponent* ent_state = entity.get_component(); Movement* movement = entity.get_component(); - + IntentComponent* intent = entity.get_component(); + if (!ent_state) { LOG_WARN("Entity %u missing EntityStateComponent", entity.get_id()); return false; @@ -74,42 +76,9 @@ bool InputSystem::process_movement_input(Entity& entity, const Vec2& target_posi transformed_position = target_position - ctx.map->offset; } - // Attempt to use pathfinding if NavigationService and Map are available - if (ctx.navigation_service && ctx.map) { - // Ensure entity has PathfindingComponent - PathfindingComponent* pathfinding = entity.get_component(); - if (!pathfinding) { - auto pf = std::make_unique(); - entity.add_component(std::move(pf)); - pathfinding = entity.get_component(); - } - - PathRequest request; - request.entity_id = entity.get_id(); - request.current_position = movement->position; - request.destination = transformed_position; - request.entity_pathing_radius = 0.5f; - - if (ctx.navigation_service->MakeRequest(request)) { - // Transition to pathfinding state - ent_state->current_state = EntityState::PATHFINDING_WAITING; - ent_state->state_duration_ms = 0.0f; - ent_state->target_positions.clear(); - - LOG_INFO("Entity %u requested pathfinding to (%.2f, %.2f)", entity.get_id(), transformed_position.x, transformed_position.y); - return true; - } else { - LOG_WARN("Entity %u failed to request pathfinding", entity.get_id()); - // Fall through to direct movement as fallback - } - } - - // Fallback: Use direct movement if pathfinding unavailable - LOG_DEBUG("Entity %u using direct movement to (%.2f, %.2f) (pathfinding unavailable)", - entity.get_id(), transformed_position.x, transformed_position.y); - ent_state->current_state = EntityState::MOVING; - ent_state->target_positions.clear(); - ent_state->target_positions.push_back(transformed_position); + + intent->type = IntentType::MOVE_TO_POSITION; + intent->target_position = transformed_position; return true; } diff --git a/src/systems/core/movement_system.cpp b/src/systems/core/movement_system.cpp index f815d4d..f7c3f59 100644 --- a/src/systems/core/movement_system.cpp +++ b/src/systems/core/movement_system.cpp @@ -5,7 +5,6 @@ #include #include #include -#include #include #include #include @@ -24,367 +23,80 @@ namespace { // ============================================================================ void MovementSystem::update(const SystemContext& ctx) { - // Phase 1: Process pathfinding results and retry requests - process_pathfinding_phase(ctx); - - // Phase 2: Update all moving entities + process_completed_paths(ctx); + auto moving_entities = ctx.entity_manager.get_entities_with_component(); for (auto* entity : moving_entities) { update_entity_movement(ctx, *entity); } } -void MovementSystem::process_pathfinding_phase(const SystemContext& ctx) { - if (!ctx.navigation_service) return; - - // Process completed pathfinding results - process_completed_paths(ctx); - - // Retry pending pathfinding requests - retry_stuck_entities(ctx); -} - -void MovementSystem::process_completed_paths(const SystemContext& ctx) { - std::optional result = ctx.navigation_service->GetResult(); - while (result) { - Entity* entity = ctx.entity_manager.get_entity(result->entity_id); - if (!entity || !entity->has_component()) { - result = ctx.navigation_service->GetResult(); - continue; - } - - PathfindingComponent* pathfinding = entity->get_component(); - EntityStateComponent* entity_state = entity->get_component(); - - pathfinding->waypoints = result->path; - pathfinding->current_waypoint_index = 0; - - if (result->path.empty()) { - LOG_WARN("Entity %u received EMPTY path! Retry count: %u", - entity->get_id(), pathfinding->pathfinding_retry_count); - - // Increment retry counter - pathfinding->pathfinding_retry_count++; - - // On empty path, mark as stuck so it can be retried - if (entity_state) { - entity_state->current_state = EntityState::PATHFINDING_WAITING; - } - } else { - // Successful path received, reset retry counter - pathfinding->pathfinding_retry_count = 0; - - if (entity_state) { - entity_state->current_state = EntityState::MOVING; - entity_state->state_duration_ms = 0.0f; - } - } - - result = ctx.navigation_service->GetResult(); - } -} - -void MovementSystem::retry_stuck_entities(const SystemContext& ctx) { - auto entities = ctx.entity_manager.get_entities_with_component(); - for (auto* entity : entities) { - PathfindingComponent* pathfinding = entity->get_component(); - EntityStateComponent* entity_state = entity->get_component(); - IntentComponent* intent = entity->get_component(); - Movement* movement = entity->get_component(); - - if (!pathfinding || !entity_state || !movement) continue; - - if (entity_state->current_state == EntityState::PATHFINDING_WAITING && - pathfinding->waypoints.empty()) { - - // Only retry up to max retries, don't apply fallback - if (pathfinding->pathfinding_retry_count < PathfindingComponent::MAX_PATHFINDING_RETRIES) { - // Retry pathfinding request - if (intent && intent->type == IntentType::MOVE_TO_OBJECTIVE && - intent->target_spawnpoint_id < ctx.map->spawnpoints.size()) { - request_new_path(*entity, intent->target_spawnpoint_id, ctx.navigation_service, ctx.map); - } else if (intent && intent->type == IntentType::ATTACK_TARGET && ctx.navigation_service) { - PathRequest request; - request.entity_id = entity->get_id(); - request.current_position = movement->position; - request.destination = intent->target_position; - request.entity_pathing_radius = 0.5f; - ctx.navigation_service->MakeRequest(request); - } - } else { - LOG_WARN("Entity %u exceeded max pathfinding retries and will remain stuck on navmesh", entity->get_id()); - } - } - } -} - void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& entity) { Movement* movement = entity.get_component(); PathfindingComponent* pathfinding = entity.get_component(); Stats* stats = entity.get_component(); EntityStateComponent* state_comp = entity.get_component(); - IntentComponent* intent = entity.get_component(); if (!movement || !stats) return; - - // Handle MOVE_TO_OBJECTIVE intent - set up pathfinding to target spawnpoint - if (intent && intent->type == IntentType::MOVE_TO_OBJECTIVE && pathfinding && - pathfinding->waypoints.empty() && intent->target_spawnpoint_id < ctx.map->spawnpoints.size()) { - request_new_path(entity, intent->target_spawnpoint_id, ctx.navigation_service, ctx.map); - return; // Path request submitted, will process next frame - } - - // Handle ATTACK_TARGET intent - request pathfinding to move toward target entity - if (intent && - intent->type == IntentType::ATTACK_TARGET && - intent->target_entity_id != INVALID_ENTITY_ID && - pathfinding && - pathfinding->waypoints.empty() - ) { - // Get the target entity's current position and check distance - Entity* target_entity = ctx.entity_manager.get_entity(intent->target_entity_id); - if (target_entity) { - Movement* target_movement = target_entity->get_component(); - if (target_movement && ctx.navigation_service && ctx.map && movement) { - // Check if already within attack range - float distance_to_target = (target_movement->position - movement->position).length(); - if (distance_to_target < stats->attack_range) { - // Already in range, no pathfinding needed - LOG_DEBUG("Entity %u: Already in attack range of target %u (distance=%.1f, range=%.1f)", - entity.get_id(), intent->target_entity_id, distance_to_target, stats->attack_range); - return; - } - - PathRequest request; - request.entity_id = entity.get_id(); - request.current_position = movement->position; - request.destination = target_movement->position; - request.entity_pathing_radius = 0.5f; - - if (ctx.navigation_service->MakeRequest(request)) { - if (state_comp) { - state_comp->current_state = EntityState::PATHFINDING_WAITING; - } - LOG_DEBUG("Entity %u: Requested pathfinding to attack target %u at (%.1f, %.1f)", - entity.get_id(), intent->target_entity_id, target_movement->position.x, target_movement->position.y); - } - } - } - return; // Path request submitted, will process next frame - } - - // If holding for target, move toward the target entity - if (state_comp && state_comp->current_state == EntityState::HOLDING_FOR_TARGET && - state_comp->target_entity_id != INVALID_ENTITY_ID) { - Entity* target = ctx.entity_manager.get_entity(state_comp->target_entity_id); - if (target) { - Movement* target_movement = target->get_component(); - if (target_movement) { - // Move toward target - Vec2 direction = target_movement->position - movement->position; - float distance = direction.length(); - - if (distance > 0.1f) { - Vec2 normalized_dir = direction.normalized(); - float move_speed = stats->move_speed; - float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); - movement->position = movement->position + (normalized_dir * distance_to_move); - } - } - } - return; // Don't process other movement - } - - // Handle movement during ATTACKING state (kiting) - if (state_comp && state_comp->current_state == EntityState::ATTACKING) { - // Check if entity has AutoAttackComponent and kiting is enabled - auto* auto_attack = entity.get_component(); - if (auto_attack && auto_attack->allow_kiting && auto_attack->kite_while_attacking) { - // Move toward target with reduced speed - if (state_comp->target_entity_id != INVALID_ENTITY_ID) { - Entity* target = ctx.entity_manager.get_entity(state_comp->target_entity_id); - if (target) { - Movement* target_movement = target->get_component(); - if (target_movement) { - // Move toward target at reduced speed - Vec2 direction = target_movement->position - movement->position; - float distance = direction.length(); - - if (distance > 0.1f) { - Vec2 normalized_dir = direction.normalized(); - float base_move_speed = stats->move_speed * auto_attack->movement_during_attack; - float distance_to_move = base_move_speed * (ctx.delta_time_ms / 1000.0f); - movement->position = movement->position + (normalized_dir * distance_to_move); - } - } - } - } - } - return; // Stop other movement processing during attack - } - - // Update direct movement targets (players, point-based movement) - if (state_comp && state_comp->current_state == EntityState::MOVING && - !state_comp->target_positions.empty()) { - update_direct_movement(ctx, entity, *movement, *stats, *state_comp); + + // No movement -> nothing to do + if (!movement->target.has_value()) { return; } - - // Update pathfinding entities (minions following waypoints) - // TODO: Differentiate between minions and other pathfinding entities (AI Component?) -- cmkrist 18/11/2025 - if (pathfinding && state_comp && state_comp->current_state == EntityState::MOVING) { - update_stuck_detection(ctx, entity, *movement, *pathfinding, state_comp); - update_waypoint_movement(ctx, entity, *movement, *stats, *pathfinding, state_comp); - } -} -void MovementSystem::update_direct_movement(const SystemContext& ctx, Entity& entity, - Movement& movement, Stats& stats, EntityStateComponent& state_comp) { - Vec2 current_pos = movement.position; - Vec2 target_pos = state_comp.target_positions.at(0); - Vec2 direction = target_pos - current_pos; - float distance = direction.length(); - - // Check if reached target - if (distance < TARGET_THRESHOLD) { - state_comp.target_positions.erase(state_comp.target_positions.begin()); - - // Transition to IDLE when all targets are reached - // Separate system? -- cmkrist 18/11/2025 - if (state_comp.target_positions.empty()) { - state_comp.current_state = EntityState::IDLE; - state_comp.state_duration_ms = 0.0f; - LOG_DEBUG("Entity %u reached destination, transitioning to IDLE", entity.get_id()); - } + // Entity has arrived at target -> stop moving + if((movement->position - movement->target.value()).length() <= TARGET_THRESHOLD) { + movement->target.reset(); return; } - - // Calculate new position based on speed - float move_speed = stats.move_speed; - float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); - - Vec2 new_position = (distance_to_move >= distance) - ? target_pos - : current_pos + (direction.normalized() * distance_to_move); - - movement.position = new_position; -} -void MovementSystem::update_stuck_detection(const SystemContext& ctx, Entity& entity, - Movement& movement, PathfindingComponent& pathfinding, - EntityStateComponent* entity_state) { - float movement_distance = (movement.position - pathfinding.last_position).length(); - - if (movement_distance < STUCK_DETECTION_THRESHOLD) { - // Entity hasn't moved - accumulate stuck time - pathfinding.stuck_time_ms += ctx.delta_time_ms; - - // Check if stuck long enough to request new path - if (pathfinding.stuck_time_ms >= PathfindingComponent::STUCK_THRESHOLD_MS && - entity_state && entity_state->current_state == EntityState::MOVING && - !pathfinding.waypoints.empty() && ctx.navigation_service && ctx.map && - pathfinding.target_spawnpoint_id < ctx.map->spawnpoints.size()) { - - LOG_DEBUG("Entity %u is stuck, requesting new path", entity.get_id()); - request_new_path(entity, pathfinding.target_spawnpoint_id, ctx.navigation_service, ctx.map); - - if (entity_state) { - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - pathfinding.waypoints.clear(); - pathfinding.current_waypoint_index = 0; - } - } else { - // Entity moved - reset stuck timer - pathfinding.stuck_time_ms = 0.0f; + // Entities without pathfinding move straight towards the target + if(!pathfinding) { + update_direct_movement(ctx, entity, *movement, movement->target.value(), *stats, *state_comp); + return; } - - // Update last position for next frame - pathfinding.last_position = movement.position; -} -void MovementSystem::update_waypoint_movement(const SystemContext& ctx, Entity& entity, - Movement& movement, Stats& stats, - PathfindingComponent& pathfinding, - EntityStateComponent* entity_state) { - // Skip if waiting for pathfinding or not in MOVING state - if (!pathfinding.waypoints.size() || - !entity_state || entity_state->current_state != EntityState::MOVING) { + // Pathfinding unit, so find a path + + // Entity has already requested a path and is waiting for a response, so no movement this frame + if(pathfinding->waiting_for_path) { return; } - - // If we have ATTACK_TARGET intent and are in MOVING state, check if we should stop due to attack range - auto* intent = entity.get_component(); - if (intent && intent->type == IntentType::ATTACK_TARGET && intent->target_entity_id != INVALID_ENTITY_ID) { - Entity* target_entity = ctx.entity_manager.get_entity(intent->target_entity_id); - if (target_entity) { - Movement* target_movement = target_entity->get_component(); - if (target_movement) { - float distance_to_target = (target_movement->position - movement.position).length(); - if (distance_to_target < stats.attack_range) { - // We're now in attack range - clear waypoints and stop moving - pathfinding.waypoints.clear(); - pathfinding.current_waypoint_index = 0; - LOG_DEBUG("Entity %u: Reached attack range of target %u, stopping movement", - entity.get_id(), intent->target_entity_id); - return; - } - } - } + + // No path, or path to incorrect target + if(pathfinding->waypoints.empty() || pathfinding->waypoints[pathfinding->waypoints.size() - 1] != movement->target.value()) { + request_new_path(entity, movement->target.value(), ctx.navigation_service); + return; // Path request submitted, will process next frame } - - // Check if reached end of path - if (pathfinding.current_waypoint_index >= pathfinding.waypoints.size()) { - request_path_to_next_spawnpoint(ctx, entity, pathfinding, entity_state); - return; + + // Entity is on correct path, keep moving + Vec2 next_stop = pathfinding->waypoints.front(); + + if(next_stop.distance_to(movement->position) < WAYPOINT_THRESHOLD) { + pathfinding->waypoints.erase(pathfinding->waypoints.begin()); } - - // Move toward current waypoint - Vec2 current_waypoint = pathfinding.waypoints[pathfinding.current_waypoint_index]; + // Update direct movement targets (players, point-based movement) + update_direct_movement(ctx, entity, *movement, next_stop, *stats, *state_comp); +} + +void MovementSystem::update_direct_movement(const SystemContext& ctx, Entity& entity, + Movement& movement, Vec2 target, Stats& stats, EntityStateComponent& state_comp) { Vec2 current_pos = movement.position; - Vec2 direction = current_waypoint - current_pos; + Vec2 target_pos = target; + Vec2 direction = target_pos - current_pos; float distance = direction.length(); - // Check if reached waypoint - if (distance < WAYPOINT_THRESHOLD) { - pathfinding.current_waypoint_index++; - return; - } - // Calculate new position based on speed float move_speed = stats.move_speed; float distance_to_move = move_speed * (ctx.delta_time_ms / 1000.0f); Vec2 new_position = (distance_to_move >= distance) - ? current_waypoint + ? target_pos : current_pos + (direction.normalized() * distance_to_move); movement.position = new_position; } -void MovementSystem::request_path_to_next_spawnpoint(const SystemContext& ctx, Entity& entity, - PathfindingComponent& pathfinding, - EntityStateComponent* entity_state) { - if (!ctx.map || pathfinding.target_spawnpoint_id >= ctx.map->spawnpoints.size()) { - return; - } - - uint32_t next_spawnpoint = (pathfinding.target_spawnpoint_id + 1) % ctx.map->spawnpoints.size(); - if (ctx.navigation_service && entity_state) { - request_new_path(entity, next_spawnpoint, ctx.navigation_service, ctx.map); - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - - pathfinding.waypoints.clear(); - pathfinding.current_waypoint_index = 0; -} - -// ============================================================================ -// Utility Functions -// ============================================================================ - // ============================================================================ // Utility Functions // ============================================================================ @@ -422,33 +134,39 @@ bool MovementSystem::has_collision(const Entity& entity, const Vec2& proposed_po return false; // No collision } -void MovementSystem::request_new_path(Entity& entity, uint32_t target_spawnpoint_id, NavigationService* navigation_service, const Map* map) { - if (!navigation_service || !map || target_spawnpoint_id >= map->spawnpoints.size()) { +void MovementSystem::process_completed_paths(const SystemContext& ctx) { + std::optional result = ctx.navigation_service->GetResult(); + while (result) { + Entity* entity = ctx.entity_manager.get_entity(result->entity_id); + if (!entity || !entity->has_component()) { + result = ctx.navigation_service->GetResult(); + continue; + } + + PathfindingComponent* pathfinding = entity->get_component(); + pathfinding->waypoints = result->path; + pathfinding->waiting_for_path = false; + + result = ctx.navigation_service->GetResult(); + } +} + +void MovementSystem::request_new_path(Entity& entity, Vec2 target, NavigationService* navigation_service) { + if (!navigation_service) { return; } Movement* movement = entity.get_component(); PathfindingComponent* pathfinding = entity.get_component(); - if (!movement || !pathfinding) { - return; - } - - Vec2 goal_2d = map->spawnpoints[target_spawnpoint_id]; - PathRequest request; request.entity_id = entity.get_id(); request.current_position = movement->position; - request.destination = goal_2d; + request.destination = target; request.entity_pathing_radius = 0.5f; if (navigation_service->MakeRequest(request)) { - EntityStateComponent* entity_state = entity.get_component(); - if (entity_state) { - entity_state->current_state = EntityState::PATHFINDING_WAITING; - entity_state->state_duration_ms = 0.0f; - } - pathfinding->target_spawnpoint_id = target_spawnpoint_id; - LOG_DEBUG("Entity %u requested path to spawnpoint %u", entity.get_id(), target_spawnpoint_id); + pathfinding->waypoints.clear(); + pathfinding->waiting_for_path = true; } } \ No newline at end of file diff --git a/src/systems/core/movement_system.hpp b/src/systems/core/movement_system.hpp index de5ba19..9684250 100644 --- a/src/systems/core/movement_system.hpp +++ b/src/systems/core/movement_system.hpp @@ -11,15 +11,16 @@ #include /** - * System to handle entity movement along pathfinding waypoints. - * Updates positions based on movement speed and follows path waypoints. - * Automatically requests new paths when reaching target spawnpoints. + * System to handle entity movement. + * Updates positions based on movement speed and follows path waypoints + * for pathfinding units. */ class MovementSystem { public: /** * Update all moving entities. - * Moves entities toward their current waypoints and handles path progression. + * Moves pathfinding entities toward their current waypoints and handles path progression. + * Moves entites without pathfinding directly towards their target positions * @param ctx System context containing entity manager, navigation service, and map */ void update(const SystemContext& ctx); @@ -29,21 +30,11 @@ class MovementSystem { // Phase processors // ======================================================================== - /** - * Process pathfinding-related updates (results and retries). - */ - void process_pathfinding_phase(const SystemContext& ctx); - /** * Process completed pathfinding results from NavigationService. */ static void process_completed_paths(const SystemContext& ctx); - /** - * Retry pending pathfinding requests for stuck entities. - */ - static void retry_stuck_entities(const SystemContext& ctx); - // ======================================================================== // Entity movement handlers // ======================================================================== @@ -56,35 +47,19 @@ class MovementSystem { /** * Update direct movement (player movement to target positions). */ - static void update_direct_movement(const SystemContext& ctx, Entity& entity, Movement& movement, Stats& stats, EntityStateComponent& state_comp); - - /** - * Update stuck detection and trigger repath if needed. - */ - void update_stuck_detection(const SystemContext& ctx, Entity& entity, Movement& movement, PathfindingComponent& pathfinding, EntityStateComponent* entity_state); - - /** - * Update waypoint-based movement (minion path following). - */ - static void update_waypoint_movement(const SystemContext& ctx, Entity& entity, Movement& movement, Stats& stats, PathfindingComponent& pathfinding, EntityStateComponent* entity_state); - - /** - * Request path to next spawnpoint when current waypoints exhausted. - */ - static void request_path_to_next_spawnpoint(const SystemContext& ctx, Entity& entity, PathfindingComponent& pathfinding, EntityStateComponent* entity_state); + static void update_direct_movement(const SystemContext& ctx, Entity& entity, Movement& movement, Vec2 target, Stats& stats, EntityStateComponent& state_comp); // ======================================================================== // Utility functions // ======================================================================== /** - * Request a new path for an entity to a target spawnpoint. + * Request a new path for an entity to a target position. * @param entity The entity requesting a path - * @param target_spawnpoint_id Target spawnpoint index + * @param target Target position * @param navigation_service Navigation service to queue the request - * @param map Map containing spawnpoint information */ - static void request_new_path(Entity& entity, uint32_t target_spawnpoint_id, NavigationService* navigation_service, const Map* map); + static void request_new_path(Entity& entity, Vec2 target, NavigationService* navigation_service); /** * Check for collision with other entities. diff --git a/src/systems/core/npc_system.cpp b/src/systems/core/npc_system.cpp new file mode 100644 index 0000000..a3656cc --- /dev/null +++ b/src/systems/core/npc_system.cpp @@ -0,0 +1,85 @@ +#include "npc_system.hpp" + +#include "components/npc_component.hpp" +#include "intent.hpp" + +void NPCSystem::update(const SystemContext& ctx) { + auto npc_entities = ctx.entity_manager.get_entities_with_component(); + + for(auto entity : npc_entities) { + if(entity->get_component()->npc_type == NPCType::MINION) { + handle_minion_update(ctx, entity); + } + } +} + + +void NPCSystem::handle_minion_update(const SystemContext& ctx, Entity* entity) { + NPCComponent* npc_component = entity->get_component(); + IntentComponent* intent = entity->get_component(); + Movement* movement = entity->get_component(); + Stats* stats = entity->get_component(); + + // Currently attacking an enemy unit + if(intent->type == IntentType::ATTACK_TARGET) { + Entity* target = ctx.entity_manager.get_entity(intent->target_entity_id); + + if(!target || !target->get_component() || target->get_component()->health <= 0.0f) { + // Current target is dead, continue pathing + intent->type = IntentType::MOVE_TO_POSITION; + intent->target_position = npc_component->objective; + } + + // Make sure entity is not chasing too far away + if((npc_component->objective - movement->position).length() >= npc_component->chase_distance) { + intent->type = IntentType::MOVE_TO_POSITION; + intent->target_position = npc_component->objective; + return; + } + + // Not chasing too far, keep attacking + return; + } + + // Not attacking anything, so keep following the path but aggress on targets in range + if(intent->type == IntentType::MOVE_TO_POSITION) { + float distance_to_target = npc_component->aggression_range; + EntityID id = INVALID_ENTITY_ID; + + // If an enemy entity is in range, attack them instead of running further + // TODO get entities in vicinity, not all of them... - ploinky 27.11.2025 + for (const auto& entity_pair : ctx.entity_manager.get_all_entities()) { + const Entity& other_entity = entity_pair.second; + + // Do not attack allies, entities without stats or self + if(other_entity.get_id() == entity->get_id() + || !other_entity.get_component() + || (other_entity.get_component()->team_id == stats->team_id)) { + continue; + } + + const Movement* other_movement = other_entity.get_component(); + float distance_to_other = (other_movement->position - movement->position).length(); + + // Found enemy, check range + if(distance_to_other <= distance_to_target) { + id = other_entity.get_id(); + distance_to_target = distance_to_other; + } + } + + // Found a target in aggression range, attack + if(id != INVALID_ENTITY_ID) { + intent->type = IntentType::ATTACK_TARGET; + intent->target_entity_id = id; + return; + } + } + + // If nothing else, back to objective + if(intent->type == IntentType::NONE) { + intent->type = IntentType::MOVE_TO_POSITION; + intent->target_position = npc_component->objective; + return; + } +} \ No newline at end of file diff --git a/src/systems/core/npc_system.hpp b/src/systems/core/npc_system.hpp new file mode 100644 index 0000000..675b59b --- /dev/null +++ b/src/systems/core/npc_system.hpp @@ -0,0 +1,28 @@ +#pragma once + +#include "system_context.hpp" + +/** + * NPC System - handles NPC entity behavior. + * + * Handles all entities with NPCComponents. Analyses their + * type and determines what they should do next. + */ +class NPCSystem { +public: + NPCSystem() = default; + ~NPCSystem() = default; + + // Prevent copying + NPCSystem(const NPCSystem&) = delete; + NPCSystem& operator=(const NPCSystem&) = delete; + + // Allow moving + NPCSystem(NPCSystem&&) = default; + NPCSystem& operator=(NPCSystem&&) = default; + + void update(const SystemContext& ctx); + +private: + void handle_minion_update(const SystemContext& ctx, Entity* entity); +}; \ No newline at end of file diff --git a/src/systems/core/spawning_system.cpp b/src/systems/core/spawning_system.cpp index aa4c574..97d2135 100644 --- a/src/systems/core/spawning_system.cpp +++ b/src/systems/core/spawning_system.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, @@ -39,16 +40,16 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, LOG_INFO("Spawned minion (ID %u) with health=%f, max_health=%f, team=%u", entity_id, stats->health, stats->max_health, team_id); } - // Adjust intent objective target based on team // Team 1 moves toward spawnpoint 1, Team 2 moves toward spawnpoint 0 (opposite direction) - auto* intent = entity.get_component(); - if (intent && intent->type == IntentType::MOVE_TO_OBJECTIVE) { - intent->target_spawnpoint_id = (team_id == 1) ? 1 : 0; - LOG_DEBUG("Entity %u (team %u): Set objective target to spawnpoint %u", - entity_id, team_id, intent->target_spawnpoint_id); + auto* npc = entity.get_component(); + if (npc && npc->npc_type == NPCType::MINION) { + npc->objective = (team_id == 1) ? Vec2(0, 28) : Vec2(0, -28); + LOG_DEBUG("Entity %u (team %u): Set objective target to <%f, %f>", + entity_id, team_id, npc->objective.x, npc->objective.y); } + // Add network entity component for syncing if (!entity.has_component()) { auto net_comp = std::make_unique(); diff --git a/src/systems/gameplay_coordinator.cpp b/src/systems/gameplay_coordinator.cpp index 6bda5cc..55355c3 100644 --- a/src/systems/gameplay_coordinator.cpp +++ b/src/systems/gameplay_coordinator.cpp @@ -19,6 +19,7 @@ void GameplayCoordinator::update(const SystemContext& ctx) { // INPUT & AI SYSTEMS input_system_.update(ctx); + npc_system_.update(ctx); brain_system_.update(ctx); // Process NPC intents // ENGINE SYSTEMS diff --git a/src/systems/gameplay_coordinator.hpp b/src/systems/gameplay_coordinator.hpp index 750e227..d4e68fc 100644 --- a/src/systems/gameplay_coordinator.hpp +++ b/src/systems/gameplay_coordinator.hpp @@ -6,6 +6,7 @@ // Input & AI #include #include +#include // Spawning #include @@ -147,6 +148,7 @@ class GameplayCoordinator { private: InputSystem input_system_; + NPCSystem npc_system_; std::unique_ptr wave_system_; BrainSystem brain_system_; CollisionSystem collision_system_; diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index 41231ec..e237279 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -41,64 +40,16 @@ static NPCType string_to_npc_type(const std::string& str) { return NPCType::MINION; } -/** - * Convert string to AIPersonality enum. - * @param str The string to convert (case-insensitive) - * @return AIPersonality enum value, defaults to BALANCED if unrecognized - */ -static NPCComponent::AIPersonality string_to_ai_personality(const std::string& str) { - if (str == "passive") { - return NPCComponent::AIPersonality::PASSIVE; - } else if (str == "defensive") { - return NPCComponent::AIPersonality::DEFENSIVE; - } else if (str == "aggressive") { - return NPCComponent::AIPersonality::AGGRESSIVE; - } else if (str == "zealous") { - return NPCComponent::AIPersonality::ZEALOUS; - } - // Default to BALANCED for unrecognized or empty strings - return NPCComponent::AIPersonality::BALANCED; -} - -/** - * Convert string to TargetPriority enum. - * @param str The string to convert (case-insensitive) - * @return TargetPriority enum value, defaults to NEAREST if unrecognized - */ -static TargetComponent::TargetPriority string_to_target_priority(const std::string& str) { - if (str == "lowest_health") { - return TargetComponent::TargetPriority::LOWEST_HEALTH; - } else if (str == "highest_threat") { - return TargetComponent::TargetPriority::HIGHEST_THREAT; - } else if (str == "highest_damage") { - return TargetComponent::TargetPriority::HIGHEST_DAMAGE; - } - // Default to NEAREST for unrecognized or empty strings - return TargetComponent::TargetPriority::NEAREST; -} - /** * Convert string to IntentType enum. * @param str The string to convert (case-insensitive) * @return IntentType enum value, defaults to NONE if unrecognized */ static IntentType string_to_intent_type(const std::string& str) { - if (str == "move_to_objective") { - return IntentType::MOVE_TO_OBJECTIVE; - } else if (str == "move_to_position") { + if (str == "move_to_position") { return IntentType::MOVE_TO_POSITION; - } else if (str == "move_to_spawnpoint") { - return IntentType::MOVE_TO_SPAWNPOINT; } else if (str == "attack_target") { return IntentType::ATTACK_TARGET; - } else if (str == "defend_position") { - return IntentType::DEFEND_POSITION; - } else if (str == "chase_enemy") { - return IntentType::CHASE_ENEMY; - } else if (str == "retreat") { - return IntentType::RETREAT; - } else if (str == "patrol") { - return IntentType::PATROL; } // Default to NONE for unrecognized or empty strings return IntentType::NONE; @@ -191,32 +142,14 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { if(!npc_node.empty()) { std::shared_ptr npc = std::make_shared(); LOAD_ENUM_ATTRIBUTE(npc_node, npc, npc_type, string_to_npc_type) - LOAD_ATTRIBUTE(npc_node, npc, aggressive, bool) - LOAD_ATTRIBUTE(npc_node, npc, retaliate_only, bool) LOAD_ATTRIBUTE(npc_node, npc, aggression_range, float) - LOAD_ATTRIBUTE(npc_node, npc, retreat_range, float) - LOAD_ENUM_ATTRIBUTE(npc_node, npc, personality, string_to_ai_personality) LOAD_ATTRIBUTE(npc_node, npc, chase_distance, float) temp.component_templates.push_back(npc); } - pugi::xml_node auto_attack_node = rootNode.child("auto_attack"); - if(!auto_attack_node.empty()) { - std::shared_ptr auto_attack = std::make_shared(); - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, enabled, bool) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, combat_timeout_ms, float) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, base_damage_multiplier, float) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, bonus_damage, float) - LOAD_ENUM_ATTRIBUTE(auto_attack_node, auto_attack, damage_type, string_to_damage_type) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, attack_animation_duration_ms, float) - LOAD_ATTRIBUTE(auto_attack_node, auto_attack, hit_timing_percent, float) - temp.component_templates.push_back(auto_attack); - } - pugi::xml_node target_node = rootNode.child("target"); if(!target_node.empty()) { std::shared_ptr target = std::make_shared(); - LOAD_ENUM_ATTRIBUTE(target_node, target, targeting_mode, string_to_target_priority) LOAD_ATTRIBUTE(target_node, target, target_search_interval_ms, float) temp.component_templates.push_back(target); } @@ -278,29 +211,6 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { // Load optional intent parameters LOAD_ENUM_ATTRIBUTE(intent_node, intent, type, string_to_intent_type) - LOAD_ENUM_ATTRIBUTE(intent_node, intent, priority, [](const std::string& s) { - if (s == "lowest") return IntentPriority::LOWEST; - if (s == "low") return IntentPriority::LOW; - if (s == "high") return IntentPriority::HIGH; - if (s == "critical") return IntentPriority::CRITICAL; - return IntentPriority::NORMAL; - }) - LOAD_ATTRIBUTE(intent_node, intent, max_duration_ms, float) - LOAD_ATTRIBUTE(intent_node, intent, min_range, float) - LOAD_ATTRIBUTE(intent_node, intent, max_range, float) - LOAD_ATTRIBUTE(intent_node, intent, tolerance, float) - - // Load target_spawnpoint_id for MOVE_TO_OBJECTIVE and similar - pugi::xml_attribute target_sp = intent_node.attribute("target_spawnpoint_id"); - if(!target_sp.empty()) { - intent->target_spawnpoint_id = target_sp.as_uint(); - } - - // Load objective_index for lane progression - pugi::xml_attribute obj_idx = intent_node.attribute("objective_index"); - if(!obj_idx.empty()) { - intent->objective_index = obj_idx.as_uint(); - } LOG_DEBUG("Loaded Intent component: type=%d", static_cast(intent->type)); } diff --git a/src/systems/util/targeting_utility.cpp b/src/systems/util/targeting_utility.cpp index 6c01cbc..6e51003 100644 --- a/src/systems/util/targeting_utility.cpp +++ b/src/systems/util/targeting_utility.cpp @@ -1,7 +1,6 @@ #include #include #include -#include #include #include #include From 3e79d9fd98c933ed9db991579aff29199bcc7059 Mon Sep 17 00:00:00 2001 From: ploinky Date: Mon, 1 Dec 2025 11:44:46 +0100 Subject: [PATCH 61/79] Do not recalculate pathing too often --- src/systems/core/movement_system.cpp | 2 +- src/systems/core/movement_system.hpp | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/systems/core/movement_system.cpp b/src/systems/core/movement_system.cpp index f7c3f59..d37f120 100644 --- a/src/systems/core/movement_system.cpp +++ b/src/systems/core/movement_system.cpp @@ -64,7 +64,7 @@ void MovementSystem::update_entity_movement(const SystemContext& ctx, Entity& en } // No path, or path to incorrect target - if(pathfinding->waypoints.empty() || pathfinding->waypoints[pathfinding->waypoints.size() - 1] != movement->target.value()) { + if(pathfinding->waypoints.empty() || (pathfinding->waypoints[pathfinding->waypoints.size() - 1] - movement->target.value()).length() > REPATH_DISTANCE) { request_new_path(entity, movement->target.value(), ctx.navigation_service); return; // Path request submitted, will process next frame } diff --git a/src/systems/core/movement_system.hpp b/src/systems/core/movement_system.hpp index 9684250..082c8ed 100644 --- a/src/systems/core/movement_system.hpp +++ b/src/systems/core/movement_system.hpp @@ -10,6 +10,10 @@ #include "system_context.hpp" #include +// Determines how far the end point of the current path may be +// off the current movement target before recalculating the path +#define REPATH_DISTANCE 1.0f + /** * System to handle entity movement. * Updates positions based on movement speed and follows path waypoints From 30a9fc3446b89b8b814bebe6ef6b4e21ac4fe66f Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 2 Dec 2025 08:03:19 -0500 Subject: [PATCH 62/79] Add Navigational Grid to existing systems --- src/components/map.hpp | 11 ++ src/services/astar_pathfinding.cpp | 166 +++++++++++++--------------- src/services/astar_pathfinding.hpp | 19 +++- src/services/navigation_service.cpp | 22 +++- src/systems/util/map_system.cpp | 120 ++++++++++++++++++++ src/systems/util/map_system.hpp | 9 ++ 6 files changed, 258 insertions(+), 89 deletions(-) diff --git a/src/components/map.hpp b/src/components/map.hpp index cf6500f..a4a9416 100644 --- a/src/components/map.hpp +++ b/src/components/map.hpp @@ -25,5 +25,16 @@ struct Map : public Component { Vec2 size = Vec2(0.0f, 0.0f); //width, height Vec2 offset = Vec2(0.0f, 0.0f); // 1/2 width, 1/2 height - cmkrist 15/11/2025 + // ===== Spatial Grid (computed at load time) ===== + // 2D grid of polygon IDs for fast point-in-polygon queries. + // Grid layout: grid_cells[y * grid_width + x] = {polygon_ids} + // Computed once at map load, never modified afterwards. + + std::vector> grid_cells; // grid_cells[index] = list of polygon IDs + Vec2 grid_origin; // World position of grid origin (bottom-left) + float grid_cell_size = 50.0f; // Size of each grid cell in world units + int grid_width = 0; // Number of cells in X direction + int grid_height = 0; // Number of cells in Y direction + COMPONENT_TYPE_ID(Map, 2005) }; diff --git a/src/services/astar_pathfinding.cpp b/src/services/astar_pathfinding.cpp index 94414ec..233cb7a 100644 --- a/src/services/astar_pathfinding.cpp +++ b/src/services/astar_pathfinding.cpp @@ -6,7 +6,8 @@ std::vector AStarPathfinder::FindPath( const Vec2& goal_pos, const std::vector& vertices, const std::vector>& polygons, - float entity_radius + float entity_radius, + const NavGrid* grid ) { // Handle edge cases if (vertices.empty() || polygons.empty()) { @@ -22,88 +23,98 @@ std::vector AStarPathfinder::FindPath( return {start_pos, goal_pos}; } - // Find which polygon contains the start position - int start_polygon = -1; - for (int i = 0; i < static_cast(polygons.size()); ++i) { - std::vector poly_verts; - for (uint32_t vertex_idx : polygons[i]) { - if (vertex_idx < vertices.size()) { - poly_verts.push_back(vertices[vertex_idx]); - } - } - if (PointInPolygon(start_pos, poly_verts)) { - start_polygon = i; - break; + // Helper lambda to find polygon containing position using grid + auto FindPolygonContainingPoint = [&](const Vec2& pos) -> uint32_t { + if (!grid || !grid->IsBuilt()) { + return UINT32_MAX; } - } - - // Find which polygon contains the goal position - int goal_polygon = -1; - for (int i = 0; i < static_cast(polygons.size()); ++i) { - std::vector poly_verts; - for (uint32_t vertex_idx : polygons[i]) { - if (vertex_idx < static_cast(vertices.size())) { - poly_verts.push_back(vertices[vertex_idx]); + + Vec2 rel_pos = pos - grid->grid_origin; + int gx = static_cast(std::floor(rel_pos.x / grid->grid_cell_size)); + int gy = static_cast(std::floor(rel_pos.y / grid->grid_cell_size)); + + gx = std::max(0, std::min(gx, grid->grid_width - 1)); + gy = std::max(0, std::min(gy, grid->grid_height - 1)); + + int cell_index = gy * grid->grid_width + gx; + if (cell_index >= 0 && cell_index < static_cast(grid->grid_cells.size())) { + const auto& candidates = grid->grid_cells[cell_index]; + for (uint32_t poly_id : candidates) { + if (poly_id < polygons.size()) { + std::vector poly_verts; + for (uint32_t vertex_idx : polygons[poly_id]) { + if (vertex_idx < vertices.size()) { + poly_verts.push_back(vertices[vertex_idx]); + } + } + if (PointInPolygon(pos, poly_verts)) { + return poly_id; + } + } } } - if (PointInPolygon(goal_pos, poly_verts)) { - goal_polygon = i; - break; - } - } - - LOG_DEBUG("A*: start_polygon=%d, goal_polygon=%d for path (%.1f, %.1f) -> (%.1f, %.1f)", - start_polygon, goal_polygon, start_pos.x, start_pos.y, goal_pos.x, goal_pos.y); + return UINT32_MAX; + }; - // If either position is not in a polygon, try to find the closest polygon - if (start_polygon == -1) { + // Helper lambda to find closest polygon to a position + auto FindClosestPolygon = [&](const Vec2& pos) -> int { float closest_dist = std::numeric_limits::max(); + int closest_idx = -1; + for (int i = 0; i < static_cast(polygons.size()); ++i) { - Vec2 centroid = GetPolygonCentroid(std::vector{}); + std::vector poly_verts; for (uint32_t vertex_idx : polygons[i]) { if (vertex_idx < vertices.size()) { - centroid.x += vertices[vertex_idx].x; - centroid.y += vertices[vertex_idx].y; + poly_verts.push_back(vertices[vertex_idx]); } } - centroid.x /= polygons[i].size(); - centroid.y /= polygons[i].size(); - - float dist = start_pos.distance_to(centroid); + Vec2 centroid = GetPolygonCentroid(poly_verts); + float dist = pos.distance_to(centroid); if (dist < closest_dist) { closest_dist = dist; - start_polygon = i; + closest_idx = i; } } - } + return closest_idx; + }; - if (goal_polygon == -1) { - float closest_dist = std::numeric_limits::max(); - for (int i = 0; i < static_cast(polygons.size()); ++i) { - Vec2 centroid; - for (uint32_t vertex_idx : polygons[i]) { - if (vertex_idx < vertices.size()) { - centroid.x += vertices[vertex_idx].x; - centroid.y += vertices[vertex_idx].y; - } - } - centroid.x /= polygons[i].size(); - centroid.y /= polygons[i].size(); + // Find which polygons contain start and goal positions + uint32_t start_polygon = FindPolygonContainingPoint(start_pos); + uint32_t goal_polygon = FindPolygonContainingPoint(goal_pos); - float dist = goal_pos.distance_to(centroid); - if (dist < closest_dist) { - closest_dist = dist; - goal_polygon = i; - } - } + LOG_DEBUG("A*: start_polygon=%u, goal_polygon=%u for path (%.1f, %.1f) -> (%.1f, %.1f)", + start_polygon, goal_polygon, start_pos.x, start_pos.y, goal_pos.x, goal_pos.y); + + // If either position is not in a polygon, try to find the closest polygon + if (start_polygon == UINT32_MAX) { + int closest = FindClosestPolygon(start_pos); + start_polygon = (closest >= 0) ? static_cast(closest) : UINT32_MAX; + } + + if (goal_polygon == UINT32_MAX) { + int closest = FindClosestPolygon(goal_pos); + goal_polygon = (closest >= 0) ? static_cast(closest) : UINT32_MAX; } - if (start_polygon == -1 || goal_polygon == -1) { + if (start_polygon == UINT32_MAX || goal_polygon == UINT32_MAX) { // Fallback: return direct path since we couldn't locate in polygons // This can happen if spawnpoints are outside the navmesh or on edges return {start_pos, goal_pos}; } + // Pre-compute polygon centroids to avoid redundant calculations + std::vector polygon_centroids; + polygon_centroids.reserve(polygons.size()); + for (const auto& polygon : polygons) { + std::vector verts; + for (uint32_t idx : polygon) { + if (idx < vertices.size()) { + verts.push_back(vertices[idx]); + } + } + polygon_centroids.push_back(GetPolygonCentroid(verts)); + } + // A* algorithm on polygon graph std::priority_queue, std::greater> open_set; std::unordered_map g_costs; @@ -114,7 +125,7 @@ std::vector AStarPathfinder::FindPath( Node start_node; start_node.polygon_id = start_polygon; start_node.g_cost = 0.0f; - start_node.h_cost = Heuristic(start_pos, goal_pos); + start_node.h_cost = Heuristic(polygon_centroids[start_polygon], goal_pos); start_node.parent_polygon = UINT32_MAX; start_node.is_start = true; start_node.is_goal = (start_polygon == goal_polygon); @@ -161,7 +172,7 @@ std::vector AStarPathfinder::FindPath( } in_closed_set[current.polygon_id] = true; - // Check all neighbors + // Check only adjacent neighbors, not all polygons for (uint32_t neighbor_id = 0; neighbor_id < polygons.size(); ++neighbor_id) { if (in_closed_set[neighbor_id]) { continue; @@ -171,30 +182,9 @@ std::vector AStarPathfinder::FindPath( continue; } - // Calculate cost to neighbor - Vec2 current_center = GetPolygonCentroid( - [&]() { - std::vector verts; - for (uint32_t idx : polygons[current.polygon_id]) { - if (idx < vertices.size()) { - verts.push_back(vertices[idx]); - } - } - return verts; - }() - ); - - Vec2 neighbor_center = GetPolygonCentroid( - [&]() { - std::vector verts; - for (uint32_t idx : polygons[neighbor_id]) { - if (idx < vertices.size()) { - verts.push_back(vertices[idx]); - } - } - return verts; - }() - ); + // Use pre-computed centroids + const Vec2& current_center = polygon_centroids[current.polygon_id]; + const Vec2& neighbor_center = polygon_centroids[neighbor_id]; float move_cost = current_center.distance_to(neighbor_center); float new_g_cost = g_costs[current.polygon_id] + move_cost; @@ -266,14 +256,16 @@ bool AStarPathfinder::ArePolygonsAdjacent( const std::vector& poly2 ) { // Two polygons are adjacent if they share at least 2 vertices (an edge) + // Use early termination for faster rejection of non-adjacent polygons int shared_vertices = 0; for (uint32_t v1 : poly1) { for (uint32_t v2 : poly2) { if (v1 == v2) { shared_vertices++; if (shared_vertices >= 2) { - return true; + return true; // Early exit when adjacency confirmed } + break; // Found this vertex, move to next v1 } } } diff --git a/src/services/astar_pathfinding.hpp b/src/services/astar_pathfinding.hpp index b43be68..8e23379 100644 --- a/src/services/astar_pathfinding.hpp +++ b/src/services/astar_pathfinding.hpp @@ -17,6 +17,21 @@ */ class AStarPathfinder { public: + /** + * Polygon grid data structure for spatial acceleration. + * This is pure data - no methods, just storage. + * Populated at map load time by MapSystem::build_polygon_grid(). + */ + struct NavGrid { + std::vector> grid_cells; // grid_cells[y * grid_width + x] = {polygon_ids} + Vec2 grid_origin; // World position of grid origin (bottom-left) + float grid_cell_size = 50.0f; // Size of each grid cell in world units + int grid_width = 0; // Number of cells in X direction + int grid_height = 0; // Number of cells in Y direction + + bool IsBuilt() const { return grid_width > 0 && grid_height > 0; } + }; + /** * Find a path from start to goal in the navmesh. * @@ -25,6 +40,7 @@ class AStarPathfinder { * @param vertices List of all navmesh vertices * @param polygons List of polygons (each polygon is a list of vertex indices) * @param entity_radius The radius of the entity for collision checking + * @param nav_grid Nav Grid for faster queries * @return Vector of 2D waypoints along the path, or empty if no path found */ static std::vector FindPath( @@ -32,7 +48,8 @@ class AStarPathfinder { const Vec2& goal_pos, const std::vector& vertices, const std::vector>& polygons, - float entity_radius = 0.0f + float entity_radius = 0.0f, + const NavGrid* nav_grid = nullptr ); private: diff --git a/src/services/navigation_service.cpp b/src/services/navigation_service.cpp index 5c30838..0075f8e 100644 --- a/src/services/navigation_service.cpp +++ b/src/services/navigation_service.cpp @@ -29,6 +29,17 @@ struct NavigationService::NavServiceBackend { void start_worker() { running = true; + + // Verify grid was built during map loading + if (map.grid_width > 0 && map.grid_height > 0) { + LOG_INFO("NavigationService: Using precomputed grid (size: %dx%d, cell_size: %.1f)", + map.grid_width, map.grid_height, map.grid_cell_size); + } else { + LOG_ERROR("NavigationService: Navmesh grid not precomputed. Closing navigation service."); + running = false; + return; + } + worker = std::thread([this]() { LOG_INFO("Spinning off NavigationService backend thread"); start_work(); @@ -73,12 +84,21 @@ struct NavigationService::NavServiceBackend { std::vector navmesh_vertices = this->map.vertices; std::vector> navmesh_polygons = this->map.polygons; + // Create grid structure reference from map component + AStarPathfinder::NavGrid grid; + grid.grid_cells = this->map.grid_cells; + grid.grid_origin = this->map.grid_origin; + grid.grid_cell_size = this->map.grid_cell_size; + grid.grid_width = this->map.grid_width; + grid.grid_height = this->map.grid_height; + std::vector path_2d = AStarPathfinder::FindPath( req.current_position, req.destination, navmesh_vertices, navmesh_polygons, - req.entity_pathing_radius + req.entity_pathing_radius, + &grid // Pass grid from map component ); // Store the 2D path directly diff --git a/src/systems/util/map_system.cpp b/src/systems/util/map_system.cpp index d77ed08..7282062 100644 --- a/src/systems/util/map_system.cpp +++ b/src/systems/util/map_system.cpp @@ -120,6 +120,9 @@ std::optional MapSystem::load_map(const std::optional& file_pa // Offset is the center point between min and max map.offset = Vec2((bounds.min.x + bounds.max.x) / 2.0f, (bounds.min.y + bounds.max.y) / 2.0f); + // Build spatial acceleration grid for fast polygon lookups + MapSystem::build_polygon_grid(map, 1.0f); + LOG_INFO("Loaded map '%s' with %zu vertices, %zu polygons, and %zu spawnpoints", map.name.c_str(), navmesh_data.vertices.size(), navmesh_data.polygons.size(), spawnpoints.size()); @@ -659,4 +662,121 @@ void MapSystem::apply_navigation_region_transform(const std::string& file_conten LOG_INFO("Applied NavigationRegion3D transform to %zu vertices and %zu spawnpoints", vertices.size(), spawnpoints.size()); +} + +void MapSystem::build_polygon_grid(Map& map, float cell_size) { + if (map.vertices.empty() || map.polygons.empty() || cell_size <= 0.0f) { + LOG_WARN("build_polygon_grid: Invalid input (vertices: %zu, polygons: %zu, cell_size: %.1f)", + map.vertices.size(), map.polygons.size(), cell_size); + return; + } + + map.grid_cell_size = cell_size; + + // Find bounding box of all vertices + Vec2 min_bounds = map.vertices[0]; + Vec2 max_bounds = map.vertices[0]; + + for (const auto& vertex : map.vertices) { + min_bounds.x = std::min(min_bounds.x, vertex.x); + min_bounds.y = std::min(min_bounds.y, vertex.y); + max_bounds.x = std::max(max_bounds.x, vertex.x); + max_bounds.y = std::max(max_bounds.y, vertex.y); + } + + // Add padding to bounds to handle edge cases + const float PADDING = cell_size * 0.5f; + min_bounds.x -= PADDING; + min_bounds.y -= PADDING; + max_bounds.x += PADDING; + max_bounds.y += PADDING; + + map.grid_origin = min_bounds; + + // Calculate grid dimensions + Vec2 bounds_size = max_bounds - min_bounds; + map.grid_width = std::max(1, static_cast(std::ceil(bounds_size.x / cell_size))); + map.grid_height = std::max(1, static_cast(std::ceil(bounds_size.y / cell_size))); + + // Initialize grid: grid_cells[y * grid_width + x] = {polygon_ids} + map.grid_cells.resize(map.grid_width * map.grid_height); + + LOG_DEBUG("build_polygon_grid: Grid dimensions %dx%d (cell_size: %.1f, bounds: (%.1f,%.1f) to (%.1f,%.1f))", + map.grid_width, map.grid_height, cell_size, + min_bounds.x, min_bounds.y, max_bounds.x, max_bounds.y); + + // Helper lambda to get polygon bounds + auto GetPolygonBounds = [&](const std::vector& polygon, Vec2& out_min, Vec2& out_max) { + if (polygon.empty()) { + out_min = Vec2(0.0f, 0.0f); + out_max = Vec2(0.0f, 0.0f); + return; + } + + uint32_t first_idx = polygon[0]; + if (first_idx >= map.vertices.size()) { + out_min = Vec2(0.0f, 0.0f); + out_max = Vec2(0.0f, 0.0f); + return; + } + + out_min = map.vertices[first_idx]; + out_max = map.vertices[first_idx]; + + for (uint32_t vertex_idx : polygon) { + if (vertex_idx >= map.vertices.size()) { + continue; + } + + const Vec2& vertex = map.vertices[vertex_idx]; + out_min.x = std::min(out_min.x, vertex.x); + out_min.y = std::min(out_min.y, vertex.y); + out_max.x = std::max(out_max.x, vertex.x); + out_max.y = std::max(out_max.y, vertex.y); + } + }; + + // Helper lambda to convert world position to grid coordinates + auto WorldToGridCoords = [&](const Vec2& world_pos, int& out_x, int& out_y) { + Vec2 relative_pos = world_pos - map.grid_origin; + + out_x = static_cast(std::floor(relative_pos.x / cell_size)); + out_y = static_cast(std::floor(relative_pos.y / cell_size)); + + // Clamp to valid grid range + out_x = std::max(0, std::min(out_x, map.grid_width - 1)); + out_y = std::max(0, std::min(out_y, map.grid_height - 1)); + }; + + // Add each polygon to grid cells it overlaps + for (uint32_t poly_id = 0; poly_id < map.polygons.size(); ++poly_id) { + Vec2 poly_min, poly_max; + GetPolygonBounds(map.polygons[poly_id], poly_min, poly_max); + + // Convert polygon bounds to grid coordinates + int min_x, min_y, max_x, max_y; + WorldToGridCoords(poly_min, min_x, min_y); + WorldToGridCoords(poly_max, max_x, max_y); + + // Add polygon ID to all grid cells it overlaps + for (int y = min_y; y <= max_y; ++y) { + for (int x = min_x; x <= max_x; ++x) { + int index = y * map.grid_width + x; + map.grid_cells[index].push_back(poly_id); + } + } + } + + // Log statistics + int total_entries = 0; + int non_empty_cells = 0; + for (const auto& cell : map.grid_cells) { + if (!cell.empty()) { + non_empty_cells++; + total_entries += cell.size(); + } + } + + LOG_INFO("Polygon grid built: %d non-empty cells, %.1f polygons per cell average", + non_empty_cells, non_empty_cells > 0 ? static_cast(total_entries) / non_empty_cells : 0.0f); } \ No newline at end of file diff --git a/src/systems/util/map_system.hpp b/src/systems/util/map_system.hpp index 2dc3d91..55c028d 100644 --- a/src/systems/util/map_system.hpp +++ b/src/systems/util/map_system.hpp @@ -76,6 +76,15 @@ class MapSystem { * @return Vector with serialized map data, or empty vector on failure */ static std::vector serialize_map(Entity* map_entity); + /** + * Build spatial acceleration grid for fast polygon lookups. + * Divides map space into uniform cells and assigns polygon IDs to each cell. + * Static data - computed once at load time, never modified. + * @param map The map to build grid for (modified in-place) + * @param cell_size Size of each grid cell in world units (default 50.0f) + */ + static void build_polygon_grid(Map& map, float cell_size = 50.0f); + private: /** * Structure to hold transformation matrix data. From 25230f5392ced646f52c146ef51da17f0495676a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 2 Dec 2025 08:05:33 -0500 Subject: [PATCH 63/79] Update visualizer to use files, add NavGrid Support --- src/services/visualizer_service.cpp | 507 ++++++---------------------- src/services/visualizer_service.hpp | 7 + web_ui/index.html | 432 ++++++++++++++++++++++++ web_ui/script.js | 380 +++++++++++++++++++++ web_ui/styles.css | 29 ++ 5 files changed, 950 insertions(+), 405 deletions(-) create mode 100644 web_ui/index.html create mode 100644 web_ui/script.js create mode 100644 web_ui/styles.css diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index f0e1659..1624463 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -11,6 +11,8 @@ #include #include #include +#include +#include // Windows socket headers #ifdef _WIN32 @@ -175,7 +177,18 @@ void VisualizerService::run_server() { std::string request(buffer); std::string response; - if (request.find("GET /api/gamestate") != std::string::npos) { + // Extract the request path + std::string path = "/"; + size_t path_start = request.find("GET "); + if (path_start != std::string::npos) { + path_start += 4; + size_t path_end = request.find(" ", path_start); + if (path_end != std::string::npos) { + path = request.substr(path_start, path_end - path_start); + } + } + + if (path.find("/api/gamestate") != std::string::npos) { // Return JSON game state std::string json = get_game_state_json(); response = "HTTP/1.1 200 OK\r\n"; @@ -185,23 +198,44 @@ void VisualizerService::run_server() { response += "Connection: close\r\n"; response += "\r\n"; response += json; - } else if (request.find("GET /") != std::string::npos || request.find("GET") != std::string::npos) { - // Return HTML page - std::string html = get_html_page(); - response = "HTTP/1.1 200 OK\r\n"; - response += "Content-Type: text/html\r\n"; - response += "Content-Length: " + std::to_string(html.length()) + "\r\n"; - response += "Connection: close\r\n"; - response += "\r\n"; - response += html; } else { - // 404 Not Found - response = "HTTP/1.1 404 Not Found\r\n"; - response += "Content-Type: text/plain\r\n"; - response += "Content-Length: 9\r\n"; - response += "Connection: close\r\n"; - response += "\r\n"; - response += "Not Found"; + // Serve files from web_ui/ directory + std::string file_path = "web_ui"; + if (path == "/" || path.empty()) { + file_path += "/index.html"; + } else { + file_path += path; + } + + std::string content = get_file_content(file_path); + if (!content.empty()) { + // Determine content type based on file extension + std::string content_type = "text/plain"; + if (file_path.find(".html") != std::string::npos) { + content_type = "text/html"; + } else if (file_path.find(".css") != std::string::npos) { + content_type = "text/css"; + } else if (file_path.find(".js") != std::string::npos) { + content_type = "application/javascript"; + } else if (file_path.find(".json") != std::string::npos) { + content_type = "application/json"; + } + + response = "HTTP/1.1 200 OK\r\n"; + response += "Content-Type: " + content_type + "\r\n"; + response += "Content-Length: " + std::to_string(content.length()) + "\r\n"; + response += "Connection: close\r\n"; + response += "\r\n"; + response += content; + } else { + // 404 Not Found + response = "HTTP/1.1 404 Not Found\r\n"; + response += "Content-Type: text/plain\r\n"; + response += "Content-Length: 9\r\n"; + response += "Connection: close\r\n"; + response += "\r\n"; + response += "Not Found"; + } } // Send response @@ -224,403 +258,37 @@ void VisualizerService::run_server() { } std::string VisualizerService::get_html_page() const { + // Try to load from file first + std::ifstream file("web/index.html"); + if (file.is_open()) { + std::stringstream buffer; + buffer << file.rdbuf(); + return buffer.str(); + } + + // Fallback: return minimal HTML return R"( - - GameServer Debugger - - +GameServer Debugger -

GameServer Debugger

-

Map View

- - -

Visualization Legend

-
-
█ Grid - Reference coordinate grid (10-unit spacing)
-
█ Map Bounds - Dashed line showing map boundary
-
█ Navmesh - Walkable area polygons
-
● Vertices - Navmesh vertex positions with indices
-
● Centroids - Polygon center points for pathfinding
-
★ Spawnpoints - Unit spawn locations
-
● Blue Entity - Team 1 entity
-
● Red Entity - Team 2 entity
-
⚫ Attacking Ring - Entity in ATTACKING state
-
⚫ Moving Ring - Entity in MOVING state
-
⚫ Pathfinding Ring - Entity in PATHFINDING_WAITING state
-
- -

Game State

-
- -

Entities

-
- - +

GameServer Debugger

+

web/index.html not found. Please ensure visualizer files are in the correct directory.

)"; } +std::string VisualizerService::get_file_content(const std::string& path) const { + std::ifstream file(path, std::ios::binary); + if (!file.is_open()) { + return ""; + } + std::stringstream buffer; + buffer << file.rdbuf(); + return buffer.str(); +} + std::string VisualizerService::get_game_state_json() const { std::ostringstream json; json << std::fixed << std::setprecision(2); @@ -648,7 +316,36 @@ std::string VisualizerService::get_game_state_json() const { if (i > 0) json << ","; json << "{\"x\":" << map_->spawnpoints[i].x << ",\"z\":" << map_->spawnpoints[i].y << "}"; } + json << "],"; + + // Polygon Grid (for visualization) + json << "\"grid\":{"; + json << "\"origin\":{\"x\":" << map_->grid_origin.x << ",\"y\":" << map_->grid_origin.y << "},"; + json << "\"cell_size\":" << map_->grid_cell_size << ","; + json << "\"width\":" << map_->grid_width << ","; + json << "\"height\":" << map_->grid_height << ","; + json << "\"cells\":["; + if (map_->grid_width > 0 && map_->grid_height > 0) { + bool first_cell = true; + for (int y = 0; y < map_->grid_height; y++) { + for (int x = 0; x < map_->grid_width; x++) { + int index = y * map_->grid_width + x; + int poly_count = 0; + if (index >= 0 && index < (int)map_->grid_cells.size()) { + poly_count = (int)map_->grid_cells[index].size(); + } + + // Only include cells with polygons + if (poly_count > 0) { + if (!first_cell) json << ","; + first_cell = false; + json << "{\"x\":" << x << ",\"y\":" << y << ",\"polygon_count\":" << poly_count << "}"; + } + } + } + } json << "]"; + json << "}"; } json << "},"; diff --git a/src/services/visualizer_service.hpp b/src/services/visualizer_service.hpp index 8b22fe6..7af8f41 100644 --- a/src/services/visualizer_service.hpp +++ b/src/services/visualizer_service.hpp @@ -90,6 +90,13 @@ class VisualizerService { */ std::string get_html_page() const; + /** + * Get file content from disk. + * @param path Path to file relative to working directory + * @return File content or empty string if not found + */ + std::string get_file_content(const std::string& path) const; + /** * Get current game state as JSON. * @return JSON string with map, entities, and state diff --git a/web_ui/index.html b/web_ui/index.html new file mode 100644 index 0000000..9a97b8b --- /dev/null +++ b/web_ui/index.html @@ -0,0 +1,432 @@ + + + + GameServer Debugger + + + +

GameServer Debugger

+

Map View

+ + +

Visualization Legend

+
+
█ Grid - Reference coordinate grid (10-unit spacing)
+
█ Map Bounds - Dashed line showing map boundary
+
█ Navmesh - Walkable area polygons
+
▭ Polygon Grid - Spatial acceleration grid cells for pathfinding lookup
+
● Vertices - Navmesh vertex positions with indices
+
● Centroids - Polygon center points for pathfinding
+
★ Spawnpoints - Unit spawn locations
+
● Blue Entity - Team 1 entity
+
● Red Entity - Team 2 entity
+
⚫ Attacking Ring - Entity in ATTACKING state
+
⚫ Moving Ring - Entity in MOVING state
+
⚫ Pathfinding Ring - Entity in PATHFINDING_WAITING state
+
+ +

Game State

+
+ +

Entities

+
+ + + + + + \ No newline at end of file diff --git a/web_ui/script.js b/web_ui/script.js new file mode 100644 index 0000000..b6c5b5a --- /dev/null +++ b/web_ui/script.js @@ -0,0 +1,380 @@ +const canvas = document.getElementById('mapCanvas'); +const ctx = canvas.getContext('2d'); + +async function updateView() { + try { + const response = await fetch('/api/gamestate'); + const data = await response.json(); + + // Clear canvas + ctx.fillStyle = '#000'; + ctx.fillRect(0, 0, canvas.width, canvas.height); + + // Draw grid first (background) + drawPolygonGrid(data.map); + + // Draw map bounds + drawMapBounds(data.map); + + // Draw navmesh + drawNavmesh(data.map); + + // Draw spawnpoints + drawSpawnpoints(data.map); + + // Draw entities + drawEntities(data.entities); + + // Update state info + updateStateInfo(data.state); + + // Update entities list + updateEntitiesList(data.entities); + } catch (e) { + console.error('Failed to fetch game state:', e); + } +} + +function screenToWorld(screenX, screenY) { + return { + x: (screenX - 400) / 10, + y: (screenY - 300) / 10 + }; +} + +function worldToScreen(worldX, worldY) { + return { + x: worldX * 10 + 400, + y: worldY * 10 + 300 + }; +} + +function drawPolygonGrid(mapData) { + if (!mapData || !mapData.grid) return; + + const grid = mapData.grid; + if (grid.width === 0 || grid.height === 0 || !grid.cells || grid.cells.length === 0) return; + + const cellSize = grid.cell_size; + const originX = grid.origin.x; + const originY = grid.origin.y; + + // Grid visualization: very subtle outline to show spatial acceleration cells + ctx.strokeStyle = '#3333ff'; + ctx.lineWidth = 0.5; + ctx.fillStyle = 'rgba(51, 51, 255, 0.05)'; // Very transparent + + let drawnCount = 0; + for (let cellData of grid.cells) { + const x = cellData.x; + const y = cellData.y; + + // Calculate cell bounds in world coordinates + const minX = originX + (x * cellSize); + const maxX = minX + cellSize; + const minY = originY + (y * cellSize); + const maxY = minY + cellSize; + + // Convert to screen coordinates + const topLeft = worldToScreen(minX, minY); + const topRight = worldToScreen(maxX, minY); + const bottomLeft = worldToScreen(minX, maxY); + const bottomRight = worldToScreen(maxX, maxY); + + // Skip if cell is completely outside canvas + if ((topLeft.x > canvas.width && topRight.x > canvas.width && bottomRight.x > canvas.width) || + (topLeft.x < 0 && topRight.x < 0 && bottomLeft.x < 0) || + (topLeft.y > canvas.height && bottomLeft.y > canvas.height && bottomRight.y > canvas.height) || + (topLeft.y < 0 && topRight.y < 0 && topRight.y < 0)) { + continue; + } + + drawnCount++; + + // Draw cell rectangle (very subtle) + ctx.beginPath(); + ctx.moveTo(topLeft.x, topLeft.y); + ctx.lineTo(topRight.x, topRight.y); + ctx.lineTo(bottomRight.x, bottomRight.y); + ctx.lineTo(bottomLeft.x, bottomLeft.y); + ctx.closePath(); + ctx.fill(); + ctx.stroke(); + + // Only draw labels if cell is reasonably sized on screen + const cellWidth = Math.abs(topRight.x - topLeft.x); + const cellHeight = Math.abs(bottomLeft.y - topLeft.y); + + if (cellWidth > 50 && cellHeight > 50) { + const centerX = (topLeft.x + bottomRight.x) / 2; + const centerY = (topLeft.y + bottomRight.y) / 2; + ctx.fillStyle = '#3333ff'; + ctx.font = '8px monospace'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + ctx.fillText(cellData.polygon_count + 'p', centerX, centerY); + } + } + + if (drawnCount > 0) { + console.log(`Grid: Drew ${drawnCount} / ${grid.cells.length} cells`); + } +} + +function drawMapBounds(mapData) { + if (!mapData) return; + + // Draw map boundary as a dashed line + ctx.strokeStyle = '#664040'; + ctx.lineWidth = 2; + ctx.setLineDash([10, 5]); + + const halfWidth = mapData.size.x / 2; + const halfHeight = mapData.size.y / 2; + + const minX = mapData.offset.x - halfWidth; + const maxX = mapData.offset.x + halfWidth; + const minY = mapData.offset.y - halfHeight; + const maxY = mapData.offset.y + halfHeight; + + const topLeft = worldToScreen(minX, minY); + const topRight = worldToScreen(maxX, minY); + const bottomLeft = worldToScreen(minX, maxY); + const bottomRight = worldToScreen(maxX, maxY); + + ctx.beginPath(); + ctx.moveTo(topLeft.x, topLeft.y); + ctx.lineTo(topRight.x, topRight.y); + ctx.lineTo(bottomRight.x, bottomRight.y); + ctx.lineTo(bottomLeft.x, bottomLeft.y); + ctx.closePath(); + ctx.stroke(); + + ctx.setLineDash([]); +} + +function drawNavmesh(mapData) { + if (!mapData || !mapData.vertices) return; + + const vertices = mapData.vertices; + const polygons = mapData.polygons || []; + + // Draw polygon faces + ctx.strokeStyle = '#408040'; + ctx.fillStyle = '#204020'; + ctx.lineWidth = 2; + + for (let poly of polygons) { + if (poly.length < 3) continue; + + ctx.beginPath(); + const v = vertices[poly[0]]; + const screen = worldToScreen(v.x, v.z); + ctx.moveTo(screen.x, screen.y); + + for (let i = 1; i < poly.length; i++) { + const v = vertices[poly[i]]; + const screen = worldToScreen(v.x, v.z); + ctx.lineTo(screen.x, screen.y); + } + ctx.closePath(); + ctx.fill(); + ctx.stroke(); + } + + // Draw vertices with labels + ctx.fillStyle = '#80ff80'; + ctx.strokeStyle = '#ffffff'; + ctx.lineWidth = 1; + ctx.font = 'bold 9px monospace'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + + for (let i = 0; i < vertices.length; i++) { + const v = vertices[i]; + const screen = worldToScreen(v.x, v.z); + + // Draw vertex circle + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 3, 0, Math.PI * 2); + ctx.fill(); + ctx.stroke(); + + // Draw vertex index + ctx.fillStyle = '#000000'; + ctx.fillText(i.toString(), screen.x, screen.y); + ctx.fillStyle = '#80ff80'; + } + + // Draw polygon centroids + ctx.fillStyle = '#ff6b6b'; + for (let i = 0; i < polygons.length; i++) { + const poly = polygons[i]; + if (poly.length < 3) continue; + + // Calculate centroid + let cx = 0, cy = 0; + for (let idx of poly) { + cx += vertices[idx].x; + cy += vertices[idx].z; + } + cx /= poly.length; + cy /= poly.length; + + const screen = worldToScreen(cx, cy); + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 2, 0, Math.PI * 2); + ctx.fill(); + } +} + +function drawSpawnpoints(mapData) { + if (!mapData || !mapData.spawnpoints) return; + + ctx.fillStyle = '#ffff00'; + ctx.strokeStyle = '#ffff00'; + ctx.lineWidth = 2; + ctx.font = '12px Arial'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'bottom'; + + for (let i = 0; i < mapData.spawnpoints.length; i++) { + const sp = mapData.spawnpoints[i]; + const screen = worldToScreen(sp.x, sp.z); + + // Draw spawnpoint star + ctx.beginPath(); + for (let j = 0; j < 5; j++) { + const angle = (j * 4 * Math.PI) / 5 - Math.PI / 2; + const radius = j % 2 === 0 ? 8 : 4; + const x = screen.x + Math.cos(angle) * radius; + const y = screen.y + Math.sin(angle) * radius; + if (j === 0) ctx.moveTo(x, y); + else ctx.lineTo(x, y); + } + ctx.closePath(); + ctx.fill(); + ctx.stroke(); + + // Draw label + ctx.fillStyle = '#ffff00'; + ctx.fillText('S' + i, screen.x, screen.y - 12); + } +} + +function drawEntities(entities) { + if (!entities) return; + + // First pass: draw targeting lines + for (let entity of entities) { + if (entity.target_id !== undefined) { + const attacker_screen = worldToScreen(entity.position.x, entity.position.z); + + // Find target entity + const target = entities.find(e => e.id === entity.target_id); + if (target) { + const target_screen = worldToScreen(target.position.x, target.position.z); + + // Draw targeting line + ctx.strokeStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + ctx.lineWidth = 2; + ctx.setLineDash([5, 5]); + ctx.beginPath(); + ctx.moveTo(attacker_screen.x, attacker_screen.y); + ctx.lineTo(target_screen.x, target_screen.y); + ctx.stroke(); + ctx.setLineDash([]); + + // Draw arrowhead at target + const angle = Math.atan2(target_screen.y - attacker_screen.y, target_screen.x - attacker_screen.x); + const arrowSize = 8; + + ctx.fillStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + ctx.beginPath(); + ctx.moveTo(target_screen.x, target_screen.y); + ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle - Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle - Math.PI / 6)); + ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle + Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle + Math.PI / 6)); + ctx.closePath(); + ctx.fill(); + } + } + } + + // Second pass: draw entities + for (let entity of entities) { + const screen = worldToScreen(entity.position.x, entity.position.z); + + // Color by team + ctx.fillStyle = entity.team_id === 1 ? '#4040ff' : '#ff4040'; + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 4, 0, Math.PI * 2); + ctx.fill(); + + // Draw ID + ctx.fillStyle = '#ffffff'; + ctx.font = 'bold 10px Arial'; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + ctx.fillText(entity.id.toString(), screen.x, screen.y); + + // Highlight if attacking + if (entity.state === 'ATTACKING') { + ctx.strokeStyle = '#ffff00'; + ctx.lineWidth = 2; + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 6, 0, Math.PI * 2); + ctx.stroke(); + } + + // Draw state indicator + let stateColor; + switch (entity.state) { + case 'ATTACKING': stateColor = '#ffff00'; break; + case 'MOVING': stateColor = '#4da6ff'; break; + case 'PATHFINDING_WAITING': stateColor = '#ffa500'; break; + case 'DEAD': stateColor = '#ff0000'; break; + default: stateColor = '#ffb347'; break; + } + ctx.strokeStyle = stateColor; + ctx.lineWidth = 1; + ctx.beginPath(); + ctx.arc(screen.x, screen.y, 8, 0, Math.PI * 2); + ctx.stroke(); + } +} + +function updateStateInfo(state) { + document.getElementById('state').textContent = JSON.stringify(state, null, 2); +} + +function updateEntitiesList(entities) { + const div = document.getElementById('entities'); + div.innerHTML = ''; + + if (!entities) return; + + for (let entity of entities) { + const el = document.createElement('div'); + el.className = 'entity'; + + let targetStr = ''; + if (entity.target_id !== undefined) { + const target = entities.find(e => e.id === entity.target_id); + const targetName = target ? `E${entity.target_id}` : `E${entity.target_id} (DEAD)`; + targetStr = ` → Targeting ${targetName}`; + } + + const stateColor = entity.state === 'ATTACKING' ? '#ffff00' : + entity.state === 'MOVING' ? '#4da6ff' : + entity.state === 'DEAD' ? '#ff0000' : '#ffb347'; + + el.innerHTML = `E${entity.id} [Team ${entity.team_id}] | Intent: ${entity.intent} | State: ${entity.state}${targetStr} | (${entity.position.x.toFixed(1)}, ${entity.position.z.toFixed(1)})`; + div.appendChild(el); + } +} + + + +// Update every 500ms +setInterval(updateView, 500); +updateView(); \ No newline at end of file diff --git a/web_ui/styles.css b/web_ui/styles.css new file mode 100644 index 0000000..ffdbd97 --- /dev/null +++ b/web_ui/styles.css @@ -0,0 +1,29 @@ +body { + font-family: Arial, sans-serif; + margin: 20px; + background: #1e1e1e; + color: #d4d4d4; +} + +canvas { + border: 1px solid #404040; + background: #000; + margin: 20px 0; + display: block; +} + +.info { + font-family: monospace; + white-space: pre; + background: #252526; + padding: 10px; +} + +.entity { + margin: 5px 0; +} + +h2 { + border-bottom: 1px solid #404040; + padding-bottom: 10px; +} \ No newline at end of file From 1f57ea2a386fb03e57be23d17309fbe76821915c Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 2 Dec 2025 08:48:41 -0500 Subject: [PATCH 64/79] Player Input Prioritization & Champion Metadata (clientside) --- data/entities/champions/champion.xml | 7 +++++++ src/components/component_registry.hpp | 3 +++ src/components/metadata.hpp | 17 +++++++++++++++++ src/services/navigation_service.cpp | 16 +++++++++++----- src/services/navigation_service.hpp | 6 ++++++ src/systems/core/movement_system.cpp | 3 +++ src/systems/util/data_loader.cpp | 11 +++++++++++ 7 files changed, 58 insertions(+), 5 deletions(-) create mode 100644 src/components/metadata.hpp diff --git a/data/entities/champions/champion.xml b/data/entities/champions/champion.xml index 2c3fcf0..9b62117 100644 --- a/data/entities/champions/champion.xml +++ b/data/entities/champions/champion.xml @@ -6,6 +6,13 @@ xsi:schemaLocation="https://open-champ.com/mySchema ../_entity.xsd" id="champion" > + + +#include + +/** + * Metadata component for UI/Visual Data. + * Stores metadata such as name, description, icon, and model for the entity. + */ +struct MetadataComponent : public Component { + std::string name; + std::string description; + std::string icon; + std::string model; + + COMPONENT_TYPE_ID(MetadataComponent, 4001) +}; diff --git a/src/services/navigation_service.cpp b/src/services/navigation_service.cpp index 0075f8e..b388857 100644 --- a/src/services/navigation_service.cpp +++ b/src/services/navigation_service.cpp @@ -8,20 +8,26 @@ #include #include -#include #include +// Comparator for priority queue: higher priority (player input) comes first +struct PathRequestComparator { + bool operator()(const PathRequest& a, const PathRequest& b) const { + // In priority_queue, returning true means 'a' should come AFTER 'b' + // So we return true if a has LOWER priority than b + return a.priority() < b.priority(); + } +}; + struct NavigationService::NavServiceBackend { std::thread worker; Map map; std::atomic running{false}; - std::queue requests; + std::priority_queue, PathRequestComparator> requests; std::queue results; std::queue waitingResults; std::mutex mtx; - // TODO what frame rate should this run at? infinite? - ploinky 14/11/2025 - FrameTimer frame_timer = FrameTimer(30); NavServiceBackend() { // Don't start thread yet - wait for map to be assigned @@ -70,7 +76,7 @@ struct NavigationService::NavServiceBackend { continue; } - PathRequest req = requests.front(); + PathRequest req = requests.top(); requests.pop(); // we have our request, we can unlock for now and do the pathing diff --git a/src/services/navigation_service.hpp b/src/services/navigation_service.hpp index ac54909..5424877 100644 --- a/src/services/navigation_service.hpp +++ b/src/services/navigation_service.hpp @@ -13,6 +13,12 @@ class PathRequest { float entity_pathing_radius; Vec2 current_position; Vec2 destination; + bool is_player_input = false; + + // For priority queue ordering: higher priority value = processes first + int priority() const { + return is_player_input ? 1 : 0; + } }; class PathResult { diff --git a/src/systems/core/movement_system.cpp b/src/systems/core/movement_system.cpp index d37f120..c5dc2eb 100644 --- a/src/systems/core/movement_system.cpp +++ b/src/systems/core/movement_system.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include @@ -164,6 +165,8 @@ void MovementSystem::request_new_path(Entity& entity, Vec2 target, NavigationSer request.current_position = movement->position; request.destination = target; request.entity_pathing_radius = 0.5f; + // Prioritize if this entity is player-controlled + request.is_player_input = entity.has_component(); if (navigation_service->MakeRequest(request)) { pathfinding->waypoints.clear(); diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index e237279..73cbe1f 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -11,6 +11,7 @@ #include #include #include +#include /** * Convert string to DamageType enum. @@ -147,6 +148,16 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { temp.component_templates.push_back(npc); } + pugi::xml_node meta_node = rootNode.child("meta"); + if(!meta_node.empty()) { + std::shared_ptr meta = std::make_shared(); + LOAD_ATTRIBUTE(meta_node, meta, name, string) + LOAD_ATTRIBUTE(meta_node, meta, description, string) + LOAD_ATTRIBUTE(meta_node, meta, icon, string) + LOAD_ATTRIBUTE(meta_node, meta, model, string) + temp.component_templates.push_back(meta); + } + pugi::xml_node target_node = rootNode.child("target"); if(!target_node.empty()) { std::shared_ptr target = std::make_shared(); From 698cd9a372f1f6a788303110f330eefb4b99842a Mon Sep 17 00:00:00 2001 From: cmkrist Date: Tue, 2 Dec 2025 15:22:31 -0500 Subject: [PATCH 65/79] Add OBJ parsing for navmesh, replaces tscn parsing --- CMakeLists.txt | 1 - data/maps/konda.nav.obj | 911 +++++++++++++++++++++++++++++++ data/maps/konda.xml | 8 + src/main.cpp | 2 + src/systems/entity_manager.hpp | 4 +- src/systems/gameserver.cpp | 12 +- src/systems/util/data_loader.cpp | 173 ++++++ src/systems/util/data_loader.hpp | 22 +- src/systems/util/map_system.cpp | 782 -------------------------- src/systems/util/map_system.hpp | 136 ----- 10 files changed, 1123 insertions(+), 928 deletions(-) create mode 100644 data/maps/konda.nav.obj create mode 100644 data/maps/konda.xml delete mode 100644 src/systems/util/map_system.cpp delete mode 100644 src/systems/util/map_system.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 03c6556..daaa2be 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -69,7 +69,6 @@ set(GAMESERVER_SOURCES # Systems - Utilities src/systems/util/combat_calculator.cpp src/systems/util/data_loader.cpp - src/systems/util/map_system.cpp src/systems/util/packet_handler.cpp src/systems/util/player_manager.cpp src/systems/util/serialization_system.cpp diff --git a/data/maps/konda.nav.obj b/data/maps/konda.nav.obj new file mode 100644 index 0000000..35477b2 --- /dev/null +++ b/data/maps/konda.nav.obj @@ -0,0 +1,911 @@ +# OpenChamp Navigation Mesh +# Scene: konda +# Vertices: 440 +# Faces: 465 + +v -4.250000 0.450000 -32.250000 +v -4.500000 0.450000 -32.000000 +v -5.000000 0.450000 -32.750000 +v -3.750000 0.450000 -31.500000 +v -3.250000 0.450000 -32.250000 +v -6.250000 0.450000 -31.750000 +v -5.000000 0.450000 -34.250000 +v -2.750000 0.450000 -31.500000 +v -3.750000 0.450000 -30.000000 +v -6.250000 0.450000 -29.750000 +v -18.500000 0.450000 -35.750000 +v -13.100000 0.450000 -35.150002 +v -17.150000 0.950000 -35.599998 +v -17.100000 0.950000 -35.674999 +v -4.500000 0.450000 -35.000000 +v -2.500000 0.450000 -29.500000 +v -1.750000 0.450000 -31.500000 +v -4.250000 0.450000 -29.500000 +v -17.000000 0.450000 -15.750000 +v -4.750000 0.450000 -29.000000 +v -13.000000 0.450000 -17.750000 +v -11.000000 0.450000 -18.750000 +v -4.750000 0.450000 -27.250000 +v -9.000000 0.450000 -19.750000 +v -15.000000 0.450000 -16.750000 +v -19.000000 0.450000 -14.750000 +v -18.500000 0.450000 -37.000000 +v -19.500000 0.450000 -37.000000 +v -17.113636 0.950000 -35.772728 +v -3.250000 0.450000 -34.750000 +v -3.250000 0.950000 -36.000000 +v -1.250000 0.700000 -32.250000 +v -2.000000 0.450000 -28.000000 +v -17.500000 0.450000 -14.750000 +v -15.500000 0.450000 -15.750000 +v -13.500000 0.450000 -16.750000 +v -11.500000 0.450000 -17.750000 +v -9.500000 0.450000 -18.750000 +v -7.000000 0.450000 -20.750000 +v -3.750000 0.450000 -26.750000 +v -7.500000 0.450000 -19.750000 +v -19.500000 0.450000 -14.000000 +v 1.250000 0.700000 -32.250000 +v 2.500000 0.450000 -29.500000 +v 2.000000 0.450000 -28.000000 +v 2.500000 0.450000 -26.750000 +v -2.500000 0.450000 -26.750000 +v -5.500000 0.450000 -20.750000 +v -5.000000 0.450000 -21.750000 +v -3.750000 0.450000 -21.750000 +v 1.750000 0.450000 -31.500000 +v 3.750000 0.450000 -30.000000 +v 3.750000 0.450000 -31.500000 +v 4.250000 0.450000 -29.500000 +v -2.500000 0.450000 -21.250000 +v 2.500000 0.450000 -21.250000 +v 3.750000 0.450000 -21.750000 +v 3.750000 0.450000 -26.750000 +v 4.250000 0.450000 -32.250000 +v 4.500000 0.450000 -32.000000 +v 4.750000 0.450000 -29.000000 +v 6.250000 0.450000 -29.750000 +v -2.250000 0.450000 -20.000000 +v 2.250000 0.450000 -20.000000 +v 5.000000 0.450000 -21.750000 +v 7.000000 0.450000 -20.750000 +v 4.750000 0.450000 -27.250000 +v 5.000000 0.450000 -32.750000 +v 6.250000 0.450000 -31.750000 +v 9.000000 0.450000 -19.750000 +v 17.495026 0.450000 -33.503025 +v 19.500000 0.450000 -26.000000 +v -2.750000 0.450000 -18.250000 +v 3.000000 0.450000 -18.250000 +v 5.500000 0.450000 -20.750000 +v 7.500000 0.450000 -19.750000 +v 5.000000 0.450000 -34.250000 +v 18.250000 0.950000 -35.750000 +v 13.833336 0.450000 -35.250000 +v 16.777779 0.950000 -35.583332 +v 11.000000 0.450000 -18.750000 +v 9.500000 0.450000 -18.750000 +v 20.250000 0.950000 -26.000000 +v 19.500000 0.450000 -25.000000 +v 19.500000 0.450000 -27.000000 +v -4.250000 0.450000 -18.250000 +v -5.000000 0.450000 -17.250000 +v 5.250000 0.450000 -17.250000 +v 4.500000 0.450000 -18.250000 +v 1.250000 0.450000 -11.500000 +v -1.500000 0.450000 -11.500000 +v 16.875000 0.950000 -35.674999 +v 4.500000 0.450000 -35.000000 +v 19.500000 0.450000 -31.000000 +v 18.500000 0.450000 -35.000000 +v 19.500000 0.450000 -30.000000 +v 3.250000 0.950000 -35.750000 +v 19.500000 0.450000 -29.000000 +v 19.500000 0.450000 -28.000000 +v 11.500000 0.450000 -17.750000 +v 13.000000 0.450000 -17.750000 +v 20.250000 0.950000 -25.000000 +v 19.500000 0.450000 -24.000000 +v 20.250000 0.950000 -28.000000 +v 20.250000 0.950000 -27.000000 +v -1.750000 0.450000 -11.000000 +v -6.250000 0.450000 -17.250000 +v -6.750000 0.450000 -16.250000 +v 1.500000 0.450000 -11.000000 +v 7.000000 0.450000 -16.250000 +v 6.500000 0.450000 -17.250000 +v 3.250000 0.450000 -34.750000 +v 20.250000 0.950000 -32.000000 +v 19.500000 0.450000 -32.000000 +v 20.250000 0.950000 -31.000000 +v 19.500000 0.700000 -35.000000 +v 19.500000 0.450000 -34.000000 +v 19.500000 0.450000 -33.000000 +v 20.250000 0.950000 -30.000000 +v 20.250000 0.950000 -29.000000 +v 13.500000 0.450000 -16.750000 +v 15.000000 0.450000 -16.750000 +v 19.500000 0.450000 -23.000000 +v 20.250000 0.950000 -24.000000 +v -8.750000 0.450000 -15.250000 +v -7.250000 0.450000 -5.500000 +v -1.750000 0.450000 -8.750000 +v -8.250000 0.450000 -16.250000 +v 9.000000 0.450000 -15.250000 +v 1.500000 0.450000 -8.750000 +v 5.000000 0.450000 -5.500000 +v 7.250000 0.450000 -5.500000 +v 8.500000 0.450000 -16.250000 +v 20.250000 0.950000 -33.750000 +v 20.250000 0.950000 -33.000000 +v 19.500000 0.450000 -21.000000 +v 19.500000 0.450000 -22.000000 +v 15.500000 0.450000 -15.750000 +v 17.000000 0.450000 -15.750000 +v 19.500000 0.450000 -20.000000 +v 20.250000 0.950000 -23.000000 +v -10.250000 0.450000 -15.250000 +v -10.750000 0.450000 -14.250000 +v -12.750000 0.450000 -13.250000 +v -14.750000 0.450000 -12.250000 +v -9.000000 0.450000 -2.250000 +v -5.000000 0.450000 -5.500000 +v -1.500000 0.450000 -8.250000 +v 10.500000 0.450000 -15.250000 +v 11.000000 0.450000 -14.250000 +v 1.250000 0.450000 -8.250000 +v 4.000000 0.450000 -4.500000 +v 15.000000 0.450000 -12.250000 +v 13.000000 0.450000 -13.250000 +v 9.000000 0.450000 -2.250000 +v 20.250000 0.950000 -22.000000 +v 20.250000 0.950000 -21.000000 +v 19.500000 0.450000 -19.000000 +v 17.500000 0.450000 -14.750000 +v 19.000000 0.450000 -14.750000 +v 19.500000 0.450000 -17.000000 +v 19.500000 0.450000 -18.000000 +v 20.250000 0.950000 -20.000000 +v -12.250000 0.450000 -14.250000 +v -14.250000 0.450000 -13.250000 +v -16.500000 0.450000 -2.750000 +v -16.500000 0.450000 -12.000000 +v -16.250000 0.450000 -0.750000 +v -9.000000 0.450000 2.250000 +v -4.000000 0.450000 -4.500000 +v -3.250000 0.450000 -2.000000 +v 12.500000 0.450000 -14.250000 +v 4.000000 0.450000 -3.250000 +v 3.250000 0.450000 -2.000000 +v 14.500000 0.450000 -13.250000 +v 16.500000 0.450000 -3.000000 +v 16.500000 0.450000 -12.250000 +v 16.250000 0.450000 -0.750000 +v 16.250000 0.450000 0.750000 +v 9.000000 0.450000 2.250000 +v 20.250000 0.950000 -19.000000 +v 19.500000 0.450000 -14.250000 +v 19.500000 0.450000 -15.000000 +v 19.500000 0.450000 -16.000000 +v 20.250000 0.950000 -18.000000 +v 20.250000 0.950000 -17.000000 +v -16.750000 0.450000 -2.250000 +v -16.500000 0.450000 1.500000 +v -16.500000 0.450000 3.000000 +v -17.000000 0.450000 -1.750000 +v -15.000000 0.450000 12.250000 +v -7.250000 0.450000 5.500000 +v -4.000000 0.450000 -3.250000 +v -3.250000 0.450000 2.000000 +v 3.250000 0.450000 2.000000 +v 17.000000 0.450000 -1.750000 +v 17.000000 0.450000 -2.250000 +v 16.500000 0.450000 3.000000 +v 17.000000 0.450000 1.750000 +v 7.250000 0.450000 5.500000 +v 15.000000 0.450000 12.250000 +v 20.250000 0.950000 -16.000000 +v 20.250000 0.950000 -15.000000 +v -19.000000 0.450000 -2.250000 +v -19.000000 0.450000 1.750000 +v -17.000000 0.450000 2.250000 +v -16.500000 0.450000 12.250000 +v -19.000000 0.450000 -1.750000 +v -14.500000 0.450000 13.250000 +v -13.000000 0.450000 13.250000 +v -11.000000 0.450000 14.250000 +v -1.750000 0.450000 9.000000 +v -5.000000 0.450000 5.500000 +v -1.750000 0.450000 11.500000 +v -9.000000 0.450000 15.250000 +v -4.000000 0.450000 3.250000 +v -4.000000 0.450000 4.500000 +v -1.500000 0.450000 8.500000 +v 1.250000 0.450000 8.500000 +v 4.000000 0.450000 4.500000 +v 4.000000 0.450000 3.250000 +v 19.000000 0.450000 -2.250000 +v 19.000000 0.450000 -1.750000 +v 17.000000 0.450000 2.250000 +v 16.500000 0.450000 12.250000 +v 19.000000 0.450000 1.750000 +v 11.000000 0.450000 14.250000 +v 13.000000 0.450000 13.250000 +v 5.000000 0.450000 5.500000 +v 1.500000 0.450000 9.000000 +v 1.500000 0.450000 11.250000 +v 9.000000 0.450000 15.250000 +v 14.500000 0.450000 13.250000 +v -19.500000 0.450000 -2.750000 +v -19.000000 0.450000 2.250000 +v -19.500000 0.450000 1.250000 +v -19.500000 0.450000 -1.000000 +v -12.500000 0.450000 14.250000 +v -10.500000 0.450000 15.250000 +v -5.000000 0.450000 17.250000 +v -3.250000 0.450000 18.250000 +v -7.000000 0.450000 16.250000 +v 1.250000 0.450000 11.750000 +v -8.500000 0.450000 16.250000 +v 19.500000 0.450000 -2.000000 +v 19.500000 0.450000 -2.750000 +v 19.500000 0.450000 -1.000000 +v 19.000000 0.450000 2.250000 +v 19.500000 0.450000 2.000000 +v 19.500000 0.450000 1.250000 +v 10.500000 0.450000 15.250000 +v 12.500000 0.450000 14.250000 +v 5.250000 0.450000 17.250000 +v 7.000000 0.450000 16.250000 +v 8.500000 0.450000 16.250000 +v -19.500000 0.450000 3.000000 +v -4.500000 0.450000 18.250000 +v -6.500000 0.450000 17.250000 +v -2.500000 0.450000 18.750000 +v 2.250000 0.450000 20.000000 +v 3.000000 0.450000 18.250000 +v 20.250000 0.950000 -2.000000 +v 20.250000 0.950000 -1.000000 +v 19.500000 0.450000 3.000000 +v 20.250000 0.950000 2.000000 +v 6.500000 0.450000 17.250000 +v 4.500000 0.450000 18.250000 +v -2.250000 0.450000 20.000000 +v 2.500000 0.450000 21.250000 +v 20.250000 0.950000 3.000000 +v -2.500000 0.450000 21.500000 +v 2.500000 0.450000 26.750000 +v 3.750000 0.450000 21.750000 +v -3.500000 0.450000 21.750000 +v -2.500000 0.450000 26.750000 +v 2.000000 0.450000 28.000000 +v 3.750000 0.450000 26.750000 +v 5.000000 0.450000 21.750000 +v -5.000000 0.450000 21.750000 +v -3.500000 0.450000 26.750000 +v -2.000000 0.450000 28.000000 +v 2.500000 0.450000 29.500000 +v 7.000000 0.450000 20.750000 +v 4.750000 0.450000 27.250000 +v 5.500000 0.450000 20.750000 +v -5.500000 0.450000 20.750000 +v -7.000000 0.450000 20.750000 +v -4.750000 0.450000 27.250000 +v -2.500000 0.450000 29.500000 +v -1.250000 0.700000 32.250000 +v 1.250000 0.700000 32.250000 +v 3.750000 0.450000 31.500000 +v 3.750000 0.450000 30.000000 +v 1.750000 0.450000 31.500000 +v 4.250000 0.450000 29.500000 +v 9.000000 0.450000 19.750000 +v 7.500000 0.450000 19.750000 +v 4.750000 0.450000 29.000000 +v -7.500000 0.450000 19.750000 +v -9.000000 0.450000 19.750000 +v -6.250000 0.450000 29.750000 +v -4.750000 0.450000 29.000000 +v -4.250000 0.450000 29.500000 +v -3.750000 0.450000 30.000000 +v -2.750000 0.450000 31.500000 +v -1.750000 0.450000 31.500000 +v 4.250000 0.450000 32.250000 +v 4.500000 0.450000 32.000000 +v 6.250000 0.450000 29.750000 +v 19.500000 0.450000 26.000000 +v 11.000000 0.450000 18.750000 +v 9.500000 0.450000 18.750000 +v -9.500000 0.450000 18.750000 +v -11.000000 0.450000 18.750000 +v -15.500000 0.450000 35.000000 +v -6.250000 0.450000 31.750000 +v -13.000000 0.450000 17.750000 +v -15.000000 0.450000 16.750000 +v -16.500000 0.450000 35.000000 +v -17.500000 0.450000 35.000000 +v -3.750000 0.450000 31.500000 +v -3.250000 0.450000 32.250000 +v 5.000000 0.450000 32.750000 +v 6.250000 0.450000 31.750000 +v 13.500000 0.450000 35.000000 +v 20.250000 0.950000 26.000000 +v 19.500000 0.450000 27.000000 +v 19.500000 0.450000 25.000000 +v 13.000000 0.450000 17.750000 +v 11.500000 0.450000 17.750000 +v -11.500000 0.450000 17.750000 +v -15.500000 0.950000 35.750000 +v -14.500000 0.450000 35.000000 +v -5.000000 0.450000 32.750000 +v -4.500000 0.450000 32.000000 +v -13.500000 0.450000 35.000000 +v -12.500000 0.450000 35.000000 +v -11.500000 0.450000 35.000000 +v -10.500000 0.450000 35.000000 +v -9.500000 0.450000 35.000000 +v -5.000000 0.450000 34.250000 +v -7.500000 0.450000 35.000000 +v -8.500000 0.450000 35.000000 +v -13.500000 0.450000 16.750000 +v -15.500000 0.450000 15.750000 +v -17.000000 0.450000 15.750000 +v -16.500000 0.950000 35.750000 +v -17.500000 0.950000 35.750000 +v -18.500000 0.450000 35.750000 +v -19.000000 0.450000 14.750000 +v -4.250000 0.450000 32.250000 +v 5.000000 0.450000 34.250000 +v 10.500000 0.450000 35.000000 +v 11.500000 0.450000 35.000000 +v 9.500000 0.450000 35.000000 +v 8.500000 0.450000 35.000000 +v 12.500000 0.450000 35.000000 +v 7.500000 0.450000 35.000000 +v 19.500000 0.450000 30.000000 +v 19.500000 0.450000 29.000000 +v 19.500000 0.450000 28.000000 +v 14.500000 0.450000 35.000000 +v 19.500000 0.450000 33.000000 +v 19.500000 0.450000 31.000000 +v 14.500000 0.950000 35.750000 +v 13.500000 0.950000 35.750000 +v 20.250000 0.950000 27.000000 +v 19.500000 0.450000 24.000000 +v 20.250000 0.950000 24.000000 +v 20.250000 0.950000 25.000000 +v 15.000000 0.450000 16.750000 +v 13.500000 0.450000 16.750000 +v 19.500000 0.450000 23.000000 +v -13.500000 0.950000 35.750000 +v -14.500000 0.950000 35.750000 +v -11.500000 0.950000 35.750000 +v -12.500000 0.950000 35.750000 +v -9.500000 0.950000 35.750000 +v -10.500000 0.950000 35.750000 +v -4.500000 0.450000 35.000000 +v -5.500000 0.450000 35.000000 +v -6.500000 0.450000 35.000000 +v -7.500000 0.950000 35.750000 +v -8.500000 0.950000 35.750000 +v -17.500000 0.450000 14.750000 +v -19.500000 0.450000 37.000000 +v -18.500000 0.450000 37.000000 +v -19.500000 0.450000 14.250000 +v 4.500000 0.450000 35.000000 +v 5.500000 0.450000 35.000000 +v 6.500000 0.450000 35.000000 +v 10.500000 0.950000 35.750000 +v 12.500000 0.950000 35.750000 +v 11.500000 0.950000 35.750000 +v 9.500000 0.950000 35.750000 +v 8.500000 0.950000 35.750000 +v 7.500000 0.950000 35.750000 +v 20.250000 0.950000 30.000000 +v 20.250000 0.950000 28.000000 +v 20.250000 0.950000 29.000000 +v 15.500000 0.450000 35.000000 +v 20.250000 0.950000 33.750000 +v 20.250000 0.950000 33.000000 +v 19.500000 0.450000 34.000000 +v 16.500000 0.450000 35.000000 +v 17.500000 0.450000 35.000000 +v 20.250000 0.950000 31.000000 +v 19.500000 0.450000 22.000000 +v 19.500000 0.450000 21.000000 +v 17.000000 0.450000 15.750000 +v 15.500000 0.450000 15.750000 +v 19.500000 0.450000 20.000000 +v 20.250000 0.950000 22.000000 +v 20.250000 0.950000 23.000000 +v -5.500000 0.950000 35.750000 +v -6.500000 0.950000 35.750000 +v 6.500000 0.950000 35.750000 +v 5.500000 0.950000 35.750000 +v 16.500000 0.950000 35.750000 +v 15.500000 0.950000 35.750000 +v 19.500000 0.700000 35.000000 +v 18.500000 0.450000 35.000000 +v 17.500000 0.950000 35.750000 +v 18.250000 0.950000 35.750000 +v 20.250000 0.950000 20.000000 +v 20.250000 0.950000 21.000000 +v 19.500000 0.450000 19.000000 +v 19.500000 0.450000 18.000000 +v 19.000000 0.450000 14.750000 +v 17.500000 0.450000 14.750000 +v 19.500000 0.450000 17.000000 +v 20.250000 0.950000 18.000000 +v 20.250000 0.950000 19.000000 +v 19.500000 0.450000 14.000000 +v 19.500000 0.450000 15.000000 +v 19.500000 0.450000 16.000000 +v 20.250000 0.950000 16.000000 +v 20.250000 0.950000 17.000000 +v 20.250000 0.950000 14.000000 +v 20.250000 0.950000 15.000000 + +f 1 2 3 +f 3 2 6 +f 6 10 11 +f 11 10 19 +f 11 19 26 +f 31 30 15 +f 27 11 28 +f 28 11 26 +f 28 26 42 +f 10 18 20 +f 19 34 26 +f 25 35 19 +f 21 36 25 +f 37 21 22 +f 22 21 10 +f 24 38 22 +f 41 24 39 +f 39 24 23 +f 48 39 49 +f 49 39 40 +f 40 39 23 +f 3 6 7 +f 7 6 12 +f 12 6 13 +f 13 6 11 +f 20 23 10 +f 10 23 24 +f 10 24 22 +f 40 50 49 +f 11 29 14 +f 14 29 15 +f 15 29 31 +f 25 19 10 +f 11 14 13 +f 13 14 12 +f 12 14 7 +f 7 14 15 +f 10 21 25 +f 183 182 160 +f 59 68 60 +f 60 68 69 +f 135 118 134 +f 134 118 117 +f 95 94 78 +f 78 94 96 +f 184 202 183 +f 183 202 203 +f 137 136 122 +f 162 185 161 +f 161 185 186 +f 93 97 92 +f 92 97 78 +f 140 163 158 +f 158 163 181 +f 78 96 98 +f 137 156 136 +f 136 156 157 +f 78 71 69 +f 69 71 62 +f 62 72 70 +f 70 72 81 +f 72 71 78 +f 71 72 62 +f 103 124 123 +f 123 124 141 +f 78 80 92 +f 92 80 79 +f 92 79 77 +f 92 77 93 +f 72 83 84 +f 84 83 102 +f 78 98 99 +f 99 104 85 +f 85 104 105 +f 84 103 101 +f 96 119 98 +f 98 119 120 +f 65 57 58 +f 114 113 94 +f 94 113 115 +f 140 158 139 +f 184 183 160 +f 95 116 117 +f 93 112 97 +f 95 114 94 +f 61 54 62 +f 75 65 66 +f 66 65 58 +f 66 58 67 +f 76 66 70 +f 70 66 67 +f 70 67 61 +f 70 61 62 +f 81 82 70 +f 100 81 101 +f 101 81 84 +f 84 81 72 +f 121 101 122 +f 122 101 123 +f 123 101 103 +f 138 122 139 +f 139 122 140 +f 140 122 136 +f 159 139 160 +f 160 139 161 +f 161 139 162 +f 95 117 118 +f 161 184 160 +f 123 137 122 +f 68 77 69 +f 69 77 79 +f 69 79 80 +f 69 80 78 +f 78 99 85 +f 95 118 114 +f 78 85 72 +f 158 162 139 +f 60 53 59 +f 59 53 51 +f 2 1 4 +f 4 1 5 +f 52 44 53 +f 53 44 51 +f 5 8 4 +f 4 8 9 +f 16 18 9 +f 52 54 44 +f 44 43 51 +f 16 32 33 +f 33 32 43 +f 33 43 44 +f 33 44 45 +f 17 16 8 +f 8 16 9 +f 16 17 32 +f 45 46 33 +f 33 46 47 +f 63 55 64 +f 64 55 56 +f 50 47 55 +f 55 47 46 +f 55 46 56 +f 56 46 57 +f 50 40 47 +f 46 58 57 +f 89 88 74 +f 74 88 90 +f 90 88 109 +f 87 86 73 +f 73 63 64 +f 64 74 73 +f 73 74 87 +f 87 74 91 +f 91 74 90 +f 91 106 87 +f 107 87 108 +f 108 87 106 +f 128 108 125 +f 125 108 106 +f 143 142 125 +f 164 143 144 +f 144 143 126 +f 165 144 145 +f 145 144 126 +f 145 126 146 +f 145 146 166 +f 147 126 127 +f 127 126 106 +f 106 126 125 +f 125 126 143 +f 166 167 145 +f 111 110 88 +f 88 110 109 +f 175 153 154 +f 154 153 132 +f 132 153 155 +f 155 153 176 +f 172 154 150 +f 150 154 132 +f 129 149 150 +f 133 129 110 +f 110 129 109 +f 130 109 131 +f 131 109 132 +f 132 109 129 +f 132 129 150 +f 153 177 176 +f 171 193 170 +f 152 173 174 +f 127 148 147 +f 147 148 170 +f 170 148 171 +f 171 148 151 +f 171 151 152 +f 171 152 174 +f 130 131 151 +f 151 131 152 +f 248 226 249 +f 249 226 250 +f 223 222 245 +f 245 222 246 +f 248 249 264 +f 264 249 265 +f 264 265 270 +f 197 196 176 +f 176 196 178 +f 176 178 155 +f 224 198 199 +f 199 198 179 +f 179 198 180 +f 199 226 224 +f 224 226 248 +f 223 245 247 +f 247 245 262 +f 247 262 263 +f 197 222 196 +f 196 222 223 +f 178 179 155 +f 155 179 180 +f 204 208 234 +f 234 208 237 +f 188 168 189 +f 189 168 169 +f 169 168 146 +f 205 235 236 +f 236 235 256 +f 235 205 206 +f 206 205 188 +f 208 204 190 +f 190 204 187 +f 187 166 168 +f 168 166 146 +f 168 190 187 +f 189 206 188 +f 171 174 194 +f 194 174 195 +f 195 221 220 +f 217 216 194 +f 212 213 218 +f 218 213 217 +f 217 194 218 +f 218 194 219 +f 219 194 220 +f 220 194 195 +f 230 219 229 +f 229 219 220 +f 257 240 241 +f 241 240 214 +f 209 191 210 +f 210 191 192 +f 192 191 169 +f 169 191 189 +f 238 210 211 +f 211 210 192 +f 215 239 211 +f 244 215 242 +f 242 215 214 +f 258 242 240 +f 240 242 214 +f 213 212 192 +f 192 212 214 +f 192 214 215 +f 192 215 211 +f 191 207 189 +f 266 253 254 +f 254 253 231 +f 255 254 232 +f 232 254 231 +f 227 251 232 +f 252 227 228 +f 228 227 200 +f 233 228 201 +f 201 228 200 +f 201 200 180 +f 201 180 198 +f 229 200 230 +f 230 200 231 +f 231 200 232 +f 232 200 227 +f 198 225 201 +f 267 261 253 +f 253 261 243 +f 253 243 231 +f 260 268 259 +f 259 241 260 +f 260 241 261 +f 261 241 243 +f 243 241 214 +f 307 308 323 +f 323 308 324 +f 390 389 352 +f 423 406 424 +f 424 406 422 +f 360 359 325 +f 403 402 363 +f 363 402 404 +f 371 408 373 +f 391 417 390 +f 390 417 418 +f 361 360 325 +f 356 396 358 +f 358 396 397 +f 362 325 363 +f 363 325 364 +f 353 392 355 +f 355 392 395 +f 329 368 328 +f 357 393 354 +f 354 393 394 +f 354 353 324 +f 362 365 325 +f 325 365 366 +f 359 364 325 +f 405 419 401 +f 401 419 420 +f 371 409 408 +f 359 398 364 +f 364 398 407 +f 363 401 362 +f 361 399 360 +f 360 399 400 +f 353 355 324 +f 310 326 327 +f 327 326 367 +f 277 273 278 +f 368 369 328 +f 328 369 370 +f 410 427 412 +f 408 413 373 +f 373 413 414 +f 355 356 324 +f 412 425 409 +f 409 425 426 +f 363 405 401 +f 428 432 427 +f 427 432 433 +f 410 428 427 +f 436 437 431 +f 431 437 438 +f 327 361 325 +f 429 434 435 +f 435 434 439 +f 435 439 440 +f 327 325 310 +f 310 325 309 +f 310 309 296 +f 310 296 311 +f 357 354 324 +f 436 429 435 +f 404 421 422 +f 404 406 363 +f 363 406 405 +f 309 295 298 +f 391 390 352 +f 404 422 406 +f 430 429 410 +f 410 429 431 +f 410 431 428 +f 411 410 371 +f 371 410 412 +f 371 412 409 +f 372 371 329 +f 329 371 373 +f 329 373 368 +f 330 329 311 +f 311 329 328 +f 311 328 310 +f 296 312 311 +f 297 296 283 +f 283 296 284 +f 284 296 298 +f 298 296 309 +f 285 283 278 +f 278 283 277 +f 277 283 284 +f 429 436 431 +f 358 391 352 +f 323 324 352 +f 352 324 358 +f 358 324 356 +f 357 324 325 +f 325 324 309 +f 341 380 381 +f 351 334 335 +f 335 334 316 +f 320 348 349 +f 315 332 319 +f 319 332 347 +f 333 315 316 +f 316 315 301 +f 336 374 333 +f 333 374 375 +f 336 316 337 +f 338 376 337 +f 337 376 377 +f 316 338 337 +f 340 378 339 +f 339 378 379 +f 318 317 301 +f 342 383 343 +f 343 383 384 +f 316 339 338 +f 381 415 382 +f 382 415 416 +f 301 315 319 +f 387 386 349 +f 349 386 350 +f 350 386 388 +f 316 340 339 +f 302 303 301 +f 341 381 382 +f 286 279 287 +f 287 279 280 +f 287 280 288 +f 299 287 300 +f 300 287 288 +f 314 313 300 +f 331 314 317 +f 317 314 301 +f 318 344 317 +f 346 345 318 +f 385 346 350 +f 350 346 320 +f 350 320 349 +f 341 382 342 +f 334 341 316 +f 316 341 342 +f 316 342 343 +f 302 301 288 +f 288 301 300 +f 300 301 314 +f 316 336 333 +f 319 320 301 +f 301 320 318 +f 318 320 346 +f 316 343 340 +f 279 274 280 +f 281 275 276 +f 276 275 272 +f 260 269 268 +f 268 269 271 +f 273 277 272 +f 274 271 275 +f 275 271 272 +f 272 271 269 +f 272 269 273 +f 275 280 274 +f 308 307 292 +f 292 307 294 +f 335 321 351 +f 351 321 322 +f 293 292 282 +f 282 292 294 +f 322 321 305 +f 305 321 304 +f 282 295 293 +f 304 303 289 +f 282 294 291 +f 289 281 290 +f 290 281 291 +f 291 281 282 +f 282 281 276 +f 306 305 289 +f 289 305 304 +f 289 290 306 diff --git a/data/maps/konda.xml b/data/maps/konda.xml new file mode 100644 index 0000000..fc85b63 --- /dev/null +++ b/data/maps/konda.xml @@ -0,0 +1,8 @@ + + + diff --git a/src/main.cpp b/src/main.cpp index e265e4a..0eeb379 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -40,6 +40,8 @@ static std::string get_map_path_from_env() { LOG_INFO("No map file path or name specified in environment, using default map"); return ""; } + + void signal_handler(int signal) { if (signal == SIGINT && g_server_instance) { LOG_INFO("Shutdown signal received. Cleaning up..."); diff --git a/src/systems/entity_manager.hpp b/src/systems/entity_manager.hpp index caf2f11..19dbcd6 100644 --- a/src/systems/entity_manager.hpp +++ b/src/systems/entity_manager.hpp @@ -124,8 +124,8 @@ class EntityManager { public: EntityManager() : next_entity_id_(1) { // TODO probably use system independent path separator - ploinky 14/11/2025 - LOG_INFO("Loading templates from ./data"); - for(std::string file_name : DataLoader::list_files_from_directory("./data", ".xml")) { + LOG_INFO("Loading templates from ./data/entities"); + for(std::string file_name : DataLoader::list_files_from_directory("./data/entities", ".xml")) { EntityTemplate entity_template = DataLoader::load_entity_template(file_name); if(entity_template_cache.find(entity_template.id) != entity_template_cache.end()) { LOG_WARN("OVERWRITING EXISTING TEMPLATE: %s", entity_template.id.c_str()); diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index 2a16b3a..3d4757e 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -11,7 +11,7 @@ #include #include -#include +#include #include GameServer::GameServer(int port, int max_clients, const std::string& map_path) @@ -36,17 +36,17 @@ GameServer::~GameServer() { } ERROR_CODE GameServer::initialize() { - // Initialize Map - std::optional map_opt = MapSystem::load_map(map_path_); + // Load map using DataLoader + std::optional map_opt = DataLoader::load_map(map_path_); if (!map_opt) { LOG_ERROR("Failed to load map"); return ERROR_CODE::ERROR_ENET_CREATION_FAILED; } - // Initialize Navigation FIRST before moving map + // Initialize Navigation navigation_service_ = std::make_unique(map_opt.value()); - // Now create the pointer copy for map_pointer + // Create pointer copy map_pointer_ = std::make_unique(std::move(map_opt.value())); // Initialize Network @@ -59,7 +59,7 @@ ERROR_CODE GameServer::initialize() { return net_result; } - // Initialize GameplayCoordinator with services + // Initialize GameplayCoordinator Systems initialize_coordinator(); return ERROR_CODE::ERROR_NONE; diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index 73cbe1f..e6669fd 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -1,6 +1,10 @@ #include #include +#include +#include +#include +#include #include #include @@ -232,6 +236,175 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { return temp; } +std::pair, std::vector>> DataLoader::load_navmesh_obj(const std::string& nav_file_path) { + std::vector vertices; + std::vector> polygons; + + std::ifstream file(nav_file_path); + if (!file.is_open()) { + LOG_ERROR("Failed to open navmesh OBJ file: %s", nav_file_path.c_str()); + return { vertices, polygons }; + } + + std::string line; + uint32_t line_number = 0; + + while (std::getline(file, line)) { + line_number++; + + // Skip empty lines and comments + if (line.empty() || line[0] == '#') { + continue; + } + + std::istringstream iss(line); + std::string prefix; + iss >> prefix; + + // Parse vertex (v x y z) + if (prefix == "v") { + float x, y, z; + if (!(iss >> x >> y >> z)) { + LOG_ERROR("Failed to parse vertex at line %u in: %s", line_number, nav_file_path.c_str()); + continue; + } + // Store as Vec2, using X and Z coordinates (Y is elevation) + vertices.push_back(Vec2(x, z)); + } + // Parse face (f v1 v2 v3 ...) + else if (prefix == "f") { + std::vector polygon; + std::string vertex_str; + + while (iss >> vertex_str) { + // OBJ indices are 1-based, convert to 0-based + uint32_t vertex_index = 0; + + // Handle formats: v, v/vt, v/vt/vn, v//vn + size_t first_slash = vertex_str.find('/'); + if (first_slash != std::string::npos) { + vertex_index = std::stoul(vertex_str.substr(0, first_slash)) - 1; + } else { + vertex_index = std::stoul(vertex_str) - 1; + } + + // Validate vertex index + if (vertex_index >= vertices.size()) { + LOG_ERROR("Invalid vertex index %u at line %u in: %s (only %zu vertices defined)", + vertex_index + 1, line_number, nav_file_path.c_str(), vertices.size()); + continue; + } + + polygon.push_back(vertex_index); + } + + if (polygon.size() >= 3) { + polygons.push_back(polygon); + } else if (!polygon.empty()) { + LOG_ERROR("Face with fewer than 3 vertices at line %u in: %s", line_number, nav_file_path.c_str()); + } + } + } + + file.close(); + + LOG_INFO("Loaded navmesh from %s: %zu polygons, %zu vertices", + nav_file_path.c_str(), polygons.size(), vertices.size()); + + return { vertices, polygons }; +} + +std::optional DataLoader::load_map(const std::string& map_name, const std::string& map_dir) { + Map map; + + // Verify map directory exists + if (!std::filesystem::exists(map_dir)) { + LOG_ERROR("Map directory does not exist: %s", map_dir.c_str()); + return std::nullopt; + } + + // Construct file paths + std::string xml_path = map_dir + map_name + ".xml"; + std::string nav_path = map_dir + map_name + ".nav.obj"; + + // Check both files exist + if (!std::filesystem::exists(xml_path)) { + LOG_ERROR("Map XML file not found: %s", xml_path.c_str()); + return std::nullopt; + } + + if (!std::filesystem::exists(nav_path)) { + LOG_ERROR("Map navmesh file not found: %s", nav_path.c_str()); + return std::nullopt; + } + + // Load XML metadata + pugi::xml_document doc; + pugi::xml_parse_status status = doc.load_file(xml_path.c_str()).status; + if (status != pugi::xml_parse_status::status_ok) { + LOG_ERROR("Failed to parse map XML file: %s, pugixml status is %d", xml_path.c_str(), status); + return std::nullopt; + } + + pugi::xml_node map_node = doc.child("map"); + if (map_node == NULL) { + LOG_ERROR("Map XML file missing 'map' root element: %s", xml_path.c_str()); + return std::nullopt; + } + + // Extract map name + std::string map_id = map_node.attribute("id").as_string(""); + if (map_id.empty()) { + map_id = map_name; // Fallback to provided map name + } + map.name = map_id; + + // Load navmesh OBJ data + auto [vertices, polygons] = load_navmesh_obj(nav_path); + if (vertices.empty() || polygons.empty()) { + LOG_ERROR("Failed to load navmesh data from: %s", nav_path.c_str()); + return std::nullopt; + } + + map.vertices = vertices; + map.polygons = polygons; + + // Parse spawn points from XML (if they exist) + pugi::xml_node spawn_points_node = map_node.child("spawn_points"); + if (!spawn_points_node.empty()) { + for (pugi::xml_node spawn = spawn_points_node.child("spawn"); spawn; spawn = spawn.next_sibling("spawn")) { + pugi::xml_node pos_node = spawn.child("position"); + if (!pos_node.empty()) { + float x = pos_node.attribute("x").as_float(0.0f); + float z = pos_node.attribute("z").as_float(0.0f); + map.spawnpoints.push_back(Vec2(x, z)); + LOG_DEBUG("Loaded spawn point: (%.1f, %.1f)", x, z); + } + } + } + + // Calculate map bounds and derived size/offset from vertices + if (!vertices.empty()) { + float min_x = vertices[0].x, max_x = vertices[0].x; + float min_y = vertices[0].y, max_y = vertices[0].y; + + for (const auto& v : vertices) { + min_x = std::min(min_x, v.x); + max_x = std::max(max_x, v.x); + min_y = std::min(min_y, v.y); + max_y = std::max(max_y, v.y); + } + + map.size = Vec2(max_x - min_x, max_y - min_y); + map.offset = Vec2((min_x + max_x) / 2.0f, (min_y + max_y) / 2.0f); + } + + LOG_INFO("Loaded map '%s' from XML: %zu vertices, %zu polygons, %zu spawnpoints", + map.name.c_str(), map.vertices.size(), map.polygons.size(), map.spawnpoints.size()); + + return std::optional(map); +} + std::vector DataLoader::list_files_from_directory(std::string path, std::string file_ending) { std::vector file_names; // Verify path exists diff --git a/src/systems/util/data_loader.hpp b/src/systems/util/data_loader.hpp index 63f4784..efbd378 100644 --- a/src/systems/util/data_loader.hpp +++ b/src/systems/util/data_loader.hpp @@ -3,12 +3,15 @@ #include #include #include +#include #include #include #include #include +#include #include +#include /** * Template for creating new entities. @@ -20,7 +23,7 @@ class EntityTemplate { }; /** - * Loads data (e.g. entities) from xml files + * Loads data (e.g. entities, maps) from xml and binary files */ class DataLoader { public: @@ -31,6 +34,14 @@ class DataLoader { */ static EntityTemplate load_entity_template(std::string file_name); + /** + * Load a map from XML and .nav files. + * @param map_name The name of the map (e.g., "konda") + * @param map_dir The directory containing map files (default: "./data/maps/") + * @return Optional Map component, or empty if loading failed + */ + static std::optional load_map(const std::string& map_name, const std::string& map_dir = "./data/maps/"); + /** * List all files with a matching file ending in a directory. * @param path The directory to search @@ -38,4 +49,13 @@ class DataLoader { * @return A vector of file names found in the directory, e.g. "path/file-name.xml" */ static std::vector list_files_from_directory(std::string path, std::string file_ending); + +private: + /** + * Load navmesh data from a .nav.obj OBJ file. + * Parses standard OBJ vertex (v) and face (f) definitions. + * @param nav_file_path Path to the .nav.obj file + * @return A pair of (vertices, polygons), empty if loading failed + */ + static std::pair, std::vector>> load_navmesh_obj(const std::string& nav_file_path); }; \ No newline at end of file diff --git a/src/systems/util/map_system.cpp b/src/systems/util/map_system.cpp deleted file mode 100644 index 7282062..0000000 --- a/src/systems/util/map_system.cpp +++ /dev/null @@ -1,782 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -std::optional MapSystem::load_map(const std::optional& file_path) { - std::string default_map_dir = "./data/maps/"; // STATIC -- cmkrist 15/11/2025 - // Check for default map directory, if missing error out and die - if (!std::filesystem::exists(default_map_dir)) { - LOG_ERROR("Default map directory does not exist: %s", default_map_dir.c_str()); - return std::nullopt; - } - // Create initial return variables - std::optional loaded_map; - std::string actual_file_path; - // Check for existing file path - if (file_path && !file_path->empty()) { - // Dedicated Path - if (file_path->find(".tscn") != std::string::npos) { - LOG_INFO("Loading map from specified file path: %s", file_path->c_str()); - actual_file_path = *file_path; - if (!std::filesystem::exists(actual_file_path)) { - LOG_ERROR("Specified map file does not exist: %s", actual_file_path.c_str()); - actual_file_path.clear(); - } - // Map Name - } else { - actual_file_path = default_map_dir + *file_path + ".tscn"; - if (std::filesystem::exists(actual_file_path)) { - LOG_INFO("Loading map from specified map name: %s", file_path->c_str()); - } else { - LOG_ERROR("Map file for specified map name does not exist: %s", actual_file_path.c_str()); - actual_file_path.clear(); - } - } - } - // ScanDir if no map set - if (actual_file_path.empty()) { - // Check for valid file paths - std::vector tscn_files; - for (const auto& entry : std::filesystem::directory_iterator(default_map_dir)) { - if (entry.is_regular_file() && entry.path().extension() == ".tscn") { - tscn_files.push_back(entry.path().filename().string()); - } - } - - if (tscn_files.empty()) { - LOG_ERROR("No .tscn files found in current directory. Cannot load map."); - return std::nullopt; - } - - actual_file_path = default_map_dir + tscn_files[0]; - LOG_INFO("Found .tscn file: %s", actual_file_path.c_str()); - } - // Read file - std::ifstream file(actual_file_path); - if (!file.is_open()) { - LOG_ERROR("Failed to open map file: %s", actual_file_path.c_str()); - return std::nullopt; - } - - std::stringstream buffer; - buffer << file.rdbuf(); - std::string file_content = buffer.str(); - file.close(); - - // Parse navmesh - NavMeshData navmesh_data = parse_navmesh_from_tscn(file_content); - if (navmesh_data.vertices.empty() || navmesh_data.polygons.empty()) { - LOG_ERROR("Failed to parse navmesh data from map file: %s", actual_file_path.c_str()); - return std::nullopt; - } - - // Parse spawnpoints - std::vector spawnpoints = parse_spawnpoints_from_tscn(file_content); - LOG_INFO("Parsed %zu spawnpoints from map file", spawnpoints.size()); - - // Extract spawnpoint positions for transformation - std::vector spawnpoint_positions; - for (const auto& sp : spawnpoints) { - spawnpoint_positions.push_back(sp.position); - } - - // Apply NavigationRegion3D transform to navmesh and spawnpoints - apply_navigation_region_transform(file_content, navmesh_data.vertices, spawnpoint_positions); - - // Update spawnpoints with transformed positions - for (size_t i = 0; i < spawnpoints.size() && i < spawnpoint_positions.size(); ++i) { - spawnpoints[i].position = spawnpoint_positions[i]; - } - - // Add Map component - Map map; - size_t final_slash_index = actual_file_path.find_last_of("/\\"); - // Get name from file - map.name = actual_file_path.substr(final_slash_index + 1, actual_file_path.find_last_of('.') - final_slash_index - 1); - map.vertices = navmesh_data.vertices; - map.polygons = navmesh_data.polygons; - // Store spawnpoints directly (already Vec2 from parsing) - map.spawnpoints.reserve(spawnpoints.size()); - for (const auto& sp : spawnpoints) { - map.spawnpoints.push_back(sp.position); - LOG_INFO(" Spawnpoint: (%.1f, %.1f)", sp.position.x, sp.position.y); - } - - // Calculate map bounds and derived size/offset - MapBounds bounds = MapSystem::calculate_bounds_from_vertices(navmesh_data.vertices); - map.size = Vec2(bounds.max.x - bounds.min.x, bounds.max.y - bounds.min.y); - // Offset is the center point between min and max - map.offset = Vec2((bounds.min.x + bounds.max.x) / 2.0f, (bounds.min.y + bounds.max.y) / 2.0f); - - // Build spatial acceleration grid for fast polygon lookups - MapSystem::build_polygon_grid(map, 1.0f); - - LOG_INFO("Loaded map '%s' with %zu vertices, %zu polygons, and %zu spawnpoints", - map.name.c_str(), navmesh_data.vertices.size(), navmesh_data.polygons.size(), spawnpoints.size()); - - return std::optional(map); -} - -MapSystem::NavMeshData MapSystem::parse_navmesh_from_tscn(const std::string& file_content) { - NavMeshData data; - - // Find the NavigationMesh subsection - size_t nav_mesh_pos = file_content.find("[sub_resource type=\"NavigationMesh\""); - if (nav_mesh_pos == std::string::npos) { - LOG_WARN("NavigationMesh subsection not found in tscn file"); - return data; - } - - // Find vertices line - std::string vertices_string = "vertices = PackedVector3Array("; - size_t vertices_pos = file_content.find(vertices_string, nav_mesh_pos); - if (vertices_pos == std::string::npos) { - LOG_WARN("vertices line not found in NavigationMesh"); - return data; - } - vertices_pos += vertices_string.length(); // Skip "vertices = PackedVector3Array(" - size_t vertices_end = file_content.find(")", vertices_pos); - if (vertices_end == std::string::npos) { - LOG_WARN("vertices end not found"); - return data; - } - - std::string vertices_str = file_content.substr(vertices_pos, vertices_end - vertices_pos); - data.vertices = parse_vertices_to_2D(vertices_str); - - // Find polygons line - std::string polygons_string = "polygons = ["; - size_t polygons_pos = file_content.find(polygons_string, nav_mesh_pos); - if (polygons_pos == std::string::npos) { - LOG_WARN("polygons line not found in NavigationMesh"); - return data; - } - - polygons_pos += polygons_string.length(); // Skip "polygons = [" - size_t polygons_end = file_content.find("]", polygons_pos); - if (polygons_end == std::string::npos) { - LOG_WARN("polygons end not found"); - return data; - } - - std::string polygons_data_raw = file_content.substr(polygons_pos, polygons_end - polygons_pos); - data.polygons = parse_polygons(polygons_data_raw); - - return data; -} - -std::vector MapSystem::parse_spawnpoints_from_tscn(const std::string& file_content) { - std::vector spawnpoints; - - // Find all SpawnPoint nodes - size_t pos = 0; - while (true) { - - size_t spawn_pos = file_content.find("[node name=\"", pos); - if (spawn_pos == std::string::npos) break; - - // Check type - size_t type_pos = file_content.find("type=\"Marker3D\"", spawn_pos); - if (type_pos == std::string::npos || type_pos > file_content.find("\n", spawn_pos)) { - pos = spawn_pos + 1; - continue; // Not a Marker3D node - } - - // Check groups for team and spawn type - size_t groups_pos = file_content.find("groups=[", spawn_pos); - if (groups_pos == std::string::npos || groups_pos > file_content.find("\n", spawn_pos)) { - pos = spawn_pos + 1; - continue; // No groups found - } - size_t groups_end = file_content.find("]", groups_pos); - - // Create spawnpoint before parsing details - SpawnPoint sp; - - std::string groups_str = file_content.substr(groups_pos, groups_end - groups_pos); - bool is_spawnpoint = false; - - // Check for spawn type - for (const auto& [spawn_type_str, spawn_type_enum] : spawn_groups) { - if (groups_str.find(spawn_type_str) != std::string::npos) { - is_spawnpoint = true; - sp.type = spawn_type_enum; - LOG_INFO("Marker3D node at pos %zu is a spawnpoint of type %d", spawn_pos, spawn_type_enum); - break; - } - } - - // Check for team ID (legacy: team_id appears as a group string) - // TODO: Verify team ID parsing logic - currently only checks spawn_groups for team assignment - for (const auto& [group_name, team_id] : spawn_teams) { - if (groups_str.find(group_name) != std::string::npos) { - sp.team_id = team_id; - break; - } - } - - if (!is_spawnpoint) { - pos = spawn_pos + 1; - continue; // Not a spawnpoint - } - - - // Parse position - std::string position_string = "Transform3D("; - size_t position_pos = file_content.find(position_string, spawn_pos); - if (position_pos == std::string::npos) { - LOG_WARN("SpawnPoint missing position data"); - pos = spawn_pos + 1; - continue; - } - position_pos += position_string.length(); // Skip "Transform3D(" - size_t position_end = file_content.find(")", position_pos); - if (position_end == std::string::npos) { - LOG_WARN("SpawnPoint missing position data"); - pos = spawn_pos + 1; - continue; - } - - std::string position_data = file_content.substr(position_pos, position_end - position_pos); - // Parse all values from Transform3D(m00, m01, ..., m33) - // Godot Transform3D has 12 values: 3x3 matrix (9) + position (3) - // Position is in the last 3 values (indices 9, 10, 11 which are x, y, z) - std::vector matrix_vals; - size_t tpos = 0; - - // Parse all floats - while (tpos < position_data.length()) { - // Skip whitespace - while (tpos < position_data.length() && std::isspace(position_data[tpos])) { - tpos++; - } - - if (tpos >= position_data.length()) break; - - // Negative numbers - size_t start = tpos; - if (position_data[tpos] == '-') tpos++; - - // Find end of number - while (tpos < position_data.length() && (std::isdigit(position_data[tpos]) || position_data[tpos] == '.')) { - tpos++; - } - - // Add number to coords - std::string num_str = position_data.substr(start, tpos - start); - if (!num_str.empty()) { - try { - matrix_vals.push_back(std::stof(num_str)); - } catch (...) { - LOG_WARN("Failed to parse spawnpoint matrix value: %s", num_str.c_str()); - } - } - - // Skip comma if present - if (tpos < position_data.length() && position_data[tpos] == ',') { - tpos++; - } - } - - // Set spawnpoint position from Transform3D matrix - // Transform3D has 12 values: indices 9, 10, 11 are x, y, z translation - if (matrix_vals.size() >= 12) { - sp.position = Vec2(matrix_vals[9], matrix_vals[11]); // x and z coordinates - LOG_INFO("Parsed spawnpoint position: (%.1f, %.1f)", sp.position.x, sp.position.y); - } else { - LOG_WARN("SpawnPoint position data malformed - got %zu values instead of 12", matrix_vals.size()); - } - - spawnpoints.push_back(sp); - pos = spawn_pos + 1; - } - - return spawnpoints; -} - -std::vector MapSystem::parse_vertices_to_2D(const std::string& vertices_data_raw) { - std::vector vertices; - std::vector coords; - size_t pos = 0; - // Add all vertices to coords - while (pos < vertices_data_raw.length()) { - // Skip whitespace - while (pos < vertices_data_raw.length() && std::isspace(vertices_data_raw[pos])) { - pos++; - } - - if (pos >= vertices_data_raw.length()) break; - - // Negative numbers - size_t start = pos; - if (vertices_data_raw[pos] == '-') pos++; - - // Find end of number - while (pos < vertices_data_raw.length() && (std::isdigit(vertices_data_raw[pos]) || vertices_data_raw[pos] == '.')) { - pos++; - } - - // Add number to coords - std::string num_str = vertices_data_raw.substr(start, pos - start); - if (!num_str.empty()) { - try { - coords.push_back(std::stof(num_str)); - } catch (...) { - LOG_WARN("Failed to parse vertex coordinate: %s", num_str.c_str()); - } - } - - // Skip comma if present - if (pos < vertices_data_raw.length() && vertices_data_raw[pos] == ',') { - pos++; - } - } - - // Parse Vec2 from Vec3 data (expects X, Y, Z coordinates, we use X and Z) - for (size_t i = 0; i + 2 < coords.size(); i += 3) { - vertices.push_back(Vec2(coords[i], coords[i + 2])); - } - - return vertices; -} - -std::vector> MapSystem::parse_polygons(const std::string& polygons_data_raw) { - std::vector> polygons; - - // Parse PackedInt32Array(...) entries - constexpr size_t PACKED_ARRAY_PREFIX_LEN = 17; // Length of "PackedInt32Array(" - size_t pos = 0; - while (pos < polygons_data_raw.length()) { - // Find start of PackedInt32Array - size_t array_start = polygons_data_raw.find("PackedInt32Array(", pos); - if (array_start == std::string::npos) break; - - array_start += PACKED_ARRAY_PREFIX_LEN; - size_t array_end = polygons_data_raw.find(")", array_start); - if (array_end == std::string::npos) break; - - std::string array_str = polygons_data_raw.substr(array_start, array_end - array_start); - std::vector polygon; - - // Parse indices - size_t idx_pos = 0; - while (idx_pos < array_str.length()) { - // Skip whitespace and commas - while (idx_pos < array_str.length() && (std::isspace(array_str[idx_pos]) || array_str[idx_pos] == ',')) { - idx_pos++; - } - - if (idx_pos >= array_str.length()) break; - - // Find end of number - size_t start = idx_pos; - while (idx_pos < array_str.length() && std::isdigit(array_str[idx_pos])) { - idx_pos++; - } - - std::string num_str = array_str.substr(start, idx_pos - start); - if (!num_str.empty()) { - try { - polygon.push_back(std::stoul(num_str)); - } catch (...) { - LOG_WARN("Failed to parse polygon index: %s", num_str.c_str()); - } - } - } - - if (!polygon.empty()) { - polygons.push_back(polygon); - } - - pos = array_end + 1; - } - - LOG_DEBUG("Parsed %zu polygons", polygons.size()); - return polygons; -} - -std::vector MapSystem::serialize_map(Entity* map_entity) { - if (!map_entity) { - LOG_ERROR("Cannot serialize null map entity"); - return {}; - } - - Map* map = map_entity->get_component(); - if (!map) { - LOG_ERROR("Map entity has no Map component"); - return {}; - } - - // Calculate packet size - // 1 byte (type) + 4 bytes (name length) + name + 4 bytes (vertex count) + 4 bytes (polygon count) - // Vertex and Polygon data for verification of local asset (client-side) - uint32_t name_len = (uint32_t)(map->name.length()); - uint32_t vertex_count = (uint32_t)(map->vertices.size()); - uint32_t polygon_count = (uint32_t)(map->polygons.size()); - - size_t packet_size = 1 + 4 + name_len + 4 + 4; - - std::vector data(packet_size); - size_t offset = 0; - - // Write packet type - data[offset++] = (uint8_t)(PACKET_TYPE::MAP_LOAD); - - // Write map name length - std::memcpy(data.data() + offset, &name_len, sizeof(uint32_t)); - offset += 4; - - // Write map name - std::memcpy(data.data() + offset, map->name.c_str(), name_len); - offset += name_len; - - // Write vertex count - std::memcpy(data.data() + offset, &vertex_count, sizeof(uint32_t)); - offset += 4; - - // Write polygon count - std::memcpy(data.data() + offset, &polygon_count, sizeof(uint32_t)); - offset += 4; - - LOG_INFO("Serialized map '%s' with %zu vertices and %zu polygons into packet (size: %zu bytes)", - map->name.c_str(), map->vertices.size(), map->polygons.size(), packet_size); - - return data; -} - -Vec2 MapSystem::calculate_size_from_vertices(const std::vector& vertices) { - if (vertices.empty()) { - return Vec2(0.0f, 0.0f); - } - - float min_x = vertices[0].x; - float max_x = vertices[0].x; - float min_y = vertices[0].y; - float max_y = vertices[0].y; - - for (const auto& v : vertices) { - min_x = std::min(min_x, v.x); - max_x = std::max(max_x, v.x); - min_y = std::min(min_y, v.y); - max_y = std::max(max_y, v.y); - } - - return Vec2(max_x - min_x, max_y - min_y); -} - -MapSystem::MapBounds MapSystem::calculate_bounds_from_vertices(const std::vector& vertices) { - MapBounds bounds; - - if (vertices.empty()) { - bounds.min = Vec2(0.0f, 0.0f); - bounds.max = Vec2(0.0f, 0.0f); - return bounds; - } - - bounds.min.x = vertices[0].x; - bounds.max.x = vertices[0].x; - bounds.min.y = vertices[0].y; - bounds.max.y = vertices[0].y; - - for (const auto& v : vertices) { - bounds.min.x = std::min(bounds.min.x, v.x); - bounds.max.x = std::max(bounds.max.x, v.x); - bounds.min.y = std::min(bounds.min.y, v.y); - bounds.max.y = std::max(bounds.max.y, v.y); - } - - return bounds; -} - -MapSystem::TransformData -MapSystem::parse_transform_3d(const std::string& transform_str) { - // Format: Transform3D(m00, m01, m02, m10, m11, m12, m20, m21, m22, x, y, z) - MapSystem::TransformData data; - data.has_rotation = false; - data.position.x = 0.0f; - data.position.y = 0.0f; - - // Initialize matrix to identity - for (int i = 0; i < 3; i++) { - for (int j = 0; j < 3; j++) { - data.matrix[i][j] = (i == j) ? 1.0f : 0.0f; - } - } - - std::vector values; - size_t pos = 0; - - // Parse all 12 floats from the transform string - while (pos < transform_str.length() && values.size() < 12) { - // Skip whitespace and commas - while (pos < transform_str.length() && (std::isspace(transform_str[pos]) || transform_str[pos] == ',')) { - pos++; - } - - if (pos >= transform_str.length()) break; - - // Parse number - size_t start = pos; - if (transform_str[pos] == '-') pos++; - - // Parse digits and decimal point - while (pos < transform_str.length() && (std::isdigit(transform_str[pos]) || transform_str[pos] == '.')) { - pos++; - } - - // Handle scientific notation (e or E) - if (pos < transform_str.length() && (transform_str[pos] == 'e' || transform_str[pos] == 'E')) { - pos++; - // Handle optional sign after e - if (pos < transform_str.length() && (transform_str[pos] == '+' || transform_str[pos] == '-')) { - pos++; - } - // Parse exponent digits - while (pos < transform_str.length() && std::isdigit(transform_str[pos])) { - pos++; - } - } - - if (pos > start) { - try { - values.push_back(std::stof(transform_str.substr(start, pos - start))); - } catch (...) { - LOG_WARN("Failed to parse transform value from '%s'", transform_str.substr(start, pos - start).c_str()); - } - } - } - - if (values.size() >= 12) { - // Extract 3x3 rotation matrix - for (int i = 0; i < 3; i++) { - for (int j = 0; j < 3; j++) { - data.matrix[i][j] = values[i * 3 + j]; - } - } - - // Extract position (last 3 values) - data.position.x = values[9]; - data.position.y = values[11]; // z coordinate becomes y - - // Check if there's any significant rotation (check if matrix is not identity) - const float eps = 0.0001f; - for (int i = 0; i < 3; i++) { - for (int j = 0; j < 3; j++) { - float expected = (i == j) ? 1.0f : 0.0f; - if (std::abs(data.matrix[i][j] - expected) > eps) { - data.has_rotation = true; - break; - } - } - if (data.has_rotation) break; - } - - if (data.has_rotation) { - LOG_INFO("Detected rotation in NavigationRegion3D: matrix=[[%.4f,%.4f,%.4f],[%.4f,%.4f,%.4f],[%.4f,%.4f,%.4f]]", - data.matrix[0][0], data.matrix[0][1], data.matrix[0][2], - data.matrix[1][0], data.matrix[1][1], data.matrix[1][2], - data.matrix[2][0], data.matrix[2][1], data.matrix[2][2]); - } - } else { - LOG_WARN("Failed to parse Transform3D - expected 12 values, got %zu", values.size()); - } - - return data; -} - -void MapSystem::apply_navigation_region_transform(const std::string& file_content, - std::vector& vertices, - std::vector& spawnpoints) { - // Find the NavigationRegion3D node and extract its transform - size_t nav_region_pos = file_content.find("[node name=\""); - if (nav_region_pos == std::string::npos) { - LOG_WARN("No node found in tscn file"); - return; - } - - // Find the first node's transform line (should be the root NavigationRegion3D) - size_t transform_pos = file_content.find("transform = Transform3D(", nav_region_pos); - if (transform_pos == std::string::npos) { - LOG_DEBUG("No transform found on NavigationRegion3D node (using default identity)"); - return; - } - - // Extract transform string - transform_pos += std::string("transform = Transform3D(").length(); - size_t transform_end = file_content.find(")", transform_pos); - if (transform_end == std::string::npos) { - LOG_WARN("Failed to find end of Transform3D string"); - return; - } - - std::string transform_str = file_content.substr(transform_pos, transform_end - transform_pos); - MapSystem::TransformData transform_data = parse_transform_3d(transform_str); - - if (!transform_data.has_rotation) { - LOG_DEBUG("NavigationRegion3D has identity rotation (no transformation needed)"); - return; - } - - // Apply rotation to vertices - // Transform is 3D: (X, Y, Z) -> applying 2D projection - // Godot uses X-right, Y-up, Z-back coordinate system - // We extract X and Z (converting Z to Y in 2D) - for (auto& v : vertices) { - float x3d = v.x; - float z3d = v.y; // Y in 2D is Z in 3D - float y3d = 0.0f; // Navmesh is flat on Y=0 plane - - // Apply rotation: result = matrix * [x, y, z] - float new_x = transform_data.matrix[0][0] * x3d + transform_data.matrix[0][1] * y3d + transform_data.matrix[0][2] * z3d; - float new_z = transform_data.matrix[2][0] * x3d + transform_data.matrix[2][1] * y3d + transform_data.matrix[2][2] * z3d; - - // Store back as 2D (X and Z become X and Y) - v.x = new_x; - v.y = new_z; - } - - // Apply rotation to spawnpoints - for (auto& sp : spawnpoints) { - float x3d = sp.x; - float z3d = sp.y; - float y3d = 0.0f; // Spawnpoints are on the ground plane - - float new_x = transform_data.matrix[0][0] * x3d + transform_data.matrix[0][1] * y3d + transform_data.matrix[0][2] * z3d; - float new_z = transform_data.matrix[2][0] * x3d + transform_data.matrix[2][1] * y3d + transform_data.matrix[2][2] * z3d; - - sp.x = new_x; - sp.y = new_z; - } - - LOG_INFO("Applied NavigationRegion3D transform to %zu vertices and %zu spawnpoints", - vertices.size(), spawnpoints.size()); -} - -void MapSystem::build_polygon_grid(Map& map, float cell_size) { - if (map.vertices.empty() || map.polygons.empty() || cell_size <= 0.0f) { - LOG_WARN("build_polygon_grid: Invalid input (vertices: %zu, polygons: %zu, cell_size: %.1f)", - map.vertices.size(), map.polygons.size(), cell_size); - return; - } - - map.grid_cell_size = cell_size; - - // Find bounding box of all vertices - Vec2 min_bounds = map.vertices[0]; - Vec2 max_bounds = map.vertices[0]; - - for (const auto& vertex : map.vertices) { - min_bounds.x = std::min(min_bounds.x, vertex.x); - min_bounds.y = std::min(min_bounds.y, vertex.y); - max_bounds.x = std::max(max_bounds.x, vertex.x); - max_bounds.y = std::max(max_bounds.y, vertex.y); - } - - // Add padding to bounds to handle edge cases - const float PADDING = cell_size * 0.5f; - min_bounds.x -= PADDING; - min_bounds.y -= PADDING; - max_bounds.x += PADDING; - max_bounds.y += PADDING; - - map.grid_origin = min_bounds; - - // Calculate grid dimensions - Vec2 bounds_size = max_bounds - min_bounds; - map.grid_width = std::max(1, static_cast(std::ceil(bounds_size.x / cell_size))); - map.grid_height = std::max(1, static_cast(std::ceil(bounds_size.y / cell_size))); - - // Initialize grid: grid_cells[y * grid_width + x] = {polygon_ids} - map.grid_cells.resize(map.grid_width * map.grid_height); - - LOG_DEBUG("build_polygon_grid: Grid dimensions %dx%d (cell_size: %.1f, bounds: (%.1f,%.1f) to (%.1f,%.1f))", - map.grid_width, map.grid_height, cell_size, - min_bounds.x, min_bounds.y, max_bounds.x, max_bounds.y); - - // Helper lambda to get polygon bounds - auto GetPolygonBounds = [&](const std::vector& polygon, Vec2& out_min, Vec2& out_max) { - if (polygon.empty()) { - out_min = Vec2(0.0f, 0.0f); - out_max = Vec2(0.0f, 0.0f); - return; - } - - uint32_t first_idx = polygon[0]; - if (first_idx >= map.vertices.size()) { - out_min = Vec2(0.0f, 0.0f); - out_max = Vec2(0.0f, 0.0f); - return; - } - - out_min = map.vertices[first_idx]; - out_max = map.vertices[first_idx]; - - for (uint32_t vertex_idx : polygon) { - if (vertex_idx >= map.vertices.size()) { - continue; - } - - const Vec2& vertex = map.vertices[vertex_idx]; - out_min.x = std::min(out_min.x, vertex.x); - out_min.y = std::min(out_min.y, vertex.y); - out_max.x = std::max(out_max.x, vertex.x); - out_max.y = std::max(out_max.y, vertex.y); - } - }; - - // Helper lambda to convert world position to grid coordinates - auto WorldToGridCoords = [&](const Vec2& world_pos, int& out_x, int& out_y) { - Vec2 relative_pos = world_pos - map.grid_origin; - - out_x = static_cast(std::floor(relative_pos.x / cell_size)); - out_y = static_cast(std::floor(relative_pos.y / cell_size)); - - // Clamp to valid grid range - out_x = std::max(0, std::min(out_x, map.grid_width - 1)); - out_y = std::max(0, std::min(out_y, map.grid_height - 1)); - }; - - // Add each polygon to grid cells it overlaps - for (uint32_t poly_id = 0; poly_id < map.polygons.size(); ++poly_id) { - Vec2 poly_min, poly_max; - GetPolygonBounds(map.polygons[poly_id], poly_min, poly_max); - - // Convert polygon bounds to grid coordinates - int min_x, min_y, max_x, max_y; - WorldToGridCoords(poly_min, min_x, min_y); - WorldToGridCoords(poly_max, max_x, max_y); - - // Add polygon ID to all grid cells it overlaps - for (int y = min_y; y <= max_y; ++y) { - for (int x = min_x; x <= max_x; ++x) { - int index = y * map.grid_width + x; - map.grid_cells[index].push_back(poly_id); - } - } - } - - // Log statistics - int total_entries = 0; - int non_empty_cells = 0; - for (const auto& cell : map.grid_cells) { - if (!cell.empty()) { - non_empty_cells++; - total_entries += cell.size(); - } - } - - LOG_INFO("Polygon grid built: %d non-empty cells, %.1f polygons per cell average", - non_empty_cells, non_empty_cells > 0 ? static_cast(total_entries) / non_empty_cells : 0.0f); -} \ No newline at end of file diff --git a/src/systems/util/map_system.hpp b/src/systems/util/map_system.hpp deleted file mode 100644 index 55c028d..0000000 --- a/src/systems/util/map_system.hpp +++ /dev/null @@ -1,136 +0,0 @@ -#pragma once - -#include "entity_manager.hpp" -#include "math.hpp" -#include "packet_validator.hpp" -#include -#include -#include -#include - -#include - -enum spawn_type : uint8_t { - PLAYER_SPAWN, - MINION_SPAWN, - MONSTER_SPAWN, - CAMP_SPAWN, - OBJECTIVE_SPAWN -}; - -const std::unordered_map spawn_groups = { - {"player_spawn", spawn_type::PLAYER_SPAWN}, - {"minion_spawn", spawn_type::MINION_SPAWN}, - {"monster_spawn", spawn_type::MONSTER_SPAWN}, - {"camp_spawn", spawn_type::CAMP_SPAWN}, - {"objective_spawn", spawn_type::OBJECTIVE_SPAWN} -}; - -const std::unordered_map spawn_teams = { - {"team1", 1}, - {"team2", 2} -}; -/** - * System to load and manage game maps from Godot tscn files. - * Parses navmesh data and provides it to clients. - */ -class MapSystem { -public: - /** - * Data structure for navmesh information. - */ - struct NavMeshData { - std::vector vertices; - std::vector> polygons; - }; - - struct SpawnPoint { - Vec2 position; - uint8_t team_id; - spawn_type type; - }; - - /** - * Load a map from a Godot tscn file. - * If no path is provided or the file doesn't exist, scans the current directory for .tscn files. - * If no map file is found using either method, returns nullptr. - * @param map_name Name of the map (e.g., "Konda"). If empty, derived from filename. - * @param file_path Path to the .tscn file. If empty, scans current directory. - * @param entity_manager Reference to the entity manager - * @return Pointer to the created map entity, or nullptr if loading failed - */ - static std::optional load_map(const std::optional& file_path); - - /** - * Serialize map data to an ENet packet. - * Packet format: - * [0] - PACKET_TYPE::GAME_STATE - * [1-4] - name length (uint32_t, little-endian) - * [5+N] - map name (string) - * [5+N+0-3] - vertex count (uint32_t) - * [5+N+4+...] - vertices (3 floats each) - * [...-3] - polygon count (uint32_t) - * [...] - polygons (variable length) - * - * @param map_entity The map entity to serialize - * @return Vector with serialized map data, or empty vector on failure - */ - static std::vector serialize_map(Entity* map_entity); - /** - * Build spatial acceleration grid for fast polygon lookups. - * Divides map space into uniform cells and assigns polygon IDs to each cell. - * Static data - computed once at load time, never modified. - * @param map The map to build grid for (modified in-place) - * @param cell_size Size of each grid cell in world units (default 50.0f) - */ - static void build_polygon_grid(Map& map, float cell_size = 50.0f); - -private: - /** - * Structure to hold transformation matrix data. - */ - struct TransformData { - float matrix[3][3]; - Vec2 position; - bool has_rotation; - }; - - /** - * Structure to hold map bounds information (min/max coordinates). - */ - struct MapBounds { - Vec2 min; // Minimum (x, y) coordinates - Vec2 max; // Maximum (x, y) coordinates - }; - - /** - * Extract the Transform3D from the NavigationRegion3D node and apply it to navmesh vertices. - * @param file_content The TSCN file content - * @param vertices The vertices to transform (modified in-place) - * @param spawnpoints The spawnpoints to transform (modified in-place) - */ - static void apply_navigation_region_transform(const std::string& file_content, - std::vector& vertices, - std::vector& spawnpoints); - - /** - * Parse a Transform3D matrix string from Godot format. - * Format: Transform3D(m00, m01, m02, m10, m11, m12, m20, m21, m22, x, y, z) - * @param transform_str The transform string to parse - * @return TransformData containing rotation matrix and position - */ - static TransformData parse_transform_3d(const std::string& transform_str); - - /** - * Parse a Godot tscn file and extract navmesh data. - * Looks for NavigationMesh subsection with vertices and polygons. - * @param file_content The contents of the tscn file - * @return NavMeshData with vertices and polygons, empty if parsing failed - */ - static NavMeshData parse_navmesh_from_tscn(const std::string& file_content); - static std::vector parse_spawnpoints_from_tscn(const std::string& file_content); - static std::vector parse_vertices_to_2D(const std::string& vertices_str); - static std::vector> parse_polygons(const std::string& polygons_str); - static Vec2 calculate_size_from_vertices(const std::vector& vertices); - static MapBounds calculate_bounds_from_vertices(const std::vector& vertices); -}; From 7a0798814441a1ab84e57ee177ea2f1a694806e7 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 07:54:34 -0500 Subject: [PATCH 66/79] unlimited/autostart on 0 max players --- .vscode/launch.json | 29 +++++++++++----- data/maps/konda.xml | 68 ++++++++++++++++++++++++++++++++++++++ src/systems/gameserver.cpp | 35 +++++++++++++++----- 3 files changed, 115 insertions(+), 17 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index fde5ad2..4aabf6c 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -9,8 +9,19 @@ "args": ["--visualize"], "stopAtEntry": false, "cwd": "${workspaceFolder}", - "environment": [], - "console": "externalTerminal" + "environment": [{"name": "MAP_NAME", "value": "konda"}], + "console": "integratedTerminal" + }, + { + "name": "Win(D) Visual Autostart", + "type": "cppvsdbg", + "request": "launch", + "program": "${workspaceFolder}/build/_output/windows_x64/Debug/gameserver.exe", + "args": ["--visualize"], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [{"name": "MAP_NAME", "value": "konda"}, {"name": "MAX_CLIENTS", "value": "0"}], + "console": "integratedTerminal" }, { "name": "Win(D) Debug", @@ -20,19 +31,19 @@ "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", - "environment": [], + "environment": [{"name": "MAP_NAME", "value": "konda"}], "console": "integratedTerminal" }, { "name": "Win(R) Visual", "type": "cppvsdbg", "request": "launch", - "program": "${workspaceFolder}/build/_output/windows_x64/Release/gameserver.exe --visualize", - "args": [], + "program": "${workspaceFolder}/build/_output/windows_x64/Release/gameserver.exe", + "args": ["--visualize"], "stopAtEntry": false, "cwd": "${workspaceFolder}", - "environment": [], - "console": "externalTerminal" + "environment": [{"name": "MAP_NAME", "value": "konda"}], + "console": "integratedTerminal" }, { "name": "Win(R) Debug", @@ -42,8 +53,8 @@ "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", - "environment": [], - "console": "externalTerminal" + "environment": [{"name": "MAP_NAME", "value": "konda"}], + "console": "integratedTerminal" } ] } \ No newline at end of file diff --git a/data/maps/konda.xml b/data/maps/konda.xml index fc85b63..fc1a479 100644 --- a/data/maps/konda.xml +++ b/data/maps/konda.xml @@ -5,4 +5,72 @@ xsi:schemaLocation="https://open-champ.com/mySchema ./maps/_map.xsd" id="konda" > + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index 3d4757e..951bd11 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -61,6 +61,17 @@ ERROR_CODE GameServer::initialize() { // Initialize GameplayCoordinator Systems initialize_coordinator(); + + // Autostart logic (Unlimited players) -- cmkrist 4/12/ + if (max_clients_ == 0) { + LOG_INFO("max_players set to 0, transitioning straight to ONGOING state"); + try_transition_state(GAME_STATE::ONGOING); + } + // Default lobby ready check + else if (is_lobby_full() && is_lobby_ready()) { + LOG_INFO("Lobby full and ready on startup, transitioning to ONGOING state"); + try_transition_state(GAME_STATE::ONGOING); + } return ERROR_CODE::ERROR_NONE; } @@ -147,8 +158,7 @@ bool GameServer::is_lobby_full() const { void GameServer::on_client_connect(std::string client_id) { // Lobby check & Map Send - - if (player_manager_.is_full(max_clients_)) { + if (max_clients_ > 0 && player_manager_.is_full(max_clients_)) { LOG_WARN("Lobby full! Rejecting new connection from %s", client_id.c_str()); network_service_.disconnect_client(client_id); network_service_.send_packet(PACKET_TYPE::LOBBY_FULL, client_id); @@ -163,7 +173,9 @@ void GameServer::on_client_connect(std::string client_id) { LOG_INFO("Player %s added. Entity ID: %u", client_id.c_str(), player_entity_id); - if (player_manager_.is_full(max_clients_)) { + if (max_clients_ == 0) { + LOG_INFO("max_players set to 0 (unlimited), player connected"); + } else if (player_manager_.is_full(max_clients_)) { LOG_INFO("Lobby full! Waiting for all players to be ready"); } else { LOG_INFO("Waiting for more players..."); @@ -174,11 +186,18 @@ void GameServer::on_packet_received(std::string client_id, const uint8_t* data, // Delegate to PacketHandler for processing packet_handler_.handle_packet(client_id, data, length); - // Check if we should transition to ONGOING after processing packet - if (current_state_ == GAME_STATE::PREGAME && - player_manager_.is_full(max_clients_) && - player_manager_.are_all_players_ready(entity_manager_)) { - + // Default lobby ready check with autostart -- cmkrist 4/12/2025 + bool should_start_game = false; + if (current_state_ == GAME_STATE::PREGAME) { + if (max_clients_ == 0) { + should_start_game = true; + } else if (player_manager_.is_full(max_clients_) && + player_manager_.are_all_players_ready(entity_manager_)) { + should_start_game = true; + } + } + + if (should_start_game) { LOG_INFO("All players ready! Transitioning to ONGOING state"); if (try_transition_state(GAME_STATE::ONGOING)) { // Notify all players that the game is starting From f6c59f95ee9db67af13c36e744de6219e51c8fab Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 07:55:04 -0500 Subject: [PATCH 67/79] Remove unnecesary debugging --- src/main.cpp | 18 ++++++------------ src/systems/entity_manager.hpp | 1 - 2 files changed, 6 insertions(+), 13 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 0eeb379..c71da9c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -62,7 +62,6 @@ int main(int argc, char* argv[]) { std::string arg(argv[i]); if (arg == "--visualize") { enable_visualizer = true; - LOG_INFO("Visualizer enabled (will run on port %u)", visualizer_port); } else if (arg == "--visualize-port" && i + 1 < argc) { try { visualizer_port = std::stoi(argv[++i]); @@ -72,6 +71,7 @@ int main(int argc, char* argv[]) { } } } + LOG_INFO("Visualizer: %s ", enable_visualizer ? ("Enabled on port " + std::to_string(visualizer_port)).c_str() : "No"); // Parse port from environment int env_port = DEFAULT_PORT; @@ -82,16 +82,13 @@ int main(int argc, char* argv[]) { if (env_port <= MIN_PORT || env_port > MAX_PORT) { LOG_ERROR("Invalid port number: %s. Using default %d", port_env, DEFAULT_PORT); env_port = DEFAULT_PORT; - } else { - LOG_INFO("Using port from environment: %d\n", env_port); - } + } } catch (const std::exception& e) { LOG_ERROR("Failed to parse SERVER_PORT: %s. Using default %d", e.what(), DEFAULT_PORT); env_port = DEFAULT_PORT; } - } else { - LOG_INFO("No port specified in environment, using default %d", DEFAULT_PORT); } + LOG_INFO("Game Port: %d", env_port); // Parse max clients from environment int max_clients = DEFAULT_MAX_CLIENTS; @@ -99,19 +96,16 @@ int main(int argc, char* argv[]) { if (clients_env != nullptr) { try { max_clients = std::stoi(clients_env); - if (max_clients <= 0 || max_clients > MAX_CLIENTS_LIMIT) { + if (max_clients < 0 || max_clients > MAX_CLIENTS_LIMIT) { LOG_ERROR("Invalid MAX_CLIENTS: %s. Using default %d", clients_env, DEFAULT_MAX_CLIENTS); max_clients = DEFAULT_MAX_CLIENTS; - } else { - LOG_INFO("Using MAX_CLIENTS from environment: %d", max_clients); } } catch (const std::exception& e) { LOG_ERROR("Failed to parse MAX_CLIENTS: %s. Using default %d", e.what(), DEFAULT_MAX_CLIENTS); max_clients = DEFAULT_MAX_CLIENTS; } - } else { - LOG_INFO("No MAX_CLIENTS specified in environment, using default %d", DEFAULT_MAX_CLIENTS); - } + } + LOG_INFO("Max Clients: %d", max_clients); // Create and initialize server GameServer server(env_port, max_clients, get_map_path_from_env()); diff --git a/src/systems/entity_manager.hpp b/src/systems/entity_manager.hpp index 19dbcd6..72d57f4 100644 --- a/src/systems/entity_manager.hpp +++ b/src/systems/entity_manager.hpp @@ -124,7 +124,6 @@ class EntityManager { public: EntityManager() : next_entity_id_(1) { // TODO probably use system independent path separator - ploinky 14/11/2025 - LOG_INFO("Loading templates from ./data/entities"); for(std::string file_name : DataLoader::list_files_from_directory("./data/entities", ".xml")) { EntityTemplate entity_template = DataLoader::load_entity_template(file_name); if(entity_template_cache.find(entity_template.id) != entity_template_cache.end()) { From ac8229f2bd1089dba559ff71900dfbd6b260632e Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 07:55:50 -0500 Subject: [PATCH 68/79] Polygon grid builder --- src/systems/util/data_loader.cpp | 167 ++++++++++++++++++++++++++++++- src/systems/util/data_loader.hpp | 7 ++ 2 files changed, 170 insertions(+), 4 deletions(-) diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index e6669fd..a115fbc 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include @@ -232,7 +233,7 @@ EntityTemplate DataLoader::load_entity_template(std::string file_name) { temp.component_templates.push_back(intent); } - LOG_INFO("Successfully loaded template entity \"%s\" from %s with %d components", temp.id.c_str(), file_name.c_str(), temp.component_templates.size()); + LOG_INFO("Entity Template Loaded: \"%s\" || %d components", temp.id.c_str(), temp.component_templates.size()); return temp; } @@ -399,8 +400,12 @@ std::optional DataLoader::load_map(const std::string& map_name, const std:: map.offset = Vec2((min_x + max_x) / 2.0f, (min_y + max_y) / 2.0f); } - LOG_INFO("Loaded map '%s' from XML: %zu vertices, %zu polygons, %zu spawnpoints", - map.name.c_str(), map.vertices.size(), map.polygons.size(), map.spawnpoints.size()); + // Build the polygon grid for spatial acceleration + build_polygon_grid(map); + + LOG_INFO("Loaded map '%s' from XML: %zu vertices, %zu polygons, %zu spawnpoints. Grid: %dx%d cells", + map.name.c_str(), map.vertices.size(), map.polygons.size(), map.spawnpoints.size(), + map.grid_width, map.grid_height); return std::optional(map); } @@ -426,4 +431,158 @@ std::vector DataLoader::list_files_from_directory(std::string path, } return file_names; -} \ No newline at end of file +} + +void DataLoader::build_polygon_grid(Map& map) { + map.grid_cell_size = 1.0f; // Default cell size + // Require at least some vertices and polygons + if (map.vertices.empty() || map.polygons.empty()) { + LOG_WARN("build_polygon_grid: Invalid input (vertices: %zu, polygons: %zu, cell_size: %.1f)", + map.vertices.size(), map.polygons.size(), map.grid_cell_size); + return; + } + + // Find bounds of all vertices + Vec2 min_bounds = map.vertices[0]; + Vec2 max_bounds = map.vertices[0]; + + for (const auto& vertex : map.vertices) { + min_bounds.x = std::min(min_bounds.x, vertex.x); + min_bounds.y = std::min(min_bounds.y, vertex.y); + max_bounds.x = std::max(max_bounds.x, vertex.x); + max_bounds.y = std::max(max_bounds.y, vertex.y); + } + + // Add padding to bounds to handle edge cases + const float PADDING = map.grid_cell_size * 0.5f; + min_bounds.x -= PADDING; + min_bounds.y -= PADDING; + max_bounds.x += PADDING; + max_bounds.y += PADDING; + + map.grid_origin = min_bounds; + + // Calculate grid dimensions + Vec2 bounds_size = max_bounds - min_bounds; + map.grid_width = std::max(1, static_cast(std::ceil(bounds_size.x / map.grid_cell_size))); + map.grid_height = std::max(1, static_cast(std::ceil(bounds_size.y / map.grid_cell_size))); + + // Initialize grid: grid_cells[y * grid_width + x] = {polygon_ids} + map.grid_cells.resize(map.grid_width * map.grid_height); + + // Helper lambda to get polygon bounds + auto GetPolygonBounds = [&](const std::vector& polygon, Vec2& out_min, Vec2& out_max) { + if (polygon.empty()) { + out_min = Vec2(0.0f, 0.0f); + out_max = Vec2(0.0f, 0.0f); + return; + } + + uint32_t first_idx = polygon[0]; + if (first_idx >= map.vertices.size()) { + out_min = Vec2(0.0f, 0.0f); + out_max = Vec2(0.0f, 0.0f); + return; + } + + out_min = map.vertices[first_idx]; + out_max = map.vertices[first_idx]; + + for (uint32_t vertex_idx : polygon) { + if (vertex_idx >= map.vertices.size()) { + continue; + } + + const Vec2& vertex = map.vertices[vertex_idx]; + out_min.x = std::min(out_min.x, vertex.x); + out_min.y = std::min(out_min.y, vertex.y); + out_max.x = std::max(out_max.x, vertex.x); + out_max.y = std::max(out_max.y, vertex.y); + } + }; + + // Helper lambda to convert world position to grid coordinates + auto WorldToGridCoords = [&](const Vec2& world_pos, int& out_x, int& out_y) { + Vec2 relative_pos = world_pos - map.grid_origin; + + out_x = static_cast(std::floor(relative_pos.x / map.grid_cell_size)); + out_y = static_cast(std::floor(relative_pos.y / map.grid_cell_size)); + + // Clamp to valid grid range + out_x = std::max(0, std::min(out_x, map.grid_width - 1)); + out_y = std::max(0, std::min(out_y, map.grid_height - 1)); + }; + + // Helper lambda: point-in-polygon test using ray casting + auto PointInPolygon = [&](const Vec2& point, const std::vector& polygon) -> bool { + if (polygon.size() < 3) return false; + + int intersections = 0; + size_t n = polygon.size(); + + for (size_t i = 0; i < n; ++i) { + uint32_t idx1 = polygon[i]; + uint32_t idx2 = polygon[(i + 1) % n]; + + if (idx1 >= map.vertices.size() || idx2 >= map.vertices.size()) { + continue; + } + + const Vec2& v1 = map.vertices[idx1]; + const Vec2& v2 = map.vertices[idx2]; + + // Check if horizontal ray from point intersects edge + if ((v1.y <= point.y && point.y < v2.y) || (v2.y <= point.y && point.y < v1.y)) { + // Compute x-intersection of ray with edge + float x_intersect = v1.x + (point.y - v1.y) * (v2.x - v1.x) / (v2.y - v1.y); + if (point.x < x_intersect) { + intersections++; + } + } + } + + return intersections % 2 == 1; + }; + + // Add each polygon to grid cells it overlaps + for (uint32_t poly_id = 0; poly_id < map.polygons.size(); ++poly_id) { + Vec2 poly_min, poly_max; + GetPolygonBounds(map.polygons[poly_id], poly_min, poly_max); + + // Convert polygon bounds to grid coordinates + int min_x, min_y, max_x, max_y; + WorldToGridCoords(poly_min, min_x, min_y); + WorldToGridCoords(poly_max, max_x, max_y); + + // Add polygon ID to grid cells only if the center of the cell is inside or touches the polygon + for (int y = min_y; y <= max_y; ++y) { + for (int x = min_x; x <= max_x; ++x) { + // Calculate cell center in world coordinates + Vec2 cell_center = map.grid_origin + Vec2( + (x + 0.5f) * map.grid_cell_size, + (y + 0.5f) * map.grid_cell_size + ); + + // Only add polygon to this cell if its center is inside the polygon + if (PointInPolygon(cell_center, map.polygons[poly_id])) { + int index = y * map.grid_width + x; + map.grid_cells[index].push_back(poly_id); + } + } + } + } + + // Log statistics + size_t total_entries = 0; + int non_empty_cells = 0; + for (const auto& cell : map.grid_cells) { + if (!cell.empty()) { + non_empty_cells++; + total_entries += cell.size(); + } + } + + LOG_INFO("Polygon grid built: %d non-empty cells, %.1f polygons per cell average", + non_empty_cells, non_empty_cells > 0 ? static_cast(total_entries) / non_empty_cells : 0.0f); +} + diff --git a/src/systems/util/data_loader.hpp b/src/systems/util/data_loader.hpp index efbd378..f8fa7ca 100644 --- a/src/systems/util/data_loader.hpp +++ b/src/systems/util/data_loader.hpp @@ -58,4 +58,11 @@ class DataLoader { * @return A pair of (vertices, polygons), empty if loading failed */ static std::pair, std::vector>> load_navmesh_obj(const std::string& nav_file_path); + + /** + * Build a spatial acceleration grid for polygon queries. + * Creates a 2D grid where each cell contains polygon IDs that intersect it. + * @param map The map to populate grid data into + */ + static void build_polygon_grid(Map& map); }; \ No newline at end of file From 995eea4335adbb9478183e9704fd0d9d0c8ee505 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 09:23:47 -0500 Subject: [PATCH 69/79] New XML --- data/maps/konda.nav.obj | 1624 +++++++++++++++++---------------------- data/maps/konda.xml | 32 +- 2 files changed, 735 insertions(+), 921 deletions(-) diff --git a/data/maps/konda.nav.obj b/data/maps/konda.nav.obj index 35477b2..c32a9c9 100644 --- a/data/maps/konda.nav.obj +++ b/data/maps/konda.nav.obj @@ -1,911 +1,725 @@ # OpenChamp Navigation Mesh # Scene: konda -# Vertices: 440 -# Faces: 465 +# Vertices: 344 +# Faces: 375 -v -4.250000 0.450000 -32.250000 -v -4.500000 0.450000 -32.000000 -v -5.000000 0.450000 -32.750000 -v -3.750000 0.450000 -31.500000 -v -3.250000 0.450000 -32.250000 -v -6.250000 0.450000 -31.750000 -v -5.000000 0.450000 -34.250000 -v -2.750000 0.450000 -31.500000 -v -3.750000 0.450000 -30.000000 -v -6.250000 0.450000 -29.750000 -v -18.500000 0.450000 -35.750000 -v -13.100000 0.450000 -35.150002 -v -17.150000 0.950000 -35.599998 -v -17.100000 0.950000 -35.674999 -v -4.500000 0.450000 -35.000000 -v -2.500000 0.450000 -29.500000 -v -1.750000 0.450000 -31.500000 -v -4.250000 0.450000 -29.500000 -v -17.000000 0.450000 -15.750000 -v -4.750000 0.450000 -29.000000 -v -13.000000 0.450000 -17.750000 -v -11.000000 0.450000 -18.750000 -v -4.750000 0.450000 -27.250000 -v -9.000000 0.450000 -19.750000 -v -15.000000 0.450000 -16.750000 -v -19.000000 0.450000 -14.750000 -v -18.500000 0.450000 -37.000000 -v -19.500000 0.450000 -37.000000 -v -17.113636 0.950000 -35.772728 -v -3.250000 0.450000 -34.750000 -v -3.250000 0.950000 -36.000000 -v -1.250000 0.700000 -32.250000 -v -2.000000 0.450000 -28.000000 -v -17.500000 0.450000 -14.750000 -v -15.500000 0.450000 -15.750000 -v -13.500000 0.450000 -16.750000 -v -11.500000 0.450000 -17.750000 -v -9.500000 0.450000 -18.750000 -v -7.000000 0.450000 -20.750000 -v -3.750000 0.450000 -26.750000 -v -7.500000 0.450000 -19.750000 -v -19.500000 0.450000 -14.000000 -v 1.250000 0.700000 -32.250000 -v 2.500000 0.450000 -29.500000 -v 2.000000 0.450000 -28.000000 -v 2.500000 0.450000 -26.750000 -v -2.500000 0.450000 -26.750000 -v -5.500000 0.450000 -20.750000 -v -5.000000 0.450000 -21.750000 -v -3.750000 0.450000 -21.750000 -v 1.750000 0.450000 -31.500000 -v 3.750000 0.450000 -30.000000 -v 3.750000 0.450000 -31.500000 -v 4.250000 0.450000 -29.500000 -v -2.500000 0.450000 -21.250000 -v 2.500000 0.450000 -21.250000 -v 3.750000 0.450000 -21.750000 -v 3.750000 0.450000 -26.750000 -v 4.250000 0.450000 -32.250000 -v 4.500000 0.450000 -32.000000 -v 4.750000 0.450000 -29.000000 -v 6.250000 0.450000 -29.750000 -v -2.250000 0.450000 -20.000000 -v 2.250000 0.450000 -20.000000 -v 5.000000 0.450000 -21.750000 -v 7.000000 0.450000 -20.750000 -v 4.750000 0.450000 -27.250000 -v 5.000000 0.450000 -32.750000 -v 6.250000 0.450000 -31.750000 -v 9.000000 0.450000 -19.750000 -v 17.495026 0.450000 -33.503025 -v 19.500000 0.450000 -26.000000 -v -2.750000 0.450000 -18.250000 -v 3.000000 0.450000 -18.250000 -v 5.500000 0.450000 -20.750000 -v 7.500000 0.450000 -19.750000 -v 5.000000 0.450000 -34.250000 -v 18.250000 0.950000 -35.750000 -v 13.833336 0.450000 -35.250000 -v 16.777779 0.950000 -35.583332 -v 11.000000 0.450000 -18.750000 -v 9.500000 0.450000 -18.750000 -v 20.250000 0.950000 -26.000000 -v 19.500000 0.450000 -25.000000 -v 19.500000 0.450000 -27.000000 -v -4.250000 0.450000 -18.250000 -v -5.000000 0.450000 -17.250000 -v 5.250000 0.450000 -17.250000 -v 4.500000 0.450000 -18.250000 -v 1.250000 0.450000 -11.500000 -v -1.500000 0.450000 -11.500000 -v 16.875000 0.950000 -35.674999 -v 4.500000 0.450000 -35.000000 -v 19.500000 0.450000 -31.000000 -v 18.500000 0.450000 -35.000000 -v 19.500000 0.450000 -30.000000 -v 3.250000 0.950000 -35.750000 -v 19.500000 0.450000 -29.000000 -v 19.500000 0.450000 -28.000000 -v 11.500000 0.450000 -17.750000 -v 13.000000 0.450000 -17.750000 -v 20.250000 0.950000 -25.000000 -v 19.500000 0.450000 -24.000000 -v 20.250000 0.950000 -28.000000 -v 20.250000 0.950000 -27.000000 -v -1.750000 0.450000 -11.000000 -v -6.250000 0.450000 -17.250000 -v -6.750000 0.450000 -16.250000 -v 1.500000 0.450000 -11.000000 -v 7.000000 0.450000 -16.250000 -v 6.500000 0.450000 -17.250000 -v 3.250000 0.450000 -34.750000 -v 20.250000 0.950000 -32.000000 -v 19.500000 0.450000 -32.000000 -v 20.250000 0.950000 -31.000000 -v 19.500000 0.700000 -35.000000 -v 19.500000 0.450000 -34.000000 -v 19.500000 0.450000 -33.000000 -v 20.250000 0.950000 -30.000000 -v 20.250000 0.950000 -29.000000 -v 13.500000 0.450000 -16.750000 -v 15.000000 0.450000 -16.750000 -v 19.500000 0.450000 -23.000000 -v 20.250000 0.950000 -24.000000 -v -8.750000 0.450000 -15.250000 -v -7.250000 0.450000 -5.500000 -v -1.750000 0.450000 -8.750000 -v -8.250000 0.450000 -16.250000 -v 9.000000 0.450000 -15.250000 -v 1.500000 0.450000 -8.750000 -v 5.000000 0.450000 -5.500000 -v 7.250000 0.450000 -5.500000 -v 8.500000 0.450000 -16.250000 -v 20.250000 0.950000 -33.750000 -v 20.250000 0.950000 -33.000000 -v 19.500000 0.450000 -21.000000 -v 19.500000 0.450000 -22.000000 -v 15.500000 0.450000 -15.750000 -v 17.000000 0.450000 -15.750000 -v 19.500000 0.450000 -20.000000 -v 20.250000 0.950000 -23.000000 -v -10.250000 0.450000 -15.250000 -v -10.750000 0.450000 -14.250000 -v -12.750000 0.450000 -13.250000 -v -14.750000 0.450000 -12.250000 -v -9.000000 0.450000 -2.250000 -v -5.000000 0.450000 -5.500000 -v -1.500000 0.450000 -8.250000 -v 10.500000 0.450000 -15.250000 -v 11.000000 0.450000 -14.250000 -v 1.250000 0.450000 -8.250000 -v 4.000000 0.450000 -4.500000 -v 15.000000 0.450000 -12.250000 -v 13.000000 0.450000 -13.250000 -v 9.000000 0.450000 -2.250000 -v 20.250000 0.950000 -22.000000 -v 20.250000 0.950000 -21.000000 -v 19.500000 0.450000 -19.000000 -v 17.500000 0.450000 -14.750000 -v 19.000000 0.450000 -14.750000 -v 19.500000 0.450000 -17.000000 -v 19.500000 0.450000 -18.000000 -v 20.250000 0.950000 -20.000000 -v -12.250000 0.450000 -14.250000 -v -14.250000 0.450000 -13.250000 -v -16.500000 0.450000 -2.750000 -v -16.500000 0.450000 -12.000000 -v -16.250000 0.450000 -0.750000 -v -9.000000 0.450000 2.250000 -v -4.000000 0.450000 -4.500000 -v -3.250000 0.450000 -2.000000 -v 12.500000 0.450000 -14.250000 -v 4.000000 0.450000 -3.250000 -v 3.250000 0.450000 -2.000000 -v 14.500000 0.450000 -13.250000 -v 16.500000 0.450000 -3.000000 -v 16.500000 0.450000 -12.250000 -v 16.250000 0.450000 -0.750000 -v 16.250000 0.450000 0.750000 -v 9.000000 0.450000 2.250000 -v 20.250000 0.950000 -19.000000 -v 19.500000 0.450000 -14.250000 -v 19.500000 0.450000 -15.000000 -v 19.500000 0.450000 -16.000000 -v 20.250000 0.950000 -18.000000 -v 20.250000 0.950000 -17.000000 -v -16.750000 0.450000 -2.250000 -v -16.500000 0.450000 1.500000 -v -16.500000 0.450000 3.000000 -v -17.000000 0.450000 -1.750000 -v -15.000000 0.450000 12.250000 -v -7.250000 0.450000 5.500000 -v -4.000000 0.450000 -3.250000 -v -3.250000 0.450000 2.000000 -v 3.250000 0.450000 2.000000 -v 17.000000 0.450000 -1.750000 -v 17.000000 0.450000 -2.250000 -v 16.500000 0.450000 3.000000 -v 17.000000 0.450000 1.750000 -v 7.250000 0.450000 5.500000 -v 15.000000 0.450000 12.250000 -v 20.250000 0.950000 -16.000000 -v 20.250000 0.950000 -15.000000 -v -19.000000 0.450000 -2.250000 -v -19.000000 0.450000 1.750000 -v -17.000000 0.450000 2.250000 -v -16.500000 0.450000 12.250000 -v -19.000000 0.450000 -1.750000 -v -14.500000 0.450000 13.250000 -v -13.000000 0.450000 13.250000 -v -11.000000 0.450000 14.250000 -v -1.750000 0.450000 9.000000 -v -5.000000 0.450000 5.500000 -v -1.750000 0.450000 11.500000 -v -9.000000 0.450000 15.250000 -v -4.000000 0.450000 3.250000 -v -4.000000 0.450000 4.500000 -v -1.500000 0.450000 8.500000 -v 1.250000 0.450000 8.500000 -v 4.000000 0.450000 4.500000 -v 4.000000 0.450000 3.250000 -v 19.000000 0.450000 -2.250000 -v 19.000000 0.450000 -1.750000 -v 17.000000 0.450000 2.250000 -v 16.500000 0.450000 12.250000 -v 19.000000 0.450000 1.750000 -v 11.000000 0.450000 14.250000 -v 13.000000 0.450000 13.250000 -v 5.000000 0.450000 5.500000 -v 1.500000 0.450000 9.000000 -v 1.500000 0.450000 11.250000 -v 9.000000 0.450000 15.250000 -v 14.500000 0.450000 13.250000 -v -19.500000 0.450000 -2.750000 -v -19.000000 0.450000 2.250000 -v -19.500000 0.450000 1.250000 -v -19.500000 0.450000 -1.000000 -v -12.500000 0.450000 14.250000 -v -10.500000 0.450000 15.250000 -v -5.000000 0.450000 17.250000 -v -3.250000 0.450000 18.250000 -v -7.000000 0.450000 16.250000 -v 1.250000 0.450000 11.750000 -v -8.500000 0.450000 16.250000 -v 19.500000 0.450000 -2.000000 -v 19.500000 0.450000 -2.750000 -v 19.500000 0.450000 -1.000000 -v 19.000000 0.450000 2.250000 -v 19.500000 0.450000 2.000000 -v 19.500000 0.450000 1.250000 -v 10.500000 0.450000 15.250000 -v 12.500000 0.450000 14.250000 -v 5.250000 0.450000 17.250000 -v 7.000000 0.450000 16.250000 -v 8.500000 0.450000 16.250000 -v -19.500000 0.450000 3.000000 -v -4.500000 0.450000 18.250000 -v -6.500000 0.450000 17.250000 -v -2.500000 0.450000 18.750000 -v 2.250000 0.450000 20.000000 -v 3.000000 0.450000 18.250000 -v 20.250000 0.950000 -2.000000 -v 20.250000 0.950000 -1.000000 -v 19.500000 0.450000 3.000000 -v 20.250000 0.950000 2.000000 -v 6.500000 0.450000 17.250000 -v 4.500000 0.450000 18.250000 -v -2.250000 0.450000 20.000000 -v 2.500000 0.450000 21.250000 -v 20.250000 0.950000 3.000000 -v -2.500000 0.450000 21.500000 -v 2.500000 0.450000 26.750000 -v 3.750000 0.450000 21.750000 -v -3.500000 0.450000 21.750000 -v -2.500000 0.450000 26.750000 -v 2.000000 0.450000 28.000000 -v 3.750000 0.450000 26.750000 -v 5.000000 0.450000 21.750000 -v -5.000000 0.450000 21.750000 -v -3.500000 0.450000 26.750000 -v -2.000000 0.450000 28.000000 -v 2.500000 0.450000 29.500000 -v 7.000000 0.450000 20.750000 -v 4.750000 0.450000 27.250000 -v 5.500000 0.450000 20.750000 -v -5.500000 0.450000 20.750000 -v -7.000000 0.450000 20.750000 -v -4.750000 0.450000 27.250000 -v -2.500000 0.450000 29.500000 -v -1.250000 0.700000 32.250000 -v 1.250000 0.700000 32.250000 -v 3.750000 0.450000 31.500000 -v 3.750000 0.450000 30.000000 -v 1.750000 0.450000 31.500000 -v 4.250000 0.450000 29.500000 -v 9.000000 0.450000 19.750000 -v 7.500000 0.450000 19.750000 -v 4.750000 0.450000 29.000000 -v -7.500000 0.450000 19.750000 -v -9.000000 0.450000 19.750000 -v -6.250000 0.450000 29.750000 -v -4.750000 0.450000 29.000000 -v -4.250000 0.450000 29.500000 -v -3.750000 0.450000 30.000000 -v -2.750000 0.450000 31.500000 -v -1.750000 0.450000 31.500000 -v 4.250000 0.450000 32.250000 -v 4.500000 0.450000 32.000000 -v 6.250000 0.450000 29.750000 -v 19.500000 0.450000 26.000000 -v 11.000000 0.450000 18.750000 -v 9.500000 0.450000 18.750000 -v -9.500000 0.450000 18.750000 -v -11.000000 0.450000 18.750000 -v -15.500000 0.450000 35.000000 -v -6.250000 0.450000 31.750000 -v -13.000000 0.450000 17.750000 -v -15.000000 0.450000 16.750000 -v -16.500000 0.450000 35.000000 -v -17.500000 0.450000 35.000000 -v -3.750000 0.450000 31.500000 -v -3.250000 0.450000 32.250000 -v 5.000000 0.450000 32.750000 -v 6.250000 0.450000 31.750000 -v 13.500000 0.450000 35.000000 -v 20.250000 0.950000 26.000000 -v 19.500000 0.450000 27.000000 -v 19.500000 0.450000 25.000000 -v 13.000000 0.450000 17.750000 -v 11.500000 0.450000 17.750000 -v -11.500000 0.450000 17.750000 -v -15.500000 0.950000 35.750000 -v -14.500000 0.450000 35.000000 -v -5.000000 0.450000 32.750000 -v -4.500000 0.450000 32.000000 -v -13.500000 0.450000 35.000000 -v -12.500000 0.450000 35.000000 -v -11.500000 0.450000 35.000000 -v -10.500000 0.450000 35.000000 -v -9.500000 0.450000 35.000000 -v -5.000000 0.450000 34.250000 -v -7.500000 0.450000 35.000000 -v -8.500000 0.450000 35.000000 -v -13.500000 0.450000 16.750000 -v -15.500000 0.450000 15.750000 -v -17.000000 0.450000 15.750000 -v -16.500000 0.950000 35.750000 -v -17.500000 0.950000 35.750000 -v -18.500000 0.450000 35.750000 -v -19.000000 0.450000 14.750000 -v -4.250000 0.450000 32.250000 -v 5.000000 0.450000 34.250000 -v 10.500000 0.450000 35.000000 -v 11.500000 0.450000 35.000000 -v 9.500000 0.450000 35.000000 -v 8.500000 0.450000 35.000000 -v 12.500000 0.450000 35.000000 -v 7.500000 0.450000 35.000000 -v 19.500000 0.450000 30.000000 -v 19.500000 0.450000 29.000000 -v 19.500000 0.450000 28.000000 -v 14.500000 0.450000 35.000000 -v 19.500000 0.450000 33.000000 -v 19.500000 0.450000 31.000000 -v 14.500000 0.950000 35.750000 -v 13.500000 0.950000 35.750000 -v 20.250000 0.950000 27.000000 -v 19.500000 0.450000 24.000000 -v 20.250000 0.950000 24.000000 -v 20.250000 0.950000 25.000000 -v 15.000000 0.450000 16.750000 -v 13.500000 0.450000 16.750000 -v 19.500000 0.450000 23.000000 -v -13.500000 0.950000 35.750000 -v -14.500000 0.950000 35.750000 -v -11.500000 0.950000 35.750000 -v -12.500000 0.950000 35.750000 -v -9.500000 0.950000 35.750000 -v -10.500000 0.950000 35.750000 -v -4.500000 0.450000 35.000000 -v -5.500000 0.450000 35.000000 -v -6.500000 0.450000 35.000000 -v -7.500000 0.950000 35.750000 -v -8.500000 0.950000 35.750000 -v -17.500000 0.450000 14.750000 -v -19.500000 0.450000 37.000000 -v -18.500000 0.450000 37.000000 -v -19.500000 0.450000 14.250000 -v 4.500000 0.450000 35.000000 -v 5.500000 0.450000 35.000000 -v 6.500000 0.450000 35.000000 -v 10.500000 0.950000 35.750000 -v 12.500000 0.950000 35.750000 -v 11.500000 0.950000 35.750000 -v 9.500000 0.950000 35.750000 -v 8.500000 0.950000 35.750000 -v 7.500000 0.950000 35.750000 -v 20.250000 0.950000 30.000000 -v 20.250000 0.950000 28.000000 -v 20.250000 0.950000 29.000000 -v 15.500000 0.450000 35.000000 -v 20.250000 0.950000 33.750000 -v 20.250000 0.950000 33.000000 -v 19.500000 0.450000 34.000000 -v 16.500000 0.450000 35.000000 -v 17.500000 0.450000 35.000000 -v 20.250000 0.950000 31.000000 -v 19.500000 0.450000 22.000000 -v 19.500000 0.450000 21.000000 -v 17.000000 0.450000 15.750000 -v 15.500000 0.450000 15.750000 -v 19.500000 0.450000 20.000000 -v 20.250000 0.950000 22.000000 -v 20.250000 0.950000 23.000000 -v -5.500000 0.950000 35.750000 -v -6.500000 0.950000 35.750000 -v 6.500000 0.950000 35.750000 -v 5.500000 0.950000 35.750000 -v 16.500000 0.950000 35.750000 -v 15.500000 0.950000 35.750000 -v 19.500000 0.700000 35.000000 -v 18.500000 0.450000 35.000000 -v 17.500000 0.950000 35.750000 -v 18.250000 0.950000 35.750000 -v 20.250000 0.950000 20.000000 -v 20.250000 0.950000 21.000000 -v 19.500000 0.450000 19.000000 -v 19.500000 0.450000 18.000000 -v 19.000000 0.450000 14.750000 -v 17.500000 0.450000 14.750000 -v 19.500000 0.450000 17.000000 -v 20.250000 0.950000 18.000000 -v 20.250000 0.950000 19.000000 -v 19.500000 0.450000 14.000000 -v 19.500000 0.450000 15.000000 -v 19.500000 0.450000 16.000000 -v 20.250000 0.950000 16.000000 -v 20.250000 0.950000 17.000000 -v 20.250000 0.950000 14.000000 -v 20.250000 0.950000 15.000000 +v -32.250000 0.543138 -4.250002 +v -32.750000 0.543138 -4.750002 +v -32.000000 0.543138 -4.250002 +v -31.500000 0.543138 -3.750002 +v -32.250000 0.543138 -3.250002 +v -31.750000 0.543138 -6.250002 +v -34.750000 0.543138 -4.750002 +v -31.500000 0.543138 -2.750002 +v -30.000000 0.543138 -3.750002 +v -34.000000 0.543138 -19.500002 +v -35.750000 1.043138 -18.250002 +v -29.750000 0.543138 -6.250002 +v -35.750000 0.793138 -3.500002 +v -34.750000 0.543138 -3.500002 +v -31.500000 0.543138 -1.750002 +v -29.500000 0.543138 -2.500002 +v -29.500000 0.543138 -4.250002 +v -32.025002 0.543138 -19.025002 +v -33.750000 1.043138 -20.250002 +v -35.000000 0.793138 -19.500002 +v -29.000000 0.543138 -4.750002 +v -17.750000 0.543138 -13.000002 +v -16.750000 0.543138 -15.000002 +v -15.750000 0.543138 -17.000002 +v -18.750000 0.543138 -11.000002 +v -27.250000 0.543138 -4.750002 +v -19.750000 0.543138 -9.000002 +v -35.750000 0.793138 -2.750002 +v -35.250000 0.543138 -3.000002 +v -32.250000 0.793138 -1.250002 +v -28.000000 0.543138 1.999998 +v -28.000000 0.543138 -2.000002 +v -14.750000 0.543138 -19.000002 +v -10.750000 0.793138 -19.750002 +v -9.250000 0.793138 -19.750002 +v 13.750000 1.043138 -20.250002 +v -12.250000 0.793138 -19.750002 +v -14.250000 0.543138 -19.500002 +v -17.750000 0.543138 -11.500002 +v -16.750000 0.543138 -13.500002 +v -15.750000 0.543138 -15.500002 +v -14.750000 0.543138 -17.500002 +v -18.750000 0.543138 -9.500002 +v -26.750000 0.543138 -3.750002 +v -20.750000 0.543138 -7.000002 +v -19.750000 0.543138 -7.500002 +v -35.250000 0.543138 -1.250002 +v -37.000000 0.793138 -1.750002 +v -32.250000 0.793138 1.249998 +v -29.500000 0.543138 2.499998 +v -26.750000 0.543138 -2.500002 +v -26.750000 0.543138 2.499998 +v -11.250000 0.543138 -19.250002 +v -7.750000 0.793138 -19.750002 +v -8.250000 0.543138 -19.250002 +v -0.750000 0.793138 -19.750002 +v -3.250000 0.793138 -19.750002 +v 0.750000 0.793138 -19.750002 +v 11.250000 0.543138 -19.250002 +v 13.750000 0.793138 -19.750002 +v 10.750000 0.793138 -19.750002 +v 9.250000 0.793138 -19.750002 +v -4.750000 0.793138 -19.750002 +v 7.750000 0.793138 -19.750002 +v -6.250000 0.793138 -19.750002 +v 6.250000 0.793138 -19.750002 +v 4.750000 0.793138 -19.750002 +v 3.250000 0.793138 -19.750002 +v 14.750000 0.543138 -19.000002 +v 33.750000 1.043138 -20.250002 +v -21.750000 0.543138 -5.000002 +v -21.750000 0.543138 -3.750002 +v -20.750000 0.543138 -5.500002 +v -35.250000 0.543138 1.249998 +v -34.750000 0.543138 -0.750002 +v -37.000000 0.543138 0.249998 +v -31.500000 0.543138 1.749998 +v -31.500000 0.543138 2.749998 +v -30.000000 0.543138 3.749998 +v -29.500000 0.543138 4.249998 +v -21.250000 0.543138 -2.500002 +v -21.250000 0.543138 2.499998 +v -21.750000 0.543138 3.749998 +v -26.750000 0.543138 3.749998 +v -1.750000 0.543138 -19.000002 +v -2.250000 0.543138 -19.000002 +v 1.750000 0.543138 -19.000002 +v 2.250000 0.543138 -19.000002 +v 8.250000 0.543138 -19.250002 +v -5.250000 0.543138 -19.250002 +v 5.250000 0.543138 -19.250002 +v 14.750000 0.543138 -17.500002 +v 15.750000 0.543138 -17.000002 +v 32.480034 0.543138 -18.992041 +v 34.000000 0.543138 -19.500002 +v -37.250000 1.043138 1.499998 +v -36.000000 0.793138 2.499998 +v -35.250000 0.543138 2.999998 +v -34.750000 0.543138 0.749998 +v -37.500000 1.043138 0.499998 +v -32.250000 0.543138 3.249998 +v -31.500000 0.543138 3.749998 +v -29.750000 0.543138 6.249998 +v -29.000000 0.543138 4.749998 +v -20.000000 0.543138 -2.250002 +v -20.000000 0.543138 2.249998 +v -21.750000 0.543138 4.999998 +v -20.750000 0.543138 6.999998 +v -27.250000 0.543138 4.749998 +v -1.750000 0.543138 -17.000002 +v -2.250000 0.543138 -17.000002 +v 2.250000 0.543138 -17.000002 +v 1.750000 0.543138 -17.000002 +v 15.750000 0.543138 -15.500002 +v 16.750000 0.543138 -15.000002 +v 29.750000 0.543138 -6.250002 +v 35.250000 0.793138 -18.500002 +v 35.000000 0.793138 -19.500002 +v 31.750000 0.543138 -6.250002 +v -35.750000 0.793138 3.749998 +v -34.750000 0.543138 3.249998 +v -32.250000 0.543138 4.249998 +v -32.000000 0.543138 4.249998 +v -19.750000 0.543138 8.999998 +v -18.750000 0.543138 10.999998 +v -17.750000 0.543138 12.999998 +v -16.750000 0.543138 14.999998 +v -15.750000 0.543138 16.999998 +v -31.750000 0.543138 6.249998 +v -35.750000 0.793138 18.249998 +v -18.500000 0.543138 2.499998 +v -18.250000 0.543138 -3.000002 +v -20.750000 0.543138 5.499998 +v -19.750000 0.543138 7.499998 +v -3.000000 0.543138 -16.500002 +v -0.750000 0.543138 -16.250002 +v 3.000000 0.543138 -16.500002 +v 0.750000 0.543138 -16.250002 +v 16.750000 0.543138 -13.500002 +v 17.750000 0.543138 -13.000002 +v 29.500000 0.543138 -4.250002 +v 29.000000 0.543138 -4.750002 +v 18.750000 0.543138 -11.000002 +v 27.250000 0.543138 -4.750002 +v 19.750000 0.543138 -9.000002 +v 35.449997 0.543138 -14.375002 +v 35.750000 1.293138 -18.500002 +v 32.000000 0.543138 -4.250002 +v 32.250000 0.543138 -4.250002 +v 34.750000 0.543138 -4.750002 +v -35.000000 0.543138 4.499998 +v -33.500000 0.543138 4.749998 +v -18.750000 0.543138 9.499998 +v -17.750000 0.543138 11.499998 +v -16.750000 0.543138 13.499998 +v -15.750000 0.543138 15.499998 +v -14.750000 0.543138 17.499998 +v -14.750000 0.543138 18.999998 +v -36.000000 0.543138 18.749998 +v -18.250000 0.543138 4.249998 +v -17.250000 0.543138 4.999998 +v -17.250000 0.543138 -5.250002 +v -18.250000 0.543138 -4.500002 +v -11.500000 0.543138 -1.250002 +v -11.500000 0.543138 1.249998 +v -2.250000 0.543138 -9.000002 +v -12.250000 0.543138 -15.000002 +v -12.250000 0.543138 -16.500002 +v 2.250000 0.543138 -9.000002 +v 12.250000 0.543138 -15.000002 +v 12.250000 0.543138 -16.500002 +v 17.750000 0.543138 -11.500002 +v 29.500000 0.543138 -2.500002 +v 30.000000 0.543138 -3.750002 +v 18.750000 0.543138 -9.500002 +v 20.750000 0.543138 -7.000002 +v 26.750000 0.543138 -3.750002 +v 19.750000 0.543138 -7.500002 +v 35.750000 0.793138 -3.750002 +v 31.500000 0.543138 -3.750002 +v 32.250000 0.543138 -3.250002 +v 34.750000 0.543138 -3.500002 +v -37.000000 0.543138 19.749998 +v -13.500000 0.543138 19.749998 +v -37.000000 0.543138 18.749998 +v -11.000000 0.543138 1.499998 +v -17.250000 0.543138 6.249998 +v -16.250000 0.543138 6.749998 +v -16.250000 0.543138 -7.000002 +v -17.250000 0.543138 -6.500002 +v -11.000000 0.543138 -1.500002 +v -5.500000 0.543138 -7.250002 +v -13.250000 0.543138 -14.500002 +v -13.250000 0.543138 -13.000002 +v 5.500000 0.543138 -7.250002 +v 13.250000 0.543138 -13.000002 +v 13.250000 0.543138 -14.500002 +v 32.250000 0.793138 -1.250002 +v 28.000000 0.543138 -2.000002 +v 31.500000 0.543138 -1.750002 +v 31.500000 0.543138 -2.750002 +v 20.750000 0.543138 -5.500002 +v 21.750000 0.543138 -5.000002 +v 21.750000 0.543138 -3.750002 +v 26.750000 0.543138 -2.500002 +v 35.250000 0.543138 -3.000002 +v 36.000000 0.793138 -2.500002 +v -15.250000 0.543138 8.749998 +v -5.500000 0.543138 4.999998 +v -9.000000 0.543138 1.499998 +v -5.500000 0.543138 7.249998 +v -16.250000 0.543138 8.249998 +v -15.250000 0.543138 -9.000002 +v -16.250000 0.543138 -8.500002 +v -9.000000 0.543138 -1.500002 +v -5.500000 0.543138 -5.000002 +v -14.250000 0.543138 -11.000002 +v -14.250000 0.543138 -12.500002 +v 14.250000 0.543138 -11.000002 +v 5.500000 0.543138 -5.000002 +v 11.000000 0.543138 -1.500002 +v 15.250000 0.543138 -9.000002 +v 14.250000 0.543138 -12.500002 +v 32.250000 0.793138 1.249998 +v 29.500000 0.543138 2.499998 +v 28.000000 0.543138 1.999998 +v 26.750000 0.543138 2.499998 +v 21.250000 0.543138 -2.500002 +v 21.500000 0.543138 2.499998 +v 35.250000 0.543138 -1.250002 +v 37.500000 1.043138 -0.750002 +v -15.250000 0.543138 10.249998 +v -14.250000 0.543138 10.749998 +v -8.500000 0.543138 1.249998 +v -4.500000 0.543138 3.999998 +v -13.250000 0.543138 12.749998 +v -12.250000 0.543138 14.749998 +v -2.250000 0.543138 8.999998 +v -15.250000 0.543138 -10.500002 +v -4.500000 0.543138 -4.000002 +v -8.250000 0.543138 -0.250002 +v 15.250000 0.543138 -10.500002 +v 9.000000 0.543138 -1.500002 +v 8.500000 0.543138 -1.250002 +v 4.500000 0.543138 -4.000002 +v 17.250000 0.543138 -5.250002 +v 16.250000 0.543138 -7.000002 +v 11.750000 0.543138 -0.250002 +v 16.250000 0.543138 -8.500002 +v 31.500000 0.543138 1.749998 +v 30.000000 0.543138 3.749998 +v 31.500000 0.543138 3.749998 +v 29.500000 0.543138 4.249998 +v 21.750000 0.543138 3.499998 +v 26.750000 0.543138 3.499998 +v 20.000000 0.543138 -2.250002 +v 20.000000 0.543138 2.249998 +v 34.750000 0.543138 -0.750002 +v 34.750000 0.543138 0.749998 +v 37.000000 0.793138 1.749998 +v -14.250000 0.543138 12.249998 +v -3.250000 0.543138 3.999998 +v -2.000000 0.543138 3.249998 +v -13.250000 0.543138 14.249998 +v -2.750000 0.543138 16.499998 +v -12.000000 0.543138 16.499998 +v -0.750000 0.543138 16.249998 +v 2.250000 0.543138 8.999998 +v -3.250000 0.543138 -4.000002 +v -2.000000 0.543138 -3.250002 +v 4.500000 0.543138 3.999998 +v 8.500000 0.543138 1.249998 +v 2.000000 0.543138 3.249998 +v 3.250000 0.543138 -4.000002 +v 2.000000 0.543138 -3.250002 +v 17.250000 0.543138 -6.500002 +v 18.250000 0.543138 -3.000002 +v 18.250000 0.543138 -4.500002 +v 18.250000 0.543138 2.999998 +v 11.500000 0.543138 1.249998 +v 32.250000 0.543138 4.249998 +v 32.000000 0.543138 4.249998 +v 29.000000 0.543138 4.749998 +v 29.750000 0.543138 6.249998 +v 21.750000 0.543138 4.999998 +v 20.750000 0.543138 6.999998 +v 27.250000 0.543138 4.749998 +v 35.250000 0.543138 1.249998 +v 35.750000 0.793138 2.749998 +v -2.250000 0.543138 16.749998 +v 1.000000 0.543138 16.249998 +v -1.750000 0.543138 16.999998 +v 12.250000 0.543138 14.999998 +v 5.500000 0.543138 7.249998 +v 3.000000 0.543138 16.499998 +v 3.250000 0.543138 3.999998 +v 5.500000 0.543138 4.999998 +v 9.000000 0.543138 1.499998 +v 17.250000 0.543138 5.249998 +v 18.250000 0.543138 4.499998 +v 11.000000 0.543138 1.499998 +v 32.750000 0.543138 4.749998 +v 31.750000 0.543138 6.249998 +v 16.750000 0.543138 14.999998 +v 15.750000 0.543138 16.999998 +v 18.750000 0.543138 10.999998 +v 17.750000 0.543138 12.999998 +v 19.750000 0.543138 8.999998 +v 35.750000 0.543138 18.249998 +v 20.750000 0.543138 5.499998 +v 19.750000 0.543138 7.499998 +v 35.250000 0.543138 2.999998 +v 35.000000 0.543138 4.499998 +v 35.750000 1.043138 16.840910 +v -2.250000 0.543138 18.999998 +v 1.750000 0.543138 16.749998 +v -1.750000 0.543138 18.999998 +v 13.250000 0.543138 14.499998 +v 13.250000 0.543138 12.999998 +v 12.250000 0.543138 16.499998 +v 14.250000 0.543138 10.999998 +v 15.250000 0.543138 8.999998 +v 2.250000 0.543138 16.999998 +v 16.250000 0.543138 6.999998 +v 17.250000 0.543138 6.499998 +v 16.750000 0.543138 13.499998 +v 15.750000 0.543138 15.499998 +v 14.750000 0.543138 17.499998 +v 14.750000 0.543138 18.999998 +v 18.750000 0.543138 9.499998 +v 17.750000 0.543138 11.499998 +v 37.000000 0.543138 19.749998 +v 37.000000 0.543138 18.499998 +v 34.750000 0.543138 3.249998 +v -3.250000 0.543138 19.749998 +v 1.750000 0.543138 18.999998 +v -0.500000 0.543138 19.749998 +v 14.250000 0.543138 12.499998 +v 15.250000 0.543138 10.499998 +v 16.250000 0.543138 8.499998 +v 2.250000 0.543138 18.999998 +v 13.750000 0.543138 19.749998 +v 0.750000 0.543138 19.749998 +v 3.500000 0.543138 19.749998 f 1 2 3 f 3 2 6 -f 6 10 11 -f 11 10 19 -f 11 19 26 -f 31 30 15 -f 27 11 28 -f 28 11 26 -f 28 26 42 -f 10 18 20 -f 19 34 26 -f 25 35 19 -f 21 36 25 -f 37 21 22 -f 22 21 10 -f 24 38 22 -f 41 24 39 -f 39 24 23 -f 48 39 49 -f 49 39 40 -f 40 39 23 -f 3 6 7 -f 7 6 12 -f 12 6 13 -f 13 6 11 -f 20 23 10 -f 10 23 24 -f 10 24 22 -f 40 50 49 -f 11 29 14 -f 14 29 15 -f 15 29 31 -f 25 19 10 -f 11 14 13 -f 13 14 12 -f 12 14 7 -f 7 14 15 -f 10 21 25 -f 183 182 160 -f 59 68 60 -f 60 68 69 -f 135 118 134 -f 134 118 117 -f 95 94 78 -f 78 94 96 -f 184 202 183 -f 183 202 203 -f 137 136 122 -f 162 185 161 -f 161 185 186 -f 93 97 92 -f 92 97 78 -f 140 163 158 -f 158 163 181 -f 78 96 98 -f 137 156 136 -f 136 156 157 -f 78 71 69 -f 69 71 62 -f 62 72 70 -f 70 72 81 -f 72 71 78 -f 71 72 62 -f 103 124 123 -f 123 124 141 -f 78 80 92 -f 92 80 79 -f 92 79 77 -f 92 77 93 -f 72 83 84 -f 84 83 102 -f 78 98 99 -f 99 104 85 -f 85 104 105 -f 84 103 101 -f 96 119 98 -f 98 119 120 -f 65 57 58 -f 114 113 94 -f 94 113 115 -f 140 158 139 -f 184 183 160 -f 95 116 117 -f 93 112 97 -f 95 114 94 -f 61 54 62 -f 75 65 66 -f 66 65 58 -f 66 58 67 -f 76 66 70 -f 70 66 67 -f 70 67 61 -f 70 61 62 -f 81 82 70 -f 100 81 101 -f 101 81 84 -f 84 81 72 -f 121 101 122 -f 122 101 123 -f 123 101 103 -f 138 122 139 -f 139 122 140 -f 140 122 136 -f 159 139 160 -f 160 139 161 -f 161 139 162 -f 95 117 118 -f 161 184 160 -f 123 137 122 -f 68 77 69 -f 69 77 79 -f 69 79 80 -f 69 80 78 -f 78 99 85 -f 95 118 114 -f 78 85 72 -f 158 162 139 -f 60 53 59 -f 59 53 51 -f 2 1 4 -f 4 1 5 -f 52 44 53 -f 53 44 51 -f 5 8 4 -f 4 8 9 -f 16 18 9 -f 52 54 44 -f 44 43 51 -f 16 32 33 -f 33 32 43 -f 33 43 44 -f 33 44 45 -f 17 16 8 -f 8 16 9 -f 16 17 32 -f 45 46 33 -f 33 46 47 -f 63 55 64 -f 64 55 56 -f 50 47 55 -f 55 47 46 -f 55 46 56 -f 56 46 57 -f 50 40 47 -f 46 58 57 -f 89 88 74 -f 74 88 90 -f 90 88 109 -f 87 86 73 -f 73 63 64 -f 64 74 73 -f 73 74 87 -f 87 74 91 -f 91 74 90 -f 91 106 87 -f 107 87 108 -f 108 87 106 -f 128 108 125 -f 125 108 106 -f 143 142 125 -f 164 143 144 -f 144 143 126 -f 165 144 145 -f 145 144 126 -f 145 126 146 -f 145 146 166 -f 147 126 127 -f 127 126 106 -f 106 126 125 -f 125 126 143 -f 166 167 145 -f 111 110 88 -f 88 110 109 -f 175 153 154 -f 154 153 132 -f 132 153 155 -f 155 153 176 -f 172 154 150 -f 150 154 132 -f 129 149 150 -f 133 129 110 -f 110 129 109 -f 130 109 131 -f 131 109 132 -f 132 109 129 -f 132 129 150 -f 153 177 176 -f 171 193 170 -f 152 173 174 -f 127 148 147 -f 147 148 170 -f 170 148 171 -f 171 148 151 -f 171 151 152 -f 171 152 174 -f 130 131 151 -f 151 131 152 -f 248 226 249 -f 249 226 250 -f 223 222 245 -f 245 222 246 -f 248 249 264 -f 264 249 265 -f 264 265 270 -f 197 196 176 -f 176 196 178 -f 176 178 155 -f 224 198 199 -f 199 198 179 -f 179 198 180 -f 199 226 224 -f 224 226 248 -f 223 245 247 -f 247 245 262 -f 247 262 263 -f 197 222 196 -f 196 222 223 -f 178 179 155 -f 155 179 180 -f 204 208 234 -f 234 208 237 -f 188 168 189 -f 189 168 169 -f 169 168 146 -f 205 235 236 -f 236 235 256 -f 235 205 206 -f 206 205 188 -f 208 204 190 -f 190 204 187 -f 187 166 168 -f 168 166 146 -f 168 190 187 -f 189 206 188 -f 171 174 194 -f 194 174 195 -f 195 221 220 -f 217 216 194 -f 212 213 218 -f 218 213 217 -f 217 194 218 -f 218 194 219 -f 219 194 220 -f 220 194 195 -f 230 219 229 -f 229 219 220 -f 257 240 241 -f 241 240 214 -f 209 191 210 -f 210 191 192 -f 192 191 169 -f 169 191 189 -f 238 210 211 -f 211 210 192 -f 215 239 211 -f 244 215 242 -f 242 215 214 -f 258 242 240 -f 240 242 214 -f 213 212 192 -f 192 212 214 -f 192 214 215 -f 192 215 211 -f 191 207 189 -f 266 253 254 -f 254 253 231 -f 255 254 232 -f 232 254 231 -f 227 251 232 -f 252 227 228 -f 228 227 200 -f 233 228 201 -f 201 228 200 -f 201 200 180 -f 201 180 198 -f 229 200 230 -f 230 200 231 -f 231 200 232 -f 232 200 227 -f 198 225 201 -f 267 261 253 -f 253 261 243 -f 253 243 231 -f 260 268 259 -f 259 241 260 -f 260 241 261 -f 261 241 243 -f 243 241 214 -f 307 308 323 -f 323 308 324 -f 390 389 352 -f 423 406 424 -f 424 406 422 -f 360 359 325 -f 403 402 363 -f 363 402 404 -f 371 408 373 -f 391 417 390 -f 390 417 418 -f 361 360 325 -f 356 396 358 -f 358 396 397 -f 362 325 363 -f 363 325 364 -f 353 392 355 -f 355 392 395 -f 329 368 328 -f 357 393 354 -f 354 393 394 -f 354 353 324 -f 362 365 325 -f 325 365 366 -f 359 364 325 -f 405 419 401 -f 401 419 420 -f 371 409 408 -f 359 398 364 -f 364 398 407 -f 363 401 362 -f 361 399 360 -f 360 399 400 -f 353 355 324 -f 310 326 327 -f 327 326 367 -f 277 273 278 -f 368 369 328 -f 328 369 370 -f 410 427 412 -f 408 413 373 -f 373 413 414 -f 355 356 324 -f 412 425 409 -f 409 425 426 -f 363 405 401 -f 428 432 427 -f 427 432 433 -f 410 428 427 -f 436 437 431 -f 431 437 438 -f 327 361 325 -f 429 434 435 -f 435 434 439 -f 435 439 440 -f 327 325 310 -f 310 325 309 -f 310 309 296 -f 310 296 311 -f 357 354 324 -f 436 429 435 -f 404 421 422 -f 404 406 363 -f 363 406 405 -f 309 295 298 -f 391 390 352 -f 404 422 406 -f 430 429 410 -f 410 429 431 -f 410 431 428 -f 411 410 371 -f 371 410 412 -f 371 412 409 -f 372 371 329 -f 329 371 373 -f 329 373 368 -f 330 329 311 -f 311 329 328 -f 311 328 310 -f 296 312 311 -f 297 296 283 -f 283 296 284 -f 284 296 298 -f 298 296 309 -f 285 283 278 -f 278 283 277 -f 277 283 284 -f 429 436 431 -f 358 391 352 -f 323 324 352 -f 352 324 358 -f 358 324 356 -f 357 324 325 -f 325 324 309 -f 341 380 381 -f 351 334 335 -f 335 334 316 -f 320 348 349 -f 315 332 319 -f 319 332 347 -f 333 315 316 -f 316 315 301 -f 336 374 333 -f 333 374 375 -f 336 316 337 -f 338 376 337 -f 337 376 377 -f 316 338 337 -f 340 378 339 -f 339 378 379 -f 318 317 301 -f 342 383 343 -f 343 383 384 -f 316 339 338 -f 381 415 382 -f 382 415 416 -f 301 315 319 -f 387 386 349 -f 349 386 350 -f 350 386 388 -f 316 340 339 -f 302 303 301 -f 341 381 382 -f 286 279 287 -f 287 279 280 -f 287 280 288 -f 299 287 300 -f 300 287 288 -f 314 313 300 -f 331 314 317 -f 317 314 301 -f 318 344 317 -f 346 345 318 -f 385 346 350 -f 350 346 320 -f 350 320 349 -f 341 382 342 -f 334 341 316 -f 316 341 342 -f 316 342 343 -f 302 301 288 -f 288 301 300 -f 300 301 314 -f 316 336 333 -f 319 320 301 -f 301 320 318 -f 318 320 346 -f 316 343 340 -f 279 274 280 -f 281 275 276 -f 276 275 272 -f 260 269 268 -f 268 269 271 -f 273 277 272 -f 274 271 275 -f 275 271 272 -f 272 271 269 -f 272 269 273 -f 275 280 274 -f 308 307 292 -f 292 307 294 -f 335 321 351 -f 351 321 322 -f 293 292 282 -f 282 292 294 -f 322 321 305 -f 305 321 304 -f 282 295 293 -f 304 303 289 -f 282 294 291 -f 289 281 290 -f 290 281 291 -f 291 281 282 -f 282 281 276 -f 306 305 289 -f 289 305 304 -f 289 290 306 +f 37 34 53 +f 35 54 55 +f 65 63 90 +f 66 91 67 +f 62 89 64 +f 14 13 7 +f 7 13 11 +f 21 17 12 +f 36 56 57 +f 85 110 86 +f 86 110 111 +f 23 22 12 +f 86 57 85 +f 85 57 56 +f 88 112 87 +f 87 112 113 +f 24 18 33 +f 33 18 19 +f 19 18 10 +f 10 18 12 +f 12 18 24 +f 87 58 88 +f 88 58 68 +f 20 10 11 +f 11 10 6 +f 6 10 12 +f 73 71 45 +f 45 71 44 +f 45 44 26 +f 46 45 27 +f 27 45 26 +f 25 43 27 +f 39 25 22 +f 22 25 12 +f 23 40 22 +f 24 41 23 +f 33 42 24 +f 36 58 56 +f 36 54 35 +f 60 59 36 +f 36 59 61 +f 21 12 26 +f 26 12 27 +f 27 12 25 +f 34 19 35 +f 35 19 36 +f 2 7 6 +f 6 7 11 +f 36 61 62 +f 71 72 44 +f 36 57 63 +f 36 62 64 +f 36 65 54 +f 36 64 66 +f 34 37 19 +f 36 66 67 +f 38 33 19 +f 36 67 68 +f 37 38 19 +f 36 68 58 +f 23 12 24 +f 36 63 65 +f 182 150 179 +f 179 150 146 +f 179 146 147 +f 118 117 95 +f 95 117 119 +f 95 119 116 +f 60 36 69 +f 69 36 70 +f 116 141 142 +f 148 119 149 +f 149 119 150 +f 150 119 146 +f 146 119 117 +f 146 117 147 +f 93 92 69 +f 115 114 93 +f 140 139 115 +f 172 140 143 +f 143 140 116 +f 145 175 143 +f 178 145 176 +f 176 145 144 +f 202 176 203 +f 203 176 177 +f 177 176 144 +f 142 144 116 +f 116 144 145 +f 116 145 143 +f 115 93 116 +f 177 204 203 +f 116 140 115 +f 69 94 93 +f 93 94 116 +f 116 94 95 +f 95 94 70 +f 70 94 69 +f 112 137 113 +f 113 137 138 +f 138 137 169 +f 111 110 135 +f 135 110 136 +f 135 136 166 +f 136 138 166 +f 166 138 169 +f 190 189 162 +f 162 189 191 +f 193 167 194 +f 194 167 192 +f 192 167 166 +f 166 167 135 +f 218 194 217 +f 217 194 192 +f 213 239 217 +f 214 213 189 +f 189 213 191 +f 215 191 216 +f 216 191 192 +f 192 191 213 +f 192 213 217 +f 167 168 135 +f 276 246 247 +f 247 246 221 +f 249 247 222 +f 222 247 221 +f 219 242 222 +f 223 219 196 +f 196 219 195 +f 197 196 170 +f 170 196 195 +f 170 195 169 +f 170 169 137 +f 243 220 221 +f 221 220 195 +f 221 195 222 +f 222 195 219 +f 137 171 170 +f 163 162 132 +f 132 162 164 +f 164 162 191 +f 161 160 131 +f 131 106 105 +f 105 132 131 +f 131 132 161 +f 161 132 165 +f 165 132 164 +f 165 186 161 +f 300 299 279 +f 279 299 280 +f 280 299 301 +f 278 277 246 +f 246 277 248 +f 246 248 221 +f 257 279 256 +f 256 279 277 +f 277 279 248 +f 248 279 280 +f 263 262 235 +f 240 269 270 +f 210 234 209 +f 209 234 235 +f 234 241 235 +f 235 241 263 +f 263 241 240 +f 263 240 270 +f 216 240 215 +f 215 240 241 +f 271 296 273 +f 275 274 245 +f 298 297 272 +f 272 297 271 +f 243 244 220 +f 220 244 245 +f 272 271 244 +f 244 271 273 +f 244 273 245 +f 245 273 275 +f 123 122 102 +f 102 122 101 +f 3 4 1 +f 1 4 5 +f 77 50 78 +f 78 50 79 +f 50 49 31 +f 31 49 30 +f 31 30 16 +f 31 16 32 +f 5 4 8 +f 8 4 9 +f 101 78 102 +f 102 78 79 +f 50 80 79 +f 9 17 16 +f 16 30 15 +f 50 77 49 +f 15 8 16 +f 16 8 9 +f 282 252 281 +f 281 252 250 +f 148 149 180 +f 180 149 181 +f 251 225 252 +f 252 225 250 +f 181 201 180 +f 180 201 174 +f 251 253 225 +f 173 141 174 +f 225 224 250 +f 173 198 199 +f 199 198 224 +f 199 224 225 +f 199 225 226 +f 200 173 201 +f 201 173 174 +f 173 200 198 +f 32 51 31 +f 31 51 52 +f 106 82 105 +f 105 82 81 +f 72 81 51 +f 51 81 82 +f 51 82 83 +f 51 83 52 +f 51 44 72 +f 83 84 52 +f 226 227 199 +f 199 227 205 +f 256 228 257 +f 257 228 229 +f 204 177 205 +f 254 229 227 +f 227 229 205 +f 205 229 228 +f 205 228 204 +f 227 255 254 +f 281 302 282 +f 282 302 303 +f 182 179 206 +f 206 179 207 +f 304 284 305 +f 230 206 207 +f 313 334 312 +f 283 253 284 +f 302 313 303 +f 303 313 309 +f 333 332 309 +f 309 332 329 +f 329 332 342 +f 259 258 230 +f 310 285 286 +f 286 285 255 +f 286 255 287 +f 311 286 308 +f 308 286 287 +f 306 330 308 +f 331 306 307 +f 307 306 284 +f 304 326 307 +f 305 327 304 +f 329 328 305 +f 288 259 260 +f 260 259 230 +f 260 230 231 +f 231 230 207 +f 304 307 284 +f 283 284 287 +f 287 284 308 +f 308 284 306 +f 312 289 313 +f 313 289 314 +f 313 314 309 +f 303 309 284 +f 284 309 305 +f 305 309 329 +f 312 288 289 +f 289 288 260 +f 285 254 255 +f 28 13 29 +f 29 13 14 +f 120 97 98 +f 100 76 96 +f 96 76 74 +f 96 74 97 +f 97 74 98 +f 185 159 183 +f 183 159 158 +f 183 158 184 +f 98 121 120 +f 120 121 151 +f 122 123 152 +f 152 123 129 +f 29 47 28 +f 28 47 48 +f 103 80 104 +f 104 109 103 +f 103 109 124 +f 103 124 125 +f 99 74 75 +f 75 74 47 +f 47 74 76 +f 47 76 48 +f 128 157 158 +f 127 156 128 +f 126 155 127 +f 154 126 125 +f 125 126 103 +f 124 153 125 +f 134 124 108 +f 108 124 109 +f 133 108 107 +f 107 108 84 +f 84 108 109 +f 159 130 158 +f 103 126 127 +f 127 128 103 +f 129 103 130 +f 130 103 128 +f 130 128 158 +f 84 83 107 +f 130 120 151 +f 152 129 151 +f 151 129 130 +f 275 273 270 +f 270 273 263 +f 187 161 188 +f 188 161 186 +f 212 188 208 +f 208 188 186 +f 233 232 208 +f 261 233 236 +f 236 233 211 +f 264 236 237 +f 237 236 211 +f 237 211 238 +f 237 238 265 +f 210 209 186 +f 186 209 211 +f 186 211 208 +f 208 211 233 +f 265 266 237 +f 325 324 299 +f 299 324 301 +f 318 293 319 +f 319 293 294 +f 294 293 268 +f 268 293 295 +f 338 319 321 +f 321 319 294 +f 322 339 321 +f 340 322 324 +f 324 322 301 +f 298 301 297 +f 297 301 294 +f 294 301 322 +f 294 322 321 +f 293 320 295 +f 315 317 335 +f 335 317 337 +f 323 316 295 +f 295 316 291 +f 295 291 268 +f 336 341 343 +f 343 341 344 +f 341 336 323 +f 323 336 316 +f 317 315 292 +f 292 315 290 +f 291 267 268 +f 268 267 238 +f 267 292 290 +f 290 265 267 +f 267 265 238 diff --git a/data/maps/konda.xml b/data/maps/konda.xml index fc1a479..ccf549c 100644 --- a/data/maps/konda.xml +++ b/data/maps/konda.xml @@ -11,8 +11,8 @@ type="structure_tower" team="1" > - - + + - - + + - - + + - - + + @@ -48,29 +48,29 @@ id="MinionSpawn1" team="1" > - - + + - - + + - - + + - - + + From 7d2ec0e9b1732c4a0543bf179f93c8879719f488 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 09:24:39 -0500 Subject: [PATCH 70/79] Visualizer updates (toggles, faster poll, icon lib) --- web_ui/FiraMonoNerdFontMono-Regular.otf | Bin 0 -> 2278920 bytes web_ui/index.html | 423 +----------------------- web_ui/script.js | 139 ++++++-- web_ui/styles.css | 23 ++ 4 files changed, 140 insertions(+), 445 deletions(-) create mode 100644 web_ui/FiraMonoNerdFontMono-Regular.otf diff --git a/web_ui/FiraMonoNerdFontMono-Regular.otf b/web_ui/FiraMonoNerdFontMono-Regular.otf new file mode 100644 index 0000000000000000000000000000000000000000..9abf74559033916c0e1e90eb26b17e1f6129260b GIT binary patch literal 2278920 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

koLVj|x0XlCtL4-3 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

gT>X;LP;|<3c@^d!9XNpbGM*f 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%0A<$`nZ{QTJR-0Ikq12R0tynaRs>NiaY&87p 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

&R{$ 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%0ASUEhOceu9BcP- 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 z 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 R!Y|KrK;QGX(e*&0!< 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∼#T6JPyB)Ro85^%~xu8U4tb}lP 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≺1Bqxqtnsh4rC8>M|$Dy?zE+~DQ$|v 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 v+E5jI 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

GLu&3 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 $-utg}9Z<9Ou7U{NMUjNS9Z~x%G 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%0Dhd(vw3hR*jr!kCL_93p|-;0mUX9c=i+=+RQ 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 M{15z2($|dt0X#&*X#fBK literal 0 HcmV?d00001 diff --git a/web_ui/index.html b/web_ui/index.html index 9a97b8b..a0db6e7 100644 --- a/web_ui/index.html +++ b/web_ui/index.html @@ -3,6 +3,10 @@ GameServer Debugger +

GameServer Debugger

@@ -10,19 +14,14 @@

Map View

Visualization Legend

-
-
█ Grid - Reference coordinate grid (10-unit spacing)
-
█ Map Bounds - Dashed line showing map boundary
-
█ Navmesh - Walkable area polygons
-
▭ Polygon Grid - Spatial acceleration grid cells for pathfinding lookup
-
● Vertices - Navmesh vertex positions with indices
-
● Centroids - Polygon center points for pathfinding
-
★ Spawnpoints - Unit spawn locations
-
● Blue Entity - Team 1 entity
-
● Red Entity - Team 2 entity
-
⚫ Attacking Ring - Entity in ATTACKING state
-
⚫ Moving Ring - Entity in MOVING state
-
⚫ Pathfinding Ring - Entity in PATHFINDING_WAITING state
+
+
- Dashed line showing map boundary
+
- Spatial acceleration grid cells for pathfinding lookup
+
- Navmesh vertex positions with indices
+
- Unit spawn locations
+
- Map structures
+
- Team 1 and Team 2 entities
+
- Lines showing attack targets

Game State

@@ -33,400 +32,4 @@

Entities

- - - \ No newline at end of file + \ No newline at end of file diff --git a/web_ui/script.js b/web_ui/script.js index b6c5b5a..b826cea 100644 --- a/web_ui/script.js +++ b/web_ui/script.js @@ -1,6 +1,28 @@ const canvas = document.getElementById('mapCanvas'); const ctx = canvas.getContext('2d'); +// Visualization layer visibility state +const layerVisibility = { + mapBounds: true, + polygonGrid: true, + navmesh: true, + spawnpoints: true, + structures: true, + entities: true, + targetingLines: true +}; + +// Initialize legend toggle event listeners +function initializeLegendToggles() { + const toggles = document.querySelectorAll('.legend-toggle'); + toggles.forEach(toggle => { + toggle.addEventListener('change', (e) => { + const layer = e.target.dataset.layer; + layerVisibility[layer] = e.target.checked; + }); + }); +} + async function updateView() { try { const response = await fetch('/api/gamestate'); @@ -11,19 +33,22 @@ async function updateView() { ctx.fillRect(0, 0, canvas.width, canvas.height); // Draw grid first (background) - drawPolygonGrid(data.map); + if (layerVisibility.polygonGrid) drawPolygonGrid(data.map); // Draw map bounds - drawMapBounds(data.map); + if (layerVisibility.mapBounds) drawMapBounds(data.map); // Draw navmesh - drawNavmesh(data.map); + if (layerVisibility.navmesh) drawNavmesh(data.map); // Draw spawnpoints - drawSpawnpoints(data.map); + if (layerVisibility.spawnpoints) drawSpawnpoints(data.map); + + // Draw structures + if (layerVisibility.structures) drawStructures(data.map); // Draw entities - drawEntities(data.entities); + if (layerVisibility.entities) drawEntities(data.entities); // Update state info updateStateInfo(data.state); @@ -262,40 +287,83 @@ function drawSpawnpoints(mapData) { } } -function drawEntities(entities) { - if (!entities) return; - - // First pass: draw targeting lines - for (let entity of entities) { - if (entity.target_id !== undefined) { - const attacker_screen = worldToScreen(entity.position.x, entity.position.z); - - // Find target entity - const target = entities.find(e => e.id === entity.target_id); - if (target) { - const target_screen = worldToScreen(target.position.x, target.position.z); +function drawStructures(mapData) { + if (!mapData || !mapData.structures) return; + ctx.fillStyle = '#ffa500'; + ctx.strokeStyle = '#ffa500'; + ctx.lineWidth = 2; - // Draw targeting line - ctx.strokeStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; - ctx.lineWidth = 2; - ctx.setLineDash([5, 5]); + for (let struct of mapData.structures) { + const screen = worldToScreen(struct.position.x, struct.position.z); + // Draw structure based on type + switch (struct.type) { + case "structure_core": + // Core is a crystal shape ctx.beginPath(); - ctx.moveTo(attacker_screen.x, attacker_screen.y); - ctx.lineTo(target_screen.x, target_screen.y); + ctx.moveTo(screen.x, screen.y - 10); + ctx.lineTo(screen.x + 7, screen.y); + ctx.lineTo(screen.x, screen.y + 10); + ctx.lineTo(screen.x - 7, screen.y); + ctx.closePath(); + ctx.fill(); ctx.stroke(); - ctx.setLineDash([]); - - // Draw arrowhead at target - const angle = Math.atan2(target_screen.y - attacker_screen.y, target_screen.x - attacker_screen.x); - const arrowSize = 8; - - ctx.fillStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + break; + case "structure_tower": + // Tower is a crown shape with a T inside ctx.beginPath(); - ctx.moveTo(target_screen.x, target_screen.y); - ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle - Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle - Math.PI / 6)); - ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle + Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle + Math.PI / 6)); + ctx.moveTo(screen.x - 8, screen.y + 10); + ctx.lineTo(screen.x - 4, screen.y - 10); + ctx.lineTo(screen.x, screen.y + 5); + ctx.lineTo(screen.x + 4, screen.y - 10); + ctx.lineTo(screen.x + 8, screen.y + 10); ctx.closePath(); ctx.fill(); + ctx.stroke(); + + break; + default: + console.log(mapData); + // Add more cases for other structure types as needed + } + } +} + +function drawEntities(entities) { + if (!entities) return; + + // First pass: draw targeting lines + if (layerVisibility.targetingLines) { + for (let entity of entities) { + if (entity.target_id !== undefined) { + const attacker_screen = worldToScreen(entity.position.x, entity.position.z); + + // Find target entity + const target = entities.find(e => e.id === entity.target_id); + if (target) { + const target_screen = worldToScreen(target.position.x, target.position.z); + + // Draw targeting line + ctx.strokeStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + ctx.lineWidth = 2; + ctx.setLineDash([5, 5]); + ctx.beginPath(); + ctx.moveTo(attacker_screen.x, attacker_screen.y); + ctx.lineTo(target_screen.x, target_screen.y); + ctx.stroke(); + ctx.setLineDash([]); + + // Draw arrowhead at target + const angle = Math.atan2(target_screen.y - attacker_screen.y, target_screen.x - attacker_screen.x); + const arrowSize = 8; + + ctx.fillStyle = entity.team_id === 1 ? '#4080ff' : '#ff4080'; + ctx.beginPath(); + ctx.moveTo(target_screen.x, target_screen.y); + ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle - Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle - Math.PI / 6)); + ctx.lineTo(target_screen.x - arrowSize * Math.cos(angle + Math.PI / 6), target_screen.y - arrowSize * Math.sin(angle + Math.PI / 6)); + ctx.closePath(); + ctx.fill(); + } } } } @@ -375,6 +443,7 @@ function updateEntitiesList(entities) { -// Update every 500ms -setInterval(updateView, 500); +// Update every 50ms +initializeLegendToggles(); +setInterval(updateView, 50); updateView(); \ No newline at end of file diff --git a/web_ui/styles.css b/web_ui/styles.css index ffdbd97..32e1432 100644 --- a/web_ui/styles.css +++ b/web_ui/styles.css @@ -1,3 +1,15 @@ +@import "https://www.nerdfonts.com/assets/css/webfont.css"; + +@font-face { + font-family: "fira-mono"; + src: url("./FiraMonoNerdFontMono-Regular.otf"); +} +* { + font-size: 14px; + box-sizing: border-box; + font-family: "fira-mono", monospace; +} + body { font-family: Arial, sans-serif; margin: 20px; @@ -26,4 +38,15 @@ canvas { h2 { border-bottom: 1px solid #404040; padding-bottom: 10px; +} + +.legend-toggle { + margin-right: 5px; + cursor: pointer; +} + +#legendContainer { + background: #252526; + padding: 10px; + border-radius: 4px; } \ No newline at end of file From 7fff0d7df56bd3bd885d065162fafd2116ac4082 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 09:25:19 -0500 Subject: [PATCH 71/79] Direct movement stays in grid --- src/systems/core/movement_system.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/systems/core/movement_system.cpp b/src/systems/core/movement_system.cpp index c5dc2eb..a3ea7c7 100644 --- a/src/systems/core/movement_system.cpp +++ b/src/systems/core/movement_system.cpp @@ -95,6 +95,19 @@ void MovementSystem::update_direct_movement(const SystemContext& ctx, Entity& en ? target_pos : current_pos + (direction.normalized() * distance_to_move); + // Validate that new position stays within grid bounds + if (ctx.map && ctx.map->grid_width > 0 && ctx.map->grid_height > 0) { + Vec2 grid_min = ctx.map->grid_origin; + Vec2 grid_max = ctx.map->grid_origin + Vec2( + ctx.map->grid_width * ctx.map->grid_cell_size, + ctx.map->grid_height * ctx.map->grid_cell_size + ); + + // Clamp position to grid bounds + new_position.x = std::max(grid_min.x, std::min(new_position.x, grid_max.x)); + new_position.y = std::max(grid_min.y, std::min(new_position.y, grid_max.y)); + } + movement.position = new_position; } From 768434e2087e23a9a477faeb9588ca38823a773e Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 09:25:53 -0500 Subject: [PATCH 72/79] Navmesh grid fixes for A* --- src/services/astar_pathfinding.cpp | 107 ++++++++++++++++++++++++++++- src/services/astar_pathfinding.hpp | 12 ++++ 2 files changed, 116 insertions(+), 3 deletions(-) diff --git a/src/services/astar_pathfinding.cpp b/src/services/astar_pathfinding.cpp index 233cb7a..68ec00a 100644 --- a/src/services/astar_pathfinding.cpp +++ b/src/services/astar_pathfinding.cpp @@ -85,15 +85,26 @@ std::vector AStarPathfinder::FindPath( LOG_DEBUG("A*: start_polygon=%u, goal_polygon=%u for path (%.1f, %.1f) -> (%.1f, %.1f)", start_polygon, goal_polygon, start_pos.x, start_pos.y, goal_pos.x, goal_pos.y); - // If either position is not in a polygon, try to find the closest polygon + // If start position is not in a polygon, try to find the closest polygon if (start_polygon == UINT32_MAX) { int closest = FindClosestPolygon(start_pos); start_polygon = (closest >= 0) ? static_cast(closest) : UINT32_MAX; } + // If goal position is not in a polygon, project it onto the navmesh if (goal_polygon == UINT32_MAX) { - int closest = FindClosestPolygon(goal_pos); - goal_polygon = (closest >= 0) ? static_cast(closest) : UINT32_MAX; + Vec2 projected_goal = ProjectToNavmesh(goal_pos, vertices, polygons, grid); + LOG_DEBUG("A*: Goal (%.1f, %.1f) projected to (%.1f, %.1f)", + goal_pos.x, goal_pos.y, projected_goal.x, projected_goal.y); + + // Try to find polygon containing the projected position + goal_polygon = FindPolygonContainingPoint(projected_goal); + + // If still not found, find the closest polygon + if (goal_polygon == UINT32_MAX) { + int closest = FindClosestPolygon(projected_goal); + goal_polygon = (closest >= 0) ? static_cast(closest) : UINT32_MAX; + } } if (start_polygon == UINT32_MAX || goal_polygon == UINT32_MAX) { @@ -428,3 +439,93 @@ std::vector AStarPathfinder::SmoothPath( return smoothed; } + +Vec2 AStarPathfinder::ProjectToNavmesh( + const Vec2& pos, + const std::vector& vertices, + const std::vector>& polygons, + const NavGrid* nav_grid +) { + // Helper lambda to check if point is in polygon + auto IsInPolygon = [&](const Vec2& point, const std::vector& poly_verts) -> bool { + return PointInPolygon(point, poly_verts); + }; + + // Check if position is already inside a polygon + if (nav_grid && nav_grid->IsBuilt()) { + Vec2 rel_pos = pos - nav_grid->grid_origin; + int gx = static_cast(std::floor(rel_pos.x / nav_grid->grid_cell_size)); + int gy = static_cast(std::floor(rel_pos.y / nav_grid->grid_cell_size)); + + gx = std::max(0, std::min(gx, nav_grid->grid_width - 1)); + gy = std::max(0, std::min(gy, nav_grid->grid_height - 1)); + + int cell_index = gy * nav_grid->grid_width + gx; + if (cell_index >= 0 && cell_index < static_cast(nav_grid->grid_cells.size())) { + const auto& candidates = nav_grid->grid_cells[cell_index]; + for (uint32_t poly_id : candidates) { + if (poly_id < polygons.size()) { + std::vector poly_verts; + for (uint32_t vertex_idx : polygons[poly_id]) { + if (vertex_idx < vertices.size()) { + poly_verts.push_back(vertices[vertex_idx]); + } + } + if (IsInPolygon(pos, poly_verts)) { + return pos; // Already inside a polygon + } + } + } + } + } + + // Position is not inside a polygon, find closest point on any edge + float closest_dist = std::numeric_limits::max(); + Vec2 closest_point = pos; + + for (const auto& polygon : polygons) { + std::vector poly_verts; + for (uint32_t vertex_idx : polygon) { + if (vertex_idx < vertices.size()) { + poly_verts.push_back(vertices[vertex_idx]); + } + } + + if (poly_verts.size() < 2) continue; + + // Check each edge of this polygon + for (size_t i = 0; i < poly_verts.size(); ++i) { + const Vec2& v1 = poly_verts[i]; + const Vec2& v2 = poly_verts[(i + 1) % poly_verts.size()]; + + // Find closest point on this edge + Vec2 edge = v2 - v1; + float edge_len_sq = edge.x * edge.x + edge.y * edge.y; + + if (edge_len_sq < 0.0001f) { + // Degenerate edge, just use v1 + float dist = pos.distance_to(v1); + if (dist < closest_dist) { + closest_dist = dist; + closest_point = v1; + } + continue; + } + + Vec2 to_pos = pos - v1; + float t = (to_pos.x * edge.x + to_pos.y * edge.y) / edge_len_sq; + t = std::max(0.0f, std::min(1.0f, t)); // Clamp to edge + + Vec2 point_on_edge = v1 + edge * t; + float dist = pos.distance_to(point_on_edge); + + if (dist < closest_dist) { + closest_dist = dist; + closest_point = point_on_edge; + } + } + } + + return closest_point; +} + diff --git a/src/services/astar_pathfinding.hpp b/src/services/astar_pathfinding.hpp index 8e23379..25cd7fc 100644 --- a/src/services/astar_pathfinding.hpp +++ b/src/services/astar_pathfinding.hpp @@ -133,4 +133,16 @@ class AStarPathfinder { const std::vector>& polygons, float entity_radius ); + + /** + * Project a position onto the closest point on the navmesh. + * If the position is already inside a polygon, returns the position unchanged. + * Otherwise, finds the closest point on any polygon edge. + */ + static Vec2 ProjectToNavmesh( + const Vec2& pos, + const std::vector& vertices, + const std::vector>& polygons, + const NavGrid* nav_grid = nullptr + ); }; From d5c9f119cc74934f93afb78ee1fabd6254303d34 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 09:26:53 -0500 Subject: [PATCH 73/79] Add structures, more navgrid fixes, and set minions to target Cores --- src/components/map.hpp | 17 +++++++- src/components/pathfinding.hpp | 2 +- src/services/visualizer_service.cpp | 16 ++++++++ src/systems/core/collision_system.cpp | 57 +++++++++++++++++++++++---- src/systems/core/collision_system.hpp | 6 ++- src/systems/core/spawning_system.cpp | 26 ++++++++++-- src/systems/util/data_loader.cpp | 48 +++++++++++++++++++++- 7 files changed, 155 insertions(+), 17 deletions(-) diff --git a/src/components/map.hpp b/src/components/map.hpp index a4a9416..ba7076f 100644 --- a/src/components/map.hpp +++ b/src/components/map.hpp @@ -5,9 +5,21 @@ #include #include +/** + * Represents a single structure on the map (tower, core, etc.) (may become a full component later) -- cmkrist 4/12/2025 + */ +struct MapStructure { + std::string id; + std::string type; + uint32_t team = 0; + Vec3 position; + Vec3 rotation; + Vec3 scale; +}; + /** * Map component for the map entity. - * Stores map metadata including name, navmesh data, and spawnpoint information. + * Stores map metadata including name, navmesh data, spawnpoint information, and structures. */ struct Map : public Component { // Map name (e.g., "Konda") @@ -21,6 +33,9 @@ struct Map : public Component { // Minions path from spawnpoint[i] to spawnpoint[(i+1) % spawnpoints.size()] std::vector spawnpoints; + // Structures on the map (towers, cores, etc.) + std::vector structures; + // Grid size and offset Vec2 size = Vec2(0.0f, 0.0f); //width, height Vec2 offset = Vec2(0.0f, 0.0f); // 1/2 width, 1/2 height - cmkrist 15/11/2025 diff --git a/src/components/pathfinding.hpp b/src/components/pathfinding.hpp index 93e3cb6..6e966fd 100644 --- a/src/components/pathfinding.hpp +++ b/src/components/pathfinding.hpp @@ -18,7 +18,7 @@ struct PathfindingComponent : public Component { uint32_t path_request_id = 0; // True if the entity has requested a path and is currently waiting for it to be calculated - bool waiting_for_path; + bool waiting_for_path = false; COMPONENT_TYPE_ID(PathfindingComponent, 2009) }; \ No newline at end of file diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index 1624463..7e42e67 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -317,6 +317,22 @@ std::string VisualizerService::get_game_state_json() const { json << "{\"x\":" << map_->spawnpoints[i].x << ",\"z\":" << map_->spawnpoints[i].y << "}"; } json << "],"; + + // Structures + json << "\"structures\":["; + for (size_t i = 0; i < map_->structures.size(); i++) { + if (i > 0) json << ","; + json << "{"; + json << "\"id\":\"" << map_->structures[i].id << "\","; + json << "\"type\":\"" << map_->structures[i].type << "\","; + json << "\"team\":" << map_->structures[i].team << ","; + json << "\"position\":{\"x\":" << map_->structures[i].position.x << ",\"y\":" << map_->structures[i].position.y << ",\"z\":" << map_->structures[i].position.z << "},"; + json << "\"rotation\":{\"x\":" << map_->structures[i].rotation.x << ",\"y\":" << map_->structures[i].rotation.y << ",\"z\":" << map_->structures[i].rotation.z << "},"; + json << "\"scale\":{\"x\":" << map_->structures[i].scale.x << ",\"y\":" << map_->structures[i].scale.y << ",\"z\":" << map_->structures[i].scale.z << "}"; + json << "}"; + } + json << "],"; + // Polygon Grid (for visualization) json << "\"grid\":{"; diff --git a/src/systems/core/collision_system.cpp b/src/systems/core/collision_system.cpp index 237dd8d..82f2ba6 100644 --- a/src/systems/core/collision_system.cpp +++ b/src/systems/core/collision_system.cpp @@ -172,7 +172,25 @@ void CollisionSystem::push_colliding_entities(const Entity& entity, const Vec2& } } -Vec2 CollisionSystem::find_free_space(const Vec2& position, float collision_radius, EntityManager& entity_manager) { +Vec2 CollisionSystem::find_free_space(const Vec2& position, float collision_radius, EntityManager& entity_manager, const struct Map* map) { + // Helper to check if a position is within grid bounds + auto is_within_grid_bounds = [map](const Vec2& pos) -> bool { + if (!map || map->grid_width == 0 || map->grid_height == 0) { + return true; // No map or invalid grid, allow any position + } + + // Calculate grid boundaries + Vec2 grid_min = map->grid_origin; + Vec2 grid_max = map->grid_origin + Vec2( + map->grid_width * map->grid_cell_size, + map->grid_height * map->grid_cell_size + ); + + // Check if position is within bounds + return pos.x >= grid_min.x && pos.x <= grid_max.x && + pos.y >= grid_min.y && pos.y <= grid_max.y; + }; + // Get all entities with movement components to check for collisions auto moving_entities = entity_manager.get_entities_with_component(); @@ -193,11 +211,12 @@ Vec2 CollisionSystem::find_free_space(const Vec2& position, float collision_radi } } - if (position_free) { + // If base position is free AND within grid bounds, return it + if (position_free && is_within_grid_bounds(position)) { return position; } - // If base position is occupied, try to find a free spot nearby + // If base position is occupied or outside bounds, try to find a free spot nearby // Use expanding circles to search for free space constexpr float SEARCH_RADIUS = 5.0f; constexpr int SEARCH_SAMPLES = 16; // Number of angles to check @@ -208,6 +227,11 @@ Vec2 CollisionSystem::find_free_space(const Vec2& position, float collision_radi float angle = (2.0f * PI * i) / SEARCH_SAMPLES; Vec2 candidate = position + Vec2(std::cos(angle) * search_distance, std::sin(angle) * search_distance); + // Skip if candidate is outside grid bounds + if (!is_within_grid_bounds(candidate)) { + continue; + } + // Check if this candidate position is free bool candidate_free = true; for (auto* entity : moving_entities) { @@ -231,10 +255,29 @@ Vec2 CollisionSystem::find_free_space(const Vec2& position, float collision_radi } } - // If no free space found after search, return base position anyway - LOG_WARN("CollisionSystem: Could not find free space near (%.1f, %.1f) with radius %.1f, using base position", - position.x, position.y, collision_radius); - return position; + // If no free space found after search, log warning and return original position if in bounds + if (is_within_grid_bounds(position)) { + LOG_WARN("CollisionSystem: Could not find free space near (%.1f, %.1f) with radius %.1f, using base position", + position.x, position.y, collision_radius); + return position; + } else { + // Original position is outside grid bounds - return closest valid position + // Clamp to grid bounds + Vec2 grid_min = map->grid_origin; + Vec2 grid_max = map->grid_origin + Vec2( + map->grid_width * map->grid_cell_size, + map->grid_height * map->grid_cell_size + ); + + Vec2 clamped_position( + std::max(grid_min.x, std::min(position.x, grid_max.x)), + std::max(grid_min.y, std::min(position.y, grid_max.y)) + ); + + LOG_WARN("CollisionSystem: Spawn position (%.1f, %.1f) is outside grid bounds, clamping to (%.1f, %.1f)", + position.x, position.y, clamped_position.x, clamped_position.y); + return clamped_position; + } } float CollisionSystem::distance(const Vec2& a, const Vec2& b) { diff --git a/src/systems/core/collision_system.hpp b/src/systems/core/collision_system.hpp index d8aa4e0..9884066 100644 --- a/src/systems/core/collision_system.hpp +++ b/src/systems/core/collision_system.hpp @@ -94,13 +94,15 @@ class CollisionSystem { /** * Find a free spawn position near a given location. * Searches for a collision-free position using expanding circle pattern. + * Ensures the spawn position remains within the valid navigation grid bounds. * * @param position The desired spawn position * @param collision_radius The collision radius of the entity to spawn (default 1.0) * @param entity_manager Reference to entity manager to check existing entities - * @return A nearby collision-free position, or the original position if none found + * @param map Pointer to map for grid boundary validation (optional, nullptr skips boundary check) + * @return A nearby collision-free position within grid bounds, or the original position if none found */ - static Vec2 find_free_space(const Vec2& position, float collision_radius, EntityManager& entity_manager); + static Vec2 find_free_space(const Vec2& position, float collision_radius, EntityManager& entity_manager, const struct Map* map = nullptr); private: /** diff --git a/src/systems/core/spawning_system.cpp b/src/systems/core/spawning_system.cpp index 97d2135..d6906b2 100644 --- a/src/systems/core/spawning_system.cpp +++ b/src/systems/core/spawning_system.cpp @@ -15,8 +15,8 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, // Get collision radius from template to find free space float collision_radius = ctx.entity_manager.get_template_collision_radius(template_id); - // Find collision-free spawn position - Vec2 spawn_position = CollisionSystem::find_free_space(position, collision_radius, const_cast(ctx.entity_manager)); + // Find collision-free spawn position within grid bounds + Vec2 spawn_position = CollisionSystem::find_free_space(position, collision_radius, const_cast(ctx.entity_manager), ctx.map); // Create entity from template Entity& entity = ctx.entity_manager.create_entity_from_template(template_id); @@ -41,10 +41,28 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, entity_id, stats->health, stats->max_health, team_id); } // Adjust intent objective target based on team - // Team 1 moves toward spawnpoint 1, Team 2 moves toward spawnpoint 0 (opposite direction) + // Minions should target the enemy core (using structure data from map) auto* npc = entity.get_component(); if (npc && npc->npc_type == NPCType::MINION) { - npc->objective = (team_id == 1) ? Vec2(0, 28) : Vec2(0, -28); + // Find enemy core position from map structures + Vec2 enemy_core_position = Vec2(0, 0); // Default fallback + + if (ctx.map) { + uint8_t enemy_team = (team_id == 1) ? 2 : 1; + + // Search for enemy core in map structures + for (const auto& structure : ctx.map->structures) { + if (structure.type == "structure_core" && structure.team == enemy_team) { + // Convert 3D position to 2D (use X and Z, ignore Y) + enemy_core_position = Vec2(structure.position.x, structure.position.z); + LOG_DEBUG("Found enemy core for team %u at position (%.1f, %.1f)", + team_id, enemy_core_position.x, enemy_core_position.y); + break; + } + } + } + + npc->objective = enemy_core_position; LOG_DEBUG("Entity %u (team %u): Set objective target to <%f, %f>", entity_id, team_id, npc->objective.x, npc->objective.y); } diff --git a/src/systems/util/data_loader.cpp b/src/systems/util/data_loader.cpp index a115fbc..bb4a93b 100644 --- a/src/systems/util/data_loader.cpp +++ b/src/systems/util/data_loader.cpp @@ -383,6 +383,50 @@ std::optional DataLoader::load_map(const std::string& map_name, const std:: } } } + + // Parse structures from XML (if they exist) + pugi::xml_node structures_node = map_node.child("structures"); + if (!structures_node.empty()) { + for (pugi::xml_node structure = structures_node.child("structure"); structure; structure = structure.next_sibling("structure")) { + MapStructure struct_data; + + // Load attributes + struct_data.id = structure.attribute("id").as_string(""); + struct_data.type = structure.attribute("type").as_string(""); + struct_data.team = structure.attribute("team").as_uint(0); + + // Load position + pugi::xml_node pos_node = structure.child("position"); + if (!pos_node.empty()) { + struct_data.position.x = pos_node.attribute("x").as_float(0.0f); + struct_data.position.y = pos_node.attribute("y").as_float(0.0f); + struct_data.position.z = pos_node.attribute("z").as_float(0.0f); + } + + // Load rotation + pugi::xml_node rot_node = structure.child("rotation"); + if (!rot_node.empty()) { + struct_data.rotation.x = rot_node.attribute("x").as_float(0.0f); + struct_data.rotation.y = rot_node.attribute("y").as_float(0.0f); + struct_data.rotation.z = rot_node.attribute("z").as_float(0.0f); + } + + // Load scale + pugi::xml_node scale_node = structure.child("scale"); + if (!scale_node.empty()) { + struct_data.scale.x = scale_node.attribute("x").as_float(1.0f); + struct_data.scale.y = scale_node.attribute("y").as_float(1.0f); + struct_data.scale.z = scale_node.attribute("z").as_float(1.0f); + } else { + struct_data.scale = Vec3(1.0f, 1.0f, 1.0f); // Default scale to 1.0 + } + + map.structures.push_back(struct_data); + LOG_DEBUG("Loaded structure '%s' of type '%s' (team %u) at (%.1f, %.1f, %.1f)", + struct_data.id.c_str(), struct_data.type.c_str(), struct_data.team, + struct_data.position.x, struct_data.position.y, struct_data.position.z); + } + } // Calculate map bounds and derived size/offset from vertices if (!vertices.empty()) { @@ -403,9 +447,9 @@ std::optional DataLoader::load_map(const std::string& map_name, const std:: // Build the polygon grid for spatial acceleration build_polygon_grid(map); - LOG_INFO("Loaded map '%s' from XML: %zu vertices, %zu polygons, %zu spawnpoints. Grid: %dx%d cells", + LOG_INFO("Loaded map '%s' from XML: %zu vertices, %zu polygons, %zu spawnpoints, %zu structures. Grid: %dx%d cells", map.name.c_str(), map.vertices.size(), map.polygons.size(), map.spawnpoints.size(), - map.grid_width, map.grid_height); + map.structures.size(), map.grid_width, map.grid_height); return std::optional(map); } From 6d1ba5851759937c73456eec41070cfc3b0b65c2 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 13:57:38 -0500 Subject: [PATCH 74/79] fix magic minion autos --- data/entities/minions/magic_minion.xml | 1 + src/systems/core/combat_system.cpp | 18 +++++++++++++++--- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/data/entities/minions/magic_minion.xml b/data/entities/minions/magic_minion.xml index b5cf10b..6612d56 100644 --- a/data/entities/minions/magic_minion.xml +++ b/data/entities/minions/magic_minion.xml @@ -16,6 +16,7 @@ magic_resist="5" attack_range="5.5" attack_speed="0.8" + auto_damage_type="MAGICAL" /> diff --git a/src/systems/core/combat_system.cpp b/src/systems/core/combat_system.cpp index 1f9194b..e968b4e 100644 --- a/src/systems/core/combat_system.cpp +++ b/src/systems/core/combat_system.cpp @@ -50,13 +50,25 @@ void CombatSystem::update_auto_attack(const SystemContext& ctx, Entity& entity, auto* target_stats = target_entity ? target_entity->get_component() : nullptr; if (target_stats && target_stats->health > 0.0f && intent->target_entity_id != INVALID_ENTITY_ID) { - // Calculate damage based on attacker's physical power - float damage = stats->physical_power * 1.0f; + // Calculate damage based on attacker's auto damage type and appropriate power stat + float damage = 0.0f; + DamageType damage_type = stats->auto_damage_type; + + switch (damage_type) { + case DamageType::MAGICAL: + damage = stats->magic_power * 1.0f; + break; + case DamageType::PHYSICAL: + case DamageType::TRUE_DAMAGE: + default: + damage = stats->physical_power * 1.0f; + break; + } // Initiate attack attack->pending_target = intent->target_entity_id; attack->pending_damage = damage; - attack->pending_damage_type = DamageType::PHYSICAL; + attack->pending_damage_type = damage_type; attack->attack_in_progress = true; attack->attack_animation_progress = 0.0f; attack->can_attack = false; From 09d904b7da3dc16cca820122ac2b30882d07377c Mon Sep 17 00:00:00 2001 From: cmkrist Date: Thu, 4 Dec 2025 13:58:23 -0500 Subject: [PATCH 75/79] Add Structure Entities (no attacking) --- data/entities/structures/core.xml | 21 +++++++++++++++ data/entities/structures/tower.xml | 22 ++++++++++++++++ data/maps/konda.xml | 8 +++--- src/components/component_registry.hpp | 1 + src/components/stats.hpp | 10 +++++++- src/components/structure.hpp | 19 ++++++++++++++ src/systems/gameserver.cpp | 37 +++++++++++++++++++++++++++ web_ui/script.js | 6 ++--- 8 files changed, 115 insertions(+), 9 deletions(-) create mode 100644 data/entities/structures/core.xml create mode 100644 data/entities/structures/tower.xml create mode 100644 src/components/structure.hpp diff --git a/data/entities/structures/core.xml b/data/entities/structures/core.xml new file mode 100644 index 0000000..37c74b2 --- /dev/null +++ b/data/entities/structures/core.xml @@ -0,0 +1,21 @@ + + + + + + + + + + \ No newline at end of file diff --git a/data/entities/structures/tower.xml b/data/entities/structures/tower.xml new file mode 100644 index 0000000..d3ee901 --- /dev/null +++ b/data/entities/structures/tower.xml @@ -0,0 +1,22 @@ + + + + + + + + + + \ No newline at end of file diff --git a/data/maps/konda.xml b/data/maps/konda.xml index ccf549c..7c0fa84 100644 --- a/data/maps/konda.xml +++ b/data/maps/konda.xml @@ -8,7 +8,7 @@ @@ -17,7 +17,7 @@ @@ -26,7 +26,7 @@ @@ -35,7 +35,7 @@ diff --git a/src/components/component_registry.hpp b/src/components/component_registry.hpp index 707bf34..1ae9aed 100644 --- a/src/components/component_registry.hpp +++ b/src/components/component_registry.hpp @@ -18,6 +18,7 @@ namespace ComponentTypes { constexpr uint32_t MOVEMENT = 2001; constexpr uint32_t STATS = 2002; constexpr uint32_t NPC = 2003; + constexpr uint32_t STRUCTURE = 2010; // === State Management (2010-2099) === constexpr uint32_t ENTITY_STATE = 2010; diff --git a/src/components/stats.hpp b/src/components/stats.hpp index f3a90c1..5c82676 100644 --- a/src/components/stats.hpp +++ b/src/components/stats.hpp @@ -19,7 +19,6 @@ struct Stats : public Component { float max_mana = 0.0f; float mana = 0.0f; float move_speed = 0.0f; - int level = 1; // === Offensive Stats === float attack_range = 1.0f; @@ -46,6 +45,15 @@ struct Stats : public Component { float leech = 0.0f; // Percentage of damage dealt returned as mana float vision_range = 1.0f; + // === Experience & Gold === + int level = 1; + float level_curve = 1.5f; + int total_experience = 0; + int experience = 0; + + int total_gold = 0; + int gold = 0; + // === Team & Faction === uint8_t team_id = 0; // [0 = Neutral, 1 = Team 1, 2 = Team 2] -- cmkrist 15/11/2025 diff --git a/src/components/structure.hpp b/src/components/structure.hpp new file mode 100644 index 0000000..758de3a --- /dev/null +++ b/src/components/structure.hpp @@ -0,0 +1,19 @@ +#pragma once +#include "component.hpp" + +enum class StructureType { + TOWER, + INHIBITOR, + NEXUS, + WARD, + CUSTOM +}; + +struct Structure : public Component { + StructureType type = StructureType::TOWER; + uint32_t level = 1; // Tower level (affects stats) + bool is_active = true; // Can attack/interact + float activation_range = 30.0f; // Range to detect enemies + + COMPONENT_TYPE_ID(Structure, 2010) +}; \ No newline at end of file diff --git a/src/systems/gameserver.cpp b/src/systems/gameserver.cpp index 951bd11..07c746b 100644 --- a/src/systems/gameserver.cpp +++ b/src/systems/gameserver.cpp @@ -9,6 +9,8 @@ #include #include +#include +#include #include #include @@ -43,6 +45,41 @@ ERROR_CODE GameServer::initialize() { return ERROR_CODE::ERROR_ENET_CREATION_FAILED; } + // Send structures to EntityManager + for (const auto& structure_data : map_opt->structures) { + Entity& structure_entity = entity_manager_.create_entity_from_template(structure_data.type); + EntityID entity_id = structure_entity.get_id(); + if (entity_id == INVALID_ENTITY_ID) { + LOG_ERROR("Failed to create structure entity from template"); + continue; + } + // Set position component + auto* move = structure_entity.get_component(); + if (move) { + move->position = Vec2(structure_data.position.x, structure_data.position.z); + } + + // Set team in Stats component + auto* stats = structure_entity.get_component(); + if (stats) { + stats->team_id = structure_data.team; + } + + // Set structure type in Structure Component + auto* structure_comp = structure_entity.get_component(); + if (structure_comp) { + structure_comp->type = [&structure_data]() { + if (structure_data.type == "core") return StructureType::NEXUS; + if (structure_data.type == "tower") return StructureType::TOWER; + if (structure_data.type == "inhibitor") return StructureType::INHIBITOR; + if (structure_data.type == "ward") return StructureType::WARD; + return StructureType::CUSTOM; + }(); + } + + + } + // Initialize Navigation navigation_service_ = std::make_unique(map_opt.value()); diff --git a/web_ui/script.js b/web_ui/script.js index b826cea..b516f68 100644 --- a/web_ui/script.js +++ b/web_ui/script.js @@ -297,7 +297,7 @@ function drawStructures(mapData) { const screen = worldToScreen(struct.position.x, struct.position.z); // Draw structure based on type switch (struct.type) { - case "structure_core": + case "core": // Core is a crystal shape ctx.beginPath(); ctx.moveTo(screen.x, screen.y - 10); @@ -308,7 +308,7 @@ function drawStructures(mapData) { ctx.fill(); ctx.stroke(); break; - case "structure_tower": + case "tower": // Tower is a crown shape with a T inside ctx.beginPath(); ctx.moveTo(screen.x - 8, screen.y + 10); @@ -322,7 +322,6 @@ function drawStructures(mapData) { break; default: - console.log(mapData); // Add more cases for other structure types as needed } } @@ -443,7 +442,6 @@ function updateEntitiesList(entities) { -// Update every 50ms initializeLegendToggles(); setInterval(updateView, 50); updateView(); \ No newline at end of file From 3be4e7937db5cacc77bc377ccb6e151cc4072491 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Fri, 5 Dec 2025 10:02:58 -0500 Subject: [PATCH 76/79] Visualizer minor UI updates --- src/services/visualizer_service.cpp | 10 +++-- web_ui/index.html | 57 ++++++++++++++++------------- web_ui/script.js | 41 ++++++++++++++++++--- web_ui/styles.css | 56 +++++++++++++++++++++++++++- 4 files changed, 129 insertions(+), 35 deletions(-) diff --git a/src/services/visualizer_service.cpp b/src/services/visualizer_service.cpp index 7e42e67..0511f91 100644 --- a/src/services/visualizer_service.cpp +++ b/src/services/visualizer_service.cpp @@ -371,13 +371,17 @@ std::string VisualizerService::get_game_state_json() const { auto all_entities = entity_manager_->get_entities_with_component(); bool first = true; for (auto* entity : all_entities) { - if (!first) json << ","; - first = false; - + if (!entity) continue; + auto* move = entity->get_component(); auto* stats = entity->get_component(); auto* state = entity->get_component(); auto* intent = entity->get_component(); + + if (!move || !stats || !state || !intent) continue; + + if (!first) json << ","; + first = false; json << "{"; json << "\"id\":" << entity->get_id() << ","; diff --git a/web_ui/index.html b/web_ui/index.html index a0db6e7..f598aa1 100644 --- a/web_ui/index.html +++ b/web_ui/index.html @@ -1,35 +1,42 @@ + - GameServer Debugger + OpenChamp Debugger - + + -

GameServer Debugger

-

Map View

- - -

Visualization Legend

-
-
- Dashed line showing map boundary
-
- Spatial acceleration grid cells for pathfinding lookup
-
- Navmesh vertex positions with indices
-
- Unit spawn locations
-
- Map structures
-
- Team 1 and Team 2 entities
-
- Lines showing attack targets
+
+
+
+ +
+
+
+
+
Legend
+
+
+
+
+ +
+
+
+
Entities
+
+
+
+
+
+

Game State

+
+
+
- -

Game State

-
- -

Entities

-
- + \ No newline at end of file diff --git a/web_ui/script.js b/web_ui/script.js index b516f68..077c121 100644 --- a/web_ui/script.js +++ b/web_ui/script.js @@ -12,14 +12,46 @@ const layerVisibility = { targetingLines: true }; +const legend_array = [ + { name: 'Map Bounds', layer: 'mapBounds', color: '#664040' }, + { name: 'Polygon Grid', layer: 'polygonGrid', color: '#6666ff' }, + { name: 'Navmesh', layer: 'navmesh', color: '#80ff80' }, + { name: 'Spawnpoints', layer: 'spawnpoints', color: '#ffff00' }, + { name: 'Structures', layer: 'structures', color: '#ffa500' }, + { name: 'Entities', layer: 'entities', color: '#4040ff' }, + { name: 'Targeting Lines', layer: 'targetingLines', color: '#4da6ff' } +] + // Initialize legend toggle event listeners function initializeLegendToggles() { - const toggles = document.querySelectorAll('.legend-toggle'); - toggles.forEach(toggle => { - toggle.addEventListener('change', (e) => { + const legendDiv = document.getElementById('legendContainer'); + legend_array.forEach(item => { + // Node Generation + const label = document.createElement('label'); + label.style.display = 'block'; + label.style.marginBottom = '4px'; + const checkbox = document.createElement('input'); + checkbox.type = 'checkbox'; + checkbox.className = 'legend-toggle'; + checkbox.dataset.layer = item.layer; + checkbox.checked = layerVisibility[item.layer]; + const colorBox = document.createElement('span'); + colorBox.style.display = 'inline-block'; + colorBox.style.width = '12px'; + colorBox.style.height = '12px'; + colorBox.style.backgroundColor = item.color; + colorBox.style.marginRight = '6px'; + // Listeners + checkbox.addEventListener('click', (e) => { + e.stopPropagation(); const layer = e.target.dataset.layer; layerVisibility[layer] = e.target.checked; }); + // Assembly + label.appendChild(checkbox); + label.appendChild(colorBox); + label.appendChild(document.createTextNode(item.name)); + legendDiv.appendChild(label); }); } @@ -422,7 +454,7 @@ function updateEntitiesList(entities) { for (let entity of entities) { const el = document.createElement('div'); - el.className = 'entity'; + el.className = 'entity t'+entity.team_id; let targetStr = ''; if (entity.target_id !== undefined) { @@ -441,7 +473,6 @@ function updateEntitiesList(entities) { } - initializeLegendToggles(); setInterval(updateView, 50); updateView(); \ No newline at end of file diff --git a/web_ui/styles.css b/web_ui/styles.css index 32e1432..7d7f9c1 100644 --- a/web_ui/styles.css +++ b/web_ui/styles.css @@ -17,11 +17,48 @@ body { color: #d4d4d4; } +i { + font-style: normal; +} + + +/* Grid Layout */ +.grid_container { +display: grid; +position: absolute; +top: 0; +left: 0; +width: 100%; +height: 100%; +grid-template-columns: 1fr 4fr 1fr; +grid-template-rows: 1fr 5fr 1fr; +grid-column-gap: 0px; +grid-row-gap: 0px; +} + +.grid_container > div { + padding: 10px; + overflow: auto; +} + +.top_container { grid-area: 1 / 1 / 2 / 4; } +.left_container { grid-area: 2 / 1 / 3 / 2; } +.right_container { grid-area: 2 / 3 / 3 / 4; } +.map_container { grid-area: 2 / 2 / 3 / 3; } +.bottom_container { grid-area: 3 / 1 / 4 / 4; } + +/* Map */ +.grid_container > .map_container { + overflow: hidden; +} + canvas { border: 1px solid #404040; background: #000; - margin: 20px 0; display: block; + width: 100%; + height: auto; + margin-top:-10%; } .info { @@ -31,11 +68,26 @@ canvas { padding: 10px; } +/* Entities */ .entity { margin: 5px 0; + border-width: 2px; + border-radius: 3px; + border-style: dashed; +} + +.entity.t1 { + border-color: #000077; + background-color: #0000FF; +} + +.entity.t2 { + border-color: #770000; + background-color: #FF0000; } -h2 { + +h6 { border-bottom: 1px solid #404040; padding-bottom: 10px; } From 01832425d1dabd2a20e493cb5df2c054fefb7fcb Mon Sep 17 00:00:00 2001 From: cmkrist Date: Fri, 5 Dec 2025 11:01:41 -0500 Subject: [PATCH 77/79] State machine and ID Fixes --- src/systems/core/brain_system.cpp | 6 +++++- src/systems/core/spawning_system.cpp | 9 ++++++++- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/src/systems/core/brain_system.cpp b/src/systems/core/brain_system.cpp index f2648c7..72b3efc 100644 --- a/src/systems/core/brain_system.cpp +++ b/src/systems/core/brain_system.cpp @@ -54,6 +54,7 @@ void BrainSystem::handle_attack_intent(const SystemContext& ctx, Entity* entity) // Move into range if too far away if((target_movement->position - entity_movement->position).length() > stats->attack_range) { + state->current_state = EntityState::MOVING; attack->target = std::nullopt; // Cancel any ongoing attack entity_movement->target = target_movement->position; return; @@ -61,17 +62,20 @@ void BrainSystem::handle_attack_intent(const SystemContext& ctx, Entity* entity) // Start attack if in range if(!attack->target.has_value() || attack->target.value() != target->get_id()) { + state->current_state = EntityState::ATTACKING; entity_movement->target = std::nullopt; // Stop moving attack->target = intent->target_entity_id; + return; } } void BrainSystem::handle_move_intent(const SystemContext& ctx, Entity* entity) { Movement* movement = entity->get_component(); IntentComponent* intent = entity->get_component(); - + EntityStateComponent* state = entity->get_component(); // Set the movement target if required if(!movement->target.has_value() || movement->target.value() != intent->target_position) { + state->current_state = EntityState::MOVING; movement->target = intent->target_position; } } \ No newline at end of file diff --git a/src/systems/core/spawning_system.cpp b/src/systems/core/spawning_system.cpp index d6906b2..453f06a 100644 --- a/src/systems/core/spawning_system.cpp +++ b/src/systems/core/spawning_system.cpp @@ -52,7 +52,7 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, // Search for enemy core in map structures for (const auto& structure : ctx.map->structures) { - if (structure.type == "structure_core" && structure.team == enemy_team) { + if (structure.type == "core" && structure.team == enemy_team) { // Convert 3D position to 2D (use X and Z, ignore Y) enemy_core_position = Vec2(structure.position.x, structure.position.z); LOG_DEBUG("Found enemy core for team %u at position (%.1f, %.1f)", @@ -60,6 +60,13 @@ EntityID SpawningSystem::spawn_entity_from_template(const SystemContext& ctx, break; } } + + if (enemy_core_position.x == 0.0f && enemy_core_position.y == 0.0f) { + LOG_WARN("Could not find enemy core for team %u in %zu structures. Minion %u will default to (0,0)", + enemy_team, ctx.map->structures.size(), entity_id); + } + } else { + LOG_ERROR("Map context is null! Minion %u objective cannot be set properly", entity_id); } npc->objective = enemy_core_position; From 6d34f508e1e2cd1039d3ea096c1dbb5d9e62dd81 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Fri, 5 Dec 2025 13:43:16 -0500 Subject: [PATCH 78/79] Remove data directory from tracking (will be added as submodule) --- data/entities/_entity.xsd | 116 ---- data/entities/champions/champion.xml | 33 -- data/entities/minions/_minion.xsd | 11 - data/entities/minions/cannon_minion.xml | 29 - data/entities/minions/magic_minion.xml | 31 - data/entities/minions/melee_minion.xml | 29 - data/entities/minions/ranged_minion.xml | 29 - data/entities/player.xml | 12 - data/entities/structures/core.xml | 21 - data/entities/structures/tower.xml | 22 - data/maps/konda.nav.obj | 725 ------------------------ data/maps/konda.xml | 76 --- 12 files changed, 1134 deletions(-) delete mode 100644 data/entities/_entity.xsd delete mode 100644 data/entities/champions/champion.xml delete mode 100644 data/entities/minions/_minion.xsd delete mode 100644 data/entities/minions/cannon_minion.xml delete mode 100644 data/entities/minions/magic_minion.xml delete mode 100644 data/entities/minions/melee_minion.xml delete mode 100644 data/entities/minions/ranged_minion.xml delete mode 100644 data/entities/player.xml delete mode 100644 data/entities/structures/core.xml delete mode 100644 data/entities/structures/tower.xml delete mode 100644 data/maps/konda.nav.obj delete mode 100644 data/maps/konda.xml diff --git a/data/entities/_entity.xsd b/data/entities/_entity.xsd deleted file mode 100644 index c9ddee0..0000000 --- a/data/entities/_entity.xsd +++ /dev/null @@ -1,116 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/champions/champion.xml b/data/entities/champions/champion.xml deleted file mode 100644 index 9b62117..0000000 --- a/data/entities/champions/champion.xml +++ /dev/null @@ -1,33 +0,0 @@ - - - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/minions/_minion.xsd b/data/entities/minions/_minion.xsd deleted file mode 100644 index 4e4fc1c..0000000 --- a/data/entities/minions/_minion.xsd +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/data/entities/minions/cannon_minion.xml b/data/entities/minions/cannon_minion.xml deleted file mode 100644 index e402fe1..0000000 --- a/data/entities/minions/cannon_minion.xml +++ /dev/null @@ -1,29 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/minions/magic_minion.xml b/data/entities/minions/magic_minion.xml deleted file mode 100644 index 6612d56..0000000 --- a/data/entities/minions/magic_minion.xml +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/minions/melee_minion.xml b/data/entities/minions/melee_minion.xml deleted file mode 100644 index 7739e6a..0000000 --- a/data/entities/minions/melee_minion.xml +++ /dev/null @@ -1,29 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/minions/ranged_minion.xml b/data/entities/minions/ranged_minion.xml deleted file mode 100644 index de1ef44..0000000 --- a/data/entities/minions/ranged_minion.xml +++ /dev/null @@ -1,29 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/player.xml b/data/entities/player.xml deleted file mode 100644 index 2faf7d2..0000000 --- a/data/entities/player.xml +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - diff --git a/data/entities/structures/core.xml b/data/entities/structures/core.xml deleted file mode 100644 index 37c74b2..0000000 --- a/data/entities/structures/core.xml +++ /dev/null @@ -1,21 +0,0 @@ - - - - - - - - - - \ No newline at end of file diff --git a/data/entities/structures/tower.xml b/data/entities/structures/tower.xml deleted file mode 100644 index d3ee901..0000000 --- a/data/entities/structures/tower.xml +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - \ No newline at end of file diff --git a/data/maps/konda.nav.obj b/data/maps/konda.nav.obj deleted file mode 100644 index c32a9c9..0000000 --- a/data/maps/konda.nav.obj +++ /dev/null @@ -1,725 +0,0 @@ -# OpenChamp Navigation Mesh -# Scene: konda -# Vertices: 344 -# Faces: 375 - -v -32.250000 0.543138 -4.250002 -v -32.750000 0.543138 -4.750002 -v -32.000000 0.543138 -4.250002 -v -31.500000 0.543138 -3.750002 -v -32.250000 0.543138 -3.250002 -v -31.750000 0.543138 -6.250002 -v -34.750000 0.543138 -4.750002 -v -31.500000 0.543138 -2.750002 -v -30.000000 0.543138 -3.750002 -v -34.000000 0.543138 -19.500002 -v -35.750000 1.043138 -18.250002 -v -29.750000 0.543138 -6.250002 -v -35.750000 0.793138 -3.500002 -v -34.750000 0.543138 -3.500002 -v -31.500000 0.543138 -1.750002 -v -29.500000 0.543138 -2.500002 -v -29.500000 0.543138 -4.250002 -v -32.025002 0.543138 -19.025002 -v -33.750000 1.043138 -20.250002 -v -35.000000 0.793138 -19.500002 -v -29.000000 0.543138 -4.750002 -v -17.750000 0.543138 -13.000002 -v -16.750000 0.543138 -15.000002 -v -15.750000 0.543138 -17.000002 -v -18.750000 0.543138 -11.000002 -v -27.250000 0.543138 -4.750002 -v -19.750000 0.543138 -9.000002 -v -35.750000 0.793138 -2.750002 -v -35.250000 0.543138 -3.000002 -v -32.250000 0.793138 -1.250002 -v -28.000000 0.543138 1.999998 -v -28.000000 0.543138 -2.000002 -v -14.750000 0.543138 -19.000002 -v -10.750000 0.793138 -19.750002 -v -9.250000 0.793138 -19.750002 -v 13.750000 1.043138 -20.250002 -v -12.250000 0.793138 -19.750002 -v -14.250000 0.543138 -19.500002 -v -17.750000 0.543138 -11.500002 -v -16.750000 0.543138 -13.500002 -v -15.750000 0.543138 -15.500002 -v -14.750000 0.543138 -17.500002 -v -18.750000 0.543138 -9.500002 -v -26.750000 0.543138 -3.750002 -v -20.750000 0.543138 -7.000002 -v -19.750000 0.543138 -7.500002 -v -35.250000 0.543138 -1.250002 -v -37.000000 0.793138 -1.750002 -v -32.250000 0.793138 1.249998 -v -29.500000 0.543138 2.499998 -v -26.750000 0.543138 -2.500002 -v -26.750000 0.543138 2.499998 -v -11.250000 0.543138 -19.250002 -v -7.750000 0.793138 -19.750002 -v -8.250000 0.543138 -19.250002 -v -0.750000 0.793138 -19.750002 -v -3.250000 0.793138 -19.750002 -v 0.750000 0.793138 -19.750002 -v 11.250000 0.543138 -19.250002 -v 13.750000 0.793138 -19.750002 -v 10.750000 0.793138 -19.750002 -v 9.250000 0.793138 -19.750002 -v -4.750000 0.793138 -19.750002 -v 7.750000 0.793138 -19.750002 -v -6.250000 0.793138 -19.750002 -v 6.250000 0.793138 -19.750002 -v 4.750000 0.793138 -19.750002 -v 3.250000 0.793138 -19.750002 -v 14.750000 0.543138 -19.000002 -v 33.750000 1.043138 -20.250002 -v -21.750000 0.543138 -5.000002 -v -21.750000 0.543138 -3.750002 -v -20.750000 0.543138 -5.500002 -v -35.250000 0.543138 1.249998 -v -34.750000 0.543138 -0.750002 -v -37.000000 0.543138 0.249998 -v -31.500000 0.543138 1.749998 -v -31.500000 0.543138 2.749998 -v -30.000000 0.543138 3.749998 -v -29.500000 0.543138 4.249998 -v -21.250000 0.543138 -2.500002 -v -21.250000 0.543138 2.499998 -v -21.750000 0.543138 3.749998 -v -26.750000 0.543138 3.749998 -v -1.750000 0.543138 -19.000002 -v -2.250000 0.543138 -19.000002 -v 1.750000 0.543138 -19.000002 -v 2.250000 0.543138 -19.000002 -v 8.250000 0.543138 -19.250002 -v -5.250000 0.543138 -19.250002 -v 5.250000 0.543138 -19.250002 -v 14.750000 0.543138 -17.500002 -v 15.750000 0.543138 -17.000002 -v 32.480034 0.543138 -18.992041 -v 34.000000 0.543138 -19.500002 -v -37.250000 1.043138 1.499998 -v -36.000000 0.793138 2.499998 -v -35.250000 0.543138 2.999998 -v -34.750000 0.543138 0.749998 -v -37.500000 1.043138 0.499998 -v -32.250000 0.543138 3.249998 -v -31.500000 0.543138 3.749998 -v -29.750000 0.543138 6.249998 -v -29.000000 0.543138 4.749998 -v -20.000000 0.543138 -2.250002 -v -20.000000 0.543138 2.249998 -v -21.750000 0.543138 4.999998 -v -20.750000 0.543138 6.999998 -v -27.250000 0.543138 4.749998 -v -1.750000 0.543138 -17.000002 -v -2.250000 0.543138 -17.000002 -v 2.250000 0.543138 -17.000002 -v 1.750000 0.543138 -17.000002 -v 15.750000 0.543138 -15.500002 -v 16.750000 0.543138 -15.000002 -v 29.750000 0.543138 -6.250002 -v 35.250000 0.793138 -18.500002 -v 35.000000 0.793138 -19.500002 -v 31.750000 0.543138 -6.250002 -v -35.750000 0.793138 3.749998 -v -34.750000 0.543138 3.249998 -v -32.250000 0.543138 4.249998 -v -32.000000 0.543138 4.249998 -v -19.750000 0.543138 8.999998 -v -18.750000 0.543138 10.999998 -v -17.750000 0.543138 12.999998 -v -16.750000 0.543138 14.999998 -v -15.750000 0.543138 16.999998 -v -31.750000 0.543138 6.249998 -v -35.750000 0.793138 18.249998 -v -18.500000 0.543138 2.499998 -v -18.250000 0.543138 -3.000002 -v -20.750000 0.543138 5.499998 -v -19.750000 0.543138 7.499998 -v -3.000000 0.543138 -16.500002 -v -0.750000 0.543138 -16.250002 -v 3.000000 0.543138 -16.500002 -v 0.750000 0.543138 -16.250002 -v 16.750000 0.543138 -13.500002 -v 17.750000 0.543138 -13.000002 -v 29.500000 0.543138 -4.250002 -v 29.000000 0.543138 -4.750002 -v 18.750000 0.543138 -11.000002 -v 27.250000 0.543138 -4.750002 -v 19.750000 0.543138 -9.000002 -v 35.449997 0.543138 -14.375002 -v 35.750000 1.293138 -18.500002 -v 32.000000 0.543138 -4.250002 -v 32.250000 0.543138 -4.250002 -v 34.750000 0.543138 -4.750002 -v -35.000000 0.543138 4.499998 -v -33.500000 0.543138 4.749998 -v -18.750000 0.543138 9.499998 -v -17.750000 0.543138 11.499998 -v -16.750000 0.543138 13.499998 -v -15.750000 0.543138 15.499998 -v -14.750000 0.543138 17.499998 -v -14.750000 0.543138 18.999998 -v -36.000000 0.543138 18.749998 -v -18.250000 0.543138 4.249998 -v -17.250000 0.543138 4.999998 -v -17.250000 0.543138 -5.250002 -v -18.250000 0.543138 -4.500002 -v -11.500000 0.543138 -1.250002 -v -11.500000 0.543138 1.249998 -v -2.250000 0.543138 -9.000002 -v -12.250000 0.543138 -15.000002 -v -12.250000 0.543138 -16.500002 -v 2.250000 0.543138 -9.000002 -v 12.250000 0.543138 -15.000002 -v 12.250000 0.543138 -16.500002 -v 17.750000 0.543138 -11.500002 -v 29.500000 0.543138 -2.500002 -v 30.000000 0.543138 -3.750002 -v 18.750000 0.543138 -9.500002 -v 20.750000 0.543138 -7.000002 -v 26.750000 0.543138 -3.750002 -v 19.750000 0.543138 -7.500002 -v 35.750000 0.793138 -3.750002 -v 31.500000 0.543138 -3.750002 -v 32.250000 0.543138 -3.250002 -v 34.750000 0.543138 -3.500002 -v -37.000000 0.543138 19.749998 -v -13.500000 0.543138 19.749998 -v -37.000000 0.543138 18.749998 -v -11.000000 0.543138 1.499998 -v -17.250000 0.543138 6.249998 -v -16.250000 0.543138 6.749998 -v -16.250000 0.543138 -7.000002 -v -17.250000 0.543138 -6.500002 -v -11.000000 0.543138 -1.500002 -v -5.500000 0.543138 -7.250002 -v -13.250000 0.543138 -14.500002 -v -13.250000 0.543138 -13.000002 -v 5.500000 0.543138 -7.250002 -v 13.250000 0.543138 -13.000002 -v 13.250000 0.543138 -14.500002 -v 32.250000 0.793138 -1.250002 -v 28.000000 0.543138 -2.000002 -v 31.500000 0.543138 -1.750002 -v 31.500000 0.543138 -2.750002 -v 20.750000 0.543138 -5.500002 -v 21.750000 0.543138 -5.000002 -v 21.750000 0.543138 -3.750002 -v 26.750000 0.543138 -2.500002 -v 35.250000 0.543138 -3.000002 -v 36.000000 0.793138 -2.500002 -v -15.250000 0.543138 8.749998 -v -5.500000 0.543138 4.999998 -v -9.000000 0.543138 1.499998 -v -5.500000 0.543138 7.249998 -v -16.250000 0.543138 8.249998 -v -15.250000 0.543138 -9.000002 -v -16.250000 0.543138 -8.500002 -v -9.000000 0.543138 -1.500002 -v -5.500000 0.543138 -5.000002 -v -14.250000 0.543138 -11.000002 -v -14.250000 0.543138 -12.500002 -v 14.250000 0.543138 -11.000002 -v 5.500000 0.543138 -5.000002 -v 11.000000 0.543138 -1.500002 -v 15.250000 0.543138 -9.000002 -v 14.250000 0.543138 -12.500002 -v 32.250000 0.793138 1.249998 -v 29.500000 0.543138 2.499998 -v 28.000000 0.543138 1.999998 -v 26.750000 0.543138 2.499998 -v 21.250000 0.543138 -2.500002 -v 21.500000 0.543138 2.499998 -v 35.250000 0.543138 -1.250002 -v 37.500000 1.043138 -0.750002 -v -15.250000 0.543138 10.249998 -v -14.250000 0.543138 10.749998 -v -8.500000 0.543138 1.249998 -v -4.500000 0.543138 3.999998 -v -13.250000 0.543138 12.749998 -v -12.250000 0.543138 14.749998 -v -2.250000 0.543138 8.999998 -v -15.250000 0.543138 -10.500002 -v -4.500000 0.543138 -4.000002 -v -8.250000 0.543138 -0.250002 -v 15.250000 0.543138 -10.500002 -v 9.000000 0.543138 -1.500002 -v 8.500000 0.543138 -1.250002 -v 4.500000 0.543138 -4.000002 -v 17.250000 0.543138 -5.250002 -v 16.250000 0.543138 -7.000002 -v 11.750000 0.543138 -0.250002 -v 16.250000 0.543138 -8.500002 -v 31.500000 0.543138 1.749998 -v 30.000000 0.543138 3.749998 -v 31.500000 0.543138 3.749998 -v 29.500000 0.543138 4.249998 -v 21.750000 0.543138 3.499998 -v 26.750000 0.543138 3.499998 -v 20.000000 0.543138 -2.250002 -v 20.000000 0.543138 2.249998 -v 34.750000 0.543138 -0.750002 -v 34.750000 0.543138 0.749998 -v 37.000000 0.793138 1.749998 -v -14.250000 0.543138 12.249998 -v -3.250000 0.543138 3.999998 -v -2.000000 0.543138 3.249998 -v -13.250000 0.543138 14.249998 -v -2.750000 0.543138 16.499998 -v -12.000000 0.543138 16.499998 -v -0.750000 0.543138 16.249998 -v 2.250000 0.543138 8.999998 -v -3.250000 0.543138 -4.000002 -v -2.000000 0.543138 -3.250002 -v 4.500000 0.543138 3.999998 -v 8.500000 0.543138 1.249998 -v 2.000000 0.543138 3.249998 -v 3.250000 0.543138 -4.000002 -v 2.000000 0.543138 -3.250002 -v 17.250000 0.543138 -6.500002 -v 18.250000 0.543138 -3.000002 -v 18.250000 0.543138 -4.500002 -v 18.250000 0.543138 2.999998 -v 11.500000 0.543138 1.249998 -v 32.250000 0.543138 4.249998 -v 32.000000 0.543138 4.249998 -v 29.000000 0.543138 4.749998 -v 29.750000 0.543138 6.249998 -v 21.750000 0.543138 4.999998 -v 20.750000 0.543138 6.999998 -v 27.250000 0.543138 4.749998 -v 35.250000 0.543138 1.249998 -v 35.750000 0.793138 2.749998 -v -2.250000 0.543138 16.749998 -v 1.000000 0.543138 16.249998 -v -1.750000 0.543138 16.999998 -v 12.250000 0.543138 14.999998 -v 5.500000 0.543138 7.249998 -v 3.000000 0.543138 16.499998 -v 3.250000 0.543138 3.999998 -v 5.500000 0.543138 4.999998 -v 9.000000 0.543138 1.499998 -v 17.250000 0.543138 5.249998 -v 18.250000 0.543138 4.499998 -v 11.000000 0.543138 1.499998 -v 32.750000 0.543138 4.749998 -v 31.750000 0.543138 6.249998 -v 16.750000 0.543138 14.999998 -v 15.750000 0.543138 16.999998 -v 18.750000 0.543138 10.999998 -v 17.750000 0.543138 12.999998 -v 19.750000 0.543138 8.999998 -v 35.750000 0.543138 18.249998 -v 20.750000 0.543138 5.499998 -v 19.750000 0.543138 7.499998 -v 35.250000 0.543138 2.999998 -v 35.000000 0.543138 4.499998 -v 35.750000 1.043138 16.840910 -v -2.250000 0.543138 18.999998 -v 1.750000 0.543138 16.749998 -v -1.750000 0.543138 18.999998 -v 13.250000 0.543138 14.499998 -v 13.250000 0.543138 12.999998 -v 12.250000 0.543138 16.499998 -v 14.250000 0.543138 10.999998 -v 15.250000 0.543138 8.999998 -v 2.250000 0.543138 16.999998 -v 16.250000 0.543138 6.999998 -v 17.250000 0.543138 6.499998 -v 16.750000 0.543138 13.499998 -v 15.750000 0.543138 15.499998 -v 14.750000 0.543138 17.499998 -v 14.750000 0.543138 18.999998 -v 18.750000 0.543138 9.499998 -v 17.750000 0.543138 11.499998 -v 37.000000 0.543138 19.749998 -v 37.000000 0.543138 18.499998 -v 34.750000 0.543138 3.249998 -v -3.250000 0.543138 19.749998 -v 1.750000 0.543138 18.999998 -v -0.500000 0.543138 19.749998 -v 14.250000 0.543138 12.499998 -v 15.250000 0.543138 10.499998 -v 16.250000 0.543138 8.499998 -v 2.250000 0.543138 18.999998 -v 13.750000 0.543138 19.749998 -v 0.750000 0.543138 19.749998 -v 3.500000 0.543138 19.749998 - -f 1 2 3 -f 3 2 6 -f 37 34 53 -f 35 54 55 -f 65 63 90 -f 66 91 67 -f 62 89 64 -f 14 13 7 -f 7 13 11 -f 21 17 12 -f 36 56 57 -f 85 110 86 -f 86 110 111 -f 23 22 12 -f 86 57 85 -f 85 57 56 -f 88 112 87 -f 87 112 113 -f 24 18 33 -f 33 18 19 -f 19 18 10 -f 10 18 12 -f 12 18 24 -f 87 58 88 -f 88 58 68 -f 20 10 11 -f 11 10 6 -f 6 10 12 -f 73 71 45 -f 45 71 44 -f 45 44 26 -f 46 45 27 -f 27 45 26 -f 25 43 27 -f 39 25 22 -f 22 25 12 -f 23 40 22 -f 24 41 23 -f 33 42 24 -f 36 58 56 -f 36 54 35 -f 60 59 36 -f 36 59 61 -f 21 12 26 -f 26 12 27 -f 27 12 25 -f 34 19 35 -f 35 19 36 -f 2 7 6 -f 6 7 11 -f 36 61 62 -f 71 72 44 -f 36 57 63 -f 36 62 64 -f 36 65 54 -f 36 64 66 -f 34 37 19 -f 36 66 67 -f 38 33 19 -f 36 67 68 -f 37 38 19 -f 36 68 58 -f 23 12 24 -f 36 63 65 -f 182 150 179 -f 179 150 146 -f 179 146 147 -f 118 117 95 -f 95 117 119 -f 95 119 116 -f 60 36 69 -f 69 36 70 -f 116 141 142 -f 148 119 149 -f 149 119 150 -f 150 119 146 -f 146 119 117 -f 146 117 147 -f 93 92 69 -f 115 114 93 -f 140 139 115 -f 172 140 143 -f 143 140 116 -f 145 175 143 -f 178 145 176 -f 176 145 144 -f 202 176 203 -f 203 176 177 -f 177 176 144 -f 142 144 116 -f 116 144 145 -f 116 145 143 -f 115 93 116 -f 177 204 203 -f 116 140 115 -f 69 94 93 -f 93 94 116 -f 116 94 95 -f 95 94 70 -f 70 94 69 -f 112 137 113 -f 113 137 138 -f 138 137 169 -f 111 110 135 -f 135 110 136 -f 135 136 166 -f 136 138 166 -f 166 138 169 -f 190 189 162 -f 162 189 191 -f 193 167 194 -f 194 167 192 -f 192 167 166 -f 166 167 135 -f 218 194 217 -f 217 194 192 -f 213 239 217 -f 214 213 189 -f 189 213 191 -f 215 191 216 -f 216 191 192 -f 192 191 213 -f 192 213 217 -f 167 168 135 -f 276 246 247 -f 247 246 221 -f 249 247 222 -f 222 247 221 -f 219 242 222 -f 223 219 196 -f 196 219 195 -f 197 196 170 -f 170 196 195 -f 170 195 169 -f 170 169 137 -f 243 220 221 -f 221 220 195 -f 221 195 222 -f 222 195 219 -f 137 171 170 -f 163 162 132 -f 132 162 164 -f 164 162 191 -f 161 160 131 -f 131 106 105 -f 105 132 131 -f 131 132 161 -f 161 132 165 -f 165 132 164 -f 165 186 161 -f 300 299 279 -f 279 299 280 -f 280 299 301 -f 278 277 246 -f 246 277 248 -f 246 248 221 -f 257 279 256 -f 256 279 277 -f 277 279 248 -f 248 279 280 -f 263 262 235 -f 240 269 270 -f 210 234 209 -f 209 234 235 -f 234 241 235 -f 235 241 263 -f 263 241 240 -f 263 240 270 -f 216 240 215 -f 215 240 241 -f 271 296 273 -f 275 274 245 -f 298 297 272 -f 272 297 271 -f 243 244 220 -f 220 244 245 -f 272 271 244 -f 244 271 273 -f 244 273 245 -f 245 273 275 -f 123 122 102 -f 102 122 101 -f 3 4 1 -f 1 4 5 -f 77 50 78 -f 78 50 79 -f 50 49 31 -f 31 49 30 -f 31 30 16 -f 31 16 32 -f 5 4 8 -f 8 4 9 -f 101 78 102 -f 102 78 79 -f 50 80 79 -f 9 17 16 -f 16 30 15 -f 50 77 49 -f 15 8 16 -f 16 8 9 -f 282 252 281 -f 281 252 250 -f 148 149 180 -f 180 149 181 -f 251 225 252 -f 252 225 250 -f 181 201 180 -f 180 201 174 -f 251 253 225 -f 173 141 174 -f 225 224 250 -f 173 198 199 -f 199 198 224 -f 199 224 225 -f 199 225 226 -f 200 173 201 -f 201 173 174 -f 173 200 198 -f 32 51 31 -f 31 51 52 -f 106 82 105 -f 105 82 81 -f 72 81 51 -f 51 81 82 -f 51 82 83 -f 51 83 52 -f 51 44 72 -f 83 84 52 -f 226 227 199 -f 199 227 205 -f 256 228 257 -f 257 228 229 -f 204 177 205 -f 254 229 227 -f 227 229 205 -f 205 229 228 -f 205 228 204 -f 227 255 254 -f 281 302 282 -f 282 302 303 -f 182 179 206 -f 206 179 207 -f 304 284 305 -f 230 206 207 -f 313 334 312 -f 283 253 284 -f 302 313 303 -f 303 313 309 -f 333 332 309 -f 309 332 329 -f 329 332 342 -f 259 258 230 -f 310 285 286 -f 286 285 255 -f 286 255 287 -f 311 286 308 -f 308 286 287 -f 306 330 308 -f 331 306 307 -f 307 306 284 -f 304 326 307 -f 305 327 304 -f 329 328 305 -f 288 259 260 -f 260 259 230 -f 260 230 231 -f 231 230 207 -f 304 307 284 -f 283 284 287 -f 287 284 308 -f 308 284 306 -f 312 289 313 -f 313 289 314 -f 313 314 309 -f 303 309 284 -f 284 309 305 -f 305 309 329 -f 312 288 289 -f 289 288 260 -f 285 254 255 -f 28 13 29 -f 29 13 14 -f 120 97 98 -f 100 76 96 -f 96 76 74 -f 96 74 97 -f 97 74 98 -f 185 159 183 -f 183 159 158 -f 183 158 184 -f 98 121 120 -f 120 121 151 -f 122 123 152 -f 152 123 129 -f 29 47 28 -f 28 47 48 -f 103 80 104 -f 104 109 103 -f 103 109 124 -f 103 124 125 -f 99 74 75 -f 75 74 47 -f 47 74 76 -f 47 76 48 -f 128 157 158 -f 127 156 128 -f 126 155 127 -f 154 126 125 -f 125 126 103 -f 124 153 125 -f 134 124 108 -f 108 124 109 -f 133 108 107 -f 107 108 84 -f 84 108 109 -f 159 130 158 -f 103 126 127 -f 127 128 103 -f 129 103 130 -f 130 103 128 -f 130 128 158 -f 84 83 107 -f 130 120 151 -f 152 129 151 -f 151 129 130 -f 275 273 270 -f 270 273 263 -f 187 161 188 -f 188 161 186 -f 212 188 208 -f 208 188 186 -f 233 232 208 -f 261 233 236 -f 236 233 211 -f 264 236 237 -f 237 236 211 -f 237 211 238 -f 237 238 265 -f 210 209 186 -f 186 209 211 -f 186 211 208 -f 208 211 233 -f 265 266 237 -f 325 324 299 -f 299 324 301 -f 318 293 319 -f 319 293 294 -f 294 293 268 -f 268 293 295 -f 338 319 321 -f 321 319 294 -f 322 339 321 -f 340 322 324 -f 324 322 301 -f 298 301 297 -f 297 301 294 -f 294 301 322 -f 294 322 321 -f 293 320 295 -f 315 317 335 -f 335 317 337 -f 323 316 295 -f 295 316 291 -f 295 291 268 -f 336 341 343 -f 343 341 344 -f 341 336 323 -f 323 336 316 -f 317 315 292 -f 292 315 290 -f 291 267 268 -f 268 267 238 -f 267 292 290 -f 290 265 267 -f 267 265 238 diff --git a/data/maps/konda.xml b/data/maps/konda.xml deleted file mode 100644 index 7c0fa84..0000000 --- a/data/maps/konda.xml +++ /dev/null @@ -1,76 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From c3a25f867e08a985cfd1572a1da7c4f333783a14 Mon Sep 17 00:00:00 2001 From: cmkrist Date: Fri, 5 Dec 2025 13:43:37 -0500 Subject: [PATCH 79/79] Add data as submodule --- .gitmodules | 3 +++ data | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 data diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..3ea1ecf --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "data"] + path = data + url = https://github.com/OpenChamp/data.git diff --git a/data b/data new file mode 160000 index 0000000..0882e21 --- /dev/null +++ b/data @@ -0,0 +1 @@ +Subproject commit 0882e214f1bec8e9d733aa01d48e69c6e8a30e11