From e7dd8d49a91f61abec7218a25e500e4ad0fb5ee6 Mon Sep 17 00:00:00 2001 From: Chris Miles Date: Sun, 5 Sep 2021 01:21:23 -0500 Subject: [PATCH] [Shared Tasks] Shared Tasks System Implementation (#1451) * Shared tasks WIP; lots of logging; shared tasks and tasks work internally the same for now; lots to cleanup yet * Update task_manager.cpp * Add tables * World message handler * Zone message handler * More messaging * More rearranging * Task creation work (wip) * Tweaks * Decoupled things, added a shared task manager, moved logic to the manager, created the shared task object, now creating a sense of state on creation and members, zero validation, happy path * Cleanup unnecessary getter * More work on shared task persistence and state loading * Add int64 support into repositories * More state handling, creation loads all tables * Wrap up shared task state creation and removal * Move more lookup operations to preloading (memory). Restore shared task state during world bootup * Implement shared task updates * Add members other than just leader in task confirmations * Update shared_task_manager.cpp * Hook task cancellation for shared task removal (middleware) * Remove dynamic_zone_id from SharedTasks model in repositories (for now) since we will likely be one to many with DZ objects * Get members to show up in the window on creation * Add opcodes, cleanup * Add opcode handlers * Split some methods out, self removal of shared task and updating members * Implement offline shared task sync * Style changes * Send memberlist on initial login; implement remove player from shared task window * Refactorings, cleanup * Implement make leader in shared tasks window * Implement add player, sync shared task state after add * Add opcodes for remaining clients * Shared task invite dialogue window implementation and response handling (including validation) * Logging * Remove comment * Some cleanup * Pass NPC context through shared task request logic * Remove extra SharedTaskMember fields * Add message constants * Remove static * Only use dz for expedition request This passes expedition creation parameters through DynamicZone instead of injecting ExpeditionRequest since it can hold creation data now * Store expedition leader on dz This shifts to using the leader object that exists in the core dynamic zone object. It will be moved to the dynamic zone table later with other columns that should just be on the dz to make loading easier. Expeditions are probably the only dz type that will use this for window updates and command auth. Other systems on live do fill the window but don't keep it updated * Store expedition name on dz This uses the name stored on dz (for window packets) instead of duplicating it. This will be moved completely to dz table later * Store uuid on dynamic zone This lets dynamic zones generate the uuid instead of expeditions. Other dz type systems may want to make use of this. Lockouts should also be moved to dynamic zones at some point in the future so this will be necessary for that * Move expedition db columns to dz These columns should just belong to the core dynamic zone. This will simplify loading from the database and in the future a separate expedition table may no longer be necessary. * Move window packet methods to dz It makes more sense for these methods to be in the core This will also allow support for other systems to use the window, though live behavior that updates the window for shared task missions when not in an expedition is likely unintended since it's not updated on changes. * Store dynamic zone ids on clients These will now be used for client dynamic zone lookups to remove dependency on any dz type system caches * Move member management to dz This moves server messaging for adding and removing members to internal dynamic zone methods Set default dz member status to Unknown * Move member status caching to dz This moves world member status caching into internal dz methods Zone member updates for created expeditions are now async and sent after world replies with member statuses. Prior to this two memberlist packets were sent to members in other zones on creation to update statuses. This also fixes a bug with member statuses being wrong for offline raid members in the zone that created an expedition. Note that live kicks offline players out of raids so this is only to support emu behavior. * Move member status updates to dz * Set dz member status on all client dzs This also renames the zone entry dz update method and moves window update to a dynamic zone method. Eventually expedition components should just be merged with dz and handled as another dz type * Save instance safe return on characters Add character_instance_safereturns table and repository Previously dz safe return only worked for online characters via the dz kicktimer or offline characters with a workaround that moved them when an expedition was deleted. There were various edge cases that would cause characters to be moved to bind instead (succoring after removal, camping before kick timer, removed while offline, bulk kickplayers removal with some offline) This updates a character's instance safereturn every time they enter a zone. If a character enters world in an instance that expired or are no longer part of they'll be moved to their instance safereturn (if the safereturn data is for the same zone-instance). Bind is still a fallback This may also be used for non-dz instancing so it's named generically This removes the expedition MoveMembersToSafeReturn workaround which deprecates the is_current_member column of dynamic_zone_members and will be removed in a followup patch. * Remove is_current_member from dz members This was only being used in the workaround to move past members to dz safereturns if they were still inside the dz but not online * Let dz check leader in world This moves expedition leader processing in world to the dynamic zone. This is a step in phasing out the separate expedition class for things that can run off the dynamic zone core with simple dz type checks This greatly simplifies checking leader on member and status changes without needing callbacks. Other dz types that may use the dz leader object can just handle it directly on the dz the same as expeditions * Let dz handle member expire warnings This moves expire warning checks to dz. This will make it easier for other dz types to issue expire warnings if needed * Use separate dynamic zone cache Dynamic zones are no longer member objects of expeditions and have been placed into their own cache. This was done so other dz types can be cached without relying on their systems. Client and zone dz Lookups are now independent of any system This continues the process of phasing out a separate expedition cache. Eventually expeditions can just be run directly as dynamic zones internally with a few dz type checks. Add dz serialization methods (cereal) for passing server dz creation Modify #dz list to show cache and database separately. Also adds #dz cache reload. This command will reload expeditions too since they currently hold references to the dz in their own zone cache. Add a dynamic zone processing class to world to process all types and move expedition processing to it * Move expedition makeleader processing to dz * Let dz handle expedition deletions This removes the need for separate expedition cache in world This will greatly simplify world dynamic zone caching and processing. Dynamic zones that are expeditions can just handle this directly. Once lockouts and other components are completely moved to dynamic zones the separate expedition cache in zone will also no longer be necessary * Remove ExpeditionBase class Since world no longer caches expeditions this will not be necessary * Fix windows compile * Implement task dz creation Prototype dz creation for shared tasks * Add and remove shared task members from dz Also keep leader updated (used in choose zone window) * Fix client crash on failed shared task * Fix linux compile and warning * Check client nullptr for dz message This was accidently removed when expedition makeleader was moved * Disable dz creation for solo tasks * Add shared task repository headers to CMakeLists * Add shared task dynamic zones table * Add shared task dz database persistence * Get members from db on shared task dz creation This fixes a case where removing a member from a shared task dz would fail if the member's name was empty. This could happen if the shared task dz was created while a member was offline. This also changes the dz member removal method to only check id. It might be possible to change all dz member validations to only check ids since names are primarily for window updates, but shared task dz member names need to be non-empty anyway to support possible live-like dz window usage in the future. * Add character message methods to world Add simple and eqstr message methods to ClientList Add shared task manager methods to message all members or leader * Add SyncClientSharedTaskState and nested sync strategies to cover M3 work * Fix whitespace * Implement task request cooldown timer This implements the task request cooldown (15 seconds) that live uses when a task is accepted. This will also need to be set when shared tasks are offered (likely due to additional group/raid validations) * Implement shared task selector validation This implements the validation and filtering that occurs before the task selection window is sent to a client for shared tasks To keep things live-like, task selectors that contain a shared task will be run through shared task validation and drop non-shared tasks. Live doesn't mix types in task selections and this makes validation simpler. Also note that live sends shared task selectors via a different opcode than solo tasks but that has not been implemented yet * Add separate shared task select opcodes Live uses separate opcodes for solo and shared task selection windows * Convert ActivityType to enum class * Refactor task selector serialization This adds serializer methods to task and task objective structs for the task selection windows. This combines the duplicate task selector methods to reduce code duplication and simplify serialization * Add shared task selector This sends shared task selection window using the shared task specific opcode and adds an opcode handler for shared task accepts which are sent by client in response to setting selection window to shared task type. * Refactor task objective serialization This adds a serialization method to the task objective struct for serializing objectives in the window list and combines the separate client-based methods to reduce duplicated code. * Add task level spread and player count columns * Implement shared task accept validation This adds a common method for shared task character request queries * Add task replay and request timer columns * Add character task timers table * Use shared task accept time on clients This overrides client task accept time with shared task's creation time. This is needed for accurate window task timers and lockout messages especially for characters added to shared tasks post creation * Implement task timer lockouts This implements replay and request task timers for solo and shared tasks * Add solo and shared task timer validation * Remove logging of padding array This gets interpreted as a c string which may not be null terminated * Implement /kickplayers task This also fixes current CancelTask behavior for leader which was performing kickplayers functionality through the remove task button * Implement /taskquit command * Implement shared task invite validation Remove active invitation before invite accept validation * Remove local client db persistence during SyncClientSharedTaskRemoveLocalIfNotExists * Add missing accept time arg to assign task * Only validate non-zero task invite requirements * Fix task error log crash * Separate task cooldown timer messaging * Use method to check for client shared task * Avoid unneeded task invite validation query Only need to query character data for levels for non-zero level spread * Implement /tasktimers command May want to add some type of throttled caching mechanism for this in the future * Add /tasktimers rate limiter * Intercept shared task completion; more work to come * Change SharedTaskActivityState and SharedTasks time objects to datetime * Add updated_time updates to SharedTaskActivities * Mark shared tasks as complete when all activities are completed * Save a database query on shared task completion and use the active record in memory * Don't record shared task completions to the quest log * Implement RecordSharedTaskCompletion, add tables, repositories * Update shared_task_manager.cpp * Update shared_task_manager.cpp * Add shared task replay timers This is still not feature complete. On live any past members that ever joined the shared task will receive a replay timer when it's completed * Create FindCharactersInSharedTasks that searches through memory * Remove namespace shorthand and formatting * More minor cleanup * Implement PurgeAllSharedTasks via #task command * Add #task purgetimers * Decrease m_keepalive time between processes * Remove type ordering in /tasktimer query * Add comment for task packet reward multiplier This is likely a reward multiplier that changes text color based on value to represent any scaled bonus or penalty * Add replay timers to past members This implements the live behavior that adds replay timers to any previous member of a shared task. This likely exists to avoid possible exploits. Shared task member history is stored in memory and is used to assign replay timers. This history will be lost on world crashes or restarts but is simpler than saving past member state in database. This also makes world send shared task replay timer messages since past members need to be messaged now * Move PurgeTaskTimers client method to tasks.cpp * Remove dz members when purging shared tasks Server dz states need to be updated before shared tasks are deleted * Use exact name in shared task invites This removes the wildcards from shared task invite character queries which was sometimes selecting the wrong character Taskadd validation is called even for invalid characters to allow for proper messages to occur * Clear declined active shared task invitations This also notifies leader for declined shared task invites * Store shared task member names This adds back the character name field to SharedTaskMember. This should make serialization easier in the future and reduce database lookups when names are needed for /task commands * Implement /taskplayerlist command * Replace queries with member name lookups Now that shared task members store names these queries are unnecessary This also adds not-a-member messages for /taskremove and /taskmakeleader * Implement shared task member change packet This avoids sending the full member list to members when a single member is added or removed and lets the client generate chat messages for it. * Serialize shared task member list from world This uses cereal to serialize the full member list from world and removes the zone query workarounds * Initialize client task state array This was causing sql query errors on client state reloads The client task information array was uninitialized resulting in being filled with 0xcdcdcdcd values in msvc debug builds. Under release builds this may have resulted in indeterminate values A better fix would be to refactor some of this legacy code * Add shared task command messages Add messages for non-leader task commands This adds taskadd, taskremove, taskmakeleader, and taskquit messages The leader receives double messages for taskremove like live due to the client generated message as well as the explicit one. It also receives double server messages if the leader /taskremoves self. * Replace some task messages with eqstrs This also updates to use live colors * Avoid shared task invite leader lookup query Since member names are stored now this query is also unnecessary * Avoid reloading client state on shared task accept This was unnecessarily reloading client task state when added to a shared task. This also resulted in all active tasks being resent to shared task members on creation. The shared task itself is the only task that needs to be sent which is handled by AcceptNewTask. * Remove active shared task invite on zone Live doesn't re-send shared task invites after zoning like it does for expeditions so there's no need to keep these around. This fixes active invitations never getting reset on characters that zone or go offline. * Choose new shared task leader if leader removed * Add separate shared task kickplayers method * Enable EVENT_CAST_ON for clients This will be required for a shared task objective (The Creator) in DoN * Revert "Avoid reloading client state on shared task accept" This reverts commit 3af14fee2de8b109ffb6c2b2fc67731e1531a665. Without this clients added to a task after some objectives have been completed don't get updated state. Will need to investigate this later * Disallow looting inside a dz by non-members Non-members of a dynamic zone should not be allowed to loot npcs inside it. This should have been disabled for expeditions already but was still allowed due to an oversight (or live behavior changed). This is less critical for shared tasks since members can be added and removed at will without leaving a dz but still an important feature. * Change load where criteria * Increase task completion emote column size * Use eqstr for task item reward message * Implement radiant and ebon crystal rewards This adds reward columns for radiant and ebon crystals to the tasks table and updates task description serialization * Send task completion emote before rewards This matches live and makes it a little easier to see item rewards when tasks have a long completion emote. This also changes it to send via the same normal message opcode that live uses. * Do not send a shared task in completed task history * Allow EVENT_TASK_STAGE_COMPLETE for quest goals This invokes event_task_stage_complete for task elements flagged with a quest controlled goal method. It should be expected behavior that a completed task stage always fires this event even if a quest controls it * Add SyncSharedTaskZoneClientDoneCountState * Swap return for continue in this case * Formatting * Simplify * Formatting * Formatting * Formatting * Remove errant check * Formatting, add setter for shared tasks * Remove debugging * Comments in PR * More PR follow up * Formatting * Cleanup * Update packet comments * Comments * More cleanup * Send command error message if not in shared task /taskadd is the only command with this feedback on live. Newer live clients also generate this instead of the server sending the message * Implement expire_time on SharedTask object and add a purge on world bootup * Comment * Add SyncClientSharedTaskStateToLocal where clients fall out of sync and no longer have a task locally * Clamp shared task activity updates to max done count and discard updates out of bounds * Fix packet send * Revert packet send * Adjust clamping OOO for completed time check. Add completed tables to purge truncation * Refactor kill update logic so that shared task kill updates only update one client instead of all clients * Cleanup how we're checking for active tasks * Forward task sets that contain shared tasks This forwards task sets that contain a shared task to shared task selector validation like normal task selectors * Change eqstr for empty solo task offers This is the message live appears to use if all task offers are filtered out by solo task validation * Fix max active tasks client message This message starts at the third argument. It was maybe intended to be an npc say message but live just sends it as a normal eqstr with the first two arguments nulled. * Load client task state after zoning complete This fixes a possible race where a character removed from a shared task while zoning would be stuck with an incorrect character activities state after zoning was completed. This was caused by the character loading task state to early on zone entry but never receiving the remove player message from world since they are missing from the world cle until zoning is completed. Loading client state after zone connection is completed makes sure the client has the latest state and available to the world cle * Send message to clients removed while zoning This message should usually only be sent to characters that were removed from a shared task while zoning but will occur for any sync state removals where a message wouldn't have already occured. * Post rebase fix * HG comment for checking active task * Addressing HG comments around zeroing out a shared task id * Remove errant comment * Post rebase database manifest updates * Update eqemu_logsys_log_aliases.h * More rebase catches * Bump database version for last commit Co-authored-by: hg <4683435+hgtw@users.noreply.github.com> --- common/CMakeLists.txt | 23 +- common/database_schema.h | 13 +- common/dynamic_zone_base.cpp | 263 ++- common/dynamic_zone_base.h | 87 +- common/emu_oplist.h | 17 +- common/eq_packet_structs.h | 63 +- common/eqemu_logsys.cpp | 6 +- common/eqemu_logsys.h | 4 +- common/eqemu_logsys_log_aliases.h | 22 + common/expedition_base.cpp | 23 - common/expedition_base.h | 40 - ...haracter_instance_safereturns_repository.h | 355 ++++ .../base_character_task_timers_repository.h | 336 +++ ...ed_shared_task_activity_state_repository.h | 337 +++ ...completed_shared_task_members_repository.h | 317 +++ .../base_completed_shared_tasks_repository.h | 347 ++++ .../base_dynamic_zone_members_repository.h | 33 +- .../base/base_dynamic_zones_repository.h | 191 +- .../base/base_expeditions_repository.h | 77 +- ...se_shared_task_activity_state_repository.h | 337 +++ ...ase_shared_task_dynamic_zones_repository.h | 293 +++ .../base_shared_task_members_repository.h | 302 +++ .../base/base_shared_tasks_repository.h | 346 ++++ .../repositories/base/base_tasks_repository.h | 238 ++- ...haracter_instance_safereturns_repository.h | 108 + .../character_task_timers_repository.h | 70 + ...ed_shared_task_activity_state_repository.h | 70 + ...completed_shared_task_members_repository.h | 70 + .../completed_shared_tasks_repository.h | 70 + .../dynamic_zone_members_repository.h | 32 +- .../repositories/dynamic_zones_repository.h | 81 +- common/repositories/expeditions_repository.h | 96 - .../shared_task_activity_state_repository.h | 70 + .../shared_task_dynamic_zones_repository.h | 70 + .../shared_task_members_repository.h | 70 + common/repositories/shared_tasks_repository.h | 70 + common/ruletypes.h | 1 + common/servertalk.h | 109 +- common/shared_tasks.cpp | 139 ++ common/shared_tasks.h | 204 ++ common/tasks.h | 445 ++++ common/version.h | 2 +- utils/patches/patch_RoF.conf | 4 +- utils/patches/patch_RoF2.conf | 17 +- utils/patches/patch_SoD.conf | 16 +- utils/patches/patch_SoF.conf | 5 +- utils/patches/patch_Titanium.conf | 18 +- utils/patches/patch_UF.conf | 17 +- utils/sql/db_update_manifest.txt | 4 + .../2021_03_03_instance_safereturns.sql | 13 + ...2021_03_30_remove_dz_is_current_member.sql | 6 + .../git/required/2021_05_21_shared_tasks.sql | 97 + .../2021_06_06_dynamic_zone_moved_columns.sql | 23 + world/CMakeLists.txt | 10 +- world/client.cpp | 42 +- world/cliententry.cpp | 4 + world/clientlist.cpp | 151 +- world/clientlist.h | 7 + world/dynamic_zone.cpp | 261 ++- world/dynamic_zone.h | 22 +- world/dynamic_zone_manager.cpp | 166 ++ world/dynamic_zone_manager.h | 32 + world/expedition.cpp | 237 --- world/expedition.h | 57 - world/expedition_database.cpp | 63 +- world/expedition_database.h | 3 - world/expedition_message.cpp | 60 +- world/expedition_message.h | 1 - world/expedition_state.cpp | 172 -- world/expedition_state.h | 52 - world/main.cpp | 244 ++- world/shared_task_manager.cpp | 1820 +++++++++++++++++ world/shared_task_manager.h | 132 ++ world/shared_task_world_messaging.cpp | 355 ++++ world/shared_task_world_messaging.h | 18 + world/worlddb.cpp | 49 + world/worlddb.h | 1 + world/zonelist.cpp | 2 +- world/zoneserver.cpp | 34 +- zone/CMakeLists.txt | 2 + zone/attack.cpp | 20 +- zone/client.cpp | 201 +- zone/client.h | 42 +- zone/client_packet.cpp | 346 +++- zone/client_packet.h | 10 + zone/client_process.cpp | 17 +- zone/command.cpp | 135 +- zone/corpse.cpp | 16 +- zone/dynamic_zone.cpp | 658 +++++- zone/dynamic_zone.h | 35 +- zone/expedition.cpp | 825 ++------ zone/expedition.h | 56 +- zone/expedition_database.cpp | 16 +- zone/expedition_database.h | 4 +- zone/expedition_request.cpp | 10 +- zone/expedition_request.h | 3 +- zone/forage.cpp | 4 +- zone/lua_client.cpp | 66 +- zone/lua_client.h | 1 + zone/lua_expedition.cpp | 32 +- zone/lua_packet.cpp | 4 +- zone/lua_parser.cpp | 1 + zone/perl_expedition.cpp | 32 +- zone/shared_task_zone_messaging.cpp | 176 ++ zone/shared_task_zone_messaging.h | 12 + zone/string_ids.h | 7 + zone/task_client_state.cpp | 1117 ++++++++-- zone/task_client_state.h | 52 +- zone/task_manager.cpp | 1000 +++++---- zone/task_manager.h | 21 +- zone/tasks.cpp | 40 +- zone/tasks.h | 133 +- zone/tradeskills.cpp | 2 +- zone/worldserver.cpp | 44 +- zone/zone.cpp | 22 +- zone/zone.h | 1 + 116 files changed, 12094 insertions(+), 3131 deletions(-) delete mode 100644 common/expedition_base.cpp delete mode 100644 common/expedition_base.h create mode 100644 common/repositories/base/base_character_instance_safereturns_repository.h create mode 100644 common/repositories/base/base_character_task_timers_repository.h create mode 100644 common/repositories/base/base_completed_shared_task_activity_state_repository.h create mode 100644 common/repositories/base/base_completed_shared_task_members_repository.h create mode 100644 common/repositories/base/base_completed_shared_tasks_repository.h create mode 100644 common/repositories/base/base_shared_task_activity_state_repository.h create mode 100644 common/repositories/base/base_shared_task_dynamic_zones_repository.h create mode 100644 common/repositories/base/base_shared_task_members_repository.h create mode 100644 common/repositories/base/base_shared_tasks_repository.h create mode 100644 common/repositories/character_instance_safereturns_repository.h create mode 100644 common/repositories/character_task_timers_repository.h create mode 100644 common/repositories/completed_shared_task_activity_state_repository.h create mode 100644 common/repositories/completed_shared_task_members_repository.h create mode 100644 common/repositories/completed_shared_tasks_repository.h create mode 100644 common/repositories/shared_task_activity_state_repository.h create mode 100644 common/repositories/shared_task_dynamic_zones_repository.h create mode 100644 common/repositories/shared_task_members_repository.h create mode 100644 common/repositories/shared_tasks_repository.h create mode 100644 common/shared_tasks.cpp create mode 100644 common/shared_tasks.h create mode 100644 common/tasks.h create mode 100644 utils/sql/git/required/2021_03_03_instance_safereturns.sql create mode 100644 utils/sql/git/required/2021_03_30_remove_dz_is_current_member.sql create mode 100644 utils/sql/git/required/2021_05_21_shared_tasks.sql create mode 100644 utils/sql/git/required/2021_06_06_dynamic_zone_moved_columns.sql create mode 100644 world/dynamic_zone_manager.cpp create mode 100644 world/dynamic_zone_manager.h delete mode 100644 world/expedition.cpp delete mode 100644 world/expedition.h delete mode 100644 world/expedition_state.cpp delete mode 100644 world/expedition_state.h create mode 100644 world/shared_task_manager.cpp create mode 100644 world/shared_task_manager.h create mode 100644 world/shared_task_world_messaging.cpp create mode 100644 world/shared_task_world_messaging.h create mode 100644 zone/shared_task_zone_messaging.cpp create mode 100644 zone/shared_task_zone_messaging.h diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 47edd22e8..6e8a826fc 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -32,7 +32,6 @@ SET(common_sources eq_stream_proxy.cpp eqtime.cpp event_sub.cpp - expedition_base.cpp expedition_lockout_timer.cpp extprofile.cpp faction.cpp @@ -72,6 +71,7 @@ SET(common_sources serialize_buffer.cpp server_event_scheduler.cpp serverinfo.cpp + shared_tasks.cpp shareddb.cpp skills.cpp spdat.cpp @@ -154,6 +154,7 @@ SET(repositories repositories/base/base_character_disciplines_repository.h repositories/base/base_character_expedition_lockouts_repository.h repositories/base/base_character_inspect_messages_repository.h + repositories/base/base_character_instance_safereturns_repository.h repositories/base/base_character_item_recast_repository.h repositories/base/base_character_languages_repository.h repositories/base/base_character_leadership_abilities_repository.h @@ -165,11 +166,15 @@ SET(repositories repositories/base/base_character_potionbelt_repository.h repositories/base/base_character_skills_repository.h repositories/base/base_character_spells_repository.h + repositories/base/base_character_task_timers_repository.h repositories/base/base_character_tasks_repository.h repositories/base/base_char_create_combinations_repository.h repositories/base/base_char_create_point_allocations_repository.h repositories/base/base_char_recipe_list_repository.h repositories/base/base_completed_tasks_repository.h + repositories/base/base_completed_shared_tasks_repository.h + repositories/base/base_completed_shared_task_members_repository.h + repositories/base/base_completed_shared_task_activity_state_repository.h repositories/base/base_content_flags_repository.h repositories/base/base_damageshieldtypes_repository.h repositories/base/base_data_buckets_repository.h @@ -255,6 +260,10 @@ SET(repositories repositories/base/base_rule_values_repository.h repositories/base/base_saylink_repository.h repositories/base/base_server_scheduled_events_repository.h + repositories/base/base_shared_tasks_repository.h + repositories/base/base_shared_task_activity_state_repository.h + repositories/base/base_shared_task_dynamic_zones_repository.h + repositories/base/base_shared_task_members_repository.h repositories/base/base_skill_caps_repository.h repositories/base/base_spawn2_repository.h repositories/base/base_spawnentry_repository.h @@ -318,6 +327,7 @@ SET(repositories repositories/character_disciplines_repository.h repositories/character_expedition_lockouts_repository.h repositories/character_inspect_messages_repository.h + repositories/character_instance_safereturns_repository.h repositories/character_item_recast_repository.h repositories/character_languages_repository.h repositories/character_leadership_abilities_repository.h @@ -329,11 +339,15 @@ SET(repositories repositories/character_potionbelt_repository.h repositories/character_skills_repository.h repositories/character_spells_repository.h + repositories/character_task_timers_repository.h repositories/character_tasks_repository.h repositories/char_create_combinations_repository.h repositories/char_create_point_allocations_repository.h repositories/char_recipe_list_repository.h repositories/completed_tasks_repository.h + repositories/completed_shared_tasks_repository.h + repositories/completed_shared_task_members_repository.h + repositories/completed_shared_task_activity_state_repository.h repositories/content_flags_repository.h repositories/damageshieldtypes_repository.h repositories/data_buckets_repository.h @@ -419,6 +433,10 @@ SET(repositories repositories/rule_values_repository.h repositories/saylink_repository.h repositories/server_scheduled_events_repository.h + repositories/shared_tasks_repository.h + repositories/shared_task_activity_state_repository.h + repositories/shared_task_dynamic_zones_repository.h + repositories/shared_task_members_repository.h repositories/skill_caps_repository.h repositories/spawn2_repository.h repositories/spawnentry_repository.h @@ -497,7 +515,6 @@ SET(common_headers eqtime.h errmsg.h event_sub.h - expedition_base.h expedition_lockout_timer.h extprofile.h faction.h @@ -553,11 +570,13 @@ SET(common_headers server_event_scheduler.h serverinfo.h servertalk.h + shared_tasks.h shareddb.h skills.h spdat.h string_util.h struct_strategy.h + tasks.h textures.h timer.h types.h diff --git a/common/database_schema.h b/common/database_schema.h index 25bc70f22..ba5fb1c45 100644 --- a/common/database_schema.h +++ b/common/database_schema.h @@ -53,6 +53,7 @@ namespace DatabaseSchema { {"character_expedition_lockouts", "character_id"}, {"character_exp_modifiers", "character_id"}, {"character_inspect_messages", "id"}, + {"character_instance_safereturns", "character_id"}, {"character_item_recast", "id"}, {"character_languages", "id"}, {"character_leadership_abilities", "id"}, @@ -64,6 +65,7 @@ namespace DatabaseSchema { {"character_potionbelt", "id"}, {"character_skills", "id"}, {"character_spells", "id"}, + {"character_task_timers", "character_id"}, {"character_tasks", "charid"}, {"character_tribute", "id"}, {"completed_tasks", "charid"}, @@ -119,6 +121,7 @@ namespace DatabaseSchema { "character_expedition_lockouts", "character_exp_modifiers", "character_inspect_messages", + "character_instance_safereturns", "character_item_recast", "character_languages", "character_leadership_abilities", @@ -130,6 +133,7 @@ namespace DatabaseSchema { "character_potionbelt", "character_skills", "character_spells", + "character_task_timers", "character_tasks", "character_tribute", "completed_tasks", @@ -310,6 +314,9 @@ namespace DatabaseSchema { "banned_ips", "bug_reports", "bugs", + "completed_shared_task_activity_state", + "completed_shared_task_members", + "completed_shared_tasks", "dynamic_zone_members", "dynamic_zones", "eventlog", @@ -319,8 +326,8 @@ namespace DatabaseSchema { "group_id", "group_leaders", "hackers", - "ip_exemptions", "instance_list", + "ip_exemptions", "item_tick", "lfguild", "merchantlist_temp", @@ -332,6 +339,10 @@ namespace DatabaseSchema { "respawn_times", "saylink", "server_scheduled_events", + "shared_task_activity_state", + "shared_task_dynamic_zones", + "shared_task_members", + "shared_tasks", }; } diff --git a/common/dynamic_zone_base.cpp b/common/dynamic_zone_base.cpp index f3a499ee8..f791ed0b5 100644 --- a/common/dynamic_zone_base.cpp +++ b/common/dynamic_zone_base.cpp @@ -5,6 +5,7 @@ #include "repositories/instance_list_player_repository.h" #include "rulesys.h" #include "servertalk.h" +#include "util/uuid.h" DynamicZoneBase::DynamicZoneBase(DynamicZonesRepository::DynamicZoneInstance&& entry) { @@ -13,16 +14,12 @@ DynamicZoneBase::DynamicZoneBase(DynamicZonesRepository::DynamicZoneInstance&& e uint32_t DynamicZoneBase::Create() { - if (m_id != 0) - { - return m_id; - } - if (GetInstanceID() == 0) { CreateInstance(); } + m_uuid = EQ::Util::UUID::Generate().ToString(); m_id = SaveToDatabase(); return m_id; @@ -75,6 +72,11 @@ uint32_t DynamicZoneBase::CreateInstance() void DynamicZoneBase::LoadRepositoryResult(DynamicZonesRepository::DynamicZoneInstance&& dz_entry) { m_id = dz_entry.id; + m_uuid = std::move(dz_entry.uuid); + m_name = std::move(dz_entry.name); + m_leader.id = dz_entry.leader_id; + m_min_players = dz_entry.min_players; + m_max_players = dz_entry.max_players; m_instance_id = dz_entry.instance_id; m_type = static_cast(dz_entry.type); m_compass.zone_id = dz_entry.compass_zone_id; @@ -104,6 +106,12 @@ void DynamicZoneBase::AddMemberFromRepositoryResult( DynamicZoneMembersRepository::MemberWithName&& entry) { auto status = DynamicZoneMemberStatus::Unknown; + + if (m_leader.id == entry.character_id) + { + m_leader.name = entry.character_name; + } + AddInternalMember({ entry.character_id, std::move(entry.character_name), status }); } @@ -114,6 +122,11 @@ uint32_t DynamicZoneBase::SaveToDatabase() if (m_instance_id != 0) { auto insert_dz = DynamicZonesRepository::NewEntity(); + insert_dz.uuid = m_uuid; + insert_dz.name = m_name; + insert_dz.leader_id = m_leader.id; + insert_dz.min_players = m_min_players; + insert_dz.max_players = m_max_players; insert_dz.instance_id = m_instance_id, insert_dz.type = static_cast(m_type); insert_dz.compass_zone_id = m_compass.zone_id; @@ -137,34 +150,80 @@ uint32_t DynamicZoneBase::SaveToDatabase() return 0; } -void DynamicZoneBase::AddCharacter(uint32_t character_id) +bool DynamicZoneBase::AddMember(const DynamicZoneMember& add_member) { - DynamicZoneMembersRepository::AddMember(GetDatabase(), m_id, character_id); - GetDatabase().AddClientToInstance(m_instance_id, character_id); - SendInstanceAddRemoveCharacter(character_id, false); // stops client kick timer -} - -void DynamicZoneBase::RemoveCharacter(uint32_t character_id) -{ - DynamicZoneMembersRepository::RemoveMember(GetDatabase(), m_id, character_id); - GetDatabase().RemoveClientFromInstance(m_instance_id, character_id); - SendInstanceAddRemoveCharacter(character_id, true); // start client kick timer -} - -void DynamicZoneBase::RemoveAllCharacters(bool enable_removal_timers) -{ - if (GetInstanceID() == 0) + if (HasMember(add_member.id)) { - return; + return false; } - if (enable_removal_timers) + DynamicZoneMembersRepository::AddMember(GetDatabase(), m_id, add_member.id); + GetDatabase().AddClientToInstance(m_instance_id, add_member.id); + + ProcessMemberAddRemove(add_member, false); + SendServerPacket(CreateServerMemberAddRemovePacket(add_member, false).get()); + + return true; +} + +bool DynamicZoneBase::RemoveMember(uint32_t character_id) +{ + auto remove_member = GetMemberData(character_id); + return RemoveMember(remove_member); +} + +bool DynamicZoneBase::RemoveMember(const std::string& character_name) +{ + auto remove_member = GetMemberData(character_name); + return RemoveMember(remove_member); +} + +bool DynamicZoneBase::RemoveMember(const DynamicZoneMember& remove_member) +{ + if (remove_member.id == 0) { - SendInstanceRemoveAllCharacters(); + return false; } + DynamicZoneMembersRepository::RemoveMember(GetDatabase(), m_id, remove_member.id); + GetDatabase().RemoveClientFromInstance(m_instance_id, remove_member.id); + + ProcessMemberAddRemove(remove_member, true); + SendServerPacket(CreateServerMemberAddRemovePacket(remove_member, true).get()); + + return true; +} + +bool DynamicZoneBase::SwapMember( + const DynamicZoneMember& add_member, const std::string& remove_char_name) +{ + auto remove_member = GetMemberData(remove_char_name); + if (!add_member.IsValid() || !remove_member.IsValid()) + { + return false; + } + + // make remove and add atomic to avoid racing with separate world messages + DynamicZoneMembersRepository::RemoveMember(GetDatabase(), m_id, remove_member.id); + GetDatabase().RemoveClientFromInstance(m_instance_id, remove_member.id); + + DynamicZoneMembersRepository::AddMember(GetDatabase(), m_id, add_member.id); + GetDatabase().AddClientToInstance(m_instance_id, add_member.id); + + ProcessMemberAddRemove(remove_member, true); + ProcessMemberAddRemove(add_member, false); + SendServerPacket(CreateServerMemberSwapPacket(remove_member, add_member).get()); + + return true; +} + +void DynamicZoneBase::RemoveAllMembers() +{ DynamicZoneMembersRepository::RemoveAllMembers(GetDatabase(), m_id); GetDatabase().RemoveClientsFromInstance(GetInstanceID()); + + ProcessRemoveAllMembers(); + SendServerPacket(CreateServerRemoveAllMembersPacket().get()); } void DynamicZoneBase::SaveMembers(const std::vector& members) @@ -181,7 +240,6 @@ void DynamicZoneBase::SaveMembers(const std::vector& members) DynamicZoneMembersRepository::DynamicZoneMembers member_entry{}; member_entry.dynamic_zone_id = m_id; member_entry.character_id = member.id; - member_entry.is_current_member = true; insert_members.emplace_back(member_entry); InstanceListPlayerRepository::InstanceListPlayer player_entry; @@ -206,7 +264,7 @@ void DynamicZoneBase::SetCompass(const DynamicZoneLocation& location, bool updat DynamicZonesRepository::UpdateCompass(GetDatabase(), m_id, m_compass.zone_id, m_compass.x, m_compass.y, m_compass.z); - SendGlobalLocationChange(ServerOP_DzSetCompass, location); + SendServerPacket(CreateServerDzLocationPacket(ServerOP_DzSetCompass, location).get()); } } @@ -227,7 +285,7 @@ void DynamicZoneBase::SetSafeReturn(const DynamicZoneLocation& location, bool up DynamicZonesRepository::UpdateSafeReturn(GetDatabase(), m_id, m_safereturn.zone_id, m_safereturn.x, m_safereturn.y, m_safereturn.z, m_safereturn.heading); - SendGlobalLocationChange(ServerOP_DzSetSafeReturn, location); + SendServerPacket(CreateServerDzLocationPacket(ServerOP_DzSetSafeReturn, location).get()); } } @@ -249,7 +307,7 @@ void DynamicZoneBase::SetZoneInLocation(const DynamicZoneLocation& location, boo DynamicZonesRepository::UpdateZoneIn(GetDatabase(), m_id, m_zone_id, m_zonein.x, m_zonein.y, m_zonein.z, m_zonein.heading, m_has_zonein); - SendGlobalLocationChange(ServerOP_DzSetZoneIn, location); + SendServerPacket(CreateServerDzLocationPacket(ServerOP_DzSetZoneIn, location).get()); } } @@ -258,35 +316,71 @@ void DynamicZoneBase::SetZoneInLocation(float x, float y, float z, float heading SetZoneInLocation({ 0, x, y, z, heading }, update_db); } +void DynamicZoneBase::SetLeader(const DynamicZoneMember& new_leader, bool update_db) +{ + m_leader = new_leader; + + if (update_db) + { + DynamicZonesRepository::UpdateLeaderID(GetDatabase(), m_id, new_leader.id); + } +} + uint32_t DynamicZoneBase::GetSecondsRemaining() const { auto remaining = std::chrono::duration_cast(GetDurationRemaining()).count(); return std::max(0, static_cast(remaining)); } -std::unique_ptr DynamicZoneBase::CreateServerAddRemoveCharacterPacket( - uint32_t character_id, bool removed) +std::unique_ptr DynamicZoneBase::CreateServerMemberAddRemovePacket( + const DynamicZoneMember& member, bool removed) { - constexpr uint32_t pack_size = sizeof(ServerDzCharacter_Struct); - auto pack = std::make_unique(ServerOP_DzAddRemoveCharacter, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->zone_id = GetZoneID(); - buf->instance_id = GetInstanceID(); - buf->remove = removed; - buf->character_id = character_id; + constexpr uint32_t pack_size = sizeof(ServerDzMember_Struct); + auto pack = std::make_unique(ServerOP_DzAddRemoveMember, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->dz_zone_id = GetZoneID(); + buf->dz_instance_id = GetInstanceID(); + buf->sender_zone_id = GetCurrentZoneID(); + buf->sender_instance_id = GetCurrentInstanceID(); + buf->removed = removed; + buf->character_id = member.id; + buf->character_status = static_cast(member.status); + strn0cpy(buf->character_name, member.name.c_str(), sizeof(buf->character_name)); return pack; } -std::unique_ptr DynamicZoneBase::CreateServerRemoveAllCharactersPacket() +std::unique_ptr DynamicZoneBase::CreateServerMemberSwapPacket( + const DynamicZoneMember& remove_member, const DynamicZoneMember& add_member) { - constexpr uint32_t pack_size = sizeof(ServerDzCharacter_Struct); - auto pack = std::make_unique(ServerOP_DzRemoveAllCharacters, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->zone_id = GetZoneID(); - buf->instance_id = GetInstanceID(); - buf->remove = true; - buf->character_id = 0; + constexpr uint32_t pack_size = sizeof(ServerDzMemberSwap_Struct); + auto pack = std::make_unique(ServerOP_DzSwapMembers, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->dz_zone_id = GetZoneID(); + buf->dz_instance_id = GetInstanceID(); + buf->sender_zone_id = GetCurrentZoneID(); + buf->sender_instance_id = GetCurrentInstanceID(); + buf->add_character_status = static_cast(add_member.status); + buf->add_character_id = add_member.id; + buf->remove_character_id = remove_member.id; + strn0cpy(buf->add_character_name, add_member.name.c_str(), sizeof(buf->add_character_name)); + strn0cpy(buf->remove_character_name, remove_member.name.c_str(), sizeof(buf->remove_character_name)); + + return pack; +} + +std::unique_ptr DynamicZoneBase::CreateServerRemoveAllMembersPacket() +{ + constexpr uint32_t pack_size = sizeof(ServerDzID_Struct); + auto pack = std::make_unique(ServerOP_DzRemoveAllMembers, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->dz_zone_id = GetZoneID(); + buf->dz_instance_id = GetInstanceID(); + buf->sender_zone_id = GetCurrentZoneID(); + buf->sender_instance_id = GetCurrentInstanceID(); return pack; } @@ -309,10 +403,25 @@ std::unique_ptr DynamicZoneBase::CreateServerDzLocationPacket( return pack; } +std::unique_ptr DynamicZoneBase::CreateServerMemberStatusPacket( + uint32_t character_id, DynamicZoneMemberStatus status) +{ + constexpr uint32_t pack_size = sizeof(ServerDzMemberStatus_Struct); + auto pack = std::make_unique(ServerOP_DzUpdateMemberStatus, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->sender_zone_id = GetCurrentZoneID(); + buf->sender_instance_id = GetCurrentInstanceID(); + buf->status = static_cast(status); + buf->character_id = character_id; + + return pack; +} + uint32_t DynamicZoneBase::GetDatabaseMemberCount() { return DynamicZoneMembersRepository::GetCountWhere(GetDatabase(), - fmt::format("dynamic_zone_id = {} AND is_current_member = TRUE", m_id)); + fmt::format("dynamic_zone_id = {}", m_id)); } bool DynamicZoneBase::HasDatabaseMember(uint32_t character_id) @@ -323,7 +432,7 @@ bool DynamicZoneBase::HasDatabaseMember(uint32_t character_id) } auto entries = DynamicZoneMembersRepository::GetWhere(GetDatabase(), fmt::format( - "dynamic_zone_id = {} AND character_id = {} AND is_current_member = TRUE", + "dynamic_zone_id = {} AND character_id = {}", m_id, character_id )); @@ -411,6 +520,33 @@ bool DynamicZoneBase::SetInternalMemberStatus(uint32_t character_id, DynamicZone return false; } +void DynamicZoneBase::SetMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status) +{ + auto update_member = GetMemberData(character_id); + if (update_member.IsValid()) + { + ProcessMemberStatusChange(character_id, status); + SendServerPacket(CreateServerMemberStatusPacket(character_id, status).get()); + } +} + +void DynamicZoneBase::ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed) +{ + if (!removed) + { + AddInternalMember(member); + } + else + { + RemoveInternalMember(member.id); + } +} + +bool DynamicZoneBase::ProcessMemberStatusChange(uint32_t character_id, DynamicZoneMemberStatus status) +{ + return SetInternalMemberStatus(character_id, status); +} + std::string DynamicZoneBase::GetDynamicZoneTypeName(DynamicZoneType dz_type) { switch (dz_type) @@ -428,3 +564,36 @@ std::string DynamicZoneBase::GetDynamicZoneTypeName(DynamicZoneType dz_type) } return "Unknown"; } + +EQ::Net::DynamicPacket DynamicZoneBase::GetSerializedDzPacket() +{ + EQ::Net::DynamicPacket dyn_pack; + dyn_pack.PutSerialize(0, *this); + + LogDynamicZonesDetail("Serialized server dz size [{}]", dyn_pack.Length()); + return dyn_pack; +} + +std::unique_ptr DynamicZoneBase::CreateServerDzCreatePacket( + uint16_t origin_zone_id, uint16_t origin_instance_id) +{ + EQ::Net::DynamicPacket dyn_pack = GetSerializedDzPacket(); + + auto pack_size = sizeof(ServerDzCreateSerialized_Struct) + dyn_pack.Length(); + auto pack = std::make_unique(ServerOP_DzCreated, static_cast(pack_size)); + auto buf = reinterpret_cast(pack->pBuffer); + buf->origin_zone_id = origin_zone_id; + buf->origin_instance_id = origin_instance_id; + buf->cereal_size = static_cast(dyn_pack.Length()); + memcpy(buf->cereal_data, dyn_pack.Data(), dyn_pack.Length()); + + return pack; +} + +void DynamicZoneBase::LoadSerializedDzPacket(char* cereal_data, uint32_t cereal_size) +{ + LogDynamicZonesDetail("Deserializing server dz size [{}]", cereal_size); + EQ::Util::MemoryStreamReader ss(cereal_data, cereal_size); + cereal::BinaryInputArchive archive(ss); + archive(*this); +} diff --git a/common/dynamic_zone_base.h b/common/dynamic_zone_base.h index bc325532e..eafea5ca0 100644 --- a/common/dynamic_zone_base.h +++ b/common/dynamic_zone_base.h @@ -2,6 +2,7 @@ #define COMMON_DYNAMIC_ZONE_BASE_H #include "eq_constants.h" +#include "net/packet.h" #include "repositories/dynamic_zones_repository.h" #include "repositories/dynamic_zone_members_repository.h" #include @@ -18,7 +19,7 @@ struct DynamicZoneMember { uint32_t id = 0; std::string name; - DynamicZoneMemberStatus status = DynamicZoneMemberStatus::Online; + DynamicZoneMemberStatus status = DynamicZoneMemberStatus::Unknown; DynamicZoneMember() = default; DynamicZoneMember(uint32_t id, std::string name_) @@ -29,6 +30,12 @@ struct DynamicZoneMember bool IsOnline() const { return status == DynamicZoneMemberStatus::Online || status == DynamicZoneMemberStatus::InDynamicZone; } bool IsValid() const { return id != 0 && !name.empty(); } + + template + void serialize(Archive& archive) + { + archive(id, name, status); + } }; struct DynamicZoneLocation @@ -42,6 +49,12 @@ struct DynamicZoneLocation DynamicZoneLocation() = default; DynamicZoneLocation(uint32_t zone_id_, float x_, float y_, float z_, float heading_) : zone_id(zone_id_), x(x_), y(y_), z(z_), heading(heading_) {} + + template + void serialize(Archive& archive) + { + archive(zone_id, x, y, z, heading); + } }; class DynamicZoneBase @@ -64,6 +77,7 @@ public: uint64_t GetExpireTime() const { return std::chrono::system_clock::to_time_t(m_expire_time); } uint32_t GetID() const { return m_id; } uint16_t GetInstanceID() const { return static_cast(m_instance_id); } + uint32_t GetLeaderID() const { return m_leader.id; } uint32_t GetMaxPlayers() const { return m_max_players; } uint32_t GetMemberCount() const { return static_cast(m_members.size()); } uint32_t GetMinPlayers() const { return m_min_players; } @@ -74,6 +88,7 @@ public: DynamicZoneType GetType() const { return m_type; } const std::string& GetLeaderName() const { return m_leader.name; } const std::string& GetName() const { return m_name; } + const std::string& GetUUID() const { return m_uuid; } const DynamicZoneMember& GetLeader() const { return m_leader; } const std::vector& GetMembers() const { return m_members; } const DynamicZoneLocation& GetCompassLocation() const { return m_compass; } @@ -81,14 +96,12 @@ public: const DynamicZoneLocation& GetZoneInLocation() const { return m_zonein; } std::chrono::system_clock::duration GetDurationRemaining() const { return m_expire_time - std::chrono::system_clock::now(); } - void AddCharacter(uint32_t character_id); - void AddInternalMember(const DynamicZoneMember& member); + bool AddMember(const DynamicZoneMember& add_member); void AddMemberFromRepositoryResult(DynamicZoneMembersRepository::MemberWithName&& entry); - void ClearInternalMembers() { m_members.clear(); } - uint32_t Create(); uint32_t GetDatabaseMemberCount(); DynamicZoneMember GetMemberData(uint32_t character_id); DynamicZoneMember GetMemberData(const std::string& character_name); + EQ::Net::DynamicPacket GetSerializedDzPacket(); bool HasDatabaseMember(uint32_t character_id); bool HasMember(uint32_t character_id); bool HasMember(const std::string& character_name); @@ -98,38 +111,52 @@ public: bool IsInstanceID(uint32_t instance_id) const { return (m_instance_id != 0 && m_instance_id == instance_id); } bool IsValid() const { return m_instance_id != 0; } bool IsSameDz(uint32_t zone_id, uint32_t instance_id) const { return zone_id == m_zone_id && instance_id == m_instance_id; } - void RemoveAllCharacters(bool enable_removal_timers = true); - void RemoveCharacter(uint32_t character_id); - void RemoveInternalMember(uint32_t character_id); + void LoadSerializedDzPacket(char* cereal_data, uint32_t cereal_size); + void RemoveAllMembers(); + bool RemoveMember(uint32_t character_id); + bool RemoveMember(const std::string& character_name); + bool RemoveMember(const DynamicZoneMember& remove_member); void SaveMembers(const std::vector& members); void SetCompass(const DynamicZoneLocation& location, bool update_db = false); void SetCompass(uint32_t zone_id, float x, float y, float z, bool update_db = false); - bool SetInternalMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status); - void SetLeader(const DynamicZoneMember& leader) { m_leader = leader; } + void SetDuration(uint32_t seconds) { m_duration = std::chrono::seconds(seconds); } + void SetLeader(const DynamicZoneMember& leader, bool update_db = false); void SetMaxPlayers(uint32_t max_players) { m_max_players = max_players; } + void SetMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status); void SetMinPlayers(uint32_t min_players) { m_min_players = min_players; } void SetName(const std::string& name) { m_name = name; } void SetSafeReturn(const DynamicZoneLocation& location, bool update_db = false); void SetSafeReturn(uint32_t zone_id, float x, float y, float z, float heading, bool update_db = false); + void SetType(DynamicZoneType type) { m_type = type; } + void SetUUID(std::string uuid) { m_uuid = std::move(uuid); } void SetZoneInLocation(const DynamicZoneLocation& location, bool update_db = false); void SetZoneInLocation(float x, float y, float z, float heading, bool update_db = false); + bool SwapMember(const DynamicZoneMember& add_member, const std::string& remove_char_name); protected: virtual uint16_t GetCurrentInstanceID() { return 0; } virtual uint16_t GetCurrentZoneID() { return 0; } virtual Database& GetDatabase() = 0; virtual void ProcessCompassChange(const DynamicZoneLocation& location) { m_compass = location; } - virtual void SendInstanceAddRemoveCharacter(uint32_t character_id, bool remove) = 0; - virtual void SendInstanceRemoveAllCharacters() = 0; - virtual void SendGlobalLocationChange(uint16_t server_opcode, const DynamicZoneLocation& location) = 0; + virtual void ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed); + virtual bool ProcessMemberStatusChange(uint32_t member_id, DynamicZoneMemberStatus status); + virtual void ProcessRemoveAllMembers(bool silent = false) { m_members.clear(); } + virtual bool SendServerPacket(ServerPacket* packet) = 0; + void AddInternalMember(const DynamicZoneMember& member); + uint32_t Create(); uint32_t CreateInstance(); void LoadRepositoryResult(DynamicZonesRepository::DynamicZoneInstance&& dz_entry); + void RemoveInternalMember(uint32_t character_id); uint32_t SaveToDatabase(); + bool SetInternalMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status); - std::unique_ptr CreateServerAddRemoveCharacterPacket(uint32_t character_id, bool removed); - std::unique_ptr CreateServerRemoveAllCharactersPacket(); + std::unique_ptr CreateServerDzCreatePacket(uint16_t origin_zone_id, uint16_t origin_instance_id); std::unique_ptr CreateServerDzLocationPacket(uint16_t server_opcode, const DynamicZoneLocation& location); + std::unique_ptr CreateServerMemberAddRemovePacket(const DynamicZoneMember& member, bool removed); + std::unique_ptr CreateServerMemberStatusPacket(uint32_t character_id, DynamicZoneMemberStatus status); + std::unique_ptr CreateServerMemberSwapPacket(const DynamicZoneMember& remove_member, const DynamicZoneMember& add_member); + std::unique_ptr CreateServerRemoveAllMembersPacket(); uint32_t m_id = 0; uint32_t m_zone_id = 0; @@ -139,7 +166,9 @@ protected: uint32_t m_max_players = 0; bool m_never_expires = false; bool m_has_zonein = false; + bool m_has_member_statuses = false; std::string m_name; + std::string m_uuid; DynamicZoneMember m_leader; DynamicZoneType m_type{ DynamicZoneType::None }; DynamicZoneLocation m_compass; @@ -149,6 +178,34 @@ protected: std::chrono::time_point m_start_time; std::chrono::time_point m_expire_time; std::vector m_members; + +public: + template + void serialize(Archive& archive) + { + archive( + m_id, + m_zone_id, + m_instance_id, + m_zone_version, + m_min_players, + m_max_players, + m_never_expires, + m_has_zonein, + m_has_member_statuses, + m_name, + m_uuid, + m_leader, + m_type, + m_compass, + m_safereturn, + m_zonein, + m_duration, + m_start_time, + m_expire_time, + m_members + ); + } }; #endif diff --git a/common/emu_oplist.h b/common/emu_oplist.h index d81ed3a55..869a9bd3a 100644 --- a/common/emu_oplist.h +++ b/common/emu_oplist.h @@ -355,7 +355,6 @@ N(OP_OpenContainer), N(OP_OpenDiscordMerchant), N(OP_OpenGuildTributeMaster), N(OP_OpenInventory), -N(OP_OpenNewTasksWindow), N(OP_OpenTributeMaster), N(OP_PDeletePetition), N(OP_PetBuffWindow), @@ -464,6 +463,19 @@ N(OP_SetServerFilter), N(OP_SetStartCity), N(OP_SetTitle), N(OP_SetTitleReply), +N(OP_SharedTaskMemberList), +N(OP_SharedTaskAddPlayer), +N(OP_SharedTaskRemovePlayer), +N(OP_SharedTaskMakeLeader), +N(OP_SharedTaskMemberInvite), +N(OP_SharedTaskInvite), +N(OP_SharedTaskInviteResponse), +N(OP_SharedTaskAcceptNew), +N(OP_SharedTaskMemberChange), +N(OP_SharedTaskPlayerList), +N(OP_SharedTaskSelectWindow), +N(OP_SharedTaskQuit), +N(OP_TaskTimers), N(OP_Shielding), N(OP_ShopDelItem), N(OP_ShopEnd), @@ -499,7 +511,8 @@ N(OP_TaskActivityComplete), N(OP_TaskDescription), N(OP_TaskHistoryReply), N(OP_TaskHistoryRequest), -N(OP_TaskMemberList), +N(OP_TaskRequestTimer), +N(OP_TaskSelectWindow), N(OP_Taunt), N(OP_TestBuff), N(OP_TGB), diff --git a/common/eq_packet_structs.h b/common/eq_packet_structs.h index 308ba22e9..47f14bb4e 100644 --- a/common/eq_packet_structs.h +++ b/common/eq_packet_structs.h @@ -3714,17 +3714,66 @@ struct SetTitleReply_Struct { uint32 entity_id; }; -struct TaskMemberList_Struct { -/*00*/ uint32 gopher_id; -/*04*/ uint32 unknown04; -/*08*/ uint32 member_count; //1 less than the number of members -/*12*/ char list_pointer[0]; +struct SharedTaskMemberList_Struct { +/*00*/ uint32 gopher_id; +/*04*/ uint32 unknown04; +/*08*/ uint32 member_count; //1 less than the number of members +///*12*/ char list_pointer[0]; + char member_name[1]; //null terminated string + uint32 monster_mission; // class chosen + uint8 task_leader; //boolean flag + /* list is of the form: - char member_name[1] //null terminated string uint8 task_leader //boolean flag */ }; +struct SharedTaskQuit_Struct { + int32 field1; + int32 field2; + int32 field3; +}; + +struct SharedTaskAddPlayer_Struct { + int32 field1; + int32 field2; + char player_name[64]; +}; + +struct SharedTaskMakeLeader_Struct { + int32 field1; + int32 field2; + char player_name[64]; +}; + +struct SharedTaskRemovePlayer_Struct { + int32 field1; + int32 field2; + char player_name[64]; +}; + +struct SharedTaskInvite_Struct { + int32_t unknown00; // probably the unique character id sent in some packets + int32_t invite_id; // invite id sent back in response + char task_name[64]; + char inviter_name[64]; +}; + +struct SharedTaskInviteResponse_Struct { + int32_t unknown00; // 0 + int32_t invite_id; // same id sent in the invite, probably for server verification + int8_t accepted; // 0: declined 1: accepted + int8_t padding[3]; // padding garbage probably +}; + +struct SharedTaskAccept_Struct { + int32_t unknown00; + int32_t unknown04; + uint32_t npc_entity_id; // npc task giver entity id (sent in selection window) + uint32_t task_id; + float reward_multiplier; // added after titanium (sent in selection window) +}; + #if 0 // Old struct not used by Task System implementation but left for reference @@ -3817,7 +3866,7 @@ struct TaskHistory_Struct { #endif struct AcceptNewTask_Struct { - uint32 unknown00; + uint32 task_type; // type sent in selection window uint32 task_id; //set to 0 for 'decline' uint32 task_master_id; //entity ID }; diff --git a/common/eqemu_logsys.cpp b/common/eqemu_logsys.cpp index 3666735e4..83e9a45dd 100644 --- a/common/eqemu_logsys.cpp +++ b/common/eqemu_logsys.cpp @@ -235,9 +235,11 @@ void EQEmuLogSys::ProcessGMSay( } /** - * Check to see if the process that actually ran this is zone + * Processes that actually support hooks */ - if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) { + if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone || + EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld + ) { on_log_gmsay_hook(log_category, message); } } diff --git a/common/eqemu_logsys.h b/common/eqemu_logsys.h index 6e881eecc..c5ced8925 100644 --- a/common/eqemu_logsys.h +++ b/common/eqemu_logsys.h @@ -123,6 +123,7 @@ namespace Logs { DynamicZones, Scheduler, Cheat, + ClientList, MaxCategoryID /* Don't Remove this */ }; @@ -203,7 +204,8 @@ namespace Logs { "Expeditions", "DynamicZones", "Scheduler", - "Cheat" + "Cheat", + "ClientList", }; } diff --git a/common/eqemu_logsys_log_aliases.h b/common/eqemu_logsys_log_aliases.h index b683d9111..c5f7cd422 100644 --- a/common/eqemu_logsys_log_aliases.h +++ b/common/eqemu_logsys_log_aliases.h @@ -656,6 +656,16 @@ OutF(LogSys, Logs::Detail, Logs::Cheat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\ } while (0) +#define LogClientList(message, ...) do {\ + if (LogSys.log_settings[Logs::ClientList].is_category_enabled == 1)\ + OutF(LogSys, Logs::General, Logs::ClientList, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\ +} while (0) + +#define LogClientListDetail(message, ...) do {\ + if (LogSys.log_settings[Logs::ClientList].is_category_enabled == 1)\ + OutF(LogSys, Logs::Detail, Logs::ClientList, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\ +} while (0) + #define Log(debug_level, log_category, message, ...) do {\ if (LogSys.log_settings[log_category].is_category_enabled == 1)\ LogSys.Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\ @@ -1028,6 +1038,18 @@ #define LogDynamicZonesDetail(message, ...) do {\ } while (0) +#define LogCheatList(message, ...) do {\ +} while (0) + +#define LogCheatDetail(message, ...) do {\ +} while (0) + +#define LogClientList(message, ...) do {\ +} while (0) + +#define LogClientListDetail(message, ...) do {\ +} while (0) + #define Log(debug_level, log_category, message, ...) do {\ } while (0) diff --git a/common/expedition_base.cpp b/common/expedition_base.cpp deleted file mode 100644 index af961e4a9..000000000 --- a/common/expedition_base.cpp +++ /dev/null @@ -1,23 +0,0 @@ -#include "expedition_base.h" -#include "repositories/expeditions_repository.h" - -ExpeditionBase::ExpeditionBase(uint32_t id, const std::string& uuid, - const std::string& expedition_name, const DynamicZoneMember& leader -) : - m_id(id), - m_uuid(uuid), - m_expedition_name(expedition_name), - m_leader(leader) -{ -} - -void ExpeditionBase::LoadRepositoryResult(ExpeditionsRepository::ExpeditionWithLeader&& entry) -{ - m_id = entry.id; - m_uuid = std::move(entry.uuid); - m_expedition_name = std::move(entry.expedition_name); - m_add_replay_on_join = entry.add_replay_on_join; - m_is_locked = entry.is_locked; - m_leader.id = entry.leader_id; - m_leader.name = std::move(entry.leader_name); -} diff --git a/common/expedition_base.h b/common/expedition_base.h deleted file mode 100644 index cb6f6a591..000000000 --- a/common/expedition_base.h +++ /dev/null @@ -1,40 +0,0 @@ -#ifndef COMMON_EXPEDITION_BASE_H -#define COMMON_EXPEDITION_BASE_H - -#include "dynamic_zone_base.h" -#include "repositories/expeditions_repository.h" -#include -#include - -class ExpeditionBase -{ -public: - virtual ~ExpeditionBase() = default; - ExpeditionBase(const ExpeditionBase&) = default; - ExpeditionBase(ExpeditionBase&&) = default; - ExpeditionBase& operator=(const ExpeditionBase&) = default; - ExpeditionBase& operator=(ExpeditionBase&&) = default; - - uint32_t GetID() const { return m_id; } - uint32_t GetLeaderID() const { return m_leader.id; } - const std::string& GetName() const { return m_expedition_name; } - const std::string& GetLeaderName() const { return m_leader.name; } - const std::string& GetUUID() const { return m_uuid; } - const DynamicZoneMember& GetLeader() const { return m_leader; } - - void LoadRepositoryResult(ExpeditionsRepository::ExpeditionWithLeader&& entry); - -protected: - ExpeditionBase() = default; - ExpeditionBase(uint32_t id, const std::string& uuid, const std::string& expedition_name, - const DynamicZoneMember& leader); - - uint32_t m_id = 0; - bool m_is_locked = false; - bool m_add_replay_on_join = true; - std::string m_uuid; - std::string m_expedition_name; - DynamicZoneMember m_leader; -}; - -#endif diff --git a/common/repositories/base/base_character_instance_safereturns_repository.h b/common/repositories/base/base_character_instance_safereturns_repository.h new file mode 100644 index 000000000..735c2e4c0 --- /dev/null +++ b/common/repositories/base/base_character_instance_safereturns_repository.h @@ -0,0 +1,355 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_CHARACTER_INSTANCE_SAFERETURNS_REPOSITORY_H +#define EQEMU_BASE_CHARACTER_INSTANCE_SAFERETURNS_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" + +class BaseCharacterInstanceSafereturnsRepository { +public: + struct CharacterInstanceSafereturns { + int id; + int character_id; + int instance_zone_id; + int instance_id; + int safe_zone_id; + float safe_x; + float safe_y; + float safe_z; + float safe_heading; + }; + + static std::string PrimaryKey() + { + return std::string("id"); + } + + static std::vector Columns() + { + return { + "id", + "character_id", + "instance_zone_id", + "instance_id", + "safe_zone_id", + "safe_x", + "safe_y", + "safe_z", + "safe_heading", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string TableName() + { + return std::string("character_instance_safereturns"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + ColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static CharacterInstanceSafereturns NewEntity() + { + CharacterInstanceSafereturns entry{}; + + entry.id = 0; + entry.character_id = 0; + entry.instance_zone_id = 0; + entry.instance_id = 0; + entry.safe_zone_id = 0; + entry.safe_x = 0; + entry.safe_y = 0; + entry.safe_z = 0; + entry.safe_heading = 0; + + return entry; + } + + static CharacterInstanceSafereturns GetCharacterInstanceSafereturnsEntry( + const std::vector &character_instance_safereturnss, + int character_instance_safereturns_id + ) + { + for (auto &character_instance_safereturns : character_instance_safereturnss) { + if (character_instance_safereturns.id == character_instance_safereturns_id) { + return character_instance_safereturns; + } + } + + return NewEntity(); + } + + static CharacterInstanceSafereturns FindOne( + Database& db, + int character_instance_safereturns_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + character_instance_safereturns_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + CharacterInstanceSafereturns entry{}; + + entry.id = atoi(row[0]); + entry.character_id = atoi(row[1]); + entry.instance_zone_id = atoi(row[2]); + entry.instance_id = atoi(row[3]); + entry.safe_zone_id = atoi(row[4]); + entry.safe_x = static_cast(atof(row[5])); + entry.safe_y = static_cast(atof(row[6])); + entry.safe_z = static_cast(atof(row[7])); + entry.safe_heading = static_cast(atof(row[8])); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int character_instance_safereturns_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + character_instance_safereturns_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + CharacterInstanceSafereturns character_instance_safereturns_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[1] + " = " + std::to_string(character_instance_safereturns_entry.character_id)); + update_values.push_back(columns[2] + " = " + std::to_string(character_instance_safereturns_entry.instance_zone_id)); + update_values.push_back(columns[3] + " = " + std::to_string(character_instance_safereturns_entry.instance_id)); + update_values.push_back(columns[4] + " = " + std::to_string(character_instance_safereturns_entry.safe_zone_id)); + update_values.push_back(columns[5] + " = " + std::to_string(character_instance_safereturns_entry.safe_x)); + update_values.push_back(columns[6] + " = " + std::to_string(character_instance_safereturns_entry.safe_y)); + update_values.push_back(columns[7] + " = " + std::to_string(character_instance_safereturns_entry.safe_z)); + update_values.push_back(columns[8] + " = " + std::to_string(character_instance_safereturns_entry.safe_heading)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + character_instance_safereturns_entry.id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static CharacterInstanceSafereturns InsertOne( + Database& db, + CharacterInstanceSafereturns character_instance_safereturns_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(character_instance_safereturns_entry.id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.character_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.instance_zone_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.instance_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_zone_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_x)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_y)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_z)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_heading)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + character_instance_safereturns_entry.id = results.LastInsertedID(); + return character_instance_safereturns_entry; + } + + character_instance_safereturns_entry = NewEntity(); + + return character_instance_safereturns_entry; + } + + static int InsertMany( + Database& db, + std::vector character_instance_safereturns_entries + ) + { + std::vector insert_chunks; + + for (auto &character_instance_safereturns_entry: character_instance_safereturns_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(character_instance_safereturns_entry.id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.character_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.instance_zone_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.instance_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_zone_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_x)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_y)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_z)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_heading)); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CharacterInstanceSafereturns entry{}; + + entry.id = atoi(row[0]); + entry.character_id = atoi(row[1]); + entry.instance_zone_id = atoi(row[2]); + entry.instance_id = atoi(row[3]); + entry.safe_zone_id = atoi(row[4]); + entry.safe_x = static_cast(atof(row[5])); + entry.safe_y = static_cast(atof(row[6])); + entry.safe_z = static_cast(atof(row[7])); + entry.safe_heading = static_cast(atof(row[8])); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CharacterInstanceSafereturns entry{}; + + entry.id = atoi(row[0]); + entry.character_id = atoi(row[1]); + entry.instance_zone_id = atoi(row[2]); + entry.instance_id = atoi(row[3]); + entry.safe_zone_id = atoi(row[4]); + entry.safe_x = static_cast(atof(row[5])); + entry.safe_y = static_cast(atof(row[6])); + entry.safe_z = static_cast(atof(row[7])); + entry.safe_heading = static_cast(atof(row[8])); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_CHARACTER_INSTANCE_SAFERETURNS_REPOSITORY_H diff --git a/common/repositories/base/base_character_task_timers_repository.h b/common/repositories/base/base_character_task_timers_repository.h new file mode 100644 index 000000000..f7b5fda49 --- /dev/null +++ b/common/repositories/base/base_character_task_timers_repository.h @@ -0,0 +1,336 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_CHARACTER_TASK_TIMERS_REPOSITORY_H +#define EQEMU_BASE_CHARACTER_TASK_TIMERS_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" +#include + +class BaseCharacterTaskTimersRepository { +public: + struct CharacterTaskTimers { + int id; + int character_id; + int task_id; + int timer_type; + time_t expire_time; + }; + + static std::string PrimaryKey() + { + return std::string("id"); + } + + static std::vector Columns() + { + return { + "id", + "character_id", + "task_id", + "timer_type", + "expire_time", + }; + } + + static std::vector SelectColumns() + { + return { + "id", + "character_id", + "task_id", + "timer_type", + "UNIX_TIMESTAMP(expire_time)", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("character_task_timers"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static CharacterTaskTimers NewEntity() + { + CharacterTaskTimers entry{}; + + entry.id = 0; + entry.character_id = 0; + entry.task_id = 0; + entry.timer_type = 0; + entry.expire_time = std::time(nullptr); + + return entry; + } + + static CharacterTaskTimers GetCharacterTaskTimersEntry( + const std::vector &character_task_timerss, + int character_task_timers_id + ) + { + for (auto &character_task_timers : character_task_timerss) { + if (character_task_timers.id == character_task_timers_id) { + return character_task_timers; + } + } + + return NewEntity(); + } + + static CharacterTaskTimers FindOne( + Database& db, + int character_task_timers_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + character_task_timers_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + CharacterTaskTimers entry{}; + + entry.id = atoi(row[0]); + entry.character_id = atoi(row[1]); + entry.task_id = atoi(row[2]); + entry.timer_type = atoi(row[3]); + entry.expire_time = strtoll(row[4], nullptr, 10); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int character_task_timers_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + character_task_timers_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + CharacterTaskTimers character_task_timers_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[1] + " = " + std::to_string(character_task_timers_entry.character_id)); + update_values.push_back(columns[2] + " = " + std::to_string(character_task_timers_entry.task_id)); + update_values.push_back(columns[3] + " = " + std::to_string(character_task_timers_entry.timer_type)); + update_values.push_back(columns[4] + " = FROM_UNIXTIME(" + std::to_string(character_task_timers_entry.expire_time) + ")"); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + character_task_timers_entry.id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static CharacterTaskTimers InsertOne( + Database& db, + CharacterTaskTimers character_task_timers_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(character_task_timers_entry.id)); + insert_values.push_back(std::to_string(character_task_timers_entry.character_id)); + insert_values.push_back(std::to_string(character_task_timers_entry.task_id)); + insert_values.push_back(std::to_string(character_task_timers_entry.timer_type)); + insert_values.push_back("FROM_UNIXTIME(" + std::to_string(character_task_timers_entry.expire_time) + ")"); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + character_task_timers_entry.id = results.LastInsertedID(); + return character_task_timers_entry; + } + + character_task_timers_entry = NewEntity(); + + return character_task_timers_entry; + } + + static int InsertMany( + Database& db, + std::vector character_task_timers_entries + ) + { + std::vector insert_chunks; + + for (auto &character_task_timers_entry: character_task_timers_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(character_task_timers_entry.id)); + insert_values.push_back(std::to_string(character_task_timers_entry.character_id)); + insert_values.push_back(std::to_string(character_task_timers_entry.task_id)); + insert_values.push_back(std::to_string(character_task_timers_entry.timer_type)); + insert_values.push_back("FROM_UNIXTIME(" + std::to_string(character_task_timers_entry.expire_time) + ")"); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CharacterTaskTimers entry{}; + + entry.id = atoi(row[0]); + entry.character_id = atoi(row[1]); + entry.task_id = atoi(row[2]); + entry.timer_type = atoi(row[3]); + entry.expire_time = strtoll(row[4], nullptr, 10); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CharacterTaskTimers entry{}; + + entry.id = atoi(row[0]); + entry.character_id = atoi(row[1]); + entry.task_id = atoi(row[2]); + entry.timer_type = atoi(row[3]); + entry.expire_time = strtoll(row[4], nullptr, 10); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_CHARACTER_TASK_TIMERS_REPOSITORY_H diff --git a/common/repositories/base/base_completed_shared_task_activity_state_repository.h b/common/repositories/base/base_completed_shared_task_activity_state_repository.h new file mode 100644 index 000000000..83244b31d --- /dev/null +++ b/common/repositories/base/base_completed_shared_task_activity_state_repository.h @@ -0,0 +1,337 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_COMPLETED_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H +#define EQEMU_BASE_COMPLETED_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" +#include + +class BaseCompletedSharedTaskActivityStateRepository { +public: + struct CompletedSharedTaskActivityState { + int64 shared_task_id; + int activity_id; + int done_count; + time_t updated_time; + time_t completed_time; + }; + + static std::string PrimaryKey() + { + return std::string("shared_task_id"); + } + + static std::vector Columns() + { + return { + "shared_task_id", + "activity_id", + "done_count", + "updated_time", + "completed_time", + }; + } + + static std::vector SelectColumns() + { + return { + "shared_task_id", + "activity_id", + "done_count", + "UNIX_TIMESTAMP(updated_time)", + "UNIX_TIMESTAMP(completed_time)", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("completed_shared_task_activity_state"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static CompletedSharedTaskActivityState NewEntity() + { + CompletedSharedTaskActivityState entry{}; + + entry.shared_task_id = 0; + entry.activity_id = 0; + entry.done_count = 0; + entry.updated_time = 0; + entry.completed_time = 0; + + return entry; + } + + static CompletedSharedTaskActivityState GetCompletedSharedTaskActivityStateEntry( + const std::vector &completed_shared_task_activity_states, + int completed_shared_task_activity_state_id + ) + { + for (auto &completed_shared_task_activity_state : completed_shared_task_activity_states) { + if (completed_shared_task_activity_state.shared_task_id == completed_shared_task_activity_state_id) { + return completed_shared_task_activity_state; + } + } + + return NewEntity(); + } + + static CompletedSharedTaskActivityState FindOne( + Database& db, + int completed_shared_task_activity_state_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + completed_shared_task_activity_state_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + CompletedSharedTaskActivityState entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.activity_id = atoi(row[1]); + entry.done_count = atoi(row[2]); + entry.updated_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completed_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int completed_shared_task_activity_state_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + completed_shared_task_activity_state_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + CompletedSharedTaskActivityState completed_shared_task_activity_state_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[0] + " = " + std::to_string(completed_shared_task_activity_state_entry.shared_task_id)); + update_values.push_back(columns[1] + " = " + std::to_string(completed_shared_task_activity_state_entry.activity_id)); + update_values.push_back(columns[2] + " = " + std::to_string(completed_shared_task_activity_state_entry.done_count)); + update_values.push_back(columns[3] + " = FROM_UNIXTIME(" + (completed_shared_task_activity_state_entry.updated_time > 0 ? std::to_string(completed_shared_task_activity_state_entry.updated_time) : "null") + ")"); + update_values.push_back(columns[4] + " = FROM_UNIXTIME(" + (completed_shared_task_activity_state_entry.completed_time > 0 ? std::to_string(completed_shared_task_activity_state_entry.completed_time) : "null") + ")"); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + completed_shared_task_activity_state_entry.shared_task_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static CompletedSharedTaskActivityState InsertOne( + Database& db, + CompletedSharedTaskActivityState completed_shared_task_activity_state_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(completed_shared_task_activity_state_entry.shared_task_id)); + insert_values.push_back(std::to_string(completed_shared_task_activity_state_entry.activity_id)); + insert_values.push_back(std::to_string(completed_shared_task_activity_state_entry.done_count)); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_task_activity_state_entry.updated_time > 0 ? std::to_string(completed_shared_task_activity_state_entry.updated_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_task_activity_state_entry.completed_time > 0 ? std::to_string(completed_shared_task_activity_state_entry.completed_time) : "null") + ")"); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + completed_shared_task_activity_state_entry.shared_task_id = results.LastInsertedID(); + return completed_shared_task_activity_state_entry; + } + + completed_shared_task_activity_state_entry = NewEntity(); + + return completed_shared_task_activity_state_entry; + } + + static int InsertMany( + Database& db, + std::vector completed_shared_task_activity_state_entries + ) + { + std::vector insert_chunks; + + for (auto &completed_shared_task_activity_state_entry: completed_shared_task_activity_state_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(completed_shared_task_activity_state_entry.shared_task_id)); + insert_values.push_back(std::to_string(completed_shared_task_activity_state_entry.activity_id)); + insert_values.push_back(std::to_string(completed_shared_task_activity_state_entry.done_count)); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_task_activity_state_entry.updated_time > 0 ? std::to_string(completed_shared_task_activity_state_entry.updated_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_task_activity_state_entry.completed_time > 0 ? std::to_string(completed_shared_task_activity_state_entry.completed_time) : "null") + ")"); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CompletedSharedTaskActivityState entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.activity_id = atoi(row[1]); + entry.done_count = atoi(row[2]); + entry.updated_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completed_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CompletedSharedTaskActivityState entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.activity_id = atoi(row[1]); + entry.done_count = atoi(row[2]); + entry.updated_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completed_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_COMPLETED_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H diff --git a/common/repositories/base/base_completed_shared_task_members_repository.h b/common/repositories/base/base_completed_shared_task_members_repository.h new file mode 100644 index 000000000..05f72ce3a --- /dev/null +++ b/common/repositories/base/base_completed_shared_task_members_repository.h @@ -0,0 +1,317 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_COMPLETED_SHARED_TASK_MEMBERS_REPOSITORY_H +#define EQEMU_BASE_COMPLETED_SHARED_TASK_MEMBERS_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" +#include + +class BaseCompletedSharedTaskMembersRepository { +public: + struct CompletedSharedTaskMembers { + int64 shared_task_id; + int64 character_id; + int is_leader; + }; + + static std::string PrimaryKey() + { + return std::string("shared_task_id"); + } + + static std::vector Columns() + { + return { + "shared_task_id", + "character_id", + "is_leader", + }; + } + + static std::vector SelectColumns() + { + return { + "shared_task_id", + "character_id", + "is_leader", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("completed_shared_task_members"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static CompletedSharedTaskMembers NewEntity() + { + CompletedSharedTaskMembers entry{}; + + entry.shared_task_id = 0; + entry.character_id = 0; + entry.is_leader = 0; + + return entry; + } + + static CompletedSharedTaskMembers GetCompletedSharedTaskMembersEntry( + const std::vector &completed_shared_task_memberss, + int completed_shared_task_members_id + ) + { + for (auto &completed_shared_task_members : completed_shared_task_memberss) { + if (completed_shared_task_members.shared_task_id == completed_shared_task_members_id) { + return completed_shared_task_members; + } + } + + return NewEntity(); + } + + static CompletedSharedTaskMembers FindOne( + Database& db, + int completed_shared_task_members_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + completed_shared_task_members_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + CompletedSharedTaskMembers entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.character_id = strtoll(row[1], nullptr, 10); + entry.is_leader = atoi(row[2]); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int completed_shared_task_members_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + completed_shared_task_members_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + CompletedSharedTaskMembers completed_shared_task_members_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[0] + " = " + std::to_string(completed_shared_task_members_entry.shared_task_id)); + update_values.push_back(columns[1] + " = " + std::to_string(completed_shared_task_members_entry.character_id)); + update_values.push_back(columns[2] + " = " + std::to_string(completed_shared_task_members_entry.is_leader)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + completed_shared_task_members_entry.shared_task_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static CompletedSharedTaskMembers InsertOne( + Database& db, + CompletedSharedTaskMembers completed_shared_task_members_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(completed_shared_task_members_entry.shared_task_id)); + insert_values.push_back(std::to_string(completed_shared_task_members_entry.character_id)); + insert_values.push_back(std::to_string(completed_shared_task_members_entry.is_leader)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + completed_shared_task_members_entry.shared_task_id = results.LastInsertedID(); + return completed_shared_task_members_entry; + } + + completed_shared_task_members_entry = NewEntity(); + + return completed_shared_task_members_entry; + } + + static int InsertMany( + Database& db, + std::vector completed_shared_task_members_entries + ) + { + std::vector insert_chunks; + + for (auto &completed_shared_task_members_entry: completed_shared_task_members_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(completed_shared_task_members_entry.shared_task_id)); + insert_values.push_back(std::to_string(completed_shared_task_members_entry.character_id)); + insert_values.push_back(std::to_string(completed_shared_task_members_entry.is_leader)); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CompletedSharedTaskMembers entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.character_id = strtoll(row[1], nullptr, 10); + entry.is_leader = atoi(row[2]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CompletedSharedTaskMembers entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.character_id = strtoll(row[1], nullptr, 10); + entry.is_leader = atoi(row[2]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_COMPLETED_SHARED_TASK_MEMBERS_REPOSITORY_H diff --git a/common/repositories/base/base_completed_shared_tasks_repository.h b/common/repositories/base/base_completed_shared_tasks_repository.h new file mode 100644 index 000000000..9c1e3a87d --- /dev/null +++ b/common/repositories/base/base_completed_shared_tasks_repository.h @@ -0,0 +1,347 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_COMPLETED_SHARED_TASKS_REPOSITORY_H +#define EQEMU_BASE_COMPLETED_SHARED_TASKS_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" +#include + +class BaseCompletedSharedTasksRepository { +public: + struct CompletedSharedTasks { + int64 id; + int task_id; + time_t accepted_time; + time_t expire_time; + time_t completion_time; + int is_locked; + }; + + static std::string PrimaryKey() + { + return std::string("id"); + } + + static std::vector Columns() + { + return { + "id", + "task_id", + "accepted_time", + "expire_time", + "completion_time", + "is_locked", + }; + } + + static std::vector SelectColumns() + { + return { + "id", + "task_id", + "UNIX_TIMESTAMP(accepted_time)", + "UNIX_TIMESTAMP(expire_time)", + "UNIX_TIMESTAMP(completion_time)", + "is_locked", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("completed_shared_tasks"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static CompletedSharedTasks NewEntity() + { + CompletedSharedTasks entry{}; + + entry.id = 0; + entry.task_id = 0; + entry.accepted_time = 0; + entry.expire_time = 0; + entry.completion_time = 0; + entry.is_locked = 0; + + return entry; + } + + static CompletedSharedTasks GetCompletedSharedTasksEntry( + const std::vector &completed_shared_taskss, + int completed_shared_tasks_id + ) + { + for (auto &completed_shared_tasks : completed_shared_taskss) { + if (completed_shared_tasks.id == completed_shared_tasks_id) { + return completed_shared_tasks; + } + } + + return NewEntity(); + } + + static CompletedSharedTasks FindOne( + Database& db, + int completed_shared_tasks_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + completed_shared_tasks_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + CompletedSharedTasks entry{}; + + entry.id = strtoll(row[0], nullptr, 10); + entry.task_id = atoi(row[1]); + entry.accepted_time = strtoll(row[2] ? row[2] : "-1", nullptr, 10); + entry.expire_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completion_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + entry.is_locked = atoi(row[5]); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int completed_shared_tasks_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + completed_shared_tasks_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + CompletedSharedTasks completed_shared_tasks_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[0] + " = " + std::to_string(completed_shared_tasks_entry.id)); + update_values.push_back(columns[1] + " = " + std::to_string(completed_shared_tasks_entry.task_id)); + update_values.push_back(columns[2] + " = FROM_UNIXTIME(" + (completed_shared_tasks_entry.accepted_time > 0 ? std::to_string(completed_shared_tasks_entry.accepted_time) : "null") + ")"); + update_values.push_back(columns[3] + " = FROM_UNIXTIME(" + (completed_shared_tasks_entry.expire_time > 0 ? std::to_string(completed_shared_tasks_entry.expire_time) : "null") + ")"); + update_values.push_back(columns[4] + " = FROM_UNIXTIME(" + (completed_shared_tasks_entry.completion_time > 0 ? std::to_string(completed_shared_tasks_entry.completion_time) : "null") + ")"); + update_values.push_back(columns[5] + " = " + std::to_string(completed_shared_tasks_entry.is_locked)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + completed_shared_tasks_entry.id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static CompletedSharedTasks InsertOne( + Database& db, + CompletedSharedTasks completed_shared_tasks_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(completed_shared_tasks_entry.id)); + insert_values.push_back(std::to_string(completed_shared_tasks_entry.task_id)); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_tasks_entry.accepted_time > 0 ? std::to_string(completed_shared_tasks_entry.accepted_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_tasks_entry.expire_time > 0 ? std::to_string(completed_shared_tasks_entry.expire_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_tasks_entry.completion_time > 0 ? std::to_string(completed_shared_tasks_entry.completion_time) : "null") + ")"); + insert_values.push_back(std::to_string(completed_shared_tasks_entry.is_locked)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + completed_shared_tasks_entry.id = results.LastInsertedID(); + return completed_shared_tasks_entry; + } + + completed_shared_tasks_entry = NewEntity(); + + return completed_shared_tasks_entry; + } + + static int InsertMany( + Database& db, + std::vector completed_shared_tasks_entries + ) + { + std::vector insert_chunks; + + for (auto &completed_shared_tasks_entry: completed_shared_tasks_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(completed_shared_tasks_entry.id)); + insert_values.push_back(std::to_string(completed_shared_tasks_entry.task_id)); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_tasks_entry.accepted_time > 0 ? std::to_string(completed_shared_tasks_entry.accepted_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_tasks_entry.expire_time > 0 ? std::to_string(completed_shared_tasks_entry.expire_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (completed_shared_tasks_entry.completion_time > 0 ? std::to_string(completed_shared_tasks_entry.completion_time) : "null") + ")"); + insert_values.push_back(std::to_string(completed_shared_tasks_entry.is_locked)); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CompletedSharedTasks entry{}; + + entry.id = strtoll(row[0], nullptr, 10); + entry.task_id = atoi(row[1]); + entry.accepted_time = strtoll(row[2] ? row[2] : "-1", nullptr, 10); + entry.expire_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completion_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + entry.is_locked = atoi(row[5]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + CompletedSharedTasks entry{}; + + entry.id = strtoll(row[0], nullptr, 10); + entry.task_id = atoi(row[1]); + entry.accepted_time = strtoll(row[2] ? row[2] : "-1", nullptr, 10); + entry.expire_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completion_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + entry.is_locked = atoi(row[5]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_COMPLETED_SHARED_TASKS_REPOSITORY_H diff --git a/common/repositories/base/base_dynamic_zone_members_repository.h b/common/repositories/base/base_dynamic_zone_members_repository.h index 07fee6723..b0f41ca08 100644 --- a/common/repositories/base/base_dynamic_zone_members_repository.h +++ b/common/repositories/base/base_dynamic_zone_members_repository.h @@ -21,7 +21,6 @@ public: int id; int dynamic_zone_id; int character_id; - int is_current_member; }; static std::string PrimaryKey() @@ -35,7 +34,6 @@ public: "id", "dynamic_zone_id", "character_id", - "is_current_member", }; } @@ -71,10 +69,9 @@ public: { DynamicZoneMembers entry{}; - entry.id = 0; - entry.dynamic_zone_id = 0; - entry.character_id = 0; - entry.is_current_member = 1; + entry.id = 0; + entry.dynamic_zone_id = 0; + entry.character_id = 0; return entry; } @@ -110,10 +107,9 @@ public: if (results.RowCount() == 1) { DynamicZoneMembers entry{}; - entry.id = atoi(row[0]); - entry.dynamic_zone_id = atoi(row[1]); - entry.character_id = atoi(row[2]); - entry.is_current_member = atoi(row[3]); + entry.id = atoi(row[0]); + entry.dynamic_zone_id = atoi(row[1]); + entry.character_id = atoi(row[2]); return entry; } @@ -149,7 +145,6 @@ public: update_values.push_back(columns[1] + " = " + std::to_string(dynamic_zone_members_entry.dynamic_zone_id)); update_values.push_back(columns[2] + " = " + std::to_string(dynamic_zone_members_entry.character_id)); - update_values.push_back(columns[3] + " = " + std::to_string(dynamic_zone_members_entry.is_current_member)); auto results = db.QueryDatabase( fmt::format( @@ -174,7 +169,6 @@ public: insert_values.push_back(std::to_string(dynamic_zone_members_entry.id)); insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id)); insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id)); - insert_values.push_back(std::to_string(dynamic_zone_members_entry.is_current_member)); auto results = db.QueryDatabase( fmt::format( @@ -207,7 +201,6 @@ public: insert_values.push_back(std::to_string(dynamic_zone_members_entry.id)); insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id)); insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id)); - insert_values.push_back(std::to_string(dynamic_zone_members_entry.is_current_member)); insert_chunks.push_back("(" + implode(",", insert_values) + ")"); } @@ -241,10 +234,9 @@ public: for (auto row = results.begin(); row != results.end(); ++row) { DynamicZoneMembers entry{}; - entry.id = atoi(row[0]); - entry.dynamic_zone_id = atoi(row[1]); - entry.character_id = atoi(row[2]); - entry.is_current_member = atoi(row[3]); + entry.id = atoi(row[0]); + entry.dynamic_zone_id = atoi(row[1]); + entry.character_id = atoi(row[2]); all_entries.push_back(entry); } @@ -269,10 +261,9 @@ public: for (auto row = results.begin(); row != results.end(); ++row) { DynamicZoneMembers entry{}; - entry.id = atoi(row[0]); - entry.dynamic_zone_id = atoi(row[1]); - entry.character_id = atoi(row[2]); - entry.is_current_member = atoi(row[3]); + entry.id = atoi(row[0]); + entry.dynamic_zone_id = atoi(row[1]); + entry.character_id = atoi(row[2]); all_entries.push_back(entry); } diff --git a/common/repositories/base/base_dynamic_zones_repository.h b/common/repositories/base/base_dynamic_zones_repository.h index 283ecd754..a6f43bb73 100644 --- a/common/repositories/base/base_dynamic_zones_repository.h +++ b/common/repositories/base/base_dynamic_zones_repository.h @@ -18,23 +18,28 @@ class BaseDynamicZonesRepository { public: struct DynamicZones { - int id; - int instance_id; - int type; - int compass_zone_id; - float compass_x; - float compass_y; - float compass_z; - int safe_return_zone_id; - float safe_return_x; - float safe_return_y; - float safe_return_z; - float safe_return_heading; - float zone_in_x; - float zone_in_y; - float zone_in_z; - float zone_in_heading; - int has_zone_in; + int id; + int instance_id; + int type; + std::string uuid; + std::string name; + int leader_id; + int min_players; + int max_players; + int compass_zone_id; + float compass_x; + float compass_y; + float compass_z; + int safe_return_zone_id; + float safe_return_x; + float safe_return_y; + float safe_return_z; + float safe_return_heading; + float zone_in_x; + float zone_in_y; + float zone_in_z; + float zone_in_heading; + int has_zone_in; }; static std::string PrimaryKey() @@ -48,6 +53,11 @@ public: "id", "instance_id", "type", + "uuid", + "name", + "leader_id", + "min_players", + "max_players", "compass_zone_id", "compass_x", "compass_y", @@ -100,6 +110,11 @@ public: entry.id = 0; entry.instance_id = 0; entry.type = 0; + entry.uuid = ""; + entry.name = ""; + entry.leader_id = 0; + entry.min_players = 0; + entry.max_players = 0; entry.compass_zone_id = 0; entry.compass_x = 0; entry.compass_y = 0; @@ -152,20 +167,25 @@ public: entry.id = atoi(row[0]); entry.instance_id = atoi(row[1]); entry.type = atoi(row[2]); - entry.compass_zone_id = atoi(row[3]); - entry.compass_x = static_cast(atof(row[4])); - entry.compass_y = static_cast(atof(row[5])); - entry.compass_z = static_cast(atof(row[6])); - entry.safe_return_zone_id = atoi(row[7]); - entry.safe_return_x = static_cast(atof(row[8])); - entry.safe_return_y = static_cast(atof(row[9])); - entry.safe_return_z = static_cast(atof(row[10])); - entry.safe_return_heading = static_cast(atof(row[11])); - entry.zone_in_x = static_cast(atof(row[12])); - entry.zone_in_y = static_cast(atof(row[13])); - entry.zone_in_z = static_cast(atof(row[14])); - entry.zone_in_heading = static_cast(atof(row[15])); - entry.has_zone_in = atoi(row[16]); + entry.uuid = row[3] ? row[3] : ""; + entry.name = row[4] ? row[4] : ""; + entry.leader_id = atoi(row[5]); + entry.min_players = atoi(row[6]); + entry.max_players = atoi(row[7]); + entry.compass_zone_id = atoi(row[8]); + entry.compass_x = static_cast(atof(row[9])); + entry.compass_y = static_cast(atof(row[10])); + entry.compass_z = static_cast(atof(row[11])); + entry.safe_return_zone_id = atoi(row[12]); + entry.safe_return_x = static_cast(atof(row[13])); + entry.safe_return_y = static_cast(atof(row[14])); + entry.safe_return_z = static_cast(atof(row[15])); + entry.safe_return_heading = static_cast(atof(row[16])); + entry.zone_in_x = static_cast(atof(row[17])); + entry.zone_in_y = static_cast(atof(row[18])); + entry.zone_in_z = static_cast(atof(row[19])); + entry.zone_in_heading = static_cast(atof(row[20])); + entry.has_zone_in = atoi(row[21]); return entry; } @@ -201,20 +221,25 @@ public: update_values.push_back(columns[1] + " = " + std::to_string(dynamic_zones_entry.instance_id)); update_values.push_back(columns[2] + " = " + std::to_string(dynamic_zones_entry.type)); - update_values.push_back(columns[3] + " = " + std::to_string(dynamic_zones_entry.compass_zone_id)); - update_values.push_back(columns[4] + " = " + std::to_string(dynamic_zones_entry.compass_x)); - update_values.push_back(columns[5] + " = " + std::to_string(dynamic_zones_entry.compass_y)); - update_values.push_back(columns[6] + " = " + std::to_string(dynamic_zones_entry.compass_z)); - update_values.push_back(columns[7] + " = " + std::to_string(dynamic_zones_entry.safe_return_zone_id)); - update_values.push_back(columns[8] + " = " + std::to_string(dynamic_zones_entry.safe_return_x)); - update_values.push_back(columns[9] + " = " + std::to_string(dynamic_zones_entry.safe_return_y)); - update_values.push_back(columns[10] + " = " + std::to_string(dynamic_zones_entry.safe_return_z)); - update_values.push_back(columns[11] + " = " + std::to_string(dynamic_zones_entry.safe_return_heading)); - update_values.push_back(columns[12] + " = " + std::to_string(dynamic_zones_entry.zone_in_x)); - update_values.push_back(columns[13] + " = " + std::to_string(dynamic_zones_entry.zone_in_y)); - update_values.push_back(columns[14] + " = " + std::to_string(dynamic_zones_entry.zone_in_z)); - update_values.push_back(columns[15] + " = " + std::to_string(dynamic_zones_entry.zone_in_heading)); - update_values.push_back(columns[16] + " = " + std::to_string(dynamic_zones_entry.has_zone_in)); + update_values.push_back(columns[3] + " = '" + EscapeString(dynamic_zones_entry.uuid) + "'"); + update_values.push_back(columns[4] + " = '" + EscapeString(dynamic_zones_entry.name) + "'"); + update_values.push_back(columns[5] + " = " + std::to_string(dynamic_zones_entry.leader_id)); + update_values.push_back(columns[6] + " = " + std::to_string(dynamic_zones_entry.min_players)); + update_values.push_back(columns[7] + " = " + std::to_string(dynamic_zones_entry.max_players)); + update_values.push_back(columns[8] + " = " + std::to_string(dynamic_zones_entry.compass_zone_id)); + update_values.push_back(columns[9] + " = " + std::to_string(dynamic_zones_entry.compass_x)); + update_values.push_back(columns[10] + " = " + std::to_string(dynamic_zones_entry.compass_y)); + update_values.push_back(columns[11] + " = " + std::to_string(dynamic_zones_entry.compass_z)); + update_values.push_back(columns[12] + " = " + std::to_string(dynamic_zones_entry.safe_return_zone_id)); + update_values.push_back(columns[13] + " = " + std::to_string(dynamic_zones_entry.safe_return_x)); + update_values.push_back(columns[14] + " = " + std::to_string(dynamic_zones_entry.safe_return_y)); + update_values.push_back(columns[15] + " = " + std::to_string(dynamic_zones_entry.safe_return_z)); + update_values.push_back(columns[16] + " = " + std::to_string(dynamic_zones_entry.safe_return_heading)); + update_values.push_back(columns[17] + " = " + std::to_string(dynamic_zones_entry.zone_in_x)); + update_values.push_back(columns[18] + " = " + std::to_string(dynamic_zones_entry.zone_in_y)); + update_values.push_back(columns[19] + " = " + std::to_string(dynamic_zones_entry.zone_in_z)); + update_values.push_back(columns[20] + " = " + std::to_string(dynamic_zones_entry.zone_in_heading)); + update_values.push_back(columns[21] + " = " + std::to_string(dynamic_zones_entry.has_zone_in)); auto results = db.QueryDatabase( fmt::format( @@ -239,6 +264,11 @@ public: insert_values.push_back(std::to_string(dynamic_zones_entry.id)); insert_values.push_back(std::to_string(dynamic_zones_entry.instance_id)); insert_values.push_back(std::to_string(dynamic_zones_entry.type)); + insert_values.push_back("'" + EscapeString(dynamic_zones_entry.uuid) + "'"); + insert_values.push_back("'" + EscapeString(dynamic_zones_entry.name) + "'"); + insert_values.push_back(std::to_string(dynamic_zones_entry.leader_id)); + insert_values.push_back(std::to_string(dynamic_zones_entry.min_players)); + insert_values.push_back(std::to_string(dynamic_zones_entry.max_players)); insert_values.push_back(std::to_string(dynamic_zones_entry.compass_zone_id)); insert_values.push_back(std::to_string(dynamic_zones_entry.compass_x)); insert_values.push_back(std::to_string(dynamic_zones_entry.compass_y)); @@ -285,6 +315,11 @@ public: insert_values.push_back(std::to_string(dynamic_zones_entry.id)); insert_values.push_back(std::to_string(dynamic_zones_entry.instance_id)); insert_values.push_back(std::to_string(dynamic_zones_entry.type)); + insert_values.push_back("'" + EscapeString(dynamic_zones_entry.uuid) + "'"); + insert_values.push_back("'" + EscapeString(dynamic_zones_entry.name) + "'"); + insert_values.push_back(std::to_string(dynamic_zones_entry.leader_id)); + insert_values.push_back(std::to_string(dynamic_zones_entry.min_players)); + insert_values.push_back(std::to_string(dynamic_zones_entry.max_players)); insert_values.push_back(std::to_string(dynamic_zones_entry.compass_zone_id)); insert_values.push_back(std::to_string(dynamic_zones_entry.compass_x)); insert_values.push_back(std::to_string(dynamic_zones_entry.compass_y)); @@ -335,20 +370,25 @@ public: entry.id = atoi(row[0]); entry.instance_id = atoi(row[1]); entry.type = atoi(row[2]); - entry.compass_zone_id = atoi(row[3]); - entry.compass_x = static_cast(atof(row[4])); - entry.compass_y = static_cast(atof(row[5])); - entry.compass_z = static_cast(atof(row[6])); - entry.safe_return_zone_id = atoi(row[7]); - entry.safe_return_x = static_cast(atof(row[8])); - entry.safe_return_y = static_cast(atof(row[9])); - entry.safe_return_z = static_cast(atof(row[10])); - entry.safe_return_heading = static_cast(atof(row[11])); - entry.zone_in_x = static_cast(atof(row[12])); - entry.zone_in_y = static_cast(atof(row[13])); - entry.zone_in_z = static_cast(atof(row[14])); - entry.zone_in_heading = static_cast(atof(row[15])); - entry.has_zone_in = atoi(row[16]); + entry.uuid = row[3] ? row[3] : ""; + entry.name = row[4] ? row[4] : ""; + entry.leader_id = atoi(row[5]); + entry.min_players = atoi(row[6]); + entry.max_players = atoi(row[7]); + entry.compass_zone_id = atoi(row[8]); + entry.compass_x = static_cast(atof(row[9])); + entry.compass_y = static_cast(atof(row[10])); + entry.compass_z = static_cast(atof(row[11])); + entry.safe_return_zone_id = atoi(row[12]); + entry.safe_return_x = static_cast(atof(row[13])); + entry.safe_return_y = static_cast(atof(row[14])); + entry.safe_return_z = static_cast(atof(row[15])); + entry.safe_return_heading = static_cast(atof(row[16])); + entry.zone_in_x = static_cast(atof(row[17])); + entry.zone_in_y = static_cast(atof(row[18])); + entry.zone_in_z = static_cast(atof(row[19])); + entry.zone_in_heading = static_cast(atof(row[20])); + entry.has_zone_in = atoi(row[21]); all_entries.push_back(entry); } @@ -376,20 +416,25 @@ public: entry.id = atoi(row[0]); entry.instance_id = atoi(row[1]); entry.type = atoi(row[2]); - entry.compass_zone_id = atoi(row[3]); - entry.compass_x = static_cast(atof(row[4])); - entry.compass_y = static_cast(atof(row[5])); - entry.compass_z = static_cast(atof(row[6])); - entry.safe_return_zone_id = atoi(row[7]); - entry.safe_return_x = static_cast(atof(row[8])); - entry.safe_return_y = static_cast(atof(row[9])); - entry.safe_return_z = static_cast(atof(row[10])); - entry.safe_return_heading = static_cast(atof(row[11])); - entry.zone_in_x = static_cast(atof(row[12])); - entry.zone_in_y = static_cast(atof(row[13])); - entry.zone_in_z = static_cast(atof(row[14])); - entry.zone_in_heading = static_cast(atof(row[15])); - entry.has_zone_in = atoi(row[16]); + entry.uuid = row[3] ? row[3] : ""; + entry.name = row[4] ? row[4] : ""; + entry.leader_id = atoi(row[5]); + entry.min_players = atoi(row[6]); + entry.max_players = atoi(row[7]); + entry.compass_zone_id = atoi(row[8]); + entry.compass_x = static_cast(atof(row[9])); + entry.compass_y = static_cast(atof(row[10])); + entry.compass_z = static_cast(atof(row[11])); + entry.safe_return_zone_id = atoi(row[12]); + entry.safe_return_x = static_cast(atof(row[13])); + entry.safe_return_y = static_cast(atof(row[14])); + entry.safe_return_z = static_cast(atof(row[15])); + entry.safe_return_heading = static_cast(atof(row[16])); + entry.zone_in_x = static_cast(atof(row[17])); + entry.zone_in_y = static_cast(atof(row[18])); + entry.zone_in_z = static_cast(atof(row[19])); + entry.zone_in_heading = static_cast(atof(row[20])); + entry.has_zone_in = atoi(row[21]); all_entries.push_back(entry); } diff --git a/common/repositories/base/base_expeditions_repository.h b/common/repositories/base/base_expeditions_repository.h index fb8007339..f77be8bfa 100644 --- a/common/repositories/base/base_expeditions_repository.h +++ b/common/repositories/base/base_expeditions_repository.h @@ -18,15 +18,10 @@ class BaseExpeditionsRepository { public: struct Expeditions { - int id; - std::string uuid; - int dynamic_zone_id; - std::string expedition_name; - int leader_id; - int min_players; - int max_players; - int add_replay_on_join; - int is_locked; + int id; + int dynamic_zone_id; + int add_replay_on_join; + int is_locked; }; static std::string PrimaryKey() @@ -38,12 +33,7 @@ public: { return { "id", - "uuid", "dynamic_zone_id", - "expedition_name", - "leader_id", - "min_players", - "max_players", "add_replay_on_join", "is_locked", }; @@ -82,12 +72,7 @@ public: Expeditions entry{}; entry.id = 0; - entry.uuid = ""; entry.dynamic_zone_id = 0; - entry.expedition_name = ""; - entry.leader_id = 0; - entry.min_players = 0; - entry.max_players = 0; entry.add_replay_on_join = 1; entry.is_locked = 0; @@ -126,14 +111,9 @@ public: Expeditions entry{}; entry.id = atoi(row[0]); - entry.uuid = row[1] ? row[1] : ""; - entry.dynamic_zone_id = atoi(row[2]); - entry.expedition_name = row[3] ? row[3] : ""; - entry.leader_id = atoi(row[4]); - entry.min_players = atoi(row[5]); - entry.max_players = atoi(row[6]); - entry.add_replay_on_join = atoi(row[7]); - entry.is_locked = atoi(row[8]); + entry.dynamic_zone_id = atoi(row[1]); + entry.add_replay_on_join = atoi(row[2]); + entry.is_locked = atoi(row[3]); return entry; } @@ -167,14 +147,9 @@ public: auto columns = Columns(); - update_values.push_back(columns[1] + " = '" + EscapeString(expeditions_entry.uuid) + "'"); - update_values.push_back(columns[2] + " = " + std::to_string(expeditions_entry.dynamic_zone_id)); - update_values.push_back(columns[3] + " = '" + EscapeString(expeditions_entry.expedition_name) + "'"); - update_values.push_back(columns[4] + " = " + std::to_string(expeditions_entry.leader_id)); - update_values.push_back(columns[5] + " = " + std::to_string(expeditions_entry.min_players)); - update_values.push_back(columns[6] + " = " + std::to_string(expeditions_entry.max_players)); - update_values.push_back(columns[7] + " = " + std::to_string(expeditions_entry.add_replay_on_join)); - update_values.push_back(columns[8] + " = " + std::to_string(expeditions_entry.is_locked)); + update_values.push_back(columns[1] + " = " + std::to_string(expeditions_entry.dynamic_zone_id)); + update_values.push_back(columns[2] + " = " + std::to_string(expeditions_entry.add_replay_on_join)); + update_values.push_back(columns[3] + " = " + std::to_string(expeditions_entry.is_locked)); auto results = db.QueryDatabase( fmt::format( @@ -197,12 +172,7 @@ public: std::vector insert_values; insert_values.push_back(std::to_string(expeditions_entry.id)); - insert_values.push_back("'" + EscapeString(expeditions_entry.uuid) + "'"); insert_values.push_back(std::to_string(expeditions_entry.dynamic_zone_id)); - insert_values.push_back("'" + EscapeString(expeditions_entry.expedition_name) + "'"); - insert_values.push_back(std::to_string(expeditions_entry.leader_id)); - insert_values.push_back(std::to_string(expeditions_entry.min_players)); - insert_values.push_back(std::to_string(expeditions_entry.max_players)); insert_values.push_back(std::to_string(expeditions_entry.add_replay_on_join)); insert_values.push_back(std::to_string(expeditions_entry.is_locked)); @@ -235,12 +205,7 @@ public: std::vector insert_values; insert_values.push_back(std::to_string(expeditions_entry.id)); - insert_values.push_back("'" + EscapeString(expeditions_entry.uuid) + "'"); insert_values.push_back(std::to_string(expeditions_entry.dynamic_zone_id)); - insert_values.push_back("'" + EscapeString(expeditions_entry.expedition_name) + "'"); - insert_values.push_back(std::to_string(expeditions_entry.leader_id)); - insert_values.push_back(std::to_string(expeditions_entry.min_players)); - insert_values.push_back(std::to_string(expeditions_entry.max_players)); insert_values.push_back(std::to_string(expeditions_entry.add_replay_on_join)); insert_values.push_back(std::to_string(expeditions_entry.is_locked)); @@ -277,14 +242,9 @@ public: Expeditions entry{}; entry.id = atoi(row[0]); - entry.uuid = row[1] ? row[1] : ""; - entry.dynamic_zone_id = atoi(row[2]); - entry.expedition_name = row[3] ? row[3] : ""; - entry.leader_id = atoi(row[4]); - entry.min_players = atoi(row[5]); - entry.max_players = atoi(row[6]); - entry.add_replay_on_join = atoi(row[7]); - entry.is_locked = atoi(row[8]); + entry.dynamic_zone_id = atoi(row[1]); + entry.add_replay_on_join = atoi(row[2]); + entry.is_locked = atoi(row[3]); all_entries.push_back(entry); } @@ -310,14 +270,9 @@ public: Expeditions entry{}; entry.id = atoi(row[0]); - entry.uuid = row[1] ? row[1] : ""; - entry.dynamic_zone_id = atoi(row[2]); - entry.expedition_name = row[3] ? row[3] : ""; - entry.leader_id = atoi(row[4]); - entry.min_players = atoi(row[5]); - entry.max_players = atoi(row[6]); - entry.add_replay_on_join = atoi(row[7]); - entry.is_locked = atoi(row[8]); + entry.dynamic_zone_id = atoi(row[1]); + entry.add_replay_on_join = atoi(row[2]); + entry.is_locked = atoi(row[3]); all_entries.push_back(entry); } diff --git a/common/repositories/base/base_shared_task_activity_state_repository.h b/common/repositories/base/base_shared_task_activity_state_repository.h new file mode 100644 index 000000000..e599f3cb7 --- /dev/null +++ b/common/repositories/base/base_shared_task_activity_state_repository.h @@ -0,0 +1,337 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H +#define EQEMU_BASE_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" +#include + +class BaseSharedTaskActivityStateRepository { +public: + struct SharedTaskActivityState { + int64 shared_task_id; + int activity_id; + int done_count; + time_t updated_time; + time_t completed_time; + }; + + static std::string PrimaryKey() + { + return std::string("shared_task_id"); + } + + static std::vector Columns() + { + return { + "shared_task_id", + "activity_id", + "done_count", + "updated_time", + "completed_time", + }; + } + + static std::vector SelectColumns() + { + return { + "shared_task_id", + "activity_id", + "done_count", + "UNIX_TIMESTAMP(updated_time)", + "UNIX_TIMESTAMP(completed_time)", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("shared_task_activity_state"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static SharedTaskActivityState NewEntity() + { + SharedTaskActivityState entry{}; + + entry.shared_task_id = 0; + entry.activity_id = 0; + entry.done_count = 0; + entry.updated_time = 0; + entry.completed_time = 0; + + return entry; + } + + static SharedTaskActivityState GetSharedTaskActivityStateEntry( + const std::vector &shared_task_activity_states, + int shared_task_activity_state_id + ) + { + for (auto &shared_task_activity_state : shared_task_activity_states) { + if (shared_task_activity_state.shared_task_id == shared_task_activity_state_id) { + return shared_task_activity_state; + } + } + + return NewEntity(); + } + + static SharedTaskActivityState FindOne( + Database& db, + int shared_task_activity_state_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + shared_task_activity_state_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + SharedTaskActivityState entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.activity_id = atoi(row[1]); + entry.done_count = atoi(row[2]); + entry.updated_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completed_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int shared_task_activity_state_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + shared_task_activity_state_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + SharedTaskActivityState shared_task_activity_state_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[0] + " = " + std::to_string(shared_task_activity_state_entry.shared_task_id)); + update_values.push_back(columns[1] + " = " + std::to_string(shared_task_activity_state_entry.activity_id)); + update_values.push_back(columns[2] + " = " + std::to_string(shared_task_activity_state_entry.done_count)); + update_values.push_back(columns[3] + " = FROM_UNIXTIME(" + (shared_task_activity_state_entry.updated_time > 0 ? std::to_string(shared_task_activity_state_entry.updated_time) : "null") + ")"); + update_values.push_back(columns[4] + " = FROM_UNIXTIME(" + (shared_task_activity_state_entry.completed_time > 0 ? std::to_string(shared_task_activity_state_entry.completed_time) : "null") + ")"); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + shared_task_activity_state_entry.shared_task_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static SharedTaskActivityState InsertOne( + Database& db, + SharedTaskActivityState shared_task_activity_state_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_task_activity_state_entry.shared_task_id)); + insert_values.push_back(std::to_string(shared_task_activity_state_entry.activity_id)); + insert_values.push_back(std::to_string(shared_task_activity_state_entry.done_count)); + insert_values.push_back("FROM_UNIXTIME(" + (shared_task_activity_state_entry.updated_time > 0 ? std::to_string(shared_task_activity_state_entry.updated_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (shared_task_activity_state_entry.completed_time > 0 ? std::to_string(shared_task_activity_state_entry.completed_time) : "null") + ")"); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + shared_task_activity_state_entry.shared_task_id = results.LastInsertedID(); + return shared_task_activity_state_entry; + } + + shared_task_activity_state_entry = NewEntity(); + + return shared_task_activity_state_entry; + } + + static int InsertMany( + Database& db, + std::vector shared_task_activity_state_entries + ) + { + std::vector insert_chunks; + + for (auto &shared_task_activity_state_entry: shared_task_activity_state_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_task_activity_state_entry.shared_task_id)); + insert_values.push_back(std::to_string(shared_task_activity_state_entry.activity_id)); + insert_values.push_back(std::to_string(shared_task_activity_state_entry.done_count)); + insert_values.push_back("FROM_UNIXTIME(" + (shared_task_activity_state_entry.updated_time > 0 ? std::to_string(shared_task_activity_state_entry.updated_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (shared_task_activity_state_entry.completed_time > 0 ? std::to_string(shared_task_activity_state_entry.completed_time) : "null") + ")"); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTaskActivityState entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.activity_id = atoi(row[1]); + entry.done_count = atoi(row[2]); + entry.updated_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completed_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTaskActivityState entry{}; + + entry.shared_task_id = strtoll(row[0], nullptr, 10); + entry.activity_id = atoi(row[1]); + entry.done_count = atoi(row[2]); + entry.updated_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completed_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H diff --git a/common/repositories/base/base_shared_task_dynamic_zones_repository.h b/common/repositories/base/base_shared_task_dynamic_zones_repository.h new file mode 100644 index 000000000..ab60aa54d --- /dev/null +++ b/common/repositories/base/base_shared_task_dynamic_zones_repository.h @@ -0,0 +1,293 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_SHARED_TASK_DYNAMIC_ZONES_REPOSITORY_H +#define EQEMU_BASE_SHARED_TASK_DYNAMIC_ZONES_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" + +class BaseSharedTaskDynamicZonesRepository { +public: + struct SharedTaskDynamicZones { + int64 shared_task_id; + int dynamic_zone_id; + }; + + static std::string PrimaryKey() + { + return std::string("shared_task_id"); + } + + static std::vector Columns() + { + return { + "shared_task_id", + "dynamic_zone_id", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string TableName() + { + return std::string("shared_task_dynamic_zones"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + ColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static SharedTaskDynamicZones NewEntity() + { + SharedTaskDynamicZones entry{}; + + entry.shared_task_id = 0; + entry.dynamic_zone_id = 0; + + return entry; + } + + static SharedTaskDynamicZones GetSharedTaskDynamicZonesEntry( + const std::vector &shared_task_dynamic_zoness, + int shared_task_dynamic_zones_id + ) + { + for (auto &shared_task_dynamic_zones : shared_task_dynamic_zoness) { + if (shared_task_dynamic_zones.shared_task_id == shared_task_dynamic_zones_id) { + return shared_task_dynamic_zones; + } + } + + return NewEntity(); + } + + static SharedTaskDynamicZones FindOne( + Database& db, + int shared_task_dynamic_zones_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + shared_task_dynamic_zones_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + SharedTaskDynamicZones entry{}; + + entry.shared_task_id = strtoll(row[0], NULL, 10); + entry.dynamic_zone_id = atoi(row[1]); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int shared_task_dynamic_zones_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + shared_task_dynamic_zones_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + SharedTaskDynamicZones shared_task_dynamic_zones_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[0] + " = " + std::to_string(shared_task_dynamic_zones_entry.shared_task_id)); + update_values.push_back(columns[1] + " = " + std::to_string(shared_task_dynamic_zones_entry.dynamic_zone_id)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + shared_task_dynamic_zones_entry.shared_task_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static SharedTaskDynamicZones InsertOne( + Database& db, + SharedTaskDynamicZones shared_task_dynamic_zones_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_task_dynamic_zones_entry.shared_task_id)); + insert_values.push_back(std::to_string(shared_task_dynamic_zones_entry.dynamic_zone_id)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + shared_task_dynamic_zones_entry.shared_task_id = results.LastInsertedID(); + return shared_task_dynamic_zones_entry; + } + + shared_task_dynamic_zones_entry = NewEntity(); + + return shared_task_dynamic_zones_entry; + } + + static int InsertMany( + Database& db, + std::vector shared_task_dynamic_zones_entries + ) + { + std::vector insert_chunks; + + for (auto &shared_task_dynamic_zones_entry: shared_task_dynamic_zones_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_task_dynamic_zones_entry.shared_task_id)); + insert_values.push_back(std::to_string(shared_task_dynamic_zones_entry.dynamic_zone_id)); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTaskDynamicZones entry{}; + + entry.shared_task_id = strtoll(row[0], NULL, 10); + entry.dynamic_zone_id = atoi(row[1]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTaskDynamicZones entry{}; + + entry.shared_task_id = strtoll(row[0], NULL, 10); + entry.dynamic_zone_id = atoi(row[1]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_SHARED_TASK_DYNAMIC_ZONES_REPOSITORY_H diff --git a/common/repositories/base/base_shared_task_members_repository.h b/common/repositories/base/base_shared_task_members_repository.h new file mode 100644 index 000000000..6e5d36227 --- /dev/null +++ b/common/repositories/base/base_shared_task_members_repository.h @@ -0,0 +1,302 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_SHARED_TASK_MEMBERS_REPOSITORY_H +#define EQEMU_BASE_SHARED_TASK_MEMBERS_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" + +class BaseSharedTaskMembersRepository { +public: + struct SharedTaskMembers { + int64 shared_task_id; + int64 character_id; + int is_leader; + }; + + static std::string PrimaryKey() + { + return std::string("shared_task_id"); + } + + static std::vector Columns() + { + return { + "shared_task_id", + "character_id", + "is_leader", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string TableName() + { + return std::string("shared_task_members"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + ColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static SharedTaskMembers NewEntity() + { + SharedTaskMembers entry{}; + + entry.shared_task_id = 0; + entry.character_id = 0; + entry.is_leader = 0; + + return entry; + } + + static SharedTaskMembers GetSharedTaskMembersEntry( + const std::vector &shared_task_memberss, + int shared_task_members_id + ) + { + for (auto &shared_task_members : shared_task_memberss) { + if (shared_task_members.shared_task_id == shared_task_members_id) { + return shared_task_members; + } + } + + return NewEntity(); + } + + static SharedTaskMembers FindOne( + Database& db, + int shared_task_members_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + shared_task_members_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + SharedTaskMembers entry{}; + + entry.shared_task_id = strtoll(row[0], NULL, 10); + entry.character_id = strtoll(row[1], NULL, 10); + entry.is_leader = atoi(row[2]); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int shared_task_members_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + shared_task_members_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + SharedTaskMembers shared_task_members_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[0] + " = " + std::to_string(shared_task_members_entry.shared_task_id)); + update_values.push_back(columns[1] + " = " + std::to_string(shared_task_members_entry.character_id)); + update_values.push_back(columns[2] + " = " + std::to_string(shared_task_members_entry.is_leader)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + shared_task_members_entry.shared_task_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static SharedTaskMembers InsertOne( + Database& db, + SharedTaskMembers shared_task_members_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_task_members_entry.shared_task_id)); + insert_values.push_back(std::to_string(shared_task_members_entry.character_id)); + insert_values.push_back(std::to_string(shared_task_members_entry.is_leader)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + shared_task_members_entry.shared_task_id = results.LastInsertedID(); + return shared_task_members_entry; + } + + shared_task_members_entry = NewEntity(); + + return shared_task_members_entry; + } + + static int InsertMany( + Database& db, + std::vector shared_task_members_entries + ) + { + std::vector insert_chunks; + + for (auto &shared_task_members_entry: shared_task_members_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_task_members_entry.shared_task_id)); + insert_values.push_back(std::to_string(shared_task_members_entry.character_id)); + insert_values.push_back(std::to_string(shared_task_members_entry.is_leader)); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTaskMembers entry{}; + + entry.shared_task_id = strtoll(row[0], NULL, 10); + entry.character_id = strtoll(row[1], NULL, 10); + entry.is_leader = atoi(row[2]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTaskMembers entry{}; + + entry.shared_task_id = strtoll(row[0], NULL, 10); + entry.character_id = strtoll(row[1], NULL, 10); + entry.is_leader = atoi(row[2]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_SHARED_TASK_MEMBERS_REPOSITORY_H diff --git a/common/repositories/base/base_shared_tasks_repository.h b/common/repositories/base/base_shared_tasks_repository.h new file mode 100644 index 000000000..405bf09ed --- /dev/null +++ b/common/repositories/base/base_shared_tasks_repository.h @@ -0,0 +1,346 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_SHARED_TASKS_REPOSITORY_H +#define EQEMU_BASE_SHARED_TASKS_REPOSITORY_H + +#include "../../database.h" +#include "../../string_util.h" +#include + +class BaseSharedTasksRepository { +public: + struct SharedTasks { + int64 id; + int task_id; + time_t accepted_time; + time_t expire_time; + time_t completion_time; + int is_locked; + }; + + static std::string PrimaryKey() + { + return std::string("id"); + } + + static std::vector Columns() + { + return { + "id", + "task_id", + "accepted_time", + "expire_time", + "completion_time", + "is_locked", + }; + } + + static std::vector SelectColumns() + { + return { + "id", + "task_id", + "UNIX_TIMESTAMP(accepted_time)", + "UNIX_TIMESTAMP(expire_time)", + "UNIX_TIMESTAMP(completion_time)", + "is_locked", + }; + } + + static std::string ColumnsRaw() + { + return std::string(implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("shared_tasks"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static SharedTasks NewEntity() + { + SharedTasks entry{}; + + entry.id = 0; + entry.task_id = 0; + entry.accepted_time = 0; + entry.expire_time = 0; + entry.completion_time = 0; + entry.is_locked = 0; + + return entry; + } + + static SharedTasks GetSharedTasksEntry( + const std::vector &shared_taskss, + int shared_tasks_id + ) + { + for (auto &shared_tasks : shared_taskss) { + if (shared_tasks.id == shared_tasks_id) { + return shared_tasks; + } + } + + return NewEntity(); + } + + static SharedTasks FindOne( + Database& db, + int shared_tasks_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE id = {} LIMIT 1", + BaseSelect(), + shared_tasks_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + SharedTasks entry{}; + + entry.id = strtoll(row[0], nullptr, 10); + entry.task_id = atoi(row[1]); + entry.accepted_time = strtoll(row[2] ? row[2] : "-1", nullptr, 10); + entry.expire_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completion_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + entry.is_locked = atoi(row[5]); + + return entry; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int shared_tasks_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + shared_tasks_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + SharedTasks shared_tasks_entry + ) + { + std::vector update_values; + + auto columns = Columns(); + + update_values.push_back(columns[1] + " = " + std::to_string(shared_tasks_entry.task_id)); + update_values.push_back(columns[2] + " = FROM_UNIXTIME(" + (shared_tasks_entry.accepted_time > 0 ? std::to_string(shared_tasks_entry.accepted_time) : "null") + ")"); + update_values.push_back(columns[3] + " = FROM_UNIXTIME(" + (shared_tasks_entry.expire_time > 0 ? std::to_string(shared_tasks_entry.expire_time) : "null") + ")"); + update_values.push_back(columns[4] + " = FROM_UNIXTIME(" + (shared_tasks_entry.completion_time > 0 ? std::to_string(shared_tasks_entry.completion_time) : "null") + ")"); + update_values.push_back(columns[5] + " = " + std::to_string(shared_tasks_entry.is_locked)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + implode(", ", update_values), + PrimaryKey(), + shared_tasks_entry.id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static SharedTasks InsertOne( + Database& db, + SharedTasks shared_tasks_entry + ) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_tasks_entry.id)); + insert_values.push_back(std::to_string(shared_tasks_entry.task_id)); + insert_values.push_back("FROM_UNIXTIME(" + (shared_tasks_entry.accepted_time > 0 ? std::to_string(shared_tasks_entry.accepted_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (shared_tasks_entry.expire_time > 0 ? std::to_string(shared_tasks_entry.expire_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (shared_tasks_entry.completion_time > 0 ? std::to_string(shared_tasks_entry.completion_time) : "null") + ")"); + insert_values.push_back(std::to_string(shared_tasks_entry.is_locked)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + implode(",", insert_values) + ) + ); + + if (results.Success()) { + shared_tasks_entry.id = results.LastInsertedID(); + return shared_tasks_entry; + } + + shared_tasks_entry = NewEntity(); + + return shared_tasks_entry; + } + + static int InsertMany( + Database& db, + std::vector shared_tasks_entries + ) + { + std::vector insert_chunks; + + for (auto &shared_tasks_entry: shared_tasks_entries) { + std::vector insert_values; + + insert_values.push_back(std::to_string(shared_tasks_entry.id)); + insert_values.push_back(std::to_string(shared_tasks_entry.task_id)); + insert_values.push_back("FROM_UNIXTIME(" + (shared_tasks_entry.accepted_time > 0 ? std::to_string(shared_tasks_entry.accepted_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (shared_tasks_entry.expire_time > 0 ? std::to_string(shared_tasks_entry.expire_time) : "null") + ")"); + insert_values.push_back("FROM_UNIXTIME(" + (shared_tasks_entry.completion_time > 0 ? std::to_string(shared_tasks_entry.completion_time) : "null") + ")"); + insert_values.push_back(std::to_string(shared_tasks_entry.is_locked)); + + insert_chunks.push_back("(" + implode(",", insert_values) + ")"); + } + + std::vector insert_values; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTasks entry{}; + + entry.id = strtoll(row[0], nullptr, 10); + entry.task_id = atoi(row[1]); + entry.accepted_time = strtoll(row[2] ? row[2] : "-1", nullptr, 10); + entry.expire_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completion_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + entry.is_locked = atoi(row[5]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, std::string where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + SharedTasks entry{}; + + entry.id = strtoll(row[0], nullptr, 10); + entry.task_id = atoi(row[1]); + entry.accepted_time = strtoll(row[2] ? row[2] : "-1", nullptr, 10); + entry.expire_time = strtoll(row[3] ? row[3] : "-1", nullptr, 10); + entry.completion_time = strtoll(row[4] ? row[4] : "-1", nullptr, 10); + entry.is_locked = atoi(row[5]); + + all_entries.push_back(entry); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, std::string where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + +}; + +#endif //EQEMU_BASE_SHARED_TASKS_REPOSITORY_H diff --git a/common/repositories/base/base_tasks_repository.h b/common/repositories/base/base_tasks_repository.h index 3d1982bf2..23c76d788 100644 --- a/common/repositories/base/base_tasks_repository.h +++ b/common/repositories/base/base_tasks_repository.h @@ -14,6 +14,7 @@ #include "../../database.h" #include "../../string_util.h" +#include class BaseTasksRepository { public: @@ -29,11 +30,18 @@ public: int cashreward; int xpreward; int rewardmethod; + int reward_radiant_crystals; + int reward_ebon_crystals; int minlevel; int maxlevel; + int level_spread; + int min_players; + int max_players; int repeatable; int faction_reward; std::string completion_emote; + int replay_timer_seconds; + int request_timer_seconds; }; static std::string PrimaryKey() @@ -55,11 +63,47 @@ public: "cashreward", "xpreward", "rewardmethod", + "reward_radiant_crystals", + "reward_ebon_crystals", "minlevel", "maxlevel", + "level_spread", + "min_players", + "max_players", "repeatable", "faction_reward", "completion_emote", + "replay_timer_seconds", + "request_timer_seconds", + }; + } + + static std::vector SelectColumns() + { + return { + "id", + "type", + "duration", + "duration_code", + "title", + "description", + "reward", + "rewardid", + "cashreward", + "xpreward", + "rewardmethod", + "reward_radiant_crystals", + "reward_ebon_crystals", + "minlevel", + "maxlevel", + "level_spread", + "min_players", + "max_players", + "repeatable", + "faction_reward", + "completion_emote", + "replay_timer_seconds", + "request_timer_seconds", }; } @@ -68,6 +112,11 @@ public: return std::string(implode(", ", Columns())); } + static std::string SelectColumnsRaw() + { + return std::string(implode(", ", SelectColumns())); + } + static std::string TableName() { return std::string("tasks"); @@ -77,7 +126,7 @@ public: { return fmt::format( "SELECT {} FROM {}", - ColumnsRaw(), + SelectColumnsRaw(), TableName() ); } @@ -95,22 +144,29 @@ public: { Tasks entry{}; - entry.id = 0; - entry.type = 0; - entry.duration = 0; - entry.duration_code = 0; - entry.title = ""; - entry.description = ""; - entry.reward = ""; - entry.rewardid = 0; - entry.cashreward = 0; - entry.xpreward = 0; - entry.rewardmethod = 2; - entry.minlevel = 0; - entry.maxlevel = 0; - entry.repeatable = 1; - entry.faction_reward = 0; - entry.completion_emote = ""; + entry.id = 0; + entry.type = 0; + entry.duration = 0; + entry.duration_code = 0; + entry.title = ""; + entry.description = ""; + entry.reward = ""; + entry.rewardid = 0; + entry.cashreward = 0; + entry.xpreward = 0; + entry.rewardmethod = 2; + entry.reward_radiant_crystals = 0; + entry.reward_ebon_crystals = 0; + entry.minlevel = 0; + entry.maxlevel = 0; + entry.level_spread = 0; + entry.min_players = 0; + entry.max_players = 0; + entry.repeatable = 1; + entry.faction_reward = 0; + entry.completion_emote = ""; + entry.replay_timer_seconds = 0; + entry.request_timer_seconds = 0; return entry; } @@ -146,22 +202,29 @@ public: if (results.RowCount() == 1) { Tasks entry{}; - entry.id = atoi(row[0]); - entry.type = atoi(row[1]); - entry.duration = atoi(row[2]); - entry.duration_code = atoi(row[3]); - entry.title = row[4] ? row[4] : ""; - entry.description = row[5] ? row[5] : ""; - entry.reward = row[6] ? row[6] : ""; - entry.rewardid = atoi(row[7]); - entry.cashreward = atoi(row[8]); - entry.xpreward = atoi(row[9]); - entry.rewardmethod = atoi(row[10]); - entry.minlevel = atoi(row[11]); - entry.maxlevel = atoi(row[12]); - entry.repeatable = atoi(row[13]); - entry.faction_reward = atoi(row[14]); - entry.completion_emote = row[15] ? row[15] : ""; + entry.id = atoi(row[0]); + entry.type = atoi(row[1]); + entry.duration = atoi(row[2]); + entry.duration_code = atoi(row[3]); + entry.title = row[4] ? row[4] : ""; + entry.description = row[5] ? row[5] : ""; + entry.reward = row[6] ? row[6] : ""; + entry.rewardid = atoi(row[7]); + entry.cashreward = atoi(row[8]); + entry.xpreward = atoi(row[9]); + entry.rewardmethod = atoi(row[10]); + entry.reward_radiant_crystals = atoi(row[11]); + entry.reward_ebon_crystals = atoi(row[12]); + entry.minlevel = atoi(row[13]); + entry.maxlevel = atoi(row[14]); + entry.level_spread = atoi(row[15]); + entry.min_players = atoi(row[16]); + entry.max_players = atoi(row[17]); + entry.repeatable = atoi(row[18]); + entry.faction_reward = atoi(row[19]); + entry.completion_emote = row[20] ? row[20] : ""; + entry.replay_timer_seconds = atoi(row[21]); + entry.request_timer_seconds = atoi(row[22]); return entry; } @@ -206,11 +269,18 @@ public: update_values.push_back(columns[8] + " = " + std::to_string(tasks_entry.cashreward)); update_values.push_back(columns[9] + " = " + std::to_string(tasks_entry.xpreward)); update_values.push_back(columns[10] + " = " + std::to_string(tasks_entry.rewardmethod)); - update_values.push_back(columns[11] + " = " + std::to_string(tasks_entry.minlevel)); - update_values.push_back(columns[12] + " = " + std::to_string(tasks_entry.maxlevel)); - update_values.push_back(columns[13] + " = " + std::to_string(tasks_entry.repeatable)); - update_values.push_back(columns[14] + " = " + std::to_string(tasks_entry.faction_reward)); - update_values.push_back(columns[15] + " = '" + EscapeString(tasks_entry.completion_emote) + "'"); + update_values.push_back(columns[11] + " = " + std::to_string(tasks_entry.reward_radiant_crystals)); + update_values.push_back(columns[12] + " = " + std::to_string(tasks_entry.reward_ebon_crystals)); + update_values.push_back(columns[13] + " = " + std::to_string(tasks_entry.minlevel)); + update_values.push_back(columns[14] + " = " + std::to_string(tasks_entry.maxlevel)); + update_values.push_back(columns[15] + " = " + std::to_string(tasks_entry.level_spread)); + update_values.push_back(columns[16] + " = " + std::to_string(tasks_entry.min_players)); + update_values.push_back(columns[17] + " = " + std::to_string(tasks_entry.max_players)); + update_values.push_back(columns[18] + " = " + std::to_string(tasks_entry.repeatable)); + update_values.push_back(columns[19] + " = " + std::to_string(tasks_entry.faction_reward)); + update_values.push_back(columns[20] + " = '" + EscapeString(tasks_entry.completion_emote) + "'"); + update_values.push_back(columns[21] + " = " + std::to_string(tasks_entry.replay_timer_seconds)); + update_values.push_back(columns[22] + " = " + std::to_string(tasks_entry.request_timer_seconds)); auto results = db.QueryDatabase( fmt::format( @@ -243,11 +313,18 @@ public: insert_values.push_back(std::to_string(tasks_entry.cashreward)); insert_values.push_back(std::to_string(tasks_entry.xpreward)); insert_values.push_back(std::to_string(tasks_entry.rewardmethod)); + insert_values.push_back(std::to_string(tasks_entry.reward_radiant_crystals)); + insert_values.push_back(std::to_string(tasks_entry.reward_ebon_crystals)); insert_values.push_back(std::to_string(tasks_entry.minlevel)); insert_values.push_back(std::to_string(tasks_entry.maxlevel)); + insert_values.push_back(std::to_string(tasks_entry.level_spread)); + insert_values.push_back(std::to_string(tasks_entry.min_players)); + insert_values.push_back(std::to_string(tasks_entry.max_players)); insert_values.push_back(std::to_string(tasks_entry.repeatable)); insert_values.push_back(std::to_string(tasks_entry.faction_reward)); insert_values.push_back("'" + EscapeString(tasks_entry.completion_emote) + "'"); + insert_values.push_back(std::to_string(tasks_entry.replay_timer_seconds)); + insert_values.push_back(std::to_string(tasks_entry.request_timer_seconds)); auto results = db.QueryDatabase( fmt::format( @@ -288,11 +365,18 @@ public: insert_values.push_back(std::to_string(tasks_entry.cashreward)); insert_values.push_back(std::to_string(tasks_entry.xpreward)); insert_values.push_back(std::to_string(tasks_entry.rewardmethod)); + insert_values.push_back(std::to_string(tasks_entry.reward_radiant_crystals)); + insert_values.push_back(std::to_string(tasks_entry.reward_ebon_crystals)); insert_values.push_back(std::to_string(tasks_entry.minlevel)); insert_values.push_back(std::to_string(tasks_entry.maxlevel)); + insert_values.push_back(std::to_string(tasks_entry.level_spread)); + insert_values.push_back(std::to_string(tasks_entry.min_players)); + insert_values.push_back(std::to_string(tasks_entry.max_players)); insert_values.push_back(std::to_string(tasks_entry.repeatable)); insert_values.push_back(std::to_string(tasks_entry.faction_reward)); insert_values.push_back("'" + EscapeString(tasks_entry.completion_emote) + "'"); + insert_values.push_back(std::to_string(tasks_entry.replay_timer_seconds)); + insert_values.push_back(std::to_string(tasks_entry.request_timer_seconds)); insert_chunks.push_back("(" + implode(",", insert_values) + ")"); } @@ -326,22 +410,29 @@ public: for (auto row = results.begin(); row != results.end(); ++row) { Tasks entry{}; - entry.id = atoi(row[0]); - entry.type = atoi(row[1]); - entry.duration = atoi(row[2]); - entry.duration_code = atoi(row[3]); - entry.title = row[4] ? row[4] : ""; - entry.description = row[5] ? row[5] : ""; - entry.reward = row[6] ? row[6] : ""; - entry.rewardid = atoi(row[7]); - entry.cashreward = atoi(row[8]); - entry.xpreward = atoi(row[9]); - entry.rewardmethod = atoi(row[10]); - entry.minlevel = atoi(row[11]); - entry.maxlevel = atoi(row[12]); - entry.repeatable = atoi(row[13]); - entry.faction_reward = atoi(row[14]); - entry.completion_emote = row[15] ? row[15] : ""; + entry.id = atoi(row[0]); + entry.type = atoi(row[1]); + entry.duration = atoi(row[2]); + entry.duration_code = atoi(row[3]); + entry.title = row[4] ? row[4] : ""; + entry.description = row[5] ? row[5] : ""; + entry.reward = row[6] ? row[6] : ""; + entry.rewardid = atoi(row[7]); + entry.cashreward = atoi(row[8]); + entry.xpreward = atoi(row[9]); + entry.rewardmethod = atoi(row[10]); + entry.reward_radiant_crystals = atoi(row[11]); + entry.reward_ebon_crystals = atoi(row[12]); + entry.minlevel = atoi(row[13]); + entry.maxlevel = atoi(row[14]); + entry.level_spread = atoi(row[15]); + entry.min_players = atoi(row[16]); + entry.max_players = atoi(row[17]); + entry.repeatable = atoi(row[18]); + entry.faction_reward = atoi(row[19]); + entry.completion_emote = row[20] ? row[20] : ""; + entry.replay_timer_seconds = atoi(row[21]); + entry.request_timer_seconds = atoi(row[22]); all_entries.push_back(entry); } @@ -366,22 +457,29 @@ public: for (auto row = results.begin(); row != results.end(); ++row) { Tasks entry{}; - entry.id = atoi(row[0]); - entry.type = atoi(row[1]); - entry.duration = atoi(row[2]); - entry.duration_code = atoi(row[3]); - entry.title = row[4] ? row[4] : ""; - entry.description = row[5] ? row[5] : ""; - entry.reward = row[6] ? row[6] : ""; - entry.rewardid = atoi(row[7]); - entry.cashreward = atoi(row[8]); - entry.xpreward = atoi(row[9]); - entry.rewardmethod = atoi(row[10]); - entry.minlevel = atoi(row[11]); - entry.maxlevel = atoi(row[12]); - entry.repeatable = atoi(row[13]); - entry.faction_reward = atoi(row[14]); - entry.completion_emote = row[15] ? row[15] : ""; + entry.id = atoi(row[0]); + entry.type = atoi(row[1]); + entry.duration = atoi(row[2]); + entry.duration_code = atoi(row[3]); + entry.title = row[4] ? row[4] : ""; + entry.description = row[5] ? row[5] : ""; + entry.reward = row[6] ? row[6] : ""; + entry.rewardid = atoi(row[7]); + entry.cashreward = atoi(row[8]); + entry.xpreward = atoi(row[9]); + entry.rewardmethod = atoi(row[10]); + entry.reward_radiant_crystals = atoi(row[11]); + entry.reward_ebon_crystals = atoi(row[12]); + entry.minlevel = atoi(row[13]); + entry.maxlevel = atoi(row[14]); + entry.level_spread = atoi(row[15]); + entry.min_players = atoi(row[16]); + entry.max_players = atoi(row[17]); + entry.repeatable = atoi(row[18]); + entry.faction_reward = atoi(row[19]); + entry.completion_emote = row[20] ? row[20] : ""; + entry.replay_timer_seconds = atoi(row[21]); + entry.request_timer_seconds = atoi(row[22]); all_entries.push_back(entry); } diff --git a/common/repositories/character_instance_safereturns_repository.h b/common/repositories/character_instance_safereturns_repository.h new file mode 100644 index 000000000..89bfddead --- /dev/null +++ b/common/repositories/character_instance_safereturns_repository.h @@ -0,0 +1,108 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_CHARACTER_INSTANCE_SAFERETURNS_REPOSITORY_H +#define EQEMU_CHARACTER_INSTANCE_SAFERETURNS_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_character_instance_safereturns_repository.h" + +class CharacterInstanceSafereturnsRepository: public BaseCharacterInstanceSafereturnsRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * CharacterInstanceSafereturnsRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * CharacterInstanceSafereturnsRepository::GetWhereNeverExpires() + * CharacterInstanceSafereturnsRepository::GetWhereXAndY() + * CharacterInstanceSafereturnsRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + + static CharacterInstanceSafereturns InsertOneOrUpdate( + Database& db, CharacterInstanceSafereturns& character_instance_safereturns_entry) + { + std::vector insert_values; + + insert_values.push_back(std::to_string(character_instance_safereturns_entry.id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.character_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.instance_zone_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.instance_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_zone_id)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_x)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_y)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_z)); + insert_values.push_back(std::to_string(character_instance_safereturns_entry.safe_heading)); + + auto results = db.QueryDatabase(fmt::format(SQL( + {} VALUES ({}) + ON DUPLICATE KEY UPDATE + instance_zone_id = VALUES(instance_zone_id), + instance_id = VALUES(instance_id), + safe_zone_id = VALUES(safe_zone_id), + safe_x = VALUES(safe_x), + safe_y = VALUES(safe_y), + safe_z = VALUES(safe_z), + safe_heading = VALUES(safe_heading) + ), + BaseInsert(), + implode(",", insert_values) + )); + + if (results.Success()) + { + character_instance_safereturns_entry.id = results.LastInsertedID(); + return character_instance_safereturns_entry; + } + + return NewEntity(); + } +}; + +#endif //EQEMU_CHARACTER_INSTANCE_SAFERETURNS_REPOSITORY_H diff --git a/common/repositories/character_task_timers_repository.h b/common/repositories/character_task_timers_repository.h new file mode 100644 index 000000000..7f0b07962 --- /dev/null +++ b/common/repositories/character_task_timers_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_CHARACTER_TASK_TIMERS_REPOSITORY_H +#define EQEMU_CHARACTER_TASK_TIMERS_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_character_task_timers_repository.h" + +class CharacterTaskTimersRepository: public BaseCharacterTaskTimersRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * CharacterTaskTimersRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * CharacterTaskTimersRepository::GetWhereNeverExpires() + * CharacterTaskTimersRepository::GetWhereXAndY() + * CharacterTaskTimersRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_CHARACTER_TASK_TIMERS_REPOSITORY_H diff --git a/common/repositories/completed_shared_task_activity_state_repository.h b/common/repositories/completed_shared_task_activity_state_repository.h new file mode 100644 index 000000000..afb0ef3fd --- /dev/null +++ b/common/repositories/completed_shared_task_activity_state_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_COMPLETED_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H +#define EQEMU_COMPLETED_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_completed_shared_task_activity_state_repository.h" + +class CompletedSharedTaskActivityStateRepository: public BaseCompletedSharedTaskActivityStateRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * CompletedSharedTaskActivityStateRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * CompletedSharedTaskActivityStateRepository::GetWhereNeverExpires() + * CompletedSharedTaskActivityStateRepository::GetWhereXAndY() + * CompletedSharedTaskActivityStateRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_COMPLETED_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H diff --git a/common/repositories/completed_shared_task_members_repository.h b/common/repositories/completed_shared_task_members_repository.h new file mode 100644 index 000000000..6c0cf609a --- /dev/null +++ b/common/repositories/completed_shared_task_members_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_COMPLETED_SHARED_TASK_MEMBERS_REPOSITORY_H +#define EQEMU_COMPLETED_SHARED_TASK_MEMBERS_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_completed_shared_task_members_repository.h" + +class CompletedSharedTaskMembersRepository: public BaseCompletedSharedTaskMembersRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * CompletedSharedTaskMembersRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * CompletedSharedTaskMembersRepository::GetWhereNeverExpires() + * CompletedSharedTaskMembersRepository::GetWhereXAndY() + * CompletedSharedTaskMembersRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_COMPLETED_SHARED_TASK_MEMBERS_REPOSITORY_H diff --git a/common/repositories/completed_shared_tasks_repository.h b/common/repositories/completed_shared_tasks_repository.h new file mode 100644 index 000000000..bbf46f16c --- /dev/null +++ b/common/repositories/completed_shared_tasks_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_COMPLETED_SHARED_TASKS_REPOSITORY_H +#define EQEMU_COMPLETED_SHARED_TASKS_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_completed_shared_tasks_repository.h" + +class CompletedSharedTasksRepository: public BaseCompletedSharedTasksRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * CompletedSharedTasksRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * CompletedSharedTasksRepository::GetWhereNeverExpires() + * CompletedSharedTasksRepository::GetWhereXAndY() + * CompletedSharedTasksRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_COMPLETED_SHARED_TASKS_REPOSITORY_H diff --git a/common/repositories/dynamic_zone_members_repository.h b/common/repositories/dynamic_zone_members_repository.h index 2392b0965..3ccdd17b8 100644 --- a/common/repositories/dynamic_zone_members_repository.h +++ b/common/repositories/dynamic_zone_members_repository.h @@ -69,7 +69,6 @@ public: uint32_t id; uint32_t dynamic_zone_id; uint32_t character_id; - int is_current_member; std::string character_name; }; @@ -80,32 +79,17 @@ public: dynamic_zone_members.id, dynamic_zone_members.dynamic_zone_id, dynamic_zone_members.character_id, - dynamic_zone_members.is_current_member, character_data.name FROM dynamic_zone_members INNER JOIN character_data ON dynamic_zone_members.character_id = character_data.id )); } - static std::vector GetWithNames(Database& db, - const std::vector& dynamic_zone_ids) + static std::vector GetAllWithNames(Database& db) { - if (dynamic_zone_ids.empty()) - { - return {}; - } - std::vector all_entries; - auto results = db.QueryDatabase(fmt::format(SQL( - {} - WHERE dynamic_zone_members.dynamic_zone_id IN ({}) - AND dynamic_zone_members.is_current_member = TRUE; - ), - SelectMembersWithNames(), - fmt::join(dynamic_zone_ids, ",") - )); - + auto results = db.QueryDatabase(SelectMembersWithNames()); if (results.Success()) { all_entries.reserve(results.RowCount()); @@ -118,7 +102,6 @@ public: entry.id = strtoul(row[col++], nullptr, 10); entry.dynamic_zone_id = strtoul(row[col++], nullptr, 10); entry.character_id = strtoul(row[col++], nullptr, 10); - entry.is_current_member = strtoul(row[col++], nullptr, 10); entry.character_name = row[col++]; all_entries.emplace_back(std::move(entry)); @@ -173,7 +156,7 @@ public: (dynamic_zone_id, character_id) VALUES ({}, {}) - ON DUPLICATE KEY UPDATE is_current_member = TRUE; + ON DUPLICATE KEY UPDATE id = id; ), TableName(), dynamic_zone_id, @@ -184,7 +167,7 @@ public: static void RemoveMember(Database& db, uint32_t dynamic_zone_id, uint32_t character_id) { db.QueryDatabase(fmt::format(SQL( - UPDATE {} SET is_current_member = FALSE + DELETE FROM {} WHERE dynamic_zone_id = {} AND character_id = {}; ), TableName(), dynamic_zone_id, character_id @@ -194,7 +177,7 @@ public: static void RemoveAllMembers(Database& db, uint32_t dynamic_zone_id) { db.QueryDatabase(fmt::format(SQL( - UPDATE {} SET is_current_member = FALSE + DELETE FROM {} WHERE dynamic_zone_id = {}; ), TableName(), dynamic_zone_id @@ -206,7 +189,7 @@ public: if (!dynamic_zone_ids.empty()) { db.QueryDatabase(fmt::format(SQL( - UPDATE {} SET is_current_member = FALSE + DELETE FROM {} WHERE dynamic_zone_id IN ({}); ), TableName(), fmt::join(dynamic_zone_ids, ",") @@ -226,7 +209,6 @@ public: insert_values.push_back(std::to_string(dynamic_zone_members_entry.id)); insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id)); insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id)); - insert_values.push_back(std::to_string(dynamic_zone_members_entry.is_current_member)); insert_chunks.push_back("(" + implode(",", insert_values) + ")"); } @@ -235,7 +217,7 @@ public: auto results = db.QueryDatabase( fmt::format( - "INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE is_current_member = TRUE;", + "INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE id = id;", TableName(), ColumnsRaw(), implode(",", insert_chunks) diff --git a/common/repositories/dynamic_zones_repository.h b/common/repositories/dynamic_zones_repository.h index 24d944209..677fcc2f8 100644 --- a/common/repositories/dynamic_zones_repository.h +++ b/common/repositories/dynamic_zones_repository.h @@ -68,6 +68,11 @@ public: struct DynamicZoneInstance { uint32_t id; + std::string uuid; + std::string name; + int leader_id; + int min_players; + int max_players; int instance_id; int type; int compass_zone_id; @@ -97,6 +102,11 @@ public: return std::string(SQL( SELECT dynamic_zones.id, + dynamic_zones.uuid, + dynamic_zones.name, + dynamic_zones.leader_id, + dynamic_zones.min_players, + dynamic_zones.max_players, dynamic_zones.instance_id, dynamic_zones.type, dynamic_zones.compass_zone_id, @@ -130,6 +140,11 @@ public: int col = 0; entry.id = strtoul(row[col++], nullptr, 10); + entry.uuid = row[col++]; + entry.name = row[col++]; + entry.leader_id = strtol(row[col++], nullptr, 10); + entry.min_players = strtol(row[col++], nullptr, 10); + entry.max_players = strtol(row[col++], nullptr, 10); entry.instance_id = strtol(row[col++], nullptr, 10); entry.type = strtol(row[col++], nullptr, 10); entry.compass_zone_id = strtol(row[col++], nullptr, 10); @@ -157,21 +172,15 @@ public: return entry; } - static std::vector GetWithInstance(Database& db, - const std::vector& dynamic_zone_ids) + static std::vector AllWithInstanceNotExpired(Database& db) { - if (dynamic_zone_ids.empty()) - { - return {}; - } - std::vector all_entries; - auto results = db.QueryDatabase(fmt::format( - "{} WHERE dynamic_zones.id IN ({}) ORDER BY dynamic_zones.id;", - SelectDynamicZoneJoinInstance(), - fmt::join(dynamic_zone_ids, ",") - )); + auto results = db.QueryDatabase(fmt::format(SQL( + {} WHERE + (instance_list.start_time + instance_list.duration) > UNIX_TIMESTAMP() + AND instance_list.never_expires = 0 + ), SelectDynamicZoneJoinInstance())); if (results.Success()) { @@ -240,6 +249,18 @@ public: } } + static void UpdateLeaderID(Database& db, uint32_t dz_id, uint32_t leader_id) + { + if (dz_id != 0) + { + std::string query = fmt::format(SQL( + UPDATE {} SET leader_id = {} WHERE {} = {}; + ), TableName(), leader_id, PrimaryKey(), dz_id); + + db.QueryDatabase(query); + } + } + struct DynamicZoneInstancePlayerCount { uint32_t id; @@ -267,7 +288,6 @@ public: FROM dynamic_zones INNER JOIN instance_list ON dynamic_zones.instance_id = instance_list.id LEFT JOIN dynamic_zone_members ON dynamic_zones.id = dynamic_zone_members.dynamic_zone_id - AND dynamic_zone_members.is_current_member = TRUE GROUP BY instance_list.id ORDER BY dynamic_zones.id; )); @@ -301,6 +321,41 @@ public: } return all_entries; } + + static std::vector GetStaleIDs(Database& db) + { + std::vector all_entries; + + // dzs with no members, missing instance, or expired instance + auto results = db.QueryDatabase(SQL( + SELECT + dynamic_zones.id + FROM dynamic_zones + LEFT JOIN instance_list ON dynamic_zones.instance_id = instance_list.id + LEFT JOIN + ( + SELECT dynamic_zone_id, COUNT(*) member_count + FROM dynamic_zone_members + GROUP BY dynamic_zone_id + ) dynamic_zone_members + ON dynamic_zone_members.dynamic_zone_id = dynamic_zones.id + WHERE + instance_list.id IS NULL + OR dynamic_zone_members.member_count IS NULL + OR dynamic_zone_members.member_count = 0 + OR ((instance_list.start_time + instance_list.duration) <= UNIX_TIMESTAMP() + AND instance_list.never_expires = 0); + )); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) + { + all_entries.push_back(atoi(row[0])); + } + + return all_entries; + } }; #endif //EQEMU_DYNAMIC_ZONES_REPOSITORY_H diff --git a/common/repositories/expeditions_repository.h b/common/repositories/expeditions_repository.h index 654b676b0..1470cbad0 100644 --- a/common/repositories/expeditions_repository.h +++ b/common/repositories/expeditions_repository.h @@ -65,100 +65,6 @@ public: // Custom extended repository methods here - struct ExpeditionWithLeader - { - uint32_t id; - std::string uuid; - uint32_t dynamic_zone_id; - std::string expedition_name; - uint32_t min_players; - uint32_t max_players; - int add_replay_on_join; - int is_locked; - uint32_t leader_id; - std::string leader_name; - }; - - static std::string SelectExpeditionsJoinLeader() - { - return std::string(SQL( - SELECT - expeditions.id, - expeditions.uuid, - expeditions.dynamic_zone_id, - expeditions.expedition_name, - expeditions.min_players, - expeditions.max_players, - expeditions.add_replay_on_join, - expeditions.is_locked, - expeditions.leader_id, - character_data.name leader_name - FROM expeditions - INNER JOIN character_data ON expeditions.leader_id = character_data.id - )); - } - - static ExpeditionWithLeader FillExpeditionWithLeaderFromRow(MySQLRequestRow& row) - { - ExpeditionWithLeader entry{}; - - int col = 0; - entry.id = strtoul(row[col++], nullptr, 10); - entry.uuid = row[col++]; - entry.dynamic_zone_id = strtoul(row[col++], nullptr, 10); - entry.expedition_name = row[col++]; - entry.min_players = strtoul(row[col++], nullptr, 10); - entry.max_players = strtoul(row[col++], nullptr, 10); - entry.add_replay_on_join = strtoul(row[col++], nullptr, 10); - entry.is_locked = strtoul(row[col++], nullptr, 10); - entry.leader_id = strtoul(row[col++], nullptr, 10); - entry.leader_name = row[col++]; - - return entry; - } - - static std::vector GetAllWithLeaderName(Database& db) - { - std::vector all_entries; - - auto results = db.QueryDatabase(fmt::format( - "{} ORDER BY expeditions.id;", - SelectExpeditionsJoinLeader() - )); - - if (results.Success()) - { - all_entries.reserve(results.RowCount()); - - for (auto row = results.begin(); row != results.end(); ++row) - { - ExpeditionWithLeader entry = FillExpeditionWithLeaderFromRow(row); - all_entries.emplace_back(std::move(entry)); - } - } - - return all_entries; - } - - static ExpeditionWithLeader GetWithLeaderName(Database& db, uint32_t expedition_id) - { - ExpeditionWithLeader entry{}; - - auto results = db.QueryDatabase(fmt::format( - "{} WHERE expeditions.id = {};", - SelectExpeditionsJoinLeader(), - expedition_id - )); - - if (results.Success() && results.RowCount() > 0) - { - auto row = results.begin(); - entry = FillExpeditionWithLeaderFromRow(row); - } - - return entry; - } - struct CharacterExpedition { uint32_t id; @@ -186,7 +92,6 @@ public: FROM character_data LEFT JOIN dynamic_zone_members ON character_data.id = dynamic_zone_members.character_id - AND dynamic_zone_members.is_current_member = TRUE LEFT JOIN expeditions ON dynamic_zone_members.dynamic_zone_id = expeditions.dynamic_zone_id WHERE character_data.name IN ({}) @@ -232,7 +137,6 @@ public: ON expeditions.dynamic_zone_id = dynamic_zone_members.dynamic_zone_id WHERE dynamic_zone_members.character_id = {} - AND dynamic_zone_members.is_current_member = TRUE; ), character_id )); diff --git a/common/repositories/shared_task_activity_state_repository.h b/common/repositories/shared_task_activity_state_repository.h new file mode 100644 index 000000000..1e48c7e76 --- /dev/null +++ b/common/repositories/shared_task_activity_state_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H +#define EQEMU_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_shared_task_activity_state_repository.h" + +class SharedTaskActivityStateRepository: public BaseSharedTaskActivityStateRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * SharedTaskActivityStateRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * SharedTaskActivityStateRepository::GetWhereNeverExpires() + * SharedTaskActivityStateRepository::GetWhereXAndY() + * SharedTaskActivityStateRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_SHARED_TASK_ACTIVITY_STATE_REPOSITORY_H diff --git a/common/repositories/shared_task_dynamic_zones_repository.h b/common/repositories/shared_task_dynamic_zones_repository.h new file mode 100644 index 000000000..61ee9c9f5 --- /dev/null +++ b/common/repositories/shared_task_dynamic_zones_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_SHARED_TASK_DYNAMIC_ZONES_REPOSITORY_H +#define EQEMU_SHARED_TASK_DYNAMIC_ZONES_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_shared_task_dynamic_zones_repository.h" + +class SharedTaskDynamicZonesRepository: public BaseSharedTaskDynamicZonesRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * SharedTaskDynamicZonesRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * SharedTaskDynamicZonesRepository::GetWhereNeverExpires() + * SharedTaskDynamicZonesRepository::GetWhereXAndY() + * SharedTaskDynamicZonesRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_SHARED_TASK_DYNAMIC_ZONES_REPOSITORY_H diff --git a/common/repositories/shared_task_members_repository.h b/common/repositories/shared_task_members_repository.h new file mode 100644 index 000000000..51b8606ad --- /dev/null +++ b/common/repositories/shared_task_members_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_SHARED_TASK_MEMBERS_REPOSITORY_H +#define EQEMU_SHARED_TASK_MEMBERS_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_shared_task_members_repository.h" + +class SharedTaskMembersRepository: public BaseSharedTaskMembersRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * SharedTaskMembersRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * SharedTaskMembersRepository::GetWhereNeverExpires() + * SharedTaskMembersRepository::GetWhereXAndY() + * SharedTaskMembersRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_SHARED_TASK_MEMBERS_REPOSITORY_H diff --git a/common/repositories/shared_tasks_repository.h b/common/repositories/shared_tasks_repository.h new file mode 100644 index 000000000..3ec764beb --- /dev/null +++ b/common/repositories/shared_tasks_repository.h @@ -0,0 +1,70 @@ +/** + * EQEmulator: Everquest Server Emulator + * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY except by those people which sell it, which + * are required to give you total support for your newly bought product; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef EQEMU_SHARED_TASKS_REPOSITORY_H +#define EQEMU_SHARED_TASKS_REPOSITORY_H + +#include "../database.h" +#include "../string_util.h" +#include "base/base_shared_tasks_repository.h" + +class SharedTasksRepository: public BaseSharedTasksRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * SharedTasksRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * SharedTasksRepository::GetWhereNeverExpires() + * SharedTasksRepository::GetWhereXAndY() + * SharedTasksRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_SHARED_TASKS_REPOSITORY_H diff --git a/common/ruletypes.h b/common/ruletypes.h index 906b9d867..37bf96711 100644 --- a/common/ruletypes.h +++ b/common/ruletypes.h @@ -538,6 +538,7 @@ RULE_BOOL(TaskSystem, RecordCompletedTasks, true, "Record completed tasks") RULE_BOOL(TaskSystem, RecordCompletedOptionalActivities, false, "Record completed optional activities") RULE_BOOL(TaskSystem, KeepOneRecordPerCompletedTask, true, "Keep only one record per completed task") RULE_BOOL(TaskSystem, EnableTaskProximity, true, "Enable task proximity system") +RULE_INT(TaskSystem, RequestCooldownTimerSeconds, 15, "Seconds between allowing characters to request tasks (live-like default: 15 seconds)") RULE_CATEGORY_END() RULE_CATEGORY(Range) diff --git a/common/servertalk.h b/common/servertalk.h index b4a5000ad..3774a07cc 100644 --- a/common/servertalk.h +++ b/common/servertalk.h @@ -6,7 +6,10 @@ #include "../common/eq_packet_structs.h" #include "../common/net/packet.h" #include +#include +#include #include +#include #define SERVER_TIMEOUT 45000 // how often keepalive gets sent #define INTERSERVER_TIMER 10000 @@ -141,14 +144,9 @@ #define ServerOP_LFPMatches 0x0214 #define ServerOP_ClientVersionSummary 0x0215 +// expedition #define ServerOP_ExpeditionCreate 0x0400 -#define ServerOP_ExpeditionDeleted 0x0401 -#define ServerOP_ExpeditionLeaderChanged 0x0402 #define ServerOP_ExpeditionLockout 0x0403 -#define ServerOP_ExpeditionMemberChange 0x0404 -#define ServerOP_ExpeditionMemberSwap 0x0405 -#define ServerOP_ExpeditionMemberStatus 0x0406 -#define ServerOP_ExpeditionGetMemberStatuses 0x0407 #define ServerOP_ExpeditionDzAddPlayer 0x0408 #define ServerOP_ExpeditionDzMakeLeader 0x0409 #define ServerOP_ExpeditionCharacterLockout 0x040d @@ -156,17 +154,23 @@ #define ServerOP_ExpeditionRequestInvite 0x040f #define ServerOP_ExpeditionReplayOnJoin 0x0410 #define ServerOP_ExpeditionLockState 0x0411 -#define ServerOP_ExpeditionMembersRemoved 0x0412 #define ServerOP_ExpeditionLockoutDuration 0x0414 -#define ServerOP_ExpeditionExpireWarning 0x0416 -#define ServerOP_DzAddRemoveCharacter 0x0450 -#define ServerOP_DzRemoveAllCharacters 0x0451 +// dz +#define ServerOP_DzAddRemoveMember 0x0450 +#define ServerOP_DzRemoveAllMembers 0x0451 #define ServerOP_DzSetSecondsRemaining 0x0452 #define ServerOP_DzDurationUpdate 0x0453 #define ServerOP_DzSetCompass 0x0454 #define ServerOP_DzSetSafeReturn 0x0455 #define ServerOP_DzSetZoneIn 0x0456 +#define ServerOP_DzSwapMembers 0x0457 +#define ServerOP_DzGetMemberStatuses 0x0458 +#define ServerOP_DzUpdateMemberStatus 0x0459 +#define ServerOP_DzLeaderChanged 0x045a +#define ServerOP_DzExpireWarning 0x045b +#define ServerOP_DzCreated 0x045c +#define ServerOP_DzDeleted 0x045d #define ServerOP_LSInfo 0x1000 #define ServerOP_LSStatus 0x1001 @@ -395,7 +399,10 @@ public: } void WriteUInt8(uint8 value) { *(uint8 *)(pBuffer + _wpos) = value; _wpos += sizeof(uint8); } + void WriteInt8(uint8_t value) { *(uint8_t *)(pBuffer + _wpos) = value; _wpos += sizeof(uint8_t); } void WriteUInt32(uint32 value) { *(uint32 *)(pBuffer + _wpos) = value; _wpos += sizeof(uint32); } + void WriteInt32(int32_t value) { *(int32_t *)(pBuffer + _wpos) = value; _wpos += sizeof(int32_t); } + void WriteString(const char * str) { uint32 len = static_cast(strlen(str)) + 1; memcpy(pBuffer + _wpos, str, len); _wpos += len; } uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; } @@ -2025,47 +2032,28 @@ struct ServerExpeditionID_Struct { uint32 sender_instance_id; }; -struct ServerExpeditionLeaderID_Struct { - uint32 expedition_id; +struct ServerDzLeaderID_Struct { + uint32 dz_id; uint32 leader_id; }; -struct ServerExpeditionMemberChange_Struct { - uint32 expedition_id; - uint32 sender_zone_id; - uint16 sender_instance_id; - uint8 removed; // 0: added, 1: removed - uint32 char_id; - char char_name[64]; -}; - -struct ServerExpeditionMemberSwap_Struct { - uint32 expedition_id; - uint32 sender_zone_id; - uint16 sender_instance_id; - uint32 add_char_id; - uint32 remove_char_id; - char add_char_name[64]; - char remove_char_name[64]; -}; - -struct ServerExpeditionMemberStatus_Struct { - uint32 expedition_id; +struct ServerDzMemberStatus_Struct { + uint32 dz_id; uint32 sender_zone_id; uint16 sender_instance_id; uint8 status; // 0: unknown 1: Online 2: Offline 3: In Dynamic Zone 4: Link Dead uint32 character_id; }; -struct ServerExpeditionMemberStatusEntry_Struct { +struct ServerDzMemberStatusEntry_Struct { uint32 character_id; uint8 online_status; // 0: unknown 1: Online 2: Offline 3: In Dynamic Zone 4: Link Dead }; -struct ServerExpeditionMemberStatuses_Struct { - uint32 expedition_id; +struct ServerDzMemberStatuses_Struct { + uint32 dz_id; uint32 count; - ServerExpeditionMemberStatusEntry_Struct entries[0]; + ServerDzMemberStatusEntry_Struct entries[0]; }; struct ServerExpeditionLockout_Struct { @@ -2109,8 +2097,8 @@ struct ServerExpeditionCharacterID_Struct { uint32_t character_id; }; -struct ServerExpeditionExpireWarning_Struct { - uint32_t expedition_id; +struct ServerDzExpireWarning_Struct { + uint32_t dz_id; uint32_t minutes_remaining; }; @@ -2123,13 +2111,21 @@ struct ServerDzCommand_Struct { }; struct ServerDzCommandMakeLeader_Struct { - uint32 expedition_id; + uint32 dz_id; uint32 requester_id; uint8 is_online; // set by world, 0: new leader name offline, 1: online uint8 is_success; // set by world, 0: makeleader failed, 1: success (is online member) char new_leader_name[64]; }; +struct ServerDzID_Struct { + uint32 dz_id; + uint16 dz_zone_id; + uint16 dz_instance_id; // for cache-independent redundancy (messages to dz's instance) + uint32 sender_zone_id; + uint16 sender_instance_id; +}; + struct ServerDzLocation_Struct { uint32 dz_id; uint32 sender_zone_id; @@ -2141,11 +2137,29 @@ struct ServerDzLocation_Struct { float heading; }; -struct ServerDzCharacter_Struct { - uint16 zone_id; - uint16 instance_id; - uint8 remove; // 0: added 1: removed +struct ServerDzMember_Struct { + uint32 dz_id; + uint16 dz_zone_id; + uint16 dz_instance_id; // for cache redundancy + uint16 sender_zone_id; + uint16 sender_instance_id; + uint8 removed; // 0: added, 1: removed uint32 character_id; + uint8 character_status; // 0: unknown 1: Online 2: Offline 3: In Dynamic Zone 4: Link Dead + char character_name[64]; +}; + +struct ServerDzMemberSwap_Struct { + uint32 dz_id; + uint16 dz_zone_id; + uint16 dz_instance_id; // for cache redundancy + uint16 sender_zone_id; + uint16 sender_instance_id; + uint32 add_character_id; + uint32 remove_character_id; + uint8 add_character_status; + char add_character_name[64]; + char remove_character_name[64]; }; struct ServerDzSetDuration_Struct { @@ -2153,6 +2167,13 @@ struct ServerDzSetDuration_Struct { uint32 seconds; }; +struct ServerDzCreateSerialized_Struct { + uint16_t origin_zone_id; + uint16_t origin_instance_id; + uint32_t cereal_size; + char cereal_data[0]; +}; + #pragma pack() #endif diff --git a/common/shared_tasks.cpp b/common/shared_tasks.cpp new file mode 100644 index 000000000..18ffbfe78 --- /dev/null +++ b/common/shared_tasks.cpp @@ -0,0 +1,139 @@ +#include "shared_tasks.h" +#include "repositories/character_data_repository.h" +#include + +std::vector SharedTask::GetActivityState() const +{ + return m_shared_task_activity_state; +} + +std::vector SharedTask::GetMembers() const +{ + return m_members; +} + +void SharedTask::SetSharedTaskActivityState(const std::vector &activity_state) +{ + SharedTask::m_shared_task_activity_state = activity_state; +} + +void SharedTask::SetTaskData(const TasksRepository::Tasks &task_data) +{ + SharedTask::m_task_data = task_data; +} + +void SharedTask::SetTaskActivityData(const std::vector &task_activity_data) +{ + SharedTask::m_task_activity_data = task_activity_data; +} + +const TasksRepository::Tasks &SharedTask::GetTaskData() const +{ + return m_task_data; +} + +const std::vector &SharedTask::GetTaskActivityData() const +{ + return m_task_activity_data; +} + +void SharedTask::SetMembers(const std::vector &members) +{ + SharedTask::m_members = members; +} + +const SharedTasksRepository::SharedTasks &SharedTask::GetDbSharedTask() const +{ + return m_db_shared_task; +} + +void SharedTask::SetDbSharedTask(const SharedTasksRepository::SharedTasks &m_db_shared_task) +{ + SharedTask::m_db_shared_task = m_db_shared_task; +} + +SharedTaskRequestCharacters SharedTask::GetRequestCharacters(Database &db, uint32_t requested_character_id) +{ + SharedTaskRequestCharacters request{}; + + request.group_type = SharedTaskRequestGroupType::Group; + request.characters = CharacterDataRepository::GetWhere( + db, fmt::format( + "id IN (select charid from group_id where groupid = (select groupid from group_id where charid = {}))", + requested_character_id + ) + ); + + if (request.characters.empty()) { + request.group_type = SharedTaskRequestGroupType::Raid; + request.characters = CharacterDataRepository::GetWhere( + db, fmt::format( + "id IN (select charid from raid_members where raidid = (select raidid from raid_members where charid = {}))", + requested_character_id + ) + ); + } + + if (request.characters.empty()) // solo request + { + request.group_type = SharedTaskRequestGroupType::Solo; + request.characters = CharacterDataRepository::GetWhere( + db, fmt::format( + "id = {} LIMIT 1", + requested_character_id + ) + ); + } + + request.lowest_level = std::numeric_limits::max(); + request.highest_level = 0; + for (const auto &character: request.characters) { + request.lowest_level = std::min(request.lowest_level, character.level); + request.highest_level = std::max(request.highest_level, character.level); + request.character_ids.emplace_back(character.id); // convenience + } + + return request; +} + +void SharedTask::AddCharacterToMemberHistory(uint32_t character_id) +{ + auto it = std::find(member_id_history.begin(), member_id_history.end(), character_id); + if (it == member_id_history.end()) { + member_id_history.emplace_back(character_id); + } +} + +SharedTaskMember SharedTask::FindMemberFromCharacterID(uint32_t character_id) const +{ + auto it = std::find_if( + m_members.begin(), m_members.end(), + [&](const SharedTaskMember &member) { + return member.character_id == character_id; + } + ); + + return it != m_members.end() ? *it : SharedTaskMember{}; +} + +SharedTaskMember SharedTask::FindMemberFromCharacterName(const std::string &character_name) const +{ + auto it = std::find_if( + m_members.begin(), m_members.end(), + [&](const SharedTaskMember &member) { + return strcasecmp(member.character_name.c_str(), character_name.c_str()) == 0; + } + ); + + return it != m_members.end() ? *it : SharedTaskMember{}; +} + +SharedTaskMember SharedTask::GetLeader() const +{ + for (const auto &member : m_members) { + if (member.is_leader) { + return member; + } + } + return {}; +} diff --git a/common/shared_tasks.h b/common/shared_tasks.h new file mode 100644 index 000000000..2a2363ffd --- /dev/null +++ b/common/shared_tasks.h @@ -0,0 +1,204 @@ +#ifndef EQEMU_SHARED_TASKS_H +#define EQEMU_SHARED_TASKS_H + +#include "database.h" +#include "types.h" +#include "repositories/character_data_repository.h" +#include "repositories/tasks_repository.h" +#include "repositories/task_activities_repository.h" +#include "repositories/shared_tasks_repository.h" +#include +#include +#include + +// ops +#define ServerOP_SharedTaskRequest 0x0300 // zone -> world. Player trying to get task. Relayed world -> zone on confirmation +#define ServerOP_SharedTaskAddPlayer 0x0301 // bidirectional. /taskaddplayer request zone -> world. success world -> zone +#define ServerOP_SharedTaskMakeLeader 0x0302 // zone -> world -> zone +#define ServerOP_SharedTaskRemovePlayer 0x0303 // zone -> world -> zone +#define ServerOP_SharedTaskAttemptRemove 0x0304 // zone -> world. Player trying to delete task +#define ServerOP_SharedTaskUpdate 0x0305 // zone -> world. Client sending task update to world. Relayed world -> zone on confirmation +#define ServerOP_SharedTaskMemberlist 0x0306 // world -> zone. Send shared task memberlist +#define ServerOP_SharedTaskRequestMemberlist 0x0307 // zone -> world. Send shared task memberlist (zone in initial for now, could change) +#define ServerOP_SharedTaskAcceptNewTask 0x0308 // world -> zone. World verified, continue AcceptNewTask +#define ServerOP_SharedTaskInvitePlayer 0x0309 // world -> zone. Sends task invite to player +#define ServerOP_SharedTaskInviteAcceptedPlayer 0x0310 // zone -> world. Confirming task invite +#define ServerOP_SharedTaskCreateDynamicZone 0x0311 // zone -> world +#define ServerOP_SharedTaskPurgeAllCommand 0x0312 // zone -> world +#define ServerOP_SharedTaskPlayerList 0x0313 // zone -> world /taskplayerlist command +#define ServerOP_SharedTaskMemberChange 0x0314 // world -> zone. Send shared task single member added/removed (client also handles message) +#define ServerOP_SharedTaskKickPlayers 0x0315 // zone -> world /kickplayers task + +enum class SharedTaskRequestGroupType { + Solo = 0, + Group, + Raid +}; + +// used in +// ServerOP_SharedTaskRequest + +// ServerOP_SharedTaskAcceptNewTask +struct ServerSharedTaskRequest_Struct { + uint32 requested_character_id; + uint32 requested_task_id; + uint32 requested_npc_type_id; // original task logic passthrough + uint32 accept_time; +}; + +// ServerOP_SharedTaskInvitePlayer +struct ServerSharedTaskInvitePlayer_Struct { + uint32 requested_character_id; + uint32 invite_shared_task_id; + char task_name[64]; + char inviter_name[64]; +}; + +// ServerOP_SharedTaskAttemptRemove +// gets re-used when sent back to clients +struct ServerSharedTaskAttemptRemove_Struct { + uint32 requested_character_id; + uint32 requested_task_id; + bool remove_from_db; +}; + +// used in the shared task request process (currently) +struct SharedTaskMember { + uint32 character_id = 0; + std::string character_name; + bool is_leader = false; + + template + void serialize(Archive& archive) + { + archive(character_id, character_name, is_leader); + } +}; + +// used in shared task requests to validate group/raid members +struct SharedTaskRequestCharacters { + int lowest_level; + int highest_level; + SharedTaskRequestGroupType group_type; + std::vector character_ids; + std::vector characters; +}; + +// ServerOP_SharedTaskMemberlist +// builds the buffer and sends to clients directly +struct ServerSharedTaskMemberListPacket_Struct { + uint32 destination_character_id; + uint32 cereal_size; + char cereal_serialized_members[0]; // serialized member list using cereal +}; + +struct ServerSharedTaskMemberChangePacket_Struct { + uint32 destination_character_id; + uint32 shared_task_id; + bool removed; + char player_name[64]; +}; + +struct SharedTaskActivityStateEntry { + uint32 activity_id; + uint32 done_count; + uint32 max_done_count; // goalcount + uint32 updated_time; + uint32 completed_time; +}; + +struct ServerSharedTaskActivityUpdate_Struct { + uint32 source_character_id; + uint32 task_id; + uint32 activity_id; + uint32 done_count; + bool ignore_quest_update; +}; + +struct ServerSharedTaskRequestMemberlist_Struct { + uint32 source_character_id; + uint32 task_id; +}; + +struct ServerSharedTaskRemovePlayer_Struct { + uint32 source_character_id; + uint32 task_id; + char player_name[64]; +}; + +struct ServerSharedTaskAddPlayer_Struct { + uint32 source_character_id; + uint32 task_id; + char player_name[64]; +}; + +struct ServerSharedTaskMakeLeader_Struct { + uint32 source_character_id; + uint32 task_id; + char player_name[64]; +}; + +struct ServerSharedTaskInviteAccepted_Struct { + uint32 source_character_id; + uint32 shared_task_id; + bool accepted; + char player_name[64]; +}; + +struct ServerSharedTaskCreateDynamicZone_Struct { + uint32 source_character_id; + uint32 task_id; + uint32 cereal_size; + char cereal_data[0]; // serialized dz with creation parameters +}; + +struct ServerSharedTaskPlayerList_Struct { + uint32 source_character_id; + uint32 task_id; +}; + +struct ServerSharedTaskKickPlayers_Struct { + uint32 source_character_id; + uint32 task_id; +}; + +class SharedTask { +public: + // used in both zone and world validation + static SharedTaskRequestCharacters GetRequestCharacters(Database& db, uint32_t requested_character_id); + + void AddCharacterToMemberHistory(uint32_t character_id); + SharedTaskMember FindMemberFromCharacterID(uint32_t character_id) const; + SharedTaskMember FindMemberFromCharacterName(const std::string& character_name) const; + SharedTaskMember GetLeader() const; + std::vector GetActivityState() const; + std::vector GetMembers() const; + + // getters + const std::vector &GetTaskActivityData() const; + const TasksRepository::Tasks &GetTaskData() const; + + // setters + void SetMembers(const std::vector &members); + void SetSharedTaskActivityState(const std::vector &activity_state); + void SetTaskActivityData(const std::vector &task_activity_data); + void SetTaskData(const TasksRepository::Tasks &task_data); + + // active record of database shared task + const SharedTasksRepository::SharedTasks &GetDbSharedTask() const; + void SetDbSharedTask(const SharedTasksRepository::SharedTasks &m_db_shared_task); + + std::vector m_shared_task_activity_state; + std::vector m_members; + std::vector member_id_history; // past and present members for replay timers + std::vector dynamic_zone_ids; + +protected: + SharedTasksRepository::SharedTasks m_db_shared_task; + + // reference to task data (only for this shared task) + TasksRepository::Tasks m_task_data; + std::vector m_task_activity_data; +}; + +#endif //EQEMU_SHARED_TASKS_H diff --git a/common/tasks.h b/common/tasks.h new file mode 100644 index 000000000..8d19910e7 --- /dev/null +++ b/common/tasks.h @@ -0,0 +1,445 @@ +#ifndef EQEMU_TASKS_H +#define EQEMU_TASKS_H + +#include "serialize_buffer.h" + +#define MAXTASKS 10000 +#define MAXTASKSETS 1000 +#define MAXACTIVEQUESTS 19 // The Client has a hard cap of 19 active quests, 29 in SoD+ +#define MAXCHOOSERENTRIES 40 // The Max Chooser (Task Selector entries) is capped at 40 in the Titanium Client. +#define MAXACTIVITIESPERTASK 20 // The Client has a hard cap of 20 activities per task. +#define TASKSLOTEMPTY 0 // This is used to determine if a client's active task slot is empty. + +#define TASKSLOTTASK 0 +#define TASKSLOTSHAREDTASK 0 + +// Command Codes for worldserver ServerOP_ReloadTasks +#define RELOADTASKS 0 +#define RELOADTASKGOALLISTS 1 +#define RELOADTASKPROXIMITIES 2 +#define RELOADTASKSETS 3 + +typedef enum { + METHODSINGLEID = 0, + METHODLIST = 1, + METHODQUEST = 2 +} TaskMethodType; + +enum class TaskActivityType : int32_t // task element/objective +{ + Unknown = -1, // hidden + None = 0, + Deliver = 1, + Kill = 2, + Loot = 3, + SpeakWith = 4, + Explore = 5, + TradeSkill = 6, + Fish = 7, + Forage = 8, + CastOn = 9, + SkillOn = 10, + Touch = 11, + Collect = 13, + GiveCash = 100 +}; + +enum class TaskTimerType +{ + Replay = 0, + Request +}; + +struct ActivityInformation { + int step_number; + TaskActivityType activity_type; + std::string target_name; // name mob, location -- default empty, max length 64 + std::string item_list; // likely defaults to empty + std::string skill_list; // IDs ; separated -- default -1 + std::string spell_list; // IDs ; separated -- default 0 + std::string description_override; // overrides auto generated description -- default empty, max length 128 + int skill_id; // older clients, first id from above + int spell_id; // older clients, first id from above + int goal_id; + TaskMethodType goal_method; + int goal_count; + int deliver_to_npc; + std::vector zone_ids; + std::string zones; // IDs ; separated, ZoneID is the first in this list for older clients -- default empty string, max length 64 + bool optional; + + inline bool CheckZone(int zone_id) + { + if (zone_ids.empty()) { + return true; + } + return std::find(zone_ids.begin(), zone_ids.end(), zone_id) != zone_ids.end(); + } + + void SerializeSelector(SerializeBuffer& out, EQ::versions::ClientVersion client_version) const + { + out.WriteInt32(static_cast(activity_type)); + out.WriteInt32(0); // solo/group/raid request type? (no longer in live) + out.WriteString(target_name); // target name used in objective type string (max 64) + + if (client_version >= EQ::versions::ClientVersion::RoF) + { + out.WriteLengthString(item_list); // used in objective type string (can be empty for none) + out.WriteInt32(activity_type == TaskActivityType::GiveCash ? 1 : goal_count); + out.WriteLengthString(skill_list); // used in SkillOn objective type string, "-1" for none + out.WriteLengthString(spell_list); // used in CastOn objective type string, "0" for none + out.WriteString(zones); // used in objective zone column and task select "begins in" (may have multiple, "0" for "unknown zone", empty for "ALL") + } + else + { + out.WriteString(item_list); + out.WriteInt32(activity_type == TaskActivityType::GiveCash ? 1 : goal_count); + out.WriteInt32(skill_id); + out.WriteInt32(spell_id); + out.WriteInt32(zone_ids.empty() ? 0 : zone_ids.front()); + } + + out.WriteString(description_override); + + if (client_version >= EQ::versions::ClientVersion::RoF) { + out.WriteString(zones); // serialized again after description (seems unused) + } + } + + void SerializeObjective(SerializeBuffer& out, EQ::versions::ClientVersion client_version, int done_count) const + { + // cash objectives internally repurpose goal_count to store cash amount and + // done_count as a boolean (should not be sent as actual completed/goal counts) + int real_goal_count = goal_count; + if (activity_type == TaskActivityType::GiveCash) + { + done_count = (done_count >= goal_count) ? 1 : 0; + real_goal_count = 1; + } + + out.WriteInt32(static_cast(activity_type)); + + if (client_version >= EQ::versions::ClientVersion::RoF) { + out.WriteInt8(optional ? 1 : 0); + } else { + out.WriteInt32(optional ? 1 : 0); + } + + out.WriteInt32(0); // solo/group/raid request type? (no longer in live) + out.WriteString(target_name); // target name used in objective type string (max 64) + + if (client_version >= EQ::versions::ClientVersion::RoF) + { + out.WriteLengthString(item_list); // used in objective type string (can be empty for none) + out.WriteInt32(real_goal_count); + out.WriteLengthString(skill_list); // used in SkillOn objective type string, "-1" for none + out.WriteLengthString(spell_list); // used in CastOn objective type string, "0" for none + out.WriteString(zones); // used in objective zone column and task select "begins in" ("0" for "unknown zone", empty for "ALL") + } + else + { + out.WriteString(item_list); + out.WriteInt32(real_goal_count); + out.WriteInt32(skill_id); + out.WriteInt32(spell_id); + out.WriteInt32(zone_ids.empty() ? 0 : zone_ids.front()); + } + + out.WriteInt32(0); // unknown id + out.WriteString(description_override); + out.WriteInt32(done_count); + out.WriteInt8(1); // unknown + + if (client_version >= EQ::versions::ClientVersion::RoF) + { + out.WriteString(zones); // serialized again after description (seems unused) + } + } +}; + +typedef enum { + ActivitiesSequential = 0, + ActivitiesStepped = 1 +} SequenceType; + +enum class TaskType { + Task = 0, // can have at max 1 + Shared = 1, // can have at max 1 + Quest = 2, // can have at max 19 or 29 depending on client + E = 3 // can have at max 19 or 29 depending on client, not present in live anymore +}; + +static const uint8 TASK_TYPE_TASK = 0; +static const uint8 TASK_TYPE_SHARED = 1; +static const uint8 TASK_TYPE_QUEST = 2; + +enum class DurationCode { + None = 0, + Short = 1, + Medium = 2, + Long = 3 +}; + +struct TaskInformation { + TaskType type; + int duration{}; + DurationCode duration_code; // description for time investment for when duration == 0 + std::string title{}; // max length 64 + std::string description{}; // max length 4000, 2048 on Tit + std::string reward{}; + std::string item_link{}; // max length 128 older clients, item link gets own string + std::string completion_emote{}; // emote after completing task, yellow. Maybe should make more generic ... but yellow for now! + int reward_id{}; + int cash_reward{}; // Expressed in copper + int experience_reward{}; + int faction_reward{}; // just a npc_faction_id + TaskMethodType reward_method; + int reward_radiant_crystals; + int reward_ebon_crystals; + int activity_count{}; + SequenceType sequence_mode; + int last_step{}; + short min_level{}; + short max_level{}; + int level_spread; + int min_players; + int max_players; + bool repeatable{}; + int replay_timer_seconds; + int request_timer_seconds; + ActivityInformation activity_information[MAXACTIVITIESPERTASK]; + + void SerializeSelector(SerializeBuffer& out, EQ::versions::ClientVersion client_version) const + { + if (client_version != EQ::versions::ClientVersion::Titanium) { + out.WriteFloat(1.0f); // reward multiplier (affects color, <1.0: yellow-red, 1.0: white, >1.0: lightgreen-green) + } + + out.WriteUInt32(duration); // task duration (seconds) (0: task_duration_code used, "Unlimited" on live) + out.WriteUInt32(static_cast(duration_code)); // 1: Short 2: Medium 3: Long anything else Unlimited (no longer in live) + out.WriteString(title); // max 64 with null + out.WriteString(description); // max 4000 with null + + if (client_version != EQ::versions::ClientVersion::Titanium) { + out.WriteUInt8(0); // 0: no rewards 1: enables "Reward Preview" button + } + + // selector only needs to send the first objective to fill description starting zone + out.WriteUInt32(std::min(activity_count, 1)); // number of task objectives + if (activity_count > 0) + { + out.WriteUInt32(0); // objective index + activity_information[0].SerializeSelector(out, client_version); + } + } +}; + +typedef enum { + ActivityHidden = 0, + ActivityActive = 1, + ActivityCompleted = 2 +} ActivityState; + +struct ClientActivityInformation { + int activity_id; + int done_count; + ActivityState activity_state; + bool updated; // Flag so we know if we need to updated the database +}; + +struct ClientTaskInformation { + int slot; // intrusive, but makes things easier :P + int task_id; + int current_step; + int accepted_time; + bool updated; + ClientActivityInformation activity[MAXACTIVITIESPERTASK]; +}; + +struct CompletedTaskInformation { + int task_id; + int completed_time; + bool activity_done[MAXACTIVITIESPERTASK]; +}; + +namespace Tasks { + + inline int GetActivityStateIdentifier(ActivityState activity_state) + { + switch (activity_state) { + case ActivityHidden: + return 0; + case ActivityActive: + return 1; + case ActivityCompleted: + return 2; + default: + return 0; + } + } + inline std::string GetActivityStateDescription(ActivityState activity_state) + { + switch (activity_state) { + case ActivityHidden: + return "Hidden"; + case ActivityActive: + return "Active"; + case ActivityCompleted: + return "Completed"; + default: + return "Hidden"; + } + } + + inline int GetTaskTypeIdentifier(TaskType task_type) + { + switch (task_type) { + case TaskType::Task: + return 0; + case TaskType::Shared: + return 1; + case TaskType::Quest: + return 2; + case TaskType::E: + return 3; + default: + return 0; + } + } + inline std::string GetTaskTypeDescription(TaskType task_type) + { + switch (task_type) { + case TaskType::Task: + return "Task"; + case TaskType::Shared: + return "Shared"; + case TaskType::Quest: + return "Quest"; + case TaskType::E: + return "E"; + default: + return "Task"; + } + } +} + +namespace SharedTaskMessage { + constexpr uint16 TASK_ASSIGN_WAIT_REPLAY_TIMER = 8017; // This task can not be assigned to you because you must wait %1d:%2h:%3m before you can do another task of this type. + constexpr uint16 COULD_NOT_USE_COMMAND = 8272; // You could not use this command because you are not currently assigned to a shared task. + constexpr uint16 AVG_LVL_LOW = 8553; // You can not be assigned this shared task because your party's average level is too low. + constexpr uint16 AVG_LVL_HIGH = 8889; // You can not be assigned this shared task because your party's average level is too high. + constexpr uint16 LVL_SPREAD_HIGH = 8890; // You can not be assigned this shared task because your party's level spread is too high. + constexpr uint16 PARTY_EXCEED_MAX_PLAYER = 8891; // You can not be assigned this shared task because your party exceeds the maximum allowed number of players. + constexpr uint16 LEADER_NOT_MEET_REQUIREMENTS = 8892; // You can not be assigned this shared task because the leader does not meet the shared task requirements. + constexpr uint16 SHARED_TASK_NOT_MEET_MIN_NUM_PLAYER = 8895; // You can not be assigned this shared task because your party does not contain the minimum required number of players. + constexpr uint16 WILL_REMOVE_ZONE_TWO_MIN_RAID_NOT_MIN_NUM_PLAYER = 8908; // %1 will be removed from their zone in two minutes because your raid does not meet the minimum requirement of qualified players. + constexpr uint16 WILL_REMOVE_ZONE_TWO_MIN_GROUP_NOT_MIN_NUM_PLAYER = 8909; // %1 will be removed from their zone in two minutes because your group does not meet the minimum requirement of qualified players. + constexpr uint16 WILL_REMOVE_AREA_TWO_MIN_RAID_NOT_MIN_NUM_PLAYER = 8910; // %1 will be removed from their area in two minutes because your raid does not meet the minimum requirement of qualified players. + constexpr uint16 WILL_REMOVE_AREA_TWO_MIN_GROUP_NOT_MIN_NUM_PLAYER = 8911; // %1 will be removed from their area in two minutes because your group does not meet the minimum requirement of qualified players. + constexpr uint16 HAS_REMOVED_ZONE_TWO_MIN_RAID_NOT_MIN_NUM_PLAYER = 8912; // %1 has been removed from their zone because your raid does not meet the minimum requirement of qualified players. + constexpr uint16 HAS_REMOVED_ZONE_TWO_MIN_GROUP_NOT_MIN_NUM_PLAYER = 8913; // %1 has been removed from their zone because your group does not meet the minimum requirement of qualified players. + constexpr uint16 HAS_REMOVED_AREA_TWO_MIN_RAID_NOT_MIN_NUM_PLAYER = 8914; // %1 has been removed from their area because your raid does not meet the minimum requirement of qualified players. + constexpr uint16 HAS_REMOVED_AREA_TWO_MIN_GROUP_NOT_MIN_NUM_PLAYER = 8915; // %1 has been removed from their area because your group does not meet the minimum requirement of qualified players. + constexpr uint16 SEND_INVITE_TO = 8916; // Sending a shared task invitation to %1. + constexpr uint16 COULD_NOT_BE_INVITED = 8917; // %1 could not be invited to join you. + constexpr uint16 YOU_ARE_NOT_LEADER_COMMAND_ISSUE = 8919; // You are not the shared task leader. Only %1 can issue this command. + constexpr uint16 SWAP_SENDING_INVITATION_TO = 8920; // Sending an invitation to: %1. They must accept in order to swap party members. + constexpr uint16 SWAP_ACCEPTED_OFFER = 8921; // %1 has accepted your offer to join your shared task. Swapping %1 for %2. + constexpr uint16 IS_NOT_MEMBER = 8922; // %1 is not a member of this shared task. + constexpr uint16 NOT_ALLOW_PLAYER_REMOVE = 8923; // The shared task is not allowing players to be removed from it at this time. + constexpr uint16 PLAYER_HAS_BEEN_REMOVED = 8924; // %1 has been removed from your shared task, '%2'. + constexpr uint16 TRANSFER_LEADERSHIP_NOT_ONLINE = 8925; // %1 is not currently online. You can only transfer leadership to an online member of the shared task. + constexpr uint16 MADE_LEADER = 8926; // %1 has been made the leader for this shared task. + constexpr uint16 YOU_MADE_LEADER = 8927; // You have been made the leader of this shared task. + constexpr uint16 LEADER_PRINT = 8928; // Shared Task Leader: %1 + constexpr uint16 MEMBERS_PRINT = 8929; // Shared Task Members: %1 + constexpr uint16 PLAYER_ACCEPTED_OFFER_JOIN = 8930; // %1 has accepted your offer to join your shared task. + constexpr uint16 PLAYER_HAS_BEEN_ADDED = 8931; // %1 has been added to your shared task, '%2'. + constexpr uint16 ACCEPTED_OFFER_TO_JOIN_BUT_COULD_NOT = 8932; // %1 accepted your offer to join your shared task but could not. + constexpr uint16 PLAYER_DECLINED_OFFER = 8933; // %1 has declined your offer to join your shared task. + constexpr uint16 PLAYER_HAS_ASKED_YOU_TO_JOIN = 8934; // %1 has asked you to join the shared task '%2'. Would you like to join? + constexpr uint16 NO_REQUEST_BECAUSE_HAVE_ONE = 8935; // You may not request a shared task because you already have one. + constexpr uint16 NO_REQUEST_BECAUSE_RAID_HAS_ONE = 8936; // You may not request a shared task because someone in your raid, %1, already has one. + constexpr uint16 NO_REQUEST_BECAUSE_GROUP_HAS_ONE = 8937; // You may not request a shared task because someone in your group, %1, already has one. + constexpr uint16 YOU_DO_NOT_MEET_REQ_AVAILABLE = 8938; // You do not meet the requirements for any available shared tasks. + constexpr uint16 YOUR_RAID_DOES_NOT_MEET_REQ = 8939; // Your raid does not meet the requirements for any available shared tasks. + constexpr uint16 YOUR_GROUP_DOES_NOT_MEET_REQ = 8940; // Your group does not meet the requirements for any available shared tasks. + constexpr uint16 YOUR_GROUP__RAID_DOES_NOT_MEET_REQ = 8941; // You can not be assigned this shared task because the raid or group does not meet the shared task requirements. + constexpr uint16 YOU_NO_LONGER_MEMBER = 8942; // You are no longer a member of the shared task. + constexpr uint16 YOU_MAY_NOT_REQUEST_EXPANSION = 8943; // You may not request this shared task because you do not have the required expansion. + constexpr uint16 PLAYER_MAY_NOT_REQUEST_EXPANSION = 8944; // You may not request this shared task because %1 does not have the required expansion. + constexpr uint16 TWO_MIN_REQ_TASK_TERMINATED = 8945; // If your party does not meet the requirements in two minutes, the shared task will be terminated. + constexpr uint16 YOU_MUST_WAIT_REPLAY_TIMER = 8946; // You may not request this shared task because you must wait %1d:%2h:%3m before you can do another task of this type. + constexpr uint16 PLAYER_MUST_WAIT_REPLAY_TIMER = 8947; // You may not request this shared task because %1 must wait %2d:%3h:%4m before they can do another task of this type. + constexpr uint16 PLAYER_NOW_LEADER = 8948; // %1 is now the leader of your shared task, '%2'. + constexpr uint16 HAS_ENDED = 8951; // Your shared task, '%1', has ended. + constexpr uint16 YOU_ALREADY_LEADER = 8952; // You are already the leader of the shared task. + constexpr uint16 TASK_NO_LONGER_ACTIVE = 8953; // Your shared task, '%1', is no longer active. + constexpr uint16 YOU_HAVE_BEEN_ADDED_TO_TASK = 8954; // You have been added to the shared task '%1'. + constexpr uint16 YOU_ARE_NOW_LEADER = 8955; // You are now the leader of your shared task, '%1'. + constexpr uint16 YOU_HAVE_BEEN_REMOVED = 8956; // You have been removed from the shared task '%1'. + constexpr uint16 YOU_ARE_NO_LONGER_A_MEMBER = 8960; // You are no longer a member of the shared task, '%1'. + constexpr uint16 YOUR_TASK_NOW_LOCKED = 8961; // Your shared task is now locked. You may no longer add or remove players. + constexpr uint16 TASK_NOT_ALLOWING_PLAYERS_AT_TIME = 8962; // The shared task is not allowing players to be added at this time. + constexpr uint16 PLAYER_NOT_ONLINE_TO_ADD = 8963; // %1 is not currently online. A player needs to be online to be added to a shared task. + constexpr uint16 CANT_ADD_PLAYER_ALREADY_MEMBER = 8964; // You can not add %1 because they are already a member of this shared task. + constexpr uint16 CANT_ADD_PLAYER_ALREADY_ASSIGNED = 8965; // You can not add %1 because they are already assigned to another shared task. + constexpr uint16 PLAYER_ALREADY_OUTSTANDING_INVITATION_THIS = 8966; // %1 already has an outstanding invitation to join this shared task. + constexpr uint16 PLAYER_ALREADY_OUTSTANDING_ANOTHER = 8967; // %1 already has an outstanding invitation to join another shared task. Players may only have one invitation outstanding. + constexpr uint16 CANT_ADD_PLAYER_MAX_PLAYERS = 8968; // You can not add another player since you currently have the maximum number of players allowed (%1) in this shared task. + constexpr uint16 CANT_ADD_PLAYER_MAX_LEVEL_SPREAD = 8969; // You can not add this player because you would exceed the maximum level spread (%1) for this shared task. + constexpr uint16 CANT_ADD_PLAYER_MAX_AVERAGE_LEVEL = 8970; // You can not add this player because you would exceed the maximum average level for this shared task. + constexpr uint16 CANT_ADD_PLAYER_FALL_MIN_AVG_LEVEL = 8971; // You can not add this player because you would fall below the minimum average level for this shared task. + constexpr uint16 PLAYER_DOES_NOT_OWN_EXPANSION = 8972; // %1 does not own the expansion needed for this shared task. + constexpr uint16 CANT_ADD_PLAYER_PARTY_FILTER_REQ_FOR_TASK = 8973; // You can not add this player because your party would no longer meet the filter requirements for this shared task. + constexpr uint16 CANT_ADD_PLAYER_ONE_OF_GROUP_RAID_HAS_TASK = 8977; // You can not add %1 because they or one of their group or raid members is in another shared task. + constexpr uint16 CANT_JOIN_GROUP_ACTIVE_TASK = 8978; // You can not join that group because you have an active shared task. + constexpr uint16 CANT_ADD_PLAYER_REPLAY_TIMER = 8979; // You may not add %1 because they must wait %2d:%3h:%4m before they can do another task of this type. + constexpr uint16 CANT_LOOT_BECAUSE_TASK_LOCKED_BELONG = 8980; // You may not loot that corpse because you are not in the shared task the corpse belongs to. + constexpr uint16 CANT_ADD_PLAYER_BECAUSE_GROUP_RAID_BELONG_TASK = 8981; // The player could not be added to the raid because they or one of their group members is in a different shared task. + constexpr uint16 PLAYER_CANT_ADD_GROUP_BECAUSE_DIFF_TASK = 8982; // %1 can not be added to the group because they are in a different shared task. + constexpr uint16 YOU_CANT_ADD_TO_GROUP_BECAUSE_DIFF_TASK = 8983; // You can not be added to the group because you are in a different shared task. + constexpr uint16 PLAYER_CANT_ADD_RAID_BECAUSE_DIFF_TASK = 8984; // %1 can not be added to the raid because they are in a different shared task. + constexpr uint16 YOU_CANT_ADD_RAID_BECAUSE_DIFF_TASK = 8985; // You can not be added to the raid because you are in a different shared task. + constexpr uint16 REPLAY_TIMER_REMAINING = 8987; // '%1' replay timer: %2d:%3h:%4m remaining. + constexpr uint16 YOU_NO_CURRENT_REPLAY_TIMERS = 8989; // You do not currently have any task replay timers. + constexpr uint16 SURE_QUIT_TASK = 8995; // Are you sure you want to quit the task '%1'? + constexpr uint16 SURE_REMOVE_SELF_FROM_TASK = 8996; // Are you sure you want to remove yourself from the shared task '%1' + constexpr uint16 TASK_ASSIGN_WAIT_REQUEST_TIMER = 14506; // This task can not be assigned to you because you must wait %1d:%2h:%3m before you can request another task of this type. + constexpr uint16 REQUEST_TIMER_REMAINING = 14507; // '%1' request timer: %2d:%3h:%4m remaining. + constexpr uint16 YOU_MUST_WAIT_REQUEST_TIMER = 14508; // You may not request this shared task because you must wait %1d:%2h:%3m before you can request another task of this type. + constexpr uint16 RECEIVED_REQUEST_TIMER = 14509; // You have received a request timer for '%1': %2d:%3h:%4m remaining. + constexpr uint16 RECEIVED_REPLAY_TIMER = 14510; // You have received a replay timer for '%1': %2d:%3h:%4m remaining. + constexpr uint16 PLAYER_MUST_WAIT_REQUEST_TIMER = 14511; // You may not request this shared task because %1 must wait %2d:%3h:%4m before they can request another task of this type. + constexpr uint16 CANT_ADD_PLAYER_REQUEST_TIMER = 14512; // You may not add %1 because they must wait %2d:%3h:%4m before they can request another task of this type. + + // for eqstrs not in current emu clients (some are also used by non-shared tasks) + constexpr auto GetEQStr(uint16 eqstr_id) + { + switch (eqstr_id) + { + case SharedTaskMessage::COULD_NOT_USE_COMMAND: + return "You could not use this command because you are not currently assigned to a shared task."; + case SharedTaskMessage::TASK_ASSIGN_WAIT_REQUEST_TIMER: + return "This task can not be assigned to you because you must wait {}d:{}h:{}m before you can request another task of this type."; + case SharedTaskMessage::REQUEST_TIMER_REMAINING: + return "'{}' request timer: {}d:{}h:{}m remaining."; + case SharedTaskMessage::YOU_MUST_WAIT_REQUEST_TIMER: + return "You may not request this shared task because you must wait {}d:{}h:{}m before you can request another task of this type."; + case SharedTaskMessage::RECEIVED_REQUEST_TIMER: + return "You have received a request timer for '{}': {}d:{}h:{}m remaining."; + case SharedTaskMessage::RECEIVED_REPLAY_TIMER: + return "You have received a replay timer for '{}': {}d:{}h:{}m remaining."; + case SharedTaskMessage::PLAYER_MUST_WAIT_REQUEST_TIMER: + return "You may not request this shared task because {} must wait {}d:{}h:{}m before they can request another task of this type."; + case SharedTaskMessage::CANT_ADD_PLAYER_REQUEST_TIMER: + return "You may not add {} because they must wait {}d:{}h:{}m before they can request another task of this type."; + default: + LogTasks("[GetEQStr] Unhandled eqstr id [{}]", eqstr_id); + break; + } + return "Unknown EQStr"; + } +} + +#endif //EQEMU_TASKS_H diff --git a/common/version.h b/common/version.h index 18a11b1b1..bd84935ae 100644 --- a/common/version.h +++ b/common/version.h @@ -34,7 +34,7 @@ * Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt */ -#define CURRENT_BINARY_DATABASE_VERSION 9168 +#define CURRENT_BINARY_DATABASE_VERSION 9172 #ifdef BOTS #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9028 diff --git a/utils/patches/patch_RoF.conf b/utils/patches/patch_RoF.conf index 76178bf62..93175209e 100644 --- a/utils/patches/patch_RoF.conf +++ b/utils/patches/patch_RoF.conf @@ -560,12 +560,14 @@ OP_TaskActivityComplete=0x71cd OP_AcceptNewTask=0x394d OP_CancelTask=0x0c7f OP_TaskMemberList=0x748e # Was 0x1656 -OP_OpenNewTasksWindow=0x436c # Was 0x11de +OP_TaskSelectWindow=0x436c +OP_SharedTaskSelectWindow=0x436c OP_AvaliableTask=0x2bf8 # Was 0x2377 OP_TaskHistoryRequest=0x6cf6 OP_TaskHistoryReply=0x25eb OP_DeclineAllTasks=0x0000 OP_TaskRequestTimer=0x4b76 +OP_SharedTaskQuit=0x0000 # Title opcodes OP_NewTitlesAvailable=0x45d1 diff --git a/utils/patches/patch_RoF2.conf b/utils/patches/patch_RoF2.conf index 96f3258a8..ac69e5550 100644 --- a/utils/patches/patch_RoF2.conf +++ b/utils/patches/patch_RoF2.conf @@ -567,13 +567,26 @@ OP_CompletedTasks=0x4eba OP_TaskActivityComplete=0x5e19 OP_AcceptNewTask=0x0a23 OP_CancelTask=0x39f0 -OP_TaskMemberList=0x5727 -OP_OpenNewTasksWindow=0x48a2 OP_AvaliableTask=0x36e8 OP_TaskHistoryRequest=0x5f1c OP_TaskHistoryReply=0x3d05 OP_DeclineAllTasks=0x0000 OP_TaskRequestTimer=0x7a48 +OP_TaskSelectWindow=0x705b + +# Shared Tasks +OP_SharedTaskMemberList=0x1e7d # +OP_SharedTaskRemovePlayer=0x4865 # /taskremoveplayer +OP_SharedTaskAddPlayer=0x36e8 # /taskaddplayer +OP_SharedTaskMakeLeader=0x37f2 # /taskmakeleader +OP_SharedTaskInvite=0x3444 # Dialog window +OP_SharedTaskInviteResponse=0x7582 # Dialog window response +OP_SharedTaskAcceptNew=0x6646 # +OP_SharedTaskMemberChange=0x0119 # +OP_TaskTimers=0x2b0f # /tasktimers +OP_SharedTaskQuit=0x322e # /taskquit +OP_SharedTaskSelectWindow=0x48a2 +OP_SharedTaskPlayerList=0x5727 # /taskplayerlist # Title opcodes OP_NewTitlesAvailable=0x0d32 diff --git a/utils/patches/patch_SoD.conf b/utils/patches/patch_SoD.conf index 1ef8a138a..dd3ee0384 100644 --- a/utils/patches/patch_SoD.conf +++ b/utils/patches/patch_SoD.conf @@ -527,8 +527,6 @@ OP_LDoNOpen=0x6129 # C # Task packets OP_TaskActivityComplete=0x4df0 # C -OP_TaskMemberList=0x34ed # C -OP_OpenNewTasksWindow=0x4dd5 # C OP_AvaliableTask=0x2136 # C OP_AcceptNewTask=0x5832 # C OP_TaskHistoryRequest=0x29d7 # C @@ -536,7 +534,21 @@ OP_TaskHistoryReply=0x3d2a # C OP_CancelTask=0x726b # C OP_DeclineAllTasks=0x0000 # OP_TaskRequestTimer=0x2e70 +OP_TaskSelectWindow=0x009b +# Shared Tasks +OP_SharedTaskMemberList=0x55f4 # +OP_SharedTaskRemovePlayer=0x4a12 # /taskremoveplayer +OP_SharedTaskAddPlayer=0x2136 # /taskaddplayer +OP_SharedTaskMakeLeader=0x1da9 # /taskmakeleader +OP_SharedTaskInvite=0x40c5 # Dialog window +OP_SharedTaskInviteResponse=0x7abb # Dialog window response +OP_SharedTaskAcceptNew=0x4751 # Not sure why this has a separate handler +OP_SharedTaskMemberChange=0x98f6 # Not sure yet? +OP_TaskTimers=0x01cb # /tasktimers +OP_SharedTaskQuit=0x5854 # /taskquit +OP_SharedTaskSelectWindow=0x4dd5 +OP_SharedTaskPlayerList=0x34ed # /taskplayerlist OP_Shroud=0x6d1f OP_ShroudRemove=0x17f6 diff --git a/utils/patches/patch_SoF.conf b/utils/patches/patch_SoF.conf index 1c5fd3eda..e6aa71168 100644 --- a/utils/patches/patch_SoF.conf +++ b/utils/patches/patch_SoF.conf @@ -496,7 +496,8 @@ OP_LDoNOpen=0x4b92 #Xinu 03/19/09 #Task packets OP_TaskActivityComplete=0x7338 # -OP_OpenNewTasksWindow=0x17C3 # +OP_SharedTaskSelectWindow=0x17C3 +OP_TaskSelectWindow=0x17C3 OP_AvaliableTask=0x5d1d #Xinu 03/19/09 OP_AcceptNewTask=0x66A8 # OP_TaskHistoryRequest=0x3035 # @@ -511,7 +512,7 @@ OP_TaskMakeLeader=0x5050 OP_TaskAddPlayer=0x5d1d OP_TaskRemovePlayer=0x516f OP_TaskPlayerList=0x0ad6 -OP_TaskQuit=0x2c8c +OP_SharedTaskQuit=0x2c8c OP_TaskRequestTimer=0x0b08 #Title opcodes diff --git a/utils/patches/patch_Titanium.conf b/utils/patches/patch_Titanium.conf index 32d434e93..2c647f95c 100644 --- a/utils/patches/patch_Titanium.conf +++ b/utils/patches/patch_Titanium.conf @@ -459,8 +459,7 @@ OP_TaskActivityComplete=0x54eb OP_CompletedTasks=0x76a2 # ShowEQ 10/27/05 OP_TaskDescription=0x5ef7 # ShowEQ 10/27/05 OP_TaskActivity=0x682d # ShowEQ 10/27/05 -OP_TaskMemberList=0x722f #not sure -OP_OpenNewTasksWindow=0x5e7c #combined with OP_AvaliableTask I think +OP_TaskSelectWindow=0x5e7c OP_AvaliableTask=0x0000 OP_AcceptNewTask=0x207f OP_TaskHistoryRequest=0x5df4 @@ -473,11 +472,22 @@ OP_TaskMemberChange=0x5886 OP_TaskMakeLeader=0x1b25 OP_TaskAddPlayer=0x6bc4 OP_TaskRemovePlayer=0x37b9 -OP_TaskPlayerList=0x3961 -OP_TaskQuit=0x35dd OP_TaskRequestTimer=0x6a1d #task complete related: 0x0000 (24 bytes), 0x0000 (8 bytes), 0x0000 (4 bytes) +# Shared Tasks +OP_SharedTaskMemberList=0x722f # +OP_SharedTaskRemovePlayer=0x37b9 # /taskremoveplayer +OP_SharedTaskAddPlayer=0x6934 # /taskaddplayer +OP_SharedTaskMakeLeader=0x1b25 # /taskmakeleader +OP_SharedTaskInvite=0x79b4 # Dialog window +OP_SharedTaskInviteResponse=0x0358 # Dialog window response +OP_SharedTaskAcceptNew=0x194d # Not sure why this has a separate handler +OP_SharedTaskMemberChange=0x5886 # Not sure yet? +OP_TaskTimers=0x6a1d # /tasktimers +OP_SharedTaskQuit=0x35dd # /taskquit +OP_SharedTaskSelectWindow=0x013f +OP_SharedTaskPlayerList=0x3961 # /taskplayerlist OP_RequestClientZoneChange=0x7834 # ShowEQ 10/27/05 diff --git a/utils/patches/patch_UF.conf b/utils/patches/patch_UF.conf index 8efce91f6..4dd97fad0 100644 --- a/utils/patches/patch_UF.conf +++ b/utils/patches/patch_UF.conf @@ -551,8 +551,6 @@ OP_LDoNInspect=0x0aaa # Task packets OP_TaskActivityComplete=0x5832 # C -OP_TaskMemberList=0x66ba # C -OP_OpenNewTasksWindow=0x98f6 # C OP_AvaliableTask=0x6255 # C Mispelled? OP_AcceptNewTask=0x17d5 # C OP_TaskHistoryRequest=0x547c # C @@ -560,6 +558,21 @@ OP_TaskHistoryReply=0x4524 # C OP_CancelTask=0x3bf5 # C OP_DeclineAllTasks=0x0000 # OP_TaskRequestTimer=0x719e +OP_TaskSelectWindow=0x7309 + +# Shared Tasks +OP_SharedTaskMemberList=0x584e # +OP_SharedTaskRemovePlayer=0x18e2 # /taskremoveplayer +OP_SharedTaskAddPlayer=0x6255 # /taskaddplayer +OP_SharedTaskMakeLeader=0x5933 # /taskmakeleader +OP_SharedTaskInvite=0x55f4 # Dialog window +OP_SharedTaskInviteResponse=0x26e5 # Dialog window response +OP_SharedTaskAcceptNew=0x6ded # Not sure why this has a separate handler +OP_SharedTaskMemberChange=0x1402 # Not sure yet? +OP_TaskTimers=0x09b4 # /tasktimers +OP_SharedTaskQuit=0x6aba # /taskquit +OP_SharedTaskSelectWindow=0x98f6 +OP_SharedTaskPlayerList=0x66ba # /taskplayerlist # Title opcodes OP_NewTitlesAvailable=0x4b49 # C diff --git a/utils/sql/db_update_manifest.txt b/utils/sql/db_update_manifest.txt index 8e6a7a40e..cddfb7717 100644 --- a/utils/sql/db_update_manifest.txt +++ b/utils/sql/db_update_manifest.txt @@ -422,6 +422,10 @@ 9166|2021_02_12_dynamic_zone_members.sql|SHOW TABLES LIKE 'dynamic_zone_members'|empty| 9167|2021_06_06_beastlord_pets.sql|SHOW TABLES LIKE 'pets_beastlord_data'|empty| 9168|2021_08_31_pvp_duration.sql|SHOW COLUMNS FROM `spells_new` LIKE 'pvp_duration'|empty| +9169|2021_06_06_dynamic_zone_moved_columns.sql|SELECT * FROM db_version WHERE version >= 9169|empty| +9170|2021_03_03_instance_safereturns.sql|SHOW TABLES LIKE 'character_instance_safereturns'|empty| +9171|2021_03_30_remove_dz_is_current_member.sql|SHOW COLUMNS FROM `dynamic_zone_members` LIKE 'is_current_member'|not_empty| +9172|2021_05_21_shared_tasks.sql|SHOW TABLES LIKE 'shared_tasks'|empty| # Upgrade conditions: # This won't be needed after this system is implemented, but it is used database that are not diff --git a/utils/sql/git/required/2021_03_03_instance_safereturns.sql b/utils/sql/git/required/2021_03_03_instance_safereturns.sql new file mode 100644 index 000000000..6687b17a7 --- /dev/null +++ b/utils/sql/git/required/2021_03_03_instance_safereturns.sql @@ -0,0 +1,13 @@ +CREATE TABLE `character_instance_safereturns` ( + `id` int(10) unsigned NOT NULL AUTO_INCREMENT, + `character_id` int(10) unsigned NOT NULL, + `instance_zone_id` int(11) NOT NULL DEFAULT 0, + `instance_id` int(11) NOT NULL DEFAULT 0, + `safe_zone_id` int(11) NOT NULL DEFAULT 0, + `safe_x` float NOT NULL DEFAULT 0, + `safe_y` float NOT NULL DEFAULT 0, + `safe_z` float NOT NULL DEFAULT 0, + `safe_heading` float NOT NULL DEFAULT 0, + PRIMARY KEY (`id`), + UNIQUE KEY `character_id` (`character_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1 diff --git a/utils/sql/git/required/2021_03_30_remove_dz_is_current_member.sql b/utils/sql/git/required/2021_03_30_remove_dz_is_current_member.sql new file mode 100644 index 000000000..c3293ac2d --- /dev/null +++ b/utils/sql/git/required/2021_03_30_remove_dz_is_current_member.sql @@ -0,0 +1,6 @@ +-- remove any non-current members for new behavior +DELETE FROM `dynamic_zone_members` +WHERE is_current_member = 0; + +ALTER TABLE `dynamic_zone_members` + DROP COLUMN `is_current_member`; diff --git a/utils/sql/git/required/2021_05_21_shared_tasks.sql b/utils/sql/git/required/2021_05_21_shared_tasks.sql new file mode 100644 index 000000000..351cb5ba8 --- /dev/null +++ b/utils/sql/git/required/2021_05_21_shared_tasks.sql @@ -0,0 +1,97 @@ +-- shared task tables +CREATE TABLE `shared_tasks` +( + `id` bigint(20) NOT NULL AUTO_INCREMENT, + `task_id` int(11) DEFAULT NULL, + `accepted_time` datetime DEFAULT NULL, + `expire_time` datetime DEFAULT NULL, + `completion_time` datetime DEFAULT NULL, + `is_locked` tinyint(1) DEFAULT NULL, + PRIMARY KEY (`id`) +) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1; + +CREATE TABLE `shared_task_members` +( + `shared_task_id` bigint(20) NOT NULL, + `character_id` bigint(20) NOT NULL, + `is_leader` tinyint(4) DEFAULT NULL, + PRIMARY KEY (`shared_task_id`, `character_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +CREATE TABLE `shared_task_activity_state` +( + `shared_task_id` bigint(20) NOT NULL, + `activity_id` int(11) NOT NULL, + `done_count` int(11) DEFAULT NULL, + `updated_time` datetime DEFAULT NULL, + `completed_time` datetime DEFAULT NULL, + PRIMARY KEY (`shared_task_id`, `activity_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +CREATE TABLE `shared_task_dynamic_zones` +( + `shared_task_id` bigint(20) NOT NULL, + `dynamic_zone_id` int(10) unsigned NOT NULL, + PRIMARY KEY (`shared_task_id`, `dynamic_zone_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +-- completed shared task tables - simply stores completed for reporting and logging + +CREATE TABLE `completed_shared_tasks` +( + `id` bigint(20) NOT NULL, + `task_id` int(11) DEFAULT NULL, + `accepted_time` datetime DEFAULT NULL, + `expire_time` datetime DEFAULT NULL, + `completion_time` datetime DEFAULT NULL, + `is_locked` tinyint(1) DEFAULT NULL, + PRIMARY KEY (`id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +CREATE TABLE `completed_shared_task_members` +( + `shared_task_id` bigint(20) NOT NULL, + `character_id` bigint(20) NOT NULL, + `is_leader` tinyint(4) DEFAULT NULL, + PRIMARY KEY (`shared_task_id`, `character_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +CREATE TABLE `completed_shared_task_activity_state` +( + `shared_task_id` bigint(20) NOT NULL, + `activity_id` int(11) NOT NULL, + `done_count` int(11) DEFAULT NULL, + `updated_time` datetime DEFAULT NULL, + `completed_time` datetime DEFAULT NULL, + PRIMARY KEY (`shared_task_id`, `activity_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +-- tasks + +ALTER TABLE `tasks` + ADD COLUMN `level_spread` INT UNSIGNED NOT NULL DEFAULT 0 AFTER `maxlevel`, + ADD COLUMN `min_players` INT UNSIGNED NOT NULL DEFAULT 0 AFTER `level_spread`, + ADD COLUMN `max_players` INT UNSIGNED NOT NULL DEFAULT 0 AFTER `min_players`, + ADD COLUMN `replay_timer_seconds` INT UNSIGNED NOT NULL DEFAULT 0 AFTER `completion_emote`, + ADD COLUMN `request_timer_seconds` INT UNSIGNED NOT NULL DEFAULT 0 AFTER `replay_timer_seconds`; + +-- character timers + +CREATE TABLE `character_task_timers` +( + `id` int(10) unsigned NOT NULL AUTO_INCREMENT, + `character_id` int(10) unsigned NOT NULL DEFAULT 0, + `task_id` int(10) unsigned NOT NULL DEFAULT 0, + `timer_type` int(11) NOT NULL DEFAULT 0, + `expire_time` datetime NOT NULL DEFAULT current_timestamp(), + PRIMARY KEY (`id`), + KEY `character_id` (`character_id`), + KEY `task_id` (`task_id`) +) ENGINE=InnoDB DEFAULT CHARSET=latin1; + +ALTER TABLE `tasks` + CHANGE COLUMN `completion_emote` `completion_emote` VARCHAR (512) NOT NULL DEFAULT '' COLLATE 'latin1_swedish_ci' AFTER `faction_reward`; + +ALTER TABLE `tasks` + ADD COLUMN `reward_radiant_crystals` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `rewardmethod`, + ADD COLUMN `reward_ebon_crystals` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `reward_radiant_crystals`; diff --git a/utils/sql/git/required/2021_06_06_dynamic_zone_moved_columns.sql b/utils/sql/git/required/2021_06_06_dynamic_zone_moved_columns.sql new file mode 100644 index 000000000..29635e8af --- /dev/null +++ b/utils/sql/git/required/2021_06_06_dynamic_zone_moved_columns.sql @@ -0,0 +1,23 @@ +ALTER TABLE `dynamic_zones` + ADD COLUMN `uuid` VARCHAR(36) NOT NULL COLLATE 'latin1_swedish_ci' AFTER `type`, + ADD COLUMN `name` VARCHAR(128) NOT NULL DEFAULT '' COLLATE 'latin1_swedish_ci' AFTER `uuid`, + ADD COLUMN `leader_id` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `name`, + ADD COLUMN `min_players` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `leader_id`, + ADD COLUMN `max_players` INT UNSIGNED NOT NULL DEFAULT '0' AFTER `min_players`; + +-- migrate any currently active expeditions +UPDATE dynamic_zones +INNER JOIN expeditions ON expeditions.dynamic_zone_id = dynamic_zones.id +SET + dynamic_zones.uuid = expeditions.uuid, + dynamic_zones.name = expeditions.expedition_name, + dynamic_zones.leader_id = expeditions.leader_id, + dynamic_zones.min_players = expeditions.min_players, + dynamic_zones.max_players = expeditions.max_players; + +ALTER TABLE `expeditions` + DROP COLUMN `uuid`, + DROP COLUMN `expedition_name`, + DROP COLUMN `leader_id`, + DROP COLUMN `min_players`, + DROP COLUMN `max_players`; diff --git a/world/CMakeLists.txt b/world/CMakeLists.txt index 9a7ef5750..650d8f189 100644 --- a/world/CMakeLists.txt +++ b/world/CMakeLists.txt @@ -8,12 +8,11 @@ SET(world_sources clientlist.cpp console.cpp dynamic_zone.cpp + dynamic_zone_manager.cpp eql_config.cpp eqemu_api_world_data_service.cpp - expedition.cpp expedition_database.cpp expedition_message.cpp - expedition_state.cpp launcher_link.cpp launcher_list.cpp lfplist.cpp @@ -21,6 +20,8 @@ SET(world_sources login_server_list.cpp main.cpp queryserv.cpp + shared_task_manager.cpp + shared_task_world_messaging.cpp ucs.cpp web_interface.cpp web_interface_eqw.cpp @@ -44,18 +45,19 @@ SET(world_headers clientlist.h console.h dynamic_zone.h + dynamic_zone_manager.h eql_config.h eqemu_api_world_data_service.h - expedition.h expedition_database.h expedition_message.h - expedition_state.h launcher_link.h launcher_list.h lfplist.h login_server.h login_server_list.h queryserv.h + shared_task_manager.h + shared_task_world_messaging.h sof_char_create_data.h ucs.h web_interface.h diff --git a/world/client.cpp b/world/client.cpp index 03c6195e8..d5305eb67 100644 --- a/world/client.cpp +++ b/world/client.cpp @@ -121,7 +121,7 @@ Client::Client(EQStreamInterface* ieqs) m_ClientVersion = eqs->ClientVersion(); m_ClientVersionBit = EQ::versions::ConvertClientVersionToClientVersionBit(m_ClientVersion); - + numclients++; } @@ -833,19 +833,12 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) { if(instance_id > 0) { - if(!database.VerifyInstanceAlive(instance_id, GetCharID())) + if (!database.VerifyInstanceAlive(instance_id, GetCharID()) || + !database.VerifyZoneInstance(zone_id, instance_id)) { - zone_id = database.MoveCharacterToBind(charid); + zone_id = database.MoveCharacterToInstanceSafeReturn(charid, zone_id, instance_id); instance_id = 0; } - else - { - if(!database.VerifyZoneInstance(zone_id, instance_id)) - { - zone_id = database.MoveCharacterToBind(charid); - instance_id = 0; - } - } } if(!is_player_zoning) { @@ -1154,34 +1147,23 @@ void Client::EnterWorld(bool TryBootup) { return; ZoneServer* zone_server = nullptr; - if(instance_id > 0) + if (instance_id > 0) { - if(database.VerifyInstanceAlive(instance_id, GetCharID())) - { - if(database.VerifyZoneInstance(zone_id, instance_id)) - { - zone_server = zoneserver_list.FindByInstanceID(instance_id); - } - else - { - instance_id = 0; - zone_server = nullptr; - database.MoveCharacterToBind(GetCharID()); - TellClientZoneUnavailable(); - return; - } - } - else + if (!database.VerifyInstanceAlive(instance_id, GetCharID()) || + !database.VerifyZoneInstance(zone_id, instance_id)) { instance_id = 0; - zone_server = nullptr; - database.MoveCharacterToBind(GetCharID()); + database.MoveCharacterToInstanceSafeReturn(GetCharID(), zone_id, instance_id); TellClientZoneUnavailable(); return; } + + zone_server = zoneserver_list.FindByInstanceID(instance_id); } else + { zone_server = zoneserver_list.FindByZoneID(zone_id); + } const char *zone_name = ZoneName(zone_id, true); if (zone_server) { diff --git a/world/cliententry.cpp b/world/cliententry.cpp index 9aa2b9ae0..9e10f495d 100644 --- a/world/cliententry.cpp +++ b/world/cliententry.cpp @@ -20,6 +20,7 @@ #include "clientlist.h" #include "login_server.h" #include "login_server_list.h" +#include "shared_task_manager.h" #include "worlddb.h" #include "zoneserver.h" #include "world_config.h" @@ -30,6 +31,7 @@ extern uint32 numplayers; extern LoginServerList loginserverlist; extern ClientList client_list; extern volatile bool RunLoops; +extern SharedTaskManager shared_task_manager; /** * @param in_id @@ -249,6 +251,8 @@ void ClientListEntry::LeavingZone(ZoneServer *iZS, CLE_Status iOnline) } SetOnline(iOnline); + shared_task_manager.RemoveActiveInvitationByCharacterID(CharID()); + if (pzoneserver) { pzoneserver->RemovePlayer(); LSUpdate(pzoneserver); diff --git a/world/clientlist.cpp b/world/clientlist.cpp index 0f216c0ee..ac3c2c82f 100644 --- a/world/clientlist.cpp +++ b/world/clientlist.cpp @@ -332,30 +332,91 @@ void ClientList::CLCheckStale() { } } -void ClientList::ClientUpdate(ZoneServer* zoneserver, ServerClientList_Struct* scl) { - LinkedListIterator iterator(clientlist); - ClientListEntry* cle; +void ClientList::ClientUpdate(ZoneServer *zoneserver, ServerClientList_Struct *scl) +{ + LinkedListIterator iterator(clientlist); + ClientListEntry *cle; iterator.Reset(); - while(iterator.MoreElements()) { + while (iterator.MoreElements()) { if (iterator.GetData()->GetID() == scl->wid) { cle = iterator.GetData(); - if (scl->remove == 2){ + if (scl->remove == 2) { cle->LeavingZone(zoneserver, CLE_Status::Offline); } - else if (scl->remove == 1) + else if (scl->remove == 1) { cle->LeavingZone(zoneserver, CLE_Status::Zoning); - else + } + else { cle->Update(zoneserver, scl); + } return; } iterator.Advance(); } - if (scl->remove == 2) + if (scl->remove == 2) { cle = new ClientListEntry(GetNextCLEID(), zoneserver, scl, CLE_Status::Online); - else if (scl->remove == 1) + } + else if (scl->remove == 1) { cle = new ClientListEntry(GetNextCLEID(), zoneserver, scl, CLE_Status::Zoning); - else + } + else { cle = new ClientListEntry(GetNextCLEID(), zoneserver, scl, CLE_Status::InZone); + } + + LogClientListDetail( + "[ClientUpdate] " + " remove [{}]" + " wid [{}]" + " IP [{}]" + " zone [{}]" + " instance_id [{}]" + " Admin [{}]" + " charid [{}]" + " name [{}]" + " AccountID [{}]" + " AccountName [{}]" + " LSAccountID [{}]" + " lskey [{}]" + " race [{}]" + " class_ [{}]" + " level [{}]" + " anon [{}]" + " tellsoff [{}]" + " guild_id [{}]" + " LFG [{}]" + " gm [{}]" + " ClientVersion [{}]" + " LFGFromLevel [{}]" + " LFGToLevel [{}]" + " LFGMatchFilter [{}]" + " LFGComments [{}]", + scl->remove, + scl->wid, + scl->IP, + scl->zone, + scl->instance_id, + scl->Admin, + scl->charid, + scl->name, + scl->AccountID, + scl->AccountName, + scl->LSAccountID, + scl->lskey, + scl->race, + scl->class_, + scl->level, + scl->anon, + scl->tellsoff, + scl->guild_id, + scl->LFG, + scl->gm, + scl->ClientVersion, + scl->LFGFromLevel, + scl->LFGToLevel, + scl->LFGMatchFilter, + scl->LFGComments + ); + clientlist.Insert(cle); zoneserver->ChangeWID(scl->charid, cle->GetID()); } @@ -1508,3 +1569,73 @@ void ClientList::GetClientList(Json::Value &response) Iterator.Advance(); } } + +void ClientList::SendCharacterMessage(uint32_t character_id, int chat_type, const std::string& message) +{ + auto character = FindCLEByCharacterID(character_id); + SendCharacterMessage(character, chat_type, message); +} + +void ClientList::SendCharacterMessage(const std::string& character_name, int chat_type, const std::string& message) +{ + auto character = FindCharacter(character_name.c_str()); + SendCharacterMessage(character, chat_type, message); +} + +void ClientList::SendCharacterMessage(ClientListEntry* character, int chat_type, const std::string& message) +{ + if (!character || !character->Server()) + { + return; + } + + uint32_t pack_size = sizeof(CZMessagePlayer_Struct); + auto pack = std::make_unique(ServerOP_CZMessagePlayer, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->type = chat_type; + strn0cpy(buf->character_name, character->name(), sizeof(buf->character_name)); + strn0cpy(buf->message, message.c_str(), sizeof(buf->message)); + + character->Server()->SendPacket(pack.get()); +} + +void ClientList::SendCharacterMessageID(uint32_t character_id, + int chat_type, int eqstr_id, std::initializer_list args) +{ + auto character = FindCLEByCharacterID(character_id); + SendCharacterMessageID(character, chat_type, eqstr_id, args); +} + +void ClientList::SendCharacterMessageID(const std::string& character_name, + int chat_type, int eqstr_id, std::initializer_list args) +{ + auto character = FindCharacter(character_name.c_str()); + SendCharacterMessageID(character, chat_type, eqstr_id, args); +} + +void ClientList::SendCharacterMessageID(ClientListEntry* character, + int chat_type, int eqstr_id, std::initializer_list args) +{ + if (!character || !character->Server()) + { + return; + } + + SerializeBuffer serialized_args; + for (const auto& arg : args) + { + serialized_args.WriteString(arg); + } + + uint32_t args_size = static_cast(serialized_args.size()); + uint32_t pack_size = sizeof(CZClientMessageString_Struct) + args_size; + auto pack = std::make_unique(ServerOP_CZClientMessageString, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->string_id = eqstr_id; + buf->chat_type = chat_type; + strn0cpy(buf->character_name, character->name(), sizeof(buf->character_name)); + buf->args_size = args_size; + memcpy(buf->args, serialized_args.buffer(), serialized_args.size()); + + character->Server()->SendPacket(pack.get()); +} diff --git a/world/clientlist.h b/world/clientlist.h index 3386a6f14..ed66a11c2 100644 --- a/world/clientlist.h +++ b/world/clientlist.h @@ -72,6 +72,13 @@ public: void GetClientList(Json::Value &response); + void SendCharacterMessage(uint32_t character_id, int chat_type, const std::string& message); + void SendCharacterMessage(const std::string& character_name, int chat_type, const std::string& message); + void SendCharacterMessage(ClientListEntry* character, int chat_type, const std::string& message); + void SendCharacterMessageID(uint32_t character_id, int chat_type, int eqstr_id, std::initializer_list args = {}); + void SendCharacterMessageID(const std::string& character_name, int chat_type, int eqstr_id, std::initializer_list args = {}); + void SendCharacterMessageID(ClientListEntry* character, int chat_type, int eqstr_id, std::initializer_list args = {}); + private: void OnTick(EQ::Timer *t); inline uint32 GetNextCLEID() { return NextCLEID++; } diff --git a/world/dynamic_zone.cpp b/world/dynamic_zone.cpp index 943ea83a9..945b41ec9 100644 --- a/world/dynamic_zone.cpp +++ b/world/dynamic_zone.cpp @@ -1,12 +1,14 @@ #include "dynamic_zone.h" -#include "expedition.h" -#include "expedition_state.h" +#include "cliententry.h" +#include "clientlist.h" +#include "dynamic_zone_manager.h" #include "worlddb.h" #include "zonelist.h" #include "zoneserver.h" #include "../common/eqemu_logsys.h" #include "../common/repositories/instance_list_repository.h" +extern ClientList client_list; extern ZSList zoneserver_list; Database& DynamicZone::GetDatabase() @@ -14,17 +16,72 @@ Database& DynamicZone::GetDatabase() return database; } +bool DynamicZone::SendServerPacket(ServerPacket* packet) +{ + return zoneserver_list.SendPacket(packet); +} + DynamicZone* DynamicZone::FindDynamicZoneByID(uint32_t dz_id) { - auto expedition = expedition_state.GetExpeditionByDynamicZoneID(dz_id); - if (expedition) + auto dz = dynamic_zone_manager.dynamic_zone_cache.find(dz_id); + if (dz != dynamic_zone_manager.dynamic_zone_cache.end()) { - return &expedition->GetDynamicZone(); + return dz->second.get(); } - // todo: other system caches return nullptr; } +void DynamicZone::ChooseNewLeader() +{ + if (m_members.empty() || !m_choose_leader_cooldown_timer.Check()) + { + m_choose_leader_needed = true; + return; + } + + auto it = std::find_if(m_members.begin(), m_members.end(), [&](const DynamicZoneMember& member) { + if (member.id != GetLeaderID() && member.IsOnline()) { + auto member_cle = client_list.FindCLEByCharacterID(member.id); + return (member_cle && member_cle->GetOnline() == CLE_Status::InZone); + } + return false; + }); + + if (it == m_members.end()) + { + // no online members found, fallback to choosing any member + it = std::find_if(m_members.begin(), m_members.end(), + [&](const DynamicZoneMember& member) { return member.id != GetLeaderID(); }); + } + + if (it != m_members.end() && SetNewLeader(it->id)) + { + m_choose_leader_needed = false; + } +} + +bool DynamicZone::SetNewLeader(uint32_t member_id) +{ + auto new_leader = GetMemberData(member_id); + if (!new_leader.IsValid()) + { + return false; + } + + LogDynamicZonesDetail("Replacing dz [{}] leader [{}] with [{}]", GetID(), GetLeaderName(), new_leader.name); + SetLeader(new_leader, true); + SendZonesLeaderChanged(); + return true; +} + +void DynamicZone::CheckLeader() +{ + if (m_choose_leader_needed) + { + ChooseNewLeader(); + } +} + DynamicZoneStatus DynamicZone::Process() { DynamicZoneStatus status = DynamicZoneStatus::Normal; @@ -47,9 +104,24 @@ DynamicZoneStatus DynamicZone::Process() } } + if (GetType() == DynamicZoneType::Expedition && status != DynamicZoneStatus::ExpiredEmpty) + { + CheckExpireWarning(); + CheckLeader(); + } + return status; } +void DynamicZone::SendZonesDynamicZoneDeleted() +{ + uint32_t pack_size = sizeof(ServerDzID_Struct); + auto pack = std::make_unique(ServerOP_DzDeleted, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + zoneserver_list.SendPacket(pack.get()); +} + void DynamicZone::SetSecondsRemaining(uint32_t seconds_remaining) { auto now = std::chrono::system_clock::now(); @@ -82,10 +154,25 @@ void DynamicZone::SendZonesDurationUpdate() zoneserver_list.SendPacket(pack.get()); } +void DynamicZone::SendZonesLeaderChanged() +{ + uint32_t pack_size = sizeof(ServerDzLeaderID_Struct); + auto pack = std::make_unique(ServerOP_DzLeaderChanged, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->leader_id = GetLeaderID(); + zoneserver_list.SendPacket(pack.get()); +} + void DynamicZone::HandleZoneMessage(ServerPacket* pack) { switch (pack->opcode) { + case ServerOP_DzCreated: + { + dynamic_zone_manager.CacheNewDynamicZone(pack); + break; + } case ServerOP_DzSetCompass: case ServerOP_DzSetSafeReturn: case ServerOP_DzSetZoneIn: @@ -110,15 +197,41 @@ void DynamicZone::HandleZoneMessage(ServerPacket* pack) zoneserver_list.SendPacket(pack); break; } - case ServerOP_DzAddRemoveCharacter: - case ServerOP_DzRemoveAllCharacters: + case ServerOP_DzAddRemoveMember: { - auto buf = reinterpret_cast(pack->pBuffer); - ZoneServer* instance_zs = zoneserver_list.FindByInstanceID(buf->instance_id); - if (instance_zs) + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) { - instance_zs->SendPacket(pack); + auto status = static_cast(buf->character_status); + dz->ProcessMemberAddRemove({ buf->character_id, buf->character_name, status }, buf->removed); } + zoneserver_list.SendPacket(pack); + break; + } + case ServerOP_DzSwapMembers: + { + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + // we add first in world so new member can be chosen if leader is removed + auto status = static_cast(buf->add_character_status); + dz->ProcessMemberAddRemove({ buf->add_character_id, buf->add_character_name, status }, false); + dz->ProcessMemberAddRemove({ buf->remove_character_id, buf->remove_character_name }, true); + } + zoneserver_list.SendPacket(pack); + break; + } + case ServerOP_DzRemoveAllMembers: + { + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + dz->ProcessRemoveAllMembers(); + } + zoneserver_list.SendPacket(pack); break; } case ServerOP_DzSetSecondsRemaining: @@ -131,31 +244,131 @@ void DynamicZone::HandleZoneMessage(ServerPacket* pack) } break; } + case ServerOP_DzGetMemberStatuses: + { + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + dz->SendZoneMemberStatuses(buf->sender_zone_id, buf->sender_instance_id); + } + break; + } + case ServerOP_DzUpdateMemberStatus: + { + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + auto status = static_cast(buf->status); + dz->ProcessMemberStatusChange(buf->character_id, status); + } + zoneserver_list.SendPacket(pack); + break; + } }; } -void DynamicZone::SendInstanceAddRemoveCharacter(uint32_t character_id, bool remove) +void DynamicZone::ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed) { - ZoneServer* instance_zs = zoneserver_list.FindByInstanceID(GetInstanceID()); - if (instance_zs) + DynamicZoneBase::ProcessMemberAddRemove(member, removed); + + if (GetType() == DynamicZoneType::Expedition && removed && member.id == GetLeaderID()) { - auto pack = CreateServerAddRemoveCharacterPacket(character_id, remove); - instance_zs->SendPacket(pack.get()); + ChooseNewLeader(); } } -void DynamicZone::SendInstanceRemoveAllCharacters() +bool DynamicZone::ProcessMemberStatusChange(uint32_t character_id, DynamicZoneMemberStatus status) { - ZoneServer* instance_zs = zoneserver_list.FindByInstanceID(GetInstanceID()); - if (instance_zs) + bool changed = DynamicZoneBase::SetInternalMemberStatus(character_id, status); + if (changed && GetType() == DynamicZoneType::Expedition) { - auto pack = CreateServerRemoveAllCharactersPacket(); - instance_zs->SendPacket(pack.get()); + // any member status update will trigger a leader fix if leader was offline + if (GetLeader().status == DynamicZoneMemberStatus::Offline && GetMemberCount() > 1) + { + ChooseNewLeader(); + } } + return changed; } -void DynamicZone::SendGlobalLocationChange(uint16_t server_opcode, const DynamicZoneLocation& location) +void DynamicZone::SendZonesExpireWarning(uint32_t minutes_remaining) { - auto pack = CreateServerDzLocationPacket(server_opcode, location); + uint32_t pack_size = sizeof(ServerDzExpireWarning_Struct); + auto pack = std::make_unique(ServerOP_DzExpireWarning, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->minutes_remaining = minutes_remaining; zoneserver_list.SendPacket(pack.get()); } + +void DynamicZone::SendZoneMemberStatuses(uint16_t zone_id, uint16_t instance_id) +{ + uint32_t members_count = static_cast(m_members.size()); + uint32_t entries_size = sizeof(ServerDzMemberStatusEntry_Struct) * members_count; + uint32_t pack_size = sizeof(ServerDzMemberStatuses_Struct) + entries_size; + auto pack = std::make_unique(ServerOP_DzGetMemberStatuses, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->count = members_count; + + for (int i = 0; i < m_members.size(); ++i) + { + buf->entries[i].character_id = m_members[i].id; + buf->entries[i].online_status = static_cast(m_members[i].status); + } + + zoneserver_list.SendPacket(zone_id, instance_id, pack.get()); +} + +void DynamicZone::CacheMemberStatuses() +{ + if (m_has_member_statuses) + { + return; + } + + // called when a new dz is cached to fill member statuses + std::string zone_name{}; + std::vector all_clients; + all_clients.reserve(client_list.GetClientCount()); + client_list.GetClients(zone_name.c_str(), all_clients); + + for (const auto& member : m_members) + { + auto it = std::find_if(all_clients.begin(), all_clients.end(), + [&](const ClientListEntry* cle) { return (cle && cle->CharID() == member.id); }); + + auto status = DynamicZoneMemberStatus::Offline; + if (it != all_clients.end()) + { + status = DynamicZoneMemberStatus::Online; + if (IsSameDz((*it)->zone(), (*it)->instance())) + { + status = DynamicZoneMemberStatus::InDynamicZone; + } + } + + SetInternalMemberStatus(member.id, status); + } + + m_has_member_statuses = true; +} + +void DynamicZone::CheckExpireWarning() +{ + if (m_warning_cooldown_timer.Check(false)) + { + using namespace std::chrono_literals; + auto remaining = GetDurationRemaining(); + if ((remaining > 14min && remaining < 15min) || + (remaining > 4min && remaining < 5min) || + (remaining > 0min && remaining < 1min)) + { + int minutes = std::chrono::duration_cast(remaining).count() + 1; + SendZonesExpireWarning(minutes); + m_warning_cooldown_timer.Start(120000); // 2 minute cooldown after a warning + } + } +} diff --git a/world/dynamic_zone.h b/world/dynamic_zone.h index 597604f62..6a3d5c953 100644 --- a/world/dynamic_zone.h +++ b/world/dynamic_zone.h @@ -2,6 +2,8 @@ #define WORLD_DYNAMIC_ZONE_H #include "../common/dynamic_zone_base.h" +#include "../common/rulesys.h" +#include "../common/timer.h" class Database; class ServerPacket; @@ -24,18 +26,32 @@ public: void SetSecondsRemaining(uint32_t seconds_remaining) override; + void CacheMemberStatuses(); DynamicZoneStatus Process(); + bool SetNewLeader(uint32_t member_id); protected: Database& GetDatabase() override; - void SendInstanceAddRemoveCharacter(uint32_t character_id, bool remove) override; - void SendInstanceRemoveAllCharacters() override; - void SendGlobalLocationChange(uint16_t server_opcode, const DynamicZoneLocation& location) override; + void ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed) override; + bool ProcessMemberStatusChange(uint32_t member_id, DynamicZoneMemberStatus status) override; + bool SendServerPacket(ServerPacket* packet) override; private: + friend class DynamicZoneManager; + + void CheckExpireWarning(); + void CheckLeader(); + void ChooseNewLeader(); + void SendZoneMemberStatuses(uint16_t zone_id, uint16_t instance_id); void SendZonesDurationUpdate(); + void SendZonesDynamicZoneDeleted(); + void SendZonesExpireWarning(uint32_t minutes_remaining); + void SendZonesLeaderChanged(); bool m_is_pending_early_shutdown = false; + bool m_choose_leader_needed = false; + Timer m_choose_leader_cooldown_timer{ static_cast(RuleI(Expedition, ChooseLeaderCooldownTime)) }; + Timer m_warning_cooldown_timer{ 1 }; // non-zero so it's enabled initially }; #endif diff --git a/world/dynamic_zone_manager.cpp b/world/dynamic_zone_manager.cpp new file mode 100644 index 000000000..e71ca5cdc --- /dev/null +++ b/world/dynamic_zone_manager.cpp @@ -0,0 +1,166 @@ +#include "dynamic_zone_manager.h" +#include "dynamic_zone.h" +#include "worlddb.h" +#include "zonelist.h" +#include "zoneserver.h" +#include "../common/rulesys.h" +#include "../common/repositories/expeditions_repository.h" +#include "../common/repositories/expedition_lockouts_repository.h" + +extern ZSList zoneserver_list; + +DynamicZoneManager dynamic_zone_manager; + +DynamicZoneManager::DynamicZoneManager() : + m_process_throttle_timer{ static_cast(RuleI(DynamicZone, WorldProcessRate)) } +{ +} + +void DynamicZoneManager::PurgeExpiredDynamicZones() +{ + // purge when no members, instance is expired, or instance doesn't exist. + // this prevents characters remaining members of dzs that expired while + // server was offline but delayed instance purging hasn't cleaned yet + auto dz_ids = DynamicZonesRepository::GetStaleIDs(database); + + if (!dz_ids.empty()) + { + LogDynamicZones("Purging [{}] dynamic zone(s)", dz_ids.size()); + + DynamicZoneMembersRepository::DeleteWhere(database, + fmt::format("dynamic_zone_id IN ({})", fmt::join(dz_ids, ","))); + DynamicZonesRepository::DeleteWhere(database, + fmt::format("id IN ({})", fmt::join(dz_ids, ","))); + } +} + +DynamicZone* DynamicZoneManager::CreateNew( + DynamicZone& dz_request, const std::vector& members) +{ + // this creates a new dz instance and saves it to both db and cache + uint32_t dz_id = dz_request.Create(); + if (dz_id == 0) + { + LogDynamicZones("Failed to create dynamic zone for zone [{}]", dz_request.GetZoneID()); + return nullptr; + } + + auto dz = std::make_unique(dz_request); + if (!members.empty()) + { + dz->SaveMembers(members); + dz->CacheMemberStatuses(); + } + + LogDynamicZones("Created new dz [{}] for zone [{}]", dz_id, dz_request.GetZoneID()); + + auto pack = dz->CreateServerDzCreatePacket(0, 0); + zoneserver_list.SendPacket(pack.get()); + + auto inserted = dynamic_zone_cache.emplace(dz_id, std::move(dz)); + return inserted.first->second.get(); +} + +void DynamicZoneManager::CacheNewDynamicZone(ServerPacket* pack) +{ + auto buf = reinterpret_cast(pack->pBuffer); + + auto new_dz = std::make_unique(); + new_dz->LoadSerializedDzPacket(buf->cereal_data, buf->cereal_size); + new_dz->CacheMemberStatuses(); + + // reserialize with member statuses cached before forwarding (restore origin zone) + auto repack = new_dz->CreateServerDzCreatePacket(buf->origin_zone_id, buf->origin_instance_id); + + uint32_t dz_id = new_dz->GetID(); + dynamic_zone_cache.emplace(dz_id, std::move(new_dz)); + LogDynamicZones("Cached new dynamic zone [{}]", dz_id); + + zoneserver_list.SendPacket(repack.get()); +} + +void DynamicZoneManager::CacheAllFromDatabase() +{ + BenchTimer bench; + + auto dynamic_zones = DynamicZonesRepository::AllWithInstanceNotExpired(database); + auto dynamic_zone_members = DynamicZoneMembersRepository::GetAllWithNames(database); + + dynamic_zone_cache.clear(); + dynamic_zone_cache.reserve(dynamic_zones.size()); + + for (auto& entry : dynamic_zones) + { + uint32_t dz_id = entry.id; + auto dz = std::make_unique(std::move(entry)); + + for (auto& member : dynamic_zone_members) + { + if (member.dynamic_zone_id == dz_id) + { + dz->AddMemberFromRepositoryResult(std::move(member)); + } + } + + // note leader status won't be updated here until leader is set by owning system (expeditions) + dz->CacheMemberStatuses(); + + dynamic_zone_cache.emplace(dz_id, std::move(dz)); + } + + LogDynamicZones("Caching [{}] dynamic zone(s) took [{}s]", dynamic_zone_cache.size(), bench.elapsed()); +} + +void DynamicZoneManager::Process() +{ + if (!m_process_throttle_timer.Check()) + { + return; + } + + std::vector dynamic_zone_ids; + + for (const auto& dz_iter : dynamic_zone_cache) + { + DynamicZone* dz = dz_iter.second.get(); + + // dynamic zone is not deleted until its zone has no clients to prevent exploits + // clients should be removed by zone-based kick timers if expired but not empty + DynamicZoneStatus status = dz->Process(); + if (status == DynamicZoneStatus::ExpiredEmpty) + { + LogDynamicZones("[{}] expired with [{}] members, notifying zones and deleting", dz->GetID(), dz->GetMemberCount()); + dynamic_zone_ids.emplace_back(dz->GetID()); + dz->SendZonesDynamicZoneDeleted(); // delete dz from zone caches + } + } + + if (!dynamic_zone_ids.empty()) + { + for (const auto& dz_id : dynamic_zone_ids) + { + dynamic_zone_cache.erase(dz_id); + } + + // need to look up expedition ids until lockouts are moved to dynamic zones + std::vector expedition_ids; + auto expeditions = ExpeditionsRepository::GetWhere(database, + fmt::format("dynamic_zone_id IN ({})", fmt::join(dynamic_zone_ids, ","))); + + if (!expeditions.empty()) + { + for (const auto& expedition : expeditions) + { + expedition_ids.emplace_back(expedition.id); + } + ExpeditionLockoutsRepository::DeleteWhere(database, + fmt::format("expedition_id IN ({})", fmt::join(expedition_ids, ","))); + } + + ExpeditionsRepository::DeleteWhere(database, + fmt::format("dynamic_zone_id IN ({})", fmt::join(dynamic_zone_ids, ","))); + DynamicZoneMembersRepository::RemoveAllMembers(database, dynamic_zone_ids); + DynamicZonesRepository::DeleteWhere(database, + fmt::format("id IN ({})", fmt::join(dynamic_zone_ids, ","))); + } +} diff --git a/world/dynamic_zone_manager.h b/world/dynamic_zone_manager.h new file mode 100644 index 000000000..ce59f62ee --- /dev/null +++ b/world/dynamic_zone_manager.h @@ -0,0 +1,32 @@ +#ifndef WORLD_DYNAMIC_ZONE_MANAGER_H +#define WORLD_DYNAMIC_ZONE_MANAGER_H + +#include "../common/timer.h" +#include +#include +#include + +extern class DynamicZoneManager dynamic_zone_manager; + +class DynamicZone; +struct DynamicZoneMember; +class ServerPacket; + +class DynamicZoneManager +{ +public: + DynamicZoneManager(); + + void CacheAllFromDatabase(); + void CacheNewDynamicZone(ServerPacket* pack); + DynamicZone* CreateNew(DynamicZone& dz_request, const std::vector& members); + void Process(); + void PurgeExpiredDynamicZones(); + + std::unordered_map> dynamic_zone_cache; + +private: + Timer m_process_throttle_timer{}; +}; + +#endif diff --git a/world/expedition.cpp b/world/expedition.cpp deleted file mode 100644 index 4cc82ca03..000000000 --- a/world/expedition.cpp +++ /dev/null @@ -1,237 +0,0 @@ -/** - * EQEmulator: Everquest Server Emulator - * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; version 2 of the License. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY except by those people which sell it, which - * are required to give you total support for your newly bought product; - * without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ - -#include "expedition.h" -#include "expedition_database.h" -#include "cliententry.h" -#include "clientlist.h" -#include "zonelist.h" -#include "zoneserver.h" -#include "../common/eqemu_logsys.h" -#include "../common/rulesys.h" - -extern ClientList client_list; -extern ZSList zoneserver_list; - -Expedition::Expedition() : - m_choose_leader_cooldown_timer{ static_cast(RuleI(Expedition, ChooseLeaderCooldownTime)) } -{ - m_warning_cooldown_timer.Enable(); -} - -void Expedition::SetDynamicZone(DynamicZone&& dz) -{ - dz.SetName(GetName()); - dz.SetLeader(GetLeader()); - - m_dynamic_zone = std::move(dz); -} - -void Expedition::RemoveMember(uint32_t character_id) -{ - GetDynamicZone().RemoveInternalMember(character_id); - - if (character_id == m_leader.id) - { - ChooseNewLeader(); - } -} - -void Expedition::ChooseNewLeader() -{ - const auto& members = GetDynamicZone().GetMembers(); - if (members.empty() || !m_choose_leader_cooldown_timer.Check()) - { - m_choose_leader_needed = true; - return; - } - - auto it = std::find_if(members.begin(), members.end(), [&](const DynamicZoneMember& member) { - if (member.id != m_leader.id && member.IsOnline()) { - auto member_cle = client_list.FindCLEByCharacterID(member.id); - return (member_cle && member_cle->GetOnline() == CLE_Status::InZone); - } - return false; - }); - - if (it == members.end()) - { - // no online members found, fallback to choosing any member - it = std::find_if(members.begin(), members.end(), - [&](const DynamicZoneMember& member) { return (member.id != m_leader.id); }); - } - - if (it != members.end() && SetNewLeader(*it)) - { - m_choose_leader_needed = false; - } -} - -bool Expedition::SetNewLeader(const DynamicZoneMember& member) -{ - if (!GetDynamicZone().HasMember(member.id)) - { - return false; - } - - LogExpeditionsModerate("Replacing [{}] leader [{}] with [{}]", m_id, m_leader.name, member.name); - ExpeditionDatabase::UpdateLeaderID(m_id, member.id); - m_leader = member; - m_dynamic_zone.SetLeader(m_leader); - SendZonesLeaderChanged(); - return true; -} - -void Expedition::SendZonesExpeditionDeleted() -{ - uint32_t pack_size = sizeof(ServerExpeditionID_Struct); - auto pack = std::make_unique(ServerOP_ExpeditionDeleted, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - zoneserver_list.SendPacket(pack.get()); -} - -void Expedition::SendZonesExpireWarning(uint32_t minutes_remaining) -{ - uint32_t pack_size = sizeof(ServerExpeditionExpireWarning_Struct); - auto pack = std::make_unique(ServerOP_ExpeditionExpireWarning, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - buf->minutes_remaining = minutes_remaining; - zoneserver_list.SendPacket(pack.get()); -} - -void Expedition::SendZonesLeaderChanged() -{ - uint32_t pack_size = sizeof(ServerExpeditionLeaderID_Struct); - auto pack = std::make_unique(ServerOP_ExpeditionLeaderChanged, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - buf->leader_id = m_leader.id; - zoneserver_list.SendPacket(pack.get()); -} - -void Expedition::CheckExpireWarning() -{ - if (m_warning_cooldown_timer.Check(false)) - { - using namespace std::chrono_literals; - auto remaining = GetDynamicZone().GetDurationRemaining(); - if ((remaining > 14min && remaining < 15min) || - (remaining > 4min && remaining < 5min) || - (remaining > 0min && remaining < 1min)) - { - int minutes = std::chrono::duration_cast(remaining).count() + 1; - SendZonesExpireWarning(minutes); - m_warning_cooldown_timer.Start(70000); // 1 minute 10 seconds - } - } -} - -void Expedition::CheckLeader() -{ - if (m_choose_leader_needed) - { - ChooseNewLeader(); - } -} - -bool Expedition::Process() -{ - // returns true if expedition needs to be deleted from world cache and db - // expedition is not deleted until its dz has no clients to prevent exploits - auto status = m_dynamic_zone.Process(); - if (status == DynamicZoneStatus::ExpiredEmpty) - { - LogExpeditions("Expedition [{}] expired or empty, notifying zones and deleting", GetID()); - SendZonesExpeditionDeleted(); - return true; - } - - CheckExpireWarning(); - CheckLeader(); - - return false; -} - -void Expedition::UpdateMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status) -{ - GetDynamicZone().SetInternalMemberStatus(character_id, status); - - // temporary until move to using dz leader object completely - if (character_id == m_leader.id) - { - m_leader.status = GetDynamicZone().GetLeader().status; - } - - // any member status update will trigger a leader fix if leader was offline - if (m_leader.status == DynamicZoneMemberStatus::Offline && GetDynamicZone().GetMemberCount() > 1) - { - ChooseNewLeader(); - } -} - -void Expedition::SendZoneMemberStatuses(uint16_t zone_id, uint16_t instance_id) -{ - const auto& members = GetDynamicZone().GetMembers(); - - uint32_t members_count = static_cast(members.size()); - uint32_t entries_size = sizeof(ServerExpeditionMemberStatusEntry_Struct) * members_count; - uint32_t pack_size = sizeof(ServerExpeditionMemberStatuses_Struct) + entries_size; - auto pack = std::make_unique(ServerOP_ExpeditionGetMemberStatuses, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - buf->count = members_count; - - for (int i = 0; i < members.size(); ++i) - { - buf->entries[i].character_id = members[i].id; - buf->entries[i].online_status = static_cast(members[i].status); - } - - zoneserver_list.SendPacket(zone_id, instance_id, pack.get()); -} - -void Expedition::CacheMemberStatuses() -{ - // called when a new expedition is cached to fill member statuses - std::string zone_name{}; - std::vector all_clients; - all_clients.reserve(client_list.GetClientCount()); - client_list.GetClients(zone_name.c_str(), all_clients); - - for (const auto& member : GetDynamicZone().GetMembers()) - { - auto it = std::find_if(all_clients.begin(), all_clients.end(), - [&](const ClientListEntry* cle) { return (cle && cle->CharID() == member.id); }); - - auto status = DynamicZoneMemberStatus::Offline; - if (it != all_clients.end()) - { - status = DynamicZoneMemberStatus::Online; - if (GetDynamicZone().IsSameDz((*it)->zone(), (*it)->instance())) - { - status = DynamicZoneMemberStatus::InDynamicZone; - } - } - - GetDynamicZone().SetInternalMemberStatus(member.id, status); - } -} diff --git a/world/expedition.h b/world/expedition.h deleted file mode 100644 index 119f78685..000000000 --- a/world/expedition.h +++ /dev/null @@ -1,57 +0,0 @@ -/** - * EQEmulator: Everquest Server Emulator - * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; version 2 of the License. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY except by those people which sell it, which - * are required to give you total support for your newly bought product; - * without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ - -#ifndef WORLD_EXPEDITION_H -#define WORLD_EXPEDITION_H - -#include "dynamic_zone.h" -#include "../common/expedition_base.h" -#include "../common/timer.h" -#include - -class Expedition : public ExpeditionBase -{ -public: - Expedition(); - - void RemoveMember(uint32_t character_id); - void CacheMemberStatuses(); - void CheckExpireWarning(); - void CheckLeader(); - void ChooseNewLeader(); - DynamicZone& GetDynamicZone() { return m_dynamic_zone; } - bool Process(); - void SendZoneMemberStatuses(uint16_t zone_id, uint16_t instance_id); - void SendZonesExpeditionDeleted(); - void SendZonesExpireWarning(uint32_t minutes_remaining); - void SetDynamicZone(DynamicZone&& dz); - bool SetNewLeader(const DynamicZoneMember& member); - void UpdateMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status); - -private: - void SendZonesLeaderChanged(); - - bool m_choose_leader_needed = false; - Timer m_choose_leader_cooldown_timer; - Timer m_warning_cooldown_timer; - DynamicZone m_dynamic_zone; -}; - -#endif diff --git a/world/expedition_database.cpp b/world/expedition_database.cpp index 5c51a9e70..a3c4ca4d0 100644 --- a/world/expedition_database.cpp +++ b/world/expedition_database.cpp @@ -19,8 +19,9 @@ */ #include "expedition_database.h" -#include "expedition.h" #include "worlddb.h" +#include "../common/repositories/expeditions_repository.h" +#include "../common/repositories/expedition_lockouts_repository.h" #include "../common/repositories/dynamic_zone_members_repository.h" void ExpeditionDatabase::PurgeExpiredExpeditions() @@ -34,7 +35,7 @@ void ExpeditionDatabase::PurgeExpiredExpeditions() LEFT JOIN instance_list ON dynamic_zones.instance_id = instance_list.id LEFT JOIN ( - SELECT dynamic_zone_id, COUNT(IF(is_current_member = TRUE, 1, NULL)) member_count + SELECT dynamic_zone_id, COUNT(*) member_count FROM dynamic_zone_members GROUP BY dynamic_zone_id ) dynamic_zone_members @@ -59,8 +60,9 @@ void ExpeditionDatabase::PurgeExpiredExpeditions() if (!expedition_ids.empty()) { - ExpeditionDatabase::MoveMembersToSafeReturn(expedition_ids); - ExpeditionDatabase::DeleteExpeditions(expedition_ids); + auto joined_expedition_ids = fmt::join(expedition_ids, ","); + ExpeditionsRepository::DeleteWhere(database, fmt::format("id IN ({})", joined_expedition_ids)); + ExpeditionLockoutsRepository::DeleteWhere(database, fmt::format("expedition_id IN ({})", joined_expedition_ids)); DynamicZoneMembersRepository::RemoveAllMembers(database, dynamic_zone_ids); } } @@ -75,56 +77,3 @@ void ExpeditionDatabase::PurgeExpiredCharacterLockouts() database.QueryDatabase(query); } - -void ExpeditionDatabase::DeleteExpeditions(const std::vector& expedition_ids) -{ - LogExpeditionsDetail("Deleting [{}] expedition(s)", expedition_ids.size()); - - std::string expedition_ids_query = fmt::format("{}", fmt::join(expedition_ids, ",")); - - if (!expedition_ids_query.empty()) - { - auto query = fmt::format("DELETE FROM expeditions WHERE id IN ({});", expedition_ids_query); - database.QueryDatabase(query); - - query = fmt::format("DELETE FROM expedition_lockouts WHERE expedition_id IN ({});", expedition_ids_query); - database.QueryDatabase(query); - } -} - -void ExpeditionDatabase::UpdateLeaderID(uint32_t expedition_id, uint32_t leader_id) -{ - LogExpeditionsDetail("Updating leader [{}] for expedition [{}]", leader_id, expedition_id); - - auto query = fmt::format(SQL( - UPDATE expeditions SET leader_id = {} WHERE id = {}; - ), leader_id, expedition_id); - - database.QueryDatabase(query); -} - -void ExpeditionDatabase::MoveMembersToSafeReturn(const std::vector& expedition_ids) -{ - LogExpeditionsDetail("Moving members from [{}] expedition(s) to safereturn", expedition_ids.size()); - - // only offline members still in expired dz zones should be updated here - std::string query = fmt::format(SQL( - UPDATE character_data - INNER JOIN dynamic_zone_members ON character_data.id = dynamic_zone_members.character_id - INNER JOIN expeditions ON dynamic_zone_members.dynamic_zone_id = expeditions.dynamic_zone_id - INNER JOIN dynamic_zones ON expeditions.dynamic_zone_id = dynamic_zones.id - INNER JOIN instance_list ON dynamic_zones.instance_id = instance_list.id - AND character_data.zone_instance = instance_list.id - AND character_data.zone_id = instance_list.zone - SET - zone_id = IF(safe_return_zone_id > 0, safe_return_zone_id, zone_id), - zone_instance = IF(safe_return_zone_id > 0, 0, zone_instance), - x = IF(safe_return_zone_id > 0, safe_return_x, x), - y = IF(safe_return_zone_id > 0, safe_return_y, y), - z = IF(safe_return_zone_id > 0, safe_return_z, z), - heading = IF(safe_return_zone_id > 0, safe_return_heading, heading) - WHERE expeditions.id IN ({}); - ), fmt::join(expedition_ids, ",")); - - database.QueryDatabase(query); -} diff --git a/world/expedition_database.h b/world/expedition_database.h index b86fd8b5d..a885dfc83 100644 --- a/world/expedition_database.h +++ b/world/expedition_database.h @@ -28,11 +28,8 @@ class Expedition; namespace ExpeditionDatabase { - void DeleteExpeditions(const std::vector& expedition_ids); - void MoveMembersToSafeReturn(const std::vector& expedition_ids); void PurgeExpiredExpeditions(); void PurgeExpiredCharacterLockouts(); - void UpdateLeaderID(uint32_t expedition_id, uint32_t leader_id); }; #endif diff --git a/world/expedition_message.cpp b/world/expedition_message.cpp index 36eee5ceb..93f6ccd6e 100644 --- a/world/expedition_message.cpp +++ b/world/expedition_message.cpp @@ -18,9 +18,8 @@ * */ -#include "expedition.h" +#include "dynamic_zone.h" #include "expedition_message.h" -#include "expedition_state.h" #include "cliententry.h" #include "clientlist.h" #include "zonelist.h" @@ -37,50 +36,9 @@ void ExpeditionMessage::HandleZoneMessage(ServerPacket* pack) { case ServerOP_ExpeditionCreate: { - auto buf = reinterpret_cast(pack->pBuffer); - expedition_state.CacheFromDatabase(buf->expedition_id); zoneserver_list.SendPacket(pack); break; } - case ServerOP_ExpeditionMemberChange: - { - auto buf = reinterpret_cast(pack->pBuffer); - expedition_state.MemberChange(buf->expedition_id, { buf->char_id, buf->char_name }, buf->removed); - zoneserver_list.SendPacket(pack); - break; - } - case ServerOP_ExpeditionMemberSwap: - { - auto buf = reinterpret_cast(pack->pBuffer); - expedition_state.MemberChange(buf->expedition_id, { buf->add_char_id, buf->add_char_name }, false); - expedition_state.MemberChange(buf->expedition_id, { buf->remove_char_id, buf->remove_char_name }, true); - zoneserver_list.SendPacket(pack); - break; - } - case ServerOP_ExpeditionMembersRemoved: - { - auto buf = reinterpret_cast(pack->pBuffer); - expedition_state.RemoveAllMembers(buf->expedition_id); - zoneserver_list.SendPacket(pack); - break; - } - case ServerOP_ExpeditionMemberStatus: - { - auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = expedition_state.GetExpedition(buf->expedition_id); - if (expedition) - { - auto status = static_cast(buf->status); - expedition->UpdateMemberStatus(buf->character_id, status); - } - zoneserver_list.SendPacket(pack); - break; - } - case ServerOP_ExpeditionGetMemberStatuses: - { - ExpeditionMessage::GetMemberStatuses(pack); - break; - } case ServerOP_ExpeditionDzAddPlayer: { ExpeditionMessage::AddPlayer(pack); @@ -145,10 +103,10 @@ void ExpeditionMessage::MakeLeader(ServerPacket* pack) ClientListEntry* new_leader_cle = client_list.FindCharacter(buf->new_leader_name); if (new_leader_cle && new_leader_cle->Server()) { - auto expedition = expedition_state.GetExpedition(buf->expedition_id); - if (expedition) + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz && dz->GetLeaderID() == buf->requester_id) { - buf->is_success = expedition->SetNewLeader({ new_leader_cle->CharID(), new_leader_cle->name() }); + buf->is_success = dz->SetNewLeader(new_leader_cle->CharID()); } buf->is_online = true; @@ -164,16 +122,6 @@ void ExpeditionMessage::MakeLeader(ServerPacket* pack) } } -void ExpeditionMessage::GetMemberStatuses(ServerPacket* pack) -{ - auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = expedition_state.GetExpedition(buf->expedition_id); - if (expedition) - { - expedition->SendZoneMemberStatuses(buf->sender_zone_id, buf->sender_instance_id); - } -} - void ExpeditionMessage::SaveInvite(ServerPacket* pack) { auto buf = reinterpret_cast(pack->pBuffer); diff --git a/world/expedition_message.h b/world/expedition_message.h index 135ef0cba..b97651dbc 100644 --- a/world/expedition_message.h +++ b/world/expedition_message.h @@ -26,7 +26,6 @@ class ServerPacket; namespace ExpeditionMessage { void AddPlayer(ServerPacket* pack); - void GetMemberStatuses(ServerPacket* pack); void HandleZoneMessage(ServerPacket* pack); void MakeLeader(ServerPacket* pack); void RequestInvite(ServerPacket* pack); diff --git a/world/expedition_state.cpp b/world/expedition_state.cpp deleted file mode 100644 index a0cd245fa..000000000 --- a/world/expedition_state.cpp +++ /dev/null @@ -1,172 +0,0 @@ -/** - * EQEmulator: Everquest Server Emulator - * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; version 2 of the License. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY except by those people which sell it, which - * are required to give you total support for your newly bought product; - * without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ - -#include "expedition_state.h" -#include "expedition.h" -#include "expedition_database.h" -#include "worlddb.h" -#include "../common/dynamic_zone_base.h" -#include "../common/eqemu_logsys.h" -#include "../common/repositories/dynamic_zone_members_repository.h" -#include - -ExpeditionState expedition_state; - -Expedition* ExpeditionState::GetExpedition(uint32_t expedition_id) -{ - auto it = std::find_if(m_expeditions.begin(), m_expeditions.end(), - [&](const std::unique_ptr& expedition) { - return expedition->GetID() == expedition_id; - }); - - return (it != m_expeditions.end()) ? it->get() : nullptr; -} - -Expedition* ExpeditionState::GetExpeditionByDynamicZoneID(uint32_t dz_id) -{ - auto it = std::find_if(m_expeditions.begin(), m_expeditions.end(), - [&](const std::unique_ptr& expedition) { - return expedition->GetDynamicZone().GetID() == dz_id; - }); - - return (it != m_expeditions.end()) ? it->get() : nullptr; -} - -void ExpeditionState::CacheFromDatabase(uint32_t expedition_id) -{ - if (expedition_id == 0 || GetExpedition(expedition_id)) - { - return; - } - - auto expedition = ExpeditionsRepository::GetWithLeaderName(database, expedition_id); - CacheExpeditions({ std::move(expedition) }); -} - -void ExpeditionState::CacheAllFromDatabase() -{ - BenchTimer benchmark; - - auto expeditions = ExpeditionsRepository::GetAllWithLeaderName(database); - m_expeditions.clear(); - m_expeditions.reserve(expeditions.size()); - - CacheExpeditions(std::move(expeditions)); - - LogExpeditions("Caching [{}] expedition(s) took [{}s]", m_expeditions.size(), benchmark.elapsed()); -} - -void ExpeditionState::CacheExpeditions( - std::vector&& expedition_entries) -{ - // bulk load expedition dzs and members before caching - std::vector dynamic_zone_ids; - for (const auto& entry : expedition_entries) - { - dynamic_zone_ids.emplace_back(entry.dynamic_zone_id); - } - - auto dynamic_zones = DynamicZonesRepository::GetWithInstance(database, dynamic_zone_ids); - auto dynamic_zone_members = DynamicZoneMembersRepository::GetWithNames(database, dynamic_zone_ids); - - for (auto& entry : expedition_entries) - { - auto expedition = std::make_unique(); - expedition->LoadRepositoryResult(std::move(entry)); - - auto dz_entry_iter = std::find_if(dynamic_zones.begin(), dynamic_zones.end(), - [&](const DynamicZonesRepository::DynamicZoneInstance& dz_entry) { - return dz_entry.id == entry.dynamic_zone_id; - }); - - if (dz_entry_iter != dynamic_zones.end()) - { - expedition->SetDynamicZone(std::move(*dz_entry_iter)); - } - - for (auto& member : dynamic_zone_members) - { - if (member.dynamic_zone_id == entry.dynamic_zone_id) - { - expedition->GetDynamicZone().AddMemberFromRepositoryResult(std::move(member)); - } - } - - // stored on expedition in db but on dz in memory cache - expedition->GetDynamicZone().SetMinPlayers(entry.min_players); - expedition->GetDynamicZone().SetMaxPlayers(entry.max_players); - - expedition->CacheMemberStatuses(); - - m_expeditions.emplace_back(std::move(expedition)); - } -} - -void ExpeditionState::MemberChange( - uint32_t expedition_id, const DynamicZoneMember& member, bool remove) -{ - auto expedition = GetExpedition(expedition_id); - if (expedition) - { - if (remove) { - expedition->RemoveMember(member.id); - } else { - expedition->GetDynamicZone().AddInternalMember(member); - } - } -} - -void ExpeditionState::RemoveAllMembers(uint32_t expedition_id) -{ - auto expedition = GetExpedition(expedition_id); - if (expedition) - { - expedition->GetDynamicZone().ClearInternalMembers(); - } -} - -void ExpeditionState::Process() -{ - if (!m_process_throttle_timer.Check()) - { - return; - } - - std::vector expedition_ids; - std::vector dynamic_zone_ids; - - for (auto it = m_expeditions.begin(); it != m_expeditions.end();) - { - bool is_deleted = (*it)->Process(); - if (is_deleted) - { - expedition_ids.emplace_back((*it)->GetID()); - dynamic_zone_ids.emplace_back((*it)->GetDynamicZone().GetID()); - } - it = is_deleted ? m_expeditions.erase(it) : it + 1; - } - - if (!expedition_ids.empty()) - { - ExpeditionDatabase::MoveMembersToSafeReturn(expedition_ids); - ExpeditionDatabase::DeleteExpeditions(expedition_ids); - DynamicZoneMembersRepository::RemoveAllMembers(database, dynamic_zone_ids); - } -} diff --git a/world/expedition_state.h b/world/expedition_state.h deleted file mode 100644 index 90f4a4293..000000000 --- a/world/expedition_state.h +++ /dev/null @@ -1,52 +0,0 @@ -/** - * EQEmulator: Everquest Server Emulator - * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server) - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; version 2 of the License. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY except by those people which sell it, which - * are required to give you total support for your newly bought product; - * without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ - -#ifndef WORLD_EXPEDITION_STATE_H -#define WORLD_EXPEDITION_STATE_H - -#include "../common/repositories/expeditions_repository.h" -#include "../common/rulesys.h" -#include "../common/timer.h" -#include -#include - -extern class ExpeditionState expedition_state; - -class Expedition; -struct DynamicZoneMember; - -class ExpeditionState -{ -public: - void CacheExpeditions(std::vector&& expedition_entries); - void CacheFromDatabase(uint32_t expedition_id); - void CacheAllFromDatabase(); - Expedition* GetExpedition(uint32_t expedition_id); - Expedition* GetExpeditionByDynamicZoneID(uint32_t dz_id); - void MemberChange(uint32_t expedition_id, const DynamicZoneMember& member, bool remove); - void Process(); - void RemoveAllMembers(uint32_t expedition_id); - -private: - std::vector> m_expeditions; - Timer m_process_throttle_timer{static_cast(RuleI(DynamicZone, WorldProcessRate))}; -}; - -#endif diff --git a/world/main.cpp b/world/main.cpp index d36561544..7d3da9bfd 100644 --- a/world/main.cpp +++ b/world/main.cpp @@ -46,6 +46,7 @@ #include "../common/crash.h" #include "client.h" #include "worlddb.h" + #ifdef _WINDOWS #include #define snprintf _snprintf @@ -53,12 +54,14 @@ #define strcasecmp _stricmp #include #else + #include #include "../common/unix.h" #include #include #include #include + #if not defined (FREEBSD) && not defined (DARWIN) union semun { int val; @@ -88,41 +91,45 @@ union semun { #include "queryserv.h" #include "web_interface.h" #include "console.h" +#include "dynamic_zone_manager.h" #include "expedition_database.h" -#include "expedition_state.h" #include "../common/net/servertalk_server.h" #include "../zone/data_bucket.h" #include "world_server_command_handler.h" #include "../common/content/world_content_service.h" +#include "../common/repositories/character_task_timers_repository.h" #include "../common/repositories/merchantlist_temp_repository.h" #include "world_store.h" #include "world_event_scheduler.h" +#include "shared_task_manager.h" -WorldStore world_store; -ClientList client_list; -GroupLFPList LFPGroupList; -ZSList zoneserver_list; -LoginServerList loginserverlist; -UCSConnection UCSLink; +WorldStore world_store; +ClientList client_list; +GroupLFPList LFPGroupList; +ZSList zoneserver_list; +LoginServerList loginserverlist; +UCSConnection UCSLink; QueryServConnection QSLink; -LauncherList launcher_list; -AdventureManager adventure_manager; +LauncherList launcher_list; +AdventureManager adventure_manager; WorldEventScheduler event_scheduler; -EQ::Random emu_random; -volatile bool RunLoops = true; -uint32 numclients = 0; -uint32 numzones = 0; -bool holdzones = false; -const WorldConfig *Config; -EQEmuLogSys LogSys; +SharedTaskManager shared_task_manager; +EQ::Random emu_random; +volatile bool RunLoops = true; +uint32 numclients = 0; +uint32 numzones = 0; +bool holdzones = false; +const WorldConfig *Config; +EQEmuLogSys LogSys; WorldContentService content_service; -WebInterfaceList web_interface; +WebInterfaceList web_interface; void CatchSignal(int sig_num); void CheckForServerScript(bool force_download = false); -inline void UpdateWindowTitle(std::string new_title) { +inline void UpdateWindowTitle(std::string new_title) +{ #ifdef _WINDOWS SetConsoleTitle(new_title.c_str()); #endif @@ -154,7 +161,7 @@ void LoadDatabaseConnections() */ if (!Config->ContentDbHost.empty()) { if (!content_db.Connect( - Config->ContentDbHost.c_str() , + Config->ContentDbHost.c_str(), Config->ContentDbUsername.c_str(), Config->ContentDbPassword.c_str(), Config->ContentDbName.c_str(), @@ -164,7 +171,8 @@ void LoadDatabaseConnections() LogError("Cannot continue without a content database connection"); std::exit(1); } - } else { + } + else { content_db.SetMysql(database.getMySQL()); } @@ -174,7 +182,7 @@ void CheckForXMLConfigUpgrade() { if (!std::ifstream("eqemu_config.json") && std::ifstream("eqemu_config.xml")) { CheckForServerScript(true); - if(system("perl eqemu_server.pl convert_xml")); + if (system("perl eqemu_server.pl convert_xml")) {} } else { CheckForServerScript(); @@ -205,7 +213,7 @@ void RegisterLoginservers() } } else { - LinkedList loginlist = Config->loginlist; + LinkedList loginlist = Config->loginlist; LinkedListIterator iterator(loginlist); iterator.Reset(); while (iterator.MoreElements()) { @@ -274,7 +282,8 @@ static void GMSayHookCallBackProcessWorld(uint16 log_category, std::string messa * @param argv * @return */ -int main(int argc, char** argv) { +int main(int argc, char **argv) +{ RegisterExecutablePlatform(ExePlatformWorld); LogSys.LoadLogSettingsDefaults(); set_exception_handler(); @@ -445,7 +454,7 @@ int main(int argc, char** argv) { LogInfo("Loading EQ time of day"); TimeOfDay_Struct eqTime; - time_t realtime; + time_t realtime; eqTime = database.LoadTime(realtime); zoneserver_list.worldclock.SetCurrentEQTimeOfDay(eqTime, realtime); Timer EQTimeTimer(600000); @@ -457,37 +466,50 @@ int main(int argc, char** argv) { LogInfo("Deleted [{}] stale player corpses from database", database.DeleteStalePlayerCorpses()); LogInfo("Loading adventures"); - if (!adventure_manager.LoadAdventureTemplates()) - { + if (!adventure_manager.LoadAdventureTemplates()) { LogInfo("Unable to load adventure templates"); } - if (!adventure_manager.LoadAdventureEntries()) - { + if (!adventure_manager.LoadAdventureEntries()) { LogInfo("Unable to load adventure templates"); } adventure_manager.LoadLeaderboardInfo(); + LogInfo("Purging expired dynamic zones and members"); + dynamic_zone_manager.PurgeExpiredDynamicZones(); + LogInfo("Purging expired expeditions"); ExpeditionDatabase::PurgeExpiredExpeditions(); ExpeditionDatabase::PurgeExpiredCharacterLockouts(); + LogInfo("Purging expired character task timers"); + CharacterTaskTimersRepository::DeleteWhere(database, "expire_time <= NOW()"); + LogInfo("Purging expired instances"); database.PurgeExpiredInstances(); Timer PurgeInstanceTimer(450000); PurgeInstanceTimer.Start(450000); - LogInfo("Loading active expeditions"); - expedition_state.CacheAllFromDatabase(); + LogInfo("Loading dynamic zones"); + dynamic_zone_manager.CacheAllFromDatabase(); LogInfo("Loading char create info"); content_db.LoadCharacterCreateAllocations(); content_db.LoadCharacterCreateCombos(); + LogInfo("Initializing [EventScheduler]"); event_scheduler.SetDatabase(&database)->LoadScheduledEvents(); + LogInfo("Initializing [SharedTaskManager]"); + shared_task_manager.SetDatabase(&database) + ->SetContentDatabase(&content_db) + ->LoadTaskData() + ->LoadSharedTaskState(); + + shared_task_manager.PurgeExpiredSharedTasks(); + std::unique_ptr console; if (Config->TelnetEnabled) { LogInfo("Console (TCP) listener started"); @@ -500,8 +522,8 @@ int main(int argc, char** argv) { server_connection = std::make_unique(); EQ::Net::ServertalkServerOptions server_opts; - server_opts.port = Config->WorldTCPPort; - server_opts.ipv6 = false; + server_opts.port = Config->WorldTCPPort; + server_opts.ipv6 = false; server_opts.credentials = Config->SharedKey; server_connection->Listen(server_opts); LogInfo("Server (TCP) listener started"); @@ -516,50 +538,62 @@ int main(int argc, char** argv) { } ); - server_connection->OnConnectionRemoved("Zone", [](std::shared_ptr connection) { - LogInfo("Removed Zone Server connection from [{0}]", - connection->GetUUID()); + server_connection->OnConnectionRemoved( + "Zone", [](std::shared_ptr connection) { + LogInfo("Removed Zone Server connection from [{0}]", + connection->GetUUID()); - numzones--; - zoneserver_list.Remove(connection->GetUUID()); - }); + numzones--; + zoneserver_list.Remove(connection->GetUUID()); + } + ); - server_connection->OnConnectionIdentified("Launcher", [](std::shared_ptr connection) { - LogInfo("New Launcher connection from [{2}] at [{0}:{1}]", - connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); + server_connection->OnConnectionIdentified( + "Launcher", [](std::shared_ptr connection) { + LogInfo("New Launcher connection from [{2}] at [{0}:{1}]", + connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); - launcher_list.Add(connection); - }); + launcher_list.Add(connection); + } + ); - server_connection->OnConnectionRemoved("Launcher", [](std::shared_ptr connection) { - LogInfo("Removed Launcher connection from [{0}]", - connection->GetUUID()); + server_connection->OnConnectionRemoved( + "Launcher", [](std::shared_ptr connection) { + LogInfo("Removed Launcher connection from [{0}]", + connection->GetUUID()); - launcher_list.Remove(connection); - }); + launcher_list.Remove(connection); + } + ); - server_connection->OnConnectionIdentified("QueryServ", [](std::shared_ptr connection) { - LogInfo("New Query Server connection from [{2}] at [{0}:{1}]", - connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); + server_connection->OnConnectionIdentified( + "QueryServ", [](std::shared_ptr connection) { + LogInfo("New Query Server connection from [{2}] at [{0}:{1}]", + connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); - QSLink.AddConnection(connection); - }); + QSLink.AddConnection(connection); + } + ); - server_connection->OnConnectionRemoved("QueryServ", [](std::shared_ptr connection) { - LogInfo("Removed Query Server connection from [{0}]", - connection->GetUUID()); + server_connection->OnConnectionRemoved( + "QueryServ", [](std::shared_ptr connection) { + LogInfo("Removed Query Server connection from [{0}]", + connection->GetUUID()); - QSLink.RemoveConnection(connection); - }); + QSLink.RemoveConnection(connection); + } + ); - server_connection->OnConnectionIdentified("UCS", [](std::shared_ptr connection) { - LogInfo("New UCS Server connection from [{2}] at [{0}:{1}]", - connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); + server_connection->OnConnectionIdentified( + "UCS", [](std::shared_ptr connection) { + LogInfo("New UCS Server connection from [{2}] at [{0}:{1}]", + connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); - UCSLink.SetConnection(connection); + UCSLink.SetConnection(connection); - zoneserver_list.UpdateUCSServerAvailable(); - }); + zoneserver_list.UpdateUCSServerAvailable(); + } + ); server_connection->OnConnectionRemoved( "UCS", [](std::shared_ptr connection) { @@ -575,26 +609,30 @@ int main(int argc, char** argv) { } ); - server_connection->OnConnectionIdentified("WebInterface", [](std::shared_ptr connection) { - LogInfo("New WebInterface Server connection from [{2}] at [{0}:{1}]", - connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); + server_connection->OnConnectionIdentified( + "WebInterface", [](std::shared_ptr connection) { + LogInfo("New WebInterface Server connection from [{2}] at [{0}:{1}]", + connection->Handle()->RemoteIP(), connection->Handle()->RemotePort(), connection->GetUUID()); - web_interface.AddConnection(connection); - }); + web_interface.AddConnection(connection); + } + ); - server_connection->OnConnectionRemoved("WebInterface", [](std::shared_ptr connection) { - LogInfo("Removed WebInterface Server connection from [{0}]", - connection->GetUUID()); + server_connection->OnConnectionRemoved( + "WebInterface", [](std::shared_ptr connection) { + LogInfo("Removed WebInterface Server connection from [{0}]", + connection->GetUUID()); - web_interface.RemoveConnection(connection); - }); + web_interface.RemoveConnection(connection); + } + ); EQStreamManagerInterfaceOptions opts(9000, false, false); - opts.daybreak_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); + opts.daybreak_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); opts.daybreak_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); - opts.daybreak_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); - opts.daybreak_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); - opts.daybreak_options.outgoing_data_rate = RuleR(Network, ClientDataRate); + opts.daybreak_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); + opts.daybreak_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); + opts.daybreak_options.outgoing_data_rate = RuleR(Network, ClientDataRate); EQ::Net::EQStreamManager eqsm(opts); @@ -607,14 +645,16 @@ int main(int argc, char** argv) { zoneserver_list.reminder->Disable(); Timer InterserverTimer(INTERSERVER_TIMER); // does MySQL pings and auto-reconnect InterserverTimer.Trigger(); - uint8 ReconnectCounter = 100; + uint8 ReconnectCounter = 100; std::shared_ptr eqs; - EQStreamInterface *eqsi; + EQStreamInterface *eqsi; - eqsm.OnNewConnection([&stream_identifier](std::shared_ptr stream) { - stream_identifier.AddStream(stream); - LogInfo("New connection from IP {0}:{1}", stream->GetRemoteIP(), ntohs(stream->GetRemotePort())); - }); + eqsm.OnNewConnection( + [&stream_identifier](std::shared_ptr stream) { + stream_identifier.AddStream(stream); + LogInfo("New connection from IP {0}:{1}", stream->GetRemoteIP(), ntohs(stream->GetRemotePort())); + } + ); while (RunLoops) { Timer::SetCurrentTime(); @@ -626,7 +666,7 @@ int main(int argc, char** argv) { //check the stream identifier for any now-identified streams while ((eqsi = stream_identifier.PopIdentified())) { //now that we know what patch they are running, start up their client object - struct in_addr in{}; + struct in_addr in{}; in.s_addr = eqsi->GetRemoteIP(); if (RuleB(World, UseBannedIPsTable)) { //Lieka: Check to see if we have the responsibility for blocking IPs. LogInfo("Checking inbound connection [{}] against BannedIPs table", inet_ntoa(in)); @@ -642,7 +682,11 @@ int main(int argc, char** argv) { } } if (!RuleB(World, UseBannedIPsTable)) { - LogInfo("New connection from [{}]:[{}], processing connection", inet_ntoa(in), ntohs(eqsi->GetRemotePort())); + LogInfo( + "New connection from [{}]:[{}], processing connection", + inet_ntoa(in), + ntohs(eqsi->GetRemotePort()) + ); auto client = new Client(eqsi); // @merth: client->zoneattempt=0; client_list.Add(client); @@ -657,6 +701,7 @@ int main(int argc, char** argv) { database.PurgeExpiredInstances(); database.PurgeAllDeletedDataBuckets(); ExpeditionDatabase::PurgeExpiredCharacterLockouts(); + CharacterTaskTimersRepository::DeleteWhere(database, "expire_time <= NOW()"); } if (EQTimeTimer.Check()) { @@ -672,14 +717,18 @@ int main(int argc, char** argv) { launcher_list.Process(); LFPGroupList.Process(); adventure_manager.Process(); - expedition_state.Process(); + dynamic_zone_manager.Process(); if (InterserverTimer.Check()) { InterserverTimer.Start(); database.ping(); content_db.ping(); - std::string window_title = StringFormat("World: %s Clients: %i", Config->LongName.c_str(), client_list.GetClientCount()); + std::string window_title = StringFormat( + "World: %s Clients: %i", + Config->LongName.c_str(), + client_list.GetClientCount() + ); UpdateWindowTitle(window_title); } @@ -696,12 +745,14 @@ int main(int argc, char** argv) { return 0; } -void CatchSignal(int sig_num) { +void CatchSignal(int sig_num) +{ LogInfo("Caught signal [{}]", sig_num); RunLoops = false; } -void UpdateWindowTitle(char* iNewTitle) { +void UpdateWindowTitle(char *iNewTitle) +{ #ifdef _WINDOWS char tmp[500]; if (iNewTitle) { @@ -714,18 +765,23 @@ void UpdateWindowTitle(char* iNewTitle) { #endif } -void CheckForServerScript(bool force_download) { +void CheckForServerScript(bool force_download) +{ /* Fetch EQEmu Server script */ if (!std::ifstream("eqemu_server.pl") || force_download) { - if(force_download) - std::remove("eqemu_server.pl"); /* Delete local before fetch */ + if (force_download) { + std::remove("eqemu_server.pl"); + } /* Delete local before fetch */ std::cout << "Pulling down EQEmu Server Maintenance Script (eqemu_server.pl)..." << std::endl; #ifdef _WIN32 if(system("perl -MLWP::UserAgent -e \"require LWP::UserAgent; my $ua = LWP::UserAgent->new; $ua->timeout(10); $ua->env_proxy; my $response = $ua->get('https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_server.pl'); if ($response->is_success){ open(FILE, '> eqemu_server.pl'); print FILE $response->decoded_content; close(FILE); }\"")); #else - if(system("wget -N --no-check-certificate --quiet -O eqemu_server.pl https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_server.pl")); + if (system( + "wget -N --no-check-certificate --quiet -O eqemu_server.pl https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_server.pl" + )) {} #endif } } + diff --git a/world/shared_task_manager.cpp b/world/shared_task_manager.cpp new file mode 100644 index 000000000..d28559f90 --- /dev/null +++ b/world/shared_task_manager.cpp @@ -0,0 +1,1820 @@ +#include "shared_task_manager.h" +#include "cliententry.h" +#include "clientlist.h" +#include "dynamic_zone.h" +#include "dynamic_zone_manager.h" +#include "zonelist.h" +#include "zoneserver.h" +#include "shared_task_world_messaging.h" +#include "../common/repositories/character_data_repository.h" +#include "../common/repositories/character_task_timers_repository.h" +#include "../common/repositories/shared_task_members_repository.h" +#include "../common/repositories/shared_task_activity_state_repository.h" +#include "../common/repositories/completed_shared_tasks_repository.h" +#include "../common/repositories/completed_shared_task_members_repository.h" +#include "../common/repositories/completed_shared_task_activity_state_repository.h" +#include "../common/repositories/shared_task_dynamic_zones_repository.h" +#include + +extern ClientList client_list; +extern ZSList zoneserver_list; + +SharedTaskManager *SharedTaskManager::SetDatabase(Database *db) +{ + SharedTaskManager::m_database = db; + + return this; +} + +SharedTaskManager *SharedTaskManager::SetContentDatabase(Database *db) +{ + SharedTaskManager::m_content_database = db; + + return this; +} + +std::vector SharedTaskManager::GetRequestMembers( + uint32 requestor_character_id, + const std::vector &characters +) +{ + std::vector request_members = {}; + request_members.reserve(characters.size()); + + for (const auto &character : characters) { + SharedTaskMember member = {}; + member.character_id = character.id; + member.character_name = character.name; + + // if the solo/raid/group member is a leader, make sure we tag it as such + if (character.id == requestor_character_id) { + member.is_leader = true; + } + + request_members.emplace_back(member); + } + + return request_members; +} + +void SharedTaskManager::AttemptSharedTaskCreation( + uint32 requested_task_id, + uint32 requested_character_id, + uint32 npc_type_id +) +{ + auto task = GetSharedTaskDataByTaskId(requested_task_id); + if (task.id != 0 && task.type == TASK_TYPE_SHARED) { + LogTasksDetail( + "[AttemptSharedTaskCreation] Found Shared Task ({}) [{}]", + requested_task_id, + task.title + ); + } + + // shared task validation + auto request = SharedTask::GetRequestCharacters(*m_database, requested_character_id); + if (!CanRequestSharedTask(task.id, requested_character_id, request)) { + LogTasksDetail("[AttemptSharedTaskCreation] Shared task validation failed"); + return; + } + + auto request_members = GetRequestMembers(requested_character_id, request.characters); + if (!request_members.empty()) { + for (auto &m: request_members) { + LogTasksDetail( + "[AttemptSharedTaskCreation] Request Members ({})", + m.character_id + ); + } + } + + if (request_members.empty()) { + LogTasksDetail("[AttemptSharedTaskCreation] No additional request members found... Just leader"); + } + + // new shared task instance + auto new_shared_task = SharedTask{}; + auto activities = TaskActivitiesRepository::GetWhere(*m_content_database, fmt::format("taskid = {}", task.id)); + + // new shared task db object + auto shared_task_entity = SharedTasksRepository::NewEntity(); + shared_task_entity.task_id = (int) requested_task_id; + shared_task_entity.accepted_time = static_cast(std::time(nullptr)); + shared_task_entity.expire_time = task.duration > 0 ? (std::time(nullptr) + task.duration) : 0; + + auto created_db_shared_task = SharedTasksRepository::InsertOne(*m_database, shared_task_entity); + + // active record + new_shared_task.SetDbSharedTask(created_db_shared_task); + + // request timer lockouts + std::vector task_timers; + task_timers.reserve(request_members.size()); + + // persist members + std::vector shared_task_db_members = {}; + shared_task_db_members.reserve(request_members.size()); + for (auto &m: request_members) { + auto e = SharedTaskMembersRepository::NewEntity(); + + e.character_id = m.character_id; + e.is_leader = (m.is_leader ? 1 : 0); + e.shared_task_id = new_shared_task.GetDbSharedTask().id; + + shared_task_db_members.emplace_back(e); + + new_shared_task.AddCharacterToMemberHistory(m.character_id); // memory member history + + if (task.request_timer_seconds > 0) { + auto timer = CharacterTaskTimersRepository::NewEntity(); + timer.character_id = m.character_id; + timer.task_id = task.id; + timer.timer_type = static_cast(TaskTimerType::Request); + timer.expire_time = shared_task_entity.accepted_time + task.request_timer_seconds; + + task_timers.emplace_back(timer); + } + } + + SharedTaskMembersRepository::InsertMany(*m_database, shared_task_db_members); + + if (!task_timers.empty()) { + CharacterTaskTimersRepository::InsertMany(*m_database, task_timers); + } + + // activity state (memory) + std::vector shared_task_activity_state = {}; + shared_task_activity_state.reserve(activities.size()); + for (auto &a: activities) { + + // entry + auto e = SharedTaskActivityStateEntry{}; + e.activity_id = a.activityid; + e.done_count = 0; + e.max_done_count = a.goalcount; + + shared_task_activity_state.emplace_back(e); + } + + // activity state (database) + std::vector shared_task_db_activities = {}; + shared_task_db_activities.reserve(activities.size()); + for (auto &a: activities) { + + // entry + auto e = SharedTaskActivityStateRepository::NewEntity(); + e.shared_task_id = new_shared_task.GetDbSharedTask().id; + e.activity_id = a.activityid; + e.done_count = 0; + + shared_task_db_activities.emplace_back(e); + } + + SharedTaskActivityStateRepository::InsertMany(*m_database, shared_task_db_activities); + + // state + new_shared_task.SetSharedTaskActivityState(shared_task_activity_state); + + // set database data in memory to make it easier for any later referencing + new_shared_task.SetTaskData(task); + new_shared_task.SetTaskActivityData(activities); + new_shared_task.SetMembers(request_members); + + // add to shared tasks list + m_shared_tasks.emplace_back(new_shared_task); + + // send accept to members + for (auto &m: request_members) { + // only requester (leader) receives back the npc context to trigger task accept event + uint32_t npc_context_id = m.character_id == requested_character_id ? npc_type_id : 0; + SendAcceptNewSharedTaskPacket( + m.character_id, + requested_task_id, + npc_context_id, + shared_task_entity.accepted_time + ); + } + SendSharedTaskMemberListToAllMembers(&new_shared_task); + + LogTasks( + "[AttemptSharedTaskCreation] shared_task_id [{}] created successfully | task_id [{}] member_count [{}] activity_count [{}] current tasks in state [{}]", + new_shared_task.GetDbSharedTask().id, + task.id, + request_members.size(), + shared_task_activity_state.size(), + m_shared_tasks.size() + ); +} + +void SharedTaskManager::AttemptSharedTaskRemoval( + uint32 requested_task_id, + uint32 requested_character_id, + bool remove_from_db // inherited from zone logic - we're just passing through +) +{ + auto task = GetSharedTaskDataByTaskId(requested_task_id); + if (task.id != 0 && task.type == TASK_TYPE_SHARED) { + LogTasksDetail( + "[AttemptSharedTaskRemoval] Found Shared Task data ({}) [{}]", + requested_task_id, + task.title + ); + } + + auto t = FindSharedTaskByTaskIdAndCharacterId(requested_task_id, requested_character_id); + if (t) { + auto removed = t->FindMemberFromCharacterID(requested_character_id); + + // remove self + RemovePlayerFromSharedTask(t, requested_character_id); + SendRemovePlayerFromSharedTaskPacket( + requested_character_id, + requested_task_id, + remove_from_db + ); + + // inform clients of removal of self + SendSharedTaskMemberRemovedToAllMembers(t, removed.character_name); + + client_list.SendCharacterMessageID( + requested_character_id, Chat::Yellow, + SharedTaskMessage::PLAYER_HAS_BEEN_REMOVED, {removed.character_name, task.title} + ); + + if (removed.is_leader) { + ChooseNewLeader(t); + } + } +} + +void SharedTaskManager::RemoveEveryoneFromSharedTask(SharedTask *t, uint32 requested_character_id) +{ + // caller validates leader + LogTasksDetail("[RemoveEveryoneFromSharedTask] Leader [{}]", requested_character_id); + + // inform clients of removal + for (auto &m: t->GetMembers()) { + LogTasksDetail( + "[RemoveEveryoneFromSharedTask] Sending removal to [{}] task_id [{}]", + m.character_id, + t->GetTaskData().id + ); + + SendRemovePlayerFromSharedTaskPacket(m.character_id, t->GetTaskData().id, true); + + client_list.SendCharacterMessageID( + m.character_id, Chat::Yellow, + SharedTaskMessage::YOU_HAVE_BEEN_REMOVED, {t->GetTaskData().title} + ); + } + + client_list.SendCharacterMessageID( + requested_character_id, + Chat::Red, + SharedTaskMessage::PLAYER_HAS_BEEN_REMOVED, + {"Everyone", t->GetTaskData().title} + ); + + RemoveAllMembersFromDynamicZones(t); + + // persistence + DeleteSharedTask(t->GetDbSharedTask().id); + + PrintSharedTaskState(); +} + +void SharedTaskManager::DeleteSharedTask(int64 shared_task_id) +{ + LogTasksDetail( + "[DeleteSharedTask] shared_task_id [{}]", + shared_task_id + ); + + // remove internally + m_shared_tasks.erase( + std::remove_if( + m_shared_tasks.begin(), + m_shared_tasks.end(), + [&](SharedTask const &s) { + return s.GetDbSharedTask().id == shared_task_id; + } + ), + m_shared_tasks.end() + ); + + // database + SharedTasksRepository::DeleteWhere(*m_database, fmt::format("id = {}", shared_task_id)); + SharedTaskMembersRepository::DeleteWhere(*m_database, fmt::format("shared_task_id = {}", shared_task_id)); + SharedTaskActivityStateRepository::DeleteWhere(*m_database, fmt::format("shared_task_id = {}", shared_task_id)); + SharedTaskDynamicZonesRepository::DeleteWhere(*m_database, fmt::format("shared_task_id = {}", shared_task_id)); +} + +void SharedTaskManager::LoadSharedTaskState() +{ + LogTasksDetail("[LoadSharedTaskState] Restoring state from the database"); + + // load shared tasks + std::vector shared_tasks = {}; + + // eager load all activity state data + auto shared_tasks_activity_state_data = SharedTaskActivityStateRepository::All(*m_database); + + // eager load all member state data + auto shared_task_members_data = SharedTaskMembersRepository::All(*m_database); + + // load character data for member names + std::vector shared_task_character_data; + if (!shared_task_members_data.empty()) { + std::vector character_ids; + for (const auto &m: shared_task_members_data) { + character_ids.emplace_back(m.character_id); + } + + shared_task_character_data = CharacterDataRepository::GetWhere( + *m_database, + fmt::format("id IN ({})", fmt::join(character_ids, ",")) + ); + } + + auto shared_task_dynamic_zones_data = SharedTaskDynamicZonesRepository::All(*m_database); + + // load shared tasks not already completed + auto st = SharedTasksRepository::GetWhere(*m_database, "TRUE"); + shared_tasks.reserve(st.size()); + for (auto &s: st) { + SharedTask ns = {}; + + LogTasksDetail( + "[LoadSharedTaskState] Loading shared_task_id [{}] task_id [{}]", + s.id, + s.task_id + ); + + // shared task db data + ns.SetDbSharedTask(s); + + // set database task data for internal referencing + auto task_data = GetSharedTaskDataByTaskId(s.task_id); + + LogTasksDetail("[LoadSharedTaskState] [GetSharedTaskDataByTaskId] task_id [{}]", task_data.id); + + ns.SetTaskData(task_data); + + // set database task data for internal referencing + auto activities_data = GetSharedTaskActivityDataByTaskId(s.task_id); + ns.SetTaskActivityData(activities_data); + + // load activity state into memory + std::vector shared_task_activity_state = {}; + + // loop through shared task activity state data referencing from memory instead of + // querying inside this loop each time + for (auto &sta: shared_tasks_activity_state_data) { + + // filter by current shared task id + if (sta.shared_task_id == s.id) { + + auto e = SharedTaskActivityStateEntry{}; + e.activity_id = sta.activity_id; + e.done_count = sta.done_count; + + // get max done count from activities data + // loop through activities data in memory and grep on task_id, activity_id to pull goalcount + for (auto &ad: activities_data) { + if (ad.taskid == s.task_id && ad.activityid == sta.activity_id) { + LogTasksDetail( + "[LoadSharedTaskState] shared_task_id [{}] task_id [{}] activity_id [{}] done_count [{}] max_done_count (goalcount) [{}]", + s.id, + s.task_id, + sta.activity_id, + e.done_count, + ad.goalcount + ); + + e.max_done_count = ad.goalcount; + e.completed_time = sta.completed_time; + e.updated_time = sta.updated_time; + } + } + + shared_task_activity_state.emplace_back(e); + } + } + + ns.SetSharedTaskActivityState(shared_task_activity_state); + + // members + std::vector shared_task_members = {}; + for (auto &m: shared_task_members_data) { + if (m.shared_task_id == s.id) { + SharedTaskMember member = {}; + member.character_id = m.character_id; + member.is_leader = (m.is_leader ? 1 : 0); + + auto it = std::find_if( + shared_task_character_data.begin(), shared_task_character_data.end(), + [&](const CharacterDataRepository::CharacterData &character) { + return character.id == m.character_id; + } + ); + + if (it != shared_task_character_data.end()) { + member.character_name = it->name; + } + + shared_task_members.emplace_back(member); + + LogTasksDetail( + "[LoadSharedTaskState] shared_task_id [{}] adding member character_id [{}] character_name [{}] is_leader [{}]", + s.id, + member.character_id, + member.character_name, + member.is_leader + ); + + // add member to history (if restoring state from a world restart we lost real past member history) + ns.AddCharacterToMemberHistory(m.character_id); + } + } + + ns.SetMembers(shared_task_members); + + // dynamic zones + for (const auto &dz_entry : shared_task_dynamic_zones_data) { + if (dz_entry.shared_task_id == s.id) { + ns.dynamic_zone_ids.emplace_back(static_cast(dz_entry.dynamic_zone_id)); + + LogTasksDetail( + "[LoadSharedTaskState] shared_task_id [{}] adding dynamic_zone_id [{}]", + s.id, + dz_entry.dynamic_zone_id + ); + } + } + + LogTasks( + "[LoadSharedTaskState] Loaded shared task state | shared_task_id [{}] task_id [{}] task_title [{}] member_count [{}] state_activity_count [{}]", + s.id, + task_data.id, + task_data.title, + ns.GetMembers().size(), + ns.GetActivityState().size() + ); + + shared_tasks.emplace_back(ns); + } + + SetSharedTasks(shared_tasks); + + LogTasks( + "[LoadSharedTaskState] Loaded [{}] shared tasks", + m_shared_tasks.size() + ); + + PrintSharedTaskState(); +} + +SharedTaskManager *SharedTaskManager::LoadTaskData() +{ + m_task_data = TasksRepository::All(*m_content_database); + m_task_activity_data = TaskActivitiesRepository::All(*m_content_database); + + LogTasks("[LoadTaskData] Loaded tasks [{}] activities [{}]", m_task_data.size(), m_task_activity_data.size()); + + return this; +} + +TasksRepository::Tasks SharedTaskManager::GetSharedTaskDataByTaskId(uint32 task_id) +{ + for (auto &t: m_task_data) { + if (t.id == task_id && t.type == TASK_TYPE_SHARED) { + return t; + } + } + + return TasksRepository::NewEntity(); +} + +std::vector +SharedTaskManager::GetSharedTaskActivityDataByTaskId(uint32 task_id) +{ + std::vector activities = {}; + + for (auto &a: m_task_activity_data) { + if (a.taskid == task_id) { + activities.emplace_back(a); + } + } + + return activities; +} + +void SharedTaskManager::SharedTaskActivityUpdate( + uint32 source_character_id, + uint32 task_id, + uint32 activity_id, + uint32 done_count, + bool ignore_quest_update +) +{ + auto shared_task = FindSharedTaskByTaskIdAndCharacterId(task_id, source_character_id); + if (shared_task) { + LogTasksDetail( + "[SharedTaskActivityUpdate] shared_task_id [{}] character_id [{}] task_id [{}] activity_id [{}] done_count [{}]", + shared_task->GetDbSharedTask().id, + source_character_id, + task_id, + activity_id, + done_count + ); + + for (auto &a : shared_task->m_shared_task_activity_state) { + if (a.activity_id == activity_id) { + + // discard updates out of bounds + if (a.done_count == a.max_done_count) { + LogTasksDetail( + "[SharedTaskActivityUpdate] done_count [{}] is greater than max [{}] discarding...", + done_count, + a.max_done_count + ); + return; + } + + // if we are progressing + if (a.done_count < done_count) { + LogTasksDetail( + "[SharedTaskActivityUpdate] Propagating update for shared_task_id [{}] character_id [{}] task_id [{}] activity_id [{}] old_done_count [{}] new_done_count [{}]", + shared_task->GetDbSharedTask().id, + source_character_id, + task_id, + activity_id, + a.done_count, + done_count + ); + + a.done_count = done_count; + a.updated_time = std::time(nullptr); + + // if the update came in larger than the max for whatever reason, clamp + if (a.done_count > a.max_done_count) { + a.done_count = a.max_done_count; + } + + // if the activity is done, lets mark it as such + if (a.done_count == a.max_done_count) { + a.completed_time = std::time(nullptr); + } + + // sync state as each update comes in (for now) + SaveSharedTaskActivityState( + shared_task->GetDbSharedTask().id, + shared_task->m_shared_task_activity_state + ); + + shared_task->SetSharedTaskActivityState(shared_task->m_shared_task_activity_state); + + LogTasksDetail( + "[SharedTaskActivityUpdate] Debug done_count [{}]", + a.done_count + ); + + // loop through members - send update + for (auto &m: shared_task->GetMembers()) { + + // confirm task update to client(s) + auto p = std::make_unique( + ServerOP_SharedTaskUpdate, + sizeof(ServerSharedTaskActivityUpdate_Struct) + ); + + auto d = reinterpret_cast(p->pBuffer); + d->source_character_id = m.character_id; + d->task_id = task_id; + d->activity_id = activity_id; + d->done_count = done_count; + d->ignore_quest_update = ignore_quest_update; + + // get requested character zone server + ClientListEntry *c = client_list.FindCLEByCharacterID(m.character_id); + if (c && c->Server()) { + c->Server()->SendPacket(p.get()); + } + } + + break; + } + + LogTasksDetail( + "[SharedTaskActivityUpdate] Discarding duplicate update for shared_task_id [{}] character_id [{}] task_id [{}] activity_id [{}] done_count [{}] ignore_quest_update [{}]", + shared_task->GetDbSharedTask().id, + source_character_id, + task_id, + activity_id, + done_count, + (ignore_quest_update ? "true" : "false") + ); + } + } + + // check if completed + bool is_shared_task_completed = true; + for (auto &a : shared_task->m_shared_task_activity_state) { + if (a.done_count != a.max_done_count) { + is_shared_task_completed = false; + } + } + + // mark completed + if (is_shared_task_completed) { + auto t = shared_task->GetDbSharedTask(); + if (t.id > 0) { + LogTasksDetail( + "[SharedTaskActivityUpdate] Marking shared task [{}] completed", + shared_task->GetDbSharedTask().id + ); + + // set record + t.completion_time = std::time(nullptr); + t.is_locked = true; + // update database + SharedTasksRepository::UpdateOne(*m_database, t); + // update internally + shared_task->SetDbSharedTask(t); + // record completion + RecordSharedTaskCompletion(shared_task); + // replay timer lockouts + AddReplayTimers(shared_task); + } + } + } +} + +SharedTask *SharedTaskManager::FindSharedTaskByTaskIdAndCharacterId(uint32 task_id, uint32 character_id) +{ + for (auto &s: m_shared_tasks) { + // grep for task + if (s.GetTaskData().id == task_id) { + // find member in shared task + for (auto &m: s.GetMembers()) { + if (m.character_id == character_id) { + return &s; + } + } + } + } + + return nullptr; +} + +void SharedTaskManager::SaveSharedTaskActivityState( + int64 shared_task_id, + std::vector activity_state +) +{ + // transfer from memory to database + std::vector shared_task_db_activities = {}; + shared_task_db_activities.reserve(activity_state.size()); + + for (auto &a: activity_state) { + + // entry + auto e = SharedTaskActivityStateRepository::NewEntity(); + e.shared_task_id = shared_task_id; + e.activity_id = (int) a.activity_id; + e.done_count = (int) a.done_count; + e.completed_time = (int) a.completed_time; + e.updated_time = (int) a.updated_time; + + shared_task_db_activities.emplace_back(e); + } + + SharedTaskActivityStateRepository::DeleteWhere(*m_database, fmt::format("shared_task_id = {}", shared_task_id)); + SharedTaskActivityStateRepository::InsertMany(*m_database, shared_task_db_activities); +} + +bool SharedTaskManager::IsSharedTaskLeader(SharedTask *s, uint32 character_id) +{ + for (auto &m: s->GetMembers()) { + if (m.character_id == character_id && m.is_leader) { + return true; + } + } + + return false; +} + +void SharedTaskManager::SendAcceptNewSharedTaskPacket( + uint32 character_id, + uint32 task_id, + uint32_t npc_context_id, + int accept_time +) +{ + auto p = std::make_unique( + ServerOP_SharedTaskAcceptNewTask, + sizeof(ServerSharedTaskRequest_Struct) + ); + + auto d = reinterpret_cast(p->pBuffer); + d->requested_character_id = character_id; + d->requested_task_id = task_id; + d->requested_npc_type_id = npc_context_id; + d->accept_time = accept_time; + + // get requested character zone server + ClientListEntry *cle = client_list.FindCLEByCharacterID(character_id); + if (cle && cle->Server()) { + cle->Server()->SendPacket(p.get()); + } +} + +void SharedTaskManager::SendRemovePlayerFromSharedTaskPacket( + uint32 character_id, + uint32 task_id, + bool remove_from_db +) +{ + // confirm shared task request: inform clients + auto p = std::make_unique( + ServerOP_SharedTaskAttemptRemove, + sizeof(ServerSharedTaskAttemptRemove_Struct) + ); + + auto d = reinterpret_cast(p->pBuffer); + d->requested_character_id = character_id; + d->requested_task_id = task_id; + d->remove_from_db = remove_from_db; + + // get requested character zone server + ClientListEntry *cle = client_list.FindCLEByCharacterID(character_id); + if (cle && cle->Server()) { + cle->Server()->SendPacket(p.get()); + } +} + +void SharedTaskManager::SendSharedTaskMemberList(uint32 character_id, const std::vector &members) +{ + EQ::Net::DynamicPacket dyn_pack; + dyn_pack.PutSerialize(0, members); + + SendSharedTaskMemberList(character_id, dyn_pack); +} + +void SharedTaskManager::SendSharedTaskMemberList(uint32 character_id, const EQ::Net::DynamicPacket &serialized_members) +{ + // send member list packet + auto p = std::make_unique( + ServerOP_SharedTaskMemberlist, + sizeof(ServerSharedTaskMemberListPacket_Struct) + serialized_members.Length() + ); + + auto d = reinterpret_cast(p->pBuffer); + d->destination_character_id = character_id; + d->cereal_size = static_cast(serialized_members.Length()); + memcpy(d->cereal_serialized_members, serialized_members.Data(), serialized_members.Length()); + + // send memberlist + ClientListEntry *cle = client_list.FindCLEByCharacterID(character_id); + if (cle && cle->Server()) { + cle->Server()->SendPacket(p.get()); + } +} + +void SharedTaskManager::SendSharedTaskMemberChange( + uint32 character_id, + int64 shared_task_id, + const std::string &player_name, + bool removed +) +{ + uint32_t size = sizeof(ServerSharedTaskMemberChangePacket_Struct); + auto p = std::make_unique(ServerOP_SharedTaskMemberChange, size); + + auto d = reinterpret_cast(p->pBuffer); + d->destination_character_id = character_id; + d->shared_task_id = shared_task_id; + d->removed = removed; + strn0cpy(d->player_name, player_name.c_str(), sizeof(d->player_name)); + + ClientListEntry *cle = client_list.FindCLEByCharacterID(character_id); + if (cle && cle->Server()) { + cle->Server()->SendPacket(p.get()); + } +} + +void SharedTaskManager::RemovePlayerFromSharedTask(SharedTask *s, uint32 character_id) +{ + SharedTaskMembersRepository::DeleteWhere( + *m_database, + fmt::format( + "shared_task_id = {} and character_id = {}", + s->GetDbSharedTask().id, + character_id + ) + ); + + // remove internally + s->m_members.erase( + std::remove_if( + s->m_members.begin(), + s->m_members.end(), + [&](SharedTaskMember const &m) { + return m.character_id == character_id; + } + ), + s->m_members.end() + ); + + for (const auto &dz_id : s->dynamic_zone_ids) { + auto dz = DynamicZone::FindDynamicZoneByID(dz_id); + if (dz) { + dz->RemoveMember(character_id); + } + } +} + +void SharedTaskManager::PrintSharedTaskState() +{ + for (auto &s: m_shared_tasks) { + auto task = GetSharedTaskDataByTaskId(s.GetDbSharedTask().task_id); + + LogTasksDetail("[PrintSharedTaskState] # Shared Task"); + + LogTasksDetail( + "[PrintSharedTaskState] shared_task_id [{}] task_id [{}] task_title [{}] member_count [{}] state_activity_count [{}]", + s.GetDbSharedTask().id, + task.id, + task.title, + s.GetMembers().size(), + s.GetActivityState().size() + ); + + LogTasksDetail("[PrintSharedTaskState] # Activities"); + + // activity state + for (auto &a: s.m_shared_task_activity_state) { + LogTasksDetail( + "[PrintSharedTaskState] -- activity_id [{}] done_count [{}] max_done_count [{}] completed_time [{}]", + a.activity_id, + a.done_count, + a.max_done_count, + a.completed_time + ); + } + + LogTasksDetail("[PrintSharedTaskState] # Members"); + + // members + for (auto &m: s.m_members) { + LogTasksDetail( + "[PrintSharedTaskState] -- character_id [{}] is_leader [{}]", + m.character_id, + m.is_leader + ); + } + + LogTasksDetail("[PrintSharedTaskState] # Dynamic Zones"); + + for (auto &dz_id: s.dynamic_zone_ids) { + LogTasksDetail( + "[PrintSharedTaskState] -- dynamic_zone_id [{}]", + dz_id + ); + } + } +} + +void SharedTaskManager::RemovePlayerFromSharedTaskByPlayerName(SharedTask *s, const std::string &character_name) +{ + auto member = s->FindMemberFromCharacterName(character_name); + if (member.character_id == 0) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::IS_NOT_MEMBER, {character_name}); + return; + } + + LogTasksDetail( + "[RemovePlayerFromSharedTaskByPlayerName] shared_task_id [{}] character_name [{}]", + s->GetDbSharedTask().id, + character_name + ); + + auto leader = s->GetLeader(); // get leader now for msg in case leader is one removed + + RemovePlayerFromSharedTask(s, member.character_id); + SendRemovePlayerFromSharedTaskPacket( + member.character_id, + s->GetDbSharedTask().task_id, + true + ); + + SendSharedTaskMemberRemovedToAllMembers(s, member.character_name); + + // leader and removed player get server messages (leader sees two messages) + // results in double messages if leader removed self (live behavior) + client_list.SendCharacterMessageID( + leader.character_id, Chat::Yellow, + SharedTaskMessage::PLAYER_HAS_BEEN_REMOVED, {member.character_name, s->GetTaskData().title} + ); + + client_list.SendCharacterMessageID( + member.character_id, Chat::Yellow, + SharedTaskMessage::PLAYER_HAS_BEEN_REMOVED, {member.character_name, s->GetTaskData().title} + ); + + if (member.is_leader) { + ChooseNewLeader(s); + } +} + +void SharedTaskManager::SendSharedTaskMemberListToAllMembers(SharedTask *s) +{ + // serialize once so we don't re-serialize it for every member + EQ::Net::DynamicPacket dyn_pack; + dyn_pack.PutSerialize(0, s->GetMembers()); + + for (auto &m: s->GetMembers()) { + SendSharedTaskMemberList( + m.character_id, + dyn_pack + ); + } +} + +void SharedTaskManager::SendSharedTaskMemberAddedToAllMembers(SharedTask *s, const std::string &player_name) +{ + for (const auto &m : s->GetMembers()) { + SendSharedTaskMemberChange(m.character_id, s->GetDbSharedTask().id, player_name, false); + } +} + +void SharedTaskManager::SendSharedTaskMemberRemovedToAllMembers(SharedTask *s, const std::string &player_name) +{ + for (const auto &m : s->GetMembers()) { + SendSharedTaskMemberChange(m.character_id, s->GetDbSharedTask().id, player_name, true); + } +} + +void SharedTaskManager::MakeLeaderByPlayerName(SharedTask *s, const std::string &character_name) +{ + auto new_leader = s->FindMemberFromCharacterName(character_name); + if (new_leader.character_id == 0) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::IS_NOT_MEMBER, {character_name}); + return; + } + + bool found_new_leader = false; + + std::vector members = s->GetMembers(); + for (auto &m: members) { + LogTasksDetail( + "[MakeLeaderByPlayerName] character_id [{}] m.character_id [{}]", + new_leader.character_id, + m.character_id + ); + + m.is_leader = false; + + // destination character is in shared task, make swap + if (new_leader.character_id == m.character_id) { + found_new_leader = true; + LogTasksDetail( + "[MakeLeaderByPlayerName] shared_task_id [{}] character_name [{}]", + s->GetDbSharedTask().id, + character_name + ); + + m.is_leader = true; + } + } + + if (found_new_leader) { + s->SetMembers(members); + SaveMembers(s, members); + SendSharedTaskMemberListToAllMembers(s); + SendMembersMessageID( + s, Chat::Yellow, SharedTaskMessage::PLAYER_NOW_LEADER, + {new_leader.character_name, s->GetTaskData().title} + ); + + for (const auto &dz_id : s->dynamic_zone_ids) { + auto dz = DynamicZone::FindDynamicZoneByID(dz_id); + if (dz) { + dz->SetNewLeader(static_cast(new_leader.character_id)); + } + } + } +} + +void SharedTaskManager::SaveMembers(SharedTask *s, std::vector members) +{ + std::vector dm = {}; + dm.reserve(members.size()); + for (auto &m: members) { + auto e = SharedTaskMembersRepository::NewEntity(); + + e.character_id = m.character_id; + e.is_leader = (m.is_leader ? 1 : 0); + e.shared_task_id = s->GetDbSharedTask().id; + + dm.emplace_back(e); + } + + SharedTaskMembersRepository::DeleteWhere(*m_database, fmt::format("shared_task_id = {}", s->GetDbSharedTask().id)); + SharedTaskMembersRepository::InsertMany(*m_database, dm); +} + +void SharedTaskManager::InvitePlayerByPlayerName(SharedTask *s, const std::string &player_name) +{ + auto character = CharacterDataRepository::GetWhere( + *m_database, + fmt::format("`name` = '{}' LIMIT 1", EscapeString(player_name)) + ); + + auto character_id = !character.empty() ? character.front().id : 0; + + // we call validation even for an invalid player so error messages occur + if (CanAddPlayer(s, character_id, player_name, false)) { + // send dialogue window + SendSharedTaskInvitePacket(s, character_id); + + // keep track of active invitations at world + QueueActiveInvitation(s->GetDbSharedTask().id, character_id); + } +} + +void SharedTaskManager::SendSharedTaskInvitePacket(SharedTask *s, int64 invited_character_id) +{ + auto leader = s->GetLeader(); + + // found leader + if (leader.character_id > 0) { + + // init packet + auto p = std::make_unique( + ServerOP_SharedTaskInvitePlayer, + sizeof(ServerSharedTaskInvitePlayer_Struct) + ); + + // fill + auto d = reinterpret_cast(p->pBuffer); + d->requested_character_id = invited_character_id; + d->invite_shared_task_id = s->GetDbSharedTask().id; + strn0cpy(d->inviter_name, leader.character_name.c_str(), sizeof(d->inviter_name)); + strn0cpy(d->task_name, s->GetTaskData().title.c_str(), sizeof(d->task_name)); + + // get requested character zone server + ClientListEntry *cle = client_list.FindCLEByCharacterID(invited_character_id); + if (cle && cle->Server()) { + SendLeaderMessageID(s, Chat::Yellow, SharedTaskMessage::SEND_INVITE_TO, {cle->name()}); + cle->Server()->SendPacket(p.get()); + } + } +} + +void SharedTaskManager::AddPlayerByCharacterIdAndName( + SharedTask *s, + int64 character_id, + const std::string &character_name +) +{ + // fetch + std::vector members = s->GetMembers(); + + // create + auto new_member = SharedTaskMember{}; + new_member.character_id = character_id; + new_member.character_name = character_name; + + bool does_member_exist = false; + + for (auto &m: s->GetMembers()) { + if (m.character_id == character_id) { + does_member_exist = true; + } + } + + if (!does_member_exist && CanAddPlayer(s, character_id, character_name, true)) { + members.push_back(new_member); + + // add request timer (validation will prevent non-expired duplicates) + if (s->GetTaskData().request_timer_seconds > 0) { + auto expire_time = s->GetDbSharedTask().accepted_time + s->GetTaskData().request_timer_seconds; + if (expire_time > std::time(nullptr)) // not already expired + { + auto timer = CharacterTaskTimersRepository::NewEntity(); + timer.character_id = character_id; + timer.task_id = s->GetDbSharedTask().task_id; + timer.timer_type = static_cast(TaskTimerType::Request); + timer.expire_time = expire_time; + + CharacterTaskTimersRepository::InsertOne(*m_database, timer); + } + } + + // inform client + SendAcceptNewSharedTaskPacket(character_id, s->GetTaskData().id, 0, s->GetDbSharedTask().accepted_time); + + // add to shared task + SendSharedTaskMemberAddedToAllMembers(s, character_name); + s->SetMembers(members); + SaveMembers(s, members); + SendSharedTaskMemberList(character_id, s->GetMembers()); // new member gets full member list + s->AddCharacterToMemberHistory(character_id); + + // add to dzs tied to shared task + for (const auto &dz_id : s->dynamic_zone_ids) { + auto dz = DynamicZone::FindDynamicZoneByID(dz_id); + if (dz) { + auto status = DynamicZoneMemberStatus::Online; + dz->AddMember({static_cast(character_id), character_name, status}); + } + } + } +} + +SharedTask *SharedTaskManager::FindSharedTaskById(int64 shared_task_id) +{ + for (auto &s: m_shared_tasks) { + if (s.GetDbSharedTask().id == shared_task_id) { + return &s; + } + } + + return nullptr; +} + +void SharedTaskManager::QueueActiveInvitation(int64 shared_task_id, int64 character_id) +{ + LogTasksDetail( + "[QueueActiveInvitation] shared_task_id [{}] character_id [{}]", + shared_task_id, + character_id + ); + + auto active_invitation = SharedTaskActiveInvitation{}; + active_invitation.shared_task_id = shared_task_id; + active_invitation.character_id = character_id; + + m_active_invitations.emplace_back(active_invitation); +} + +bool SharedTaskManager::IsInvitationActive(uint32 shared_task_id, uint32 character_id) +{ + LogTasksDetail( + "[IsInvitationActive] shared_task_id [{}] character_id [{}]", + shared_task_id, + character_id + ); + + for (auto &i: m_active_invitations) { + if (i.character_id == character_id && i.shared_task_id == shared_task_id) { + return true; + } + } + + return false; +} + +void SharedTaskManager::RemoveActiveInvitation(int64 shared_task_id, int64 character_id) +{ + LogTasksDetail( + "[RemoveActiveInvitation] shared_task_id [{}] character_id [{}] pre_removal_count [{}]", + shared_task_id, + character_id, + m_active_invitations.size() + ); + + // remove internally + m_active_invitations.erase( + std::remove_if( + m_active_invitations.begin(), + m_active_invitations.end(), + [&](SharedTaskActiveInvitation const &i) { + return i.shared_task_id == shared_task_id && i.character_id == character_id; + } + ), + m_active_invitations.end() + ); + + LogTasksDetail( + "[RemoveActiveInvitation] shared_task_id [{}] character_id [{}] post_removal_count [{}]", + shared_task_id, + character_id, + m_active_invitations.size() + ); +} + +void SharedTaskManager::RemoveActiveInvitationByCharacterID(uint32_t character_id) +{ + m_active_invitations.erase( + std::remove_if( + m_active_invitations.begin(), m_active_invitations.end(), + [&](SharedTaskActiveInvitation const &i) { + return i.character_id == character_id; + } + ), m_active_invitations.end() + ); +} + +void SharedTaskManager::CreateDynamicZone(SharedTask *shared_task, DynamicZone &dz_request) +{ + std::vector dz_members; + for (const auto &member : shared_task->GetMembers()) { + dz_members.emplace_back(member.character_id, member.character_name); + if (member.is_leader) { + dz_request.SetLeader({member.character_id, member.character_name}); + } + } + + auto new_dz = dynamic_zone_manager.CreateNew(dz_request, dz_members); + if (new_dz) { + auto shared_task_dz = SharedTaskDynamicZonesRepository::NewEntity(); + shared_task_dz.shared_task_id = shared_task->GetDbSharedTask().id; + shared_task_dz.dynamic_zone_id = new_dz->GetID(); + + SharedTaskDynamicZonesRepository::InsertOne(*m_database, shared_task_dz); + + shared_task->dynamic_zone_ids.emplace_back(new_dz->GetID()); + } +} + +void SharedTaskManager::SendLeaderMessage(SharedTask *shared_task, int chat_type, const std::string &message) +{ + if (!shared_task) { + return; + } + + for (const auto &member : shared_task->GetMembers()) { + if (member.is_leader) { + client_list.SendCharacterMessage(member.character_id, chat_type, message); + break; + } + } +} + +void SharedTaskManager::SendLeaderMessageID( + SharedTask *shared_task, int chat_type, + int eqstr_id, std::initializer_list args +) +{ + if (!shared_task) { + return; + } + + for (const auto &member : shared_task->GetMembers()) { + if (member.is_leader) { + client_list.SendCharacterMessageID(member.character_id, chat_type, eqstr_id, args); + break; + } + } +} + +void SharedTaskManager::SendMembersMessage(SharedTask *shared_task, int chat_type, const std::string &message) +{ + if (!shared_task) { + return; + } + + for (const auto &member : shared_task->GetMembers()) { + client_list.SendCharacterMessage(member.character_id, chat_type, message); + } +} + +void SharedTaskManager::SendMembersMessageID( + SharedTask *shared_task, + int chat_type, + int eqstr_id, + std::initializer_list args +) +{ + if (!shared_task || shared_task->GetMembers().empty()) { + return; + } + + // serialize here since using client_list methods would re-serialize for every member + SerializeBuffer serialized_args; + for (const auto &arg : args) { + serialized_args.WriteString(arg); + } + + uint32_t args_size = static_cast(serialized_args.size()); + uint32_t pack_size = sizeof(CZClientMessageString_Struct) + args_size; + auto pack = std::make_unique(ServerOP_CZClientMessageString, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->string_id = eqstr_id; + buf->chat_type = chat_type; + buf->args_size = args_size; + memcpy(buf->args, serialized_args.buffer(), serialized_args.size()); + + for (const auto &member : shared_task->GetMembers()) { + auto character = client_list.FindCLEByCharacterID(member.character_id); + if (character && character->Server()) { + strn0cpy(buf->character_name, character->name(), sizeof(buf->character_name)); + character->Server()->SendPacket(pack.get()); + } + } +} + +bool SharedTaskManager::CanRequestSharedTask( + uint32_t task_id, + uint32_t character_id, + const SharedTaskRequestCharacters &request +) +{ + auto task = GetSharedTaskDataByTaskId(task_id); + if (task.id == 0) { + return false; + } + + // this attempts to follow live validation order + + // check if any party members are already in a shared task + auto shared_task_members = FindCharactersInSharedTasks(request.character_ids); + if (!shared_task_members.empty()) { + // messages for every character already in a shared task + for (const auto &member : shared_task_members) { + auto it = std::find_if( + request.characters.begin(), request.characters.end(), + [&](const CharacterDataRepository::CharacterData &char_data) { + return char_data.id == member; + } + ); + + if (it != request.characters.end()) { + if (it->id == character_id) { + client_list.SendCharacterMessageID( + character_id, + Chat::Red, + SharedTaskMessage::NO_REQUEST_BECAUSE_HAVE_ONE + ); + } + else if (request.group_type == SharedTaskRequestGroupType::Group) { + client_list.SendCharacterMessageID( + character_id, + Chat::Red, + SharedTaskMessage::NO_REQUEST_BECAUSE_GROUP_HAS_ONE, + {it->name} + ); + } + else { + client_list.SendCharacterMessageID( + character_id, + Chat::Red, + SharedTaskMessage::NO_REQUEST_BECAUSE_RAID_HAS_ONE, + {it->name} + ); + } + } + } + + return false; + } + + // check if any party member's minimum level is too low (pre-2014 this was average level) + if (task.minlevel > 0 && request.lowest_level < task.minlevel) { + client_list.SendCharacterMessageID(character_id, Chat::Red, SharedTaskMessage::AVG_LVL_LOW); + return false; + } + + // check if any party member's maximum level is too high (pre-2014 this was average level) + if (task.maxlevel > 0 && request.highest_level > task.maxlevel) { + client_list.SendCharacterMessageID(character_id, Chat::Red, SharedTaskMessage::AVG_LVL_HIGH); + return false; + } + + // allow gm/dev bypass for minimum player count requirements + auto requester = client_list.FindCLEByCharacterID(character_id); + bool is_gm = (requester && requester->GetGM()); + + // check if party member count is below the minimum + if (!is_gm && task.min_players > 0 && request.characters.size() < task.min_players) { + client_list.SendCharacterMessageID( + character_id, + Chat::Red, + SharedTaskMessage::SHARED_TASK_NOT_MEET_MIN_NUM_PLAYER + ); + return false; + } + + // check if party member count is above the maximum + // todo: live creates the shared task but truncates members if it exceeds max (sorted by leader and raid group numbers) + if (task.max_players > 0 && request.characters.size() > task.max_players) { + client_list.SendCharacterMessageID(character_id, Chat::Red, SharedTaskMessage::PARTY_EXCEED_MAX_PLAYER); + return false; + } + + // check if party level spread exceeds task's maximum + if (task.level_spread > 0 && (request.highest_level - request.lowest_level) > task.level_spread) { + client_list.SendCharacterMessageID(character_id, Chat::Red, SharedTaskMessage::LVL_SPREAD_HIGH); + return false; + } + + // check if any party members have a replay or request timer for the task (limit 1, replay checked first) + auto character_task_timers = CharacterTaskTimersRepository::GetWhere( + *m_database, fmt::format( + "character_id IN ({}) AND task_id = {} AND expire_time > NOW() ORDER BY timer_type ASC LIMIT 1", + fmt::join(request.character_ids, ","), task_id + ) + ); + + if (!character_task_timers.empty()) { + auto timer_type = static_cast(character_task_timers.front().timer_type); + auto seconds = character_task_timers.front().expire_time - std::time(nullptr); + auto days = fmt::format_int(seconds / 86400).str(); + auto hours = fmt::format_int((seconds / 3600) % 24).str(); + auto mins = fmt::format_int((seconds / 60) % 60).str(); + + if (character_task_timers.front().character_id == character_id) { + if (timer_type == TaskTimerType::Replay) { + client_list.SendCharacterMessageID( + character_id, + Chat::Red, + SharedTaskMessage::YOU_MUST_WAIT_REPLAY_TIMER, {days, hours, mins} + ); + } + else if (timer_type == TaskTimerType::Request) { + client_list.SendCharacterMessage( + character_id, + Chat::Red, fmt::format( + SharedTaskMessage::GetEQStr(SharedTaskMessage::YOU_MUST_WAIT_REQUEST_TIMER), days, hours, mins + ) + ); + } + } + else { + auto it = std::find_if( + request.characters.begin(), request.characters.end(), + [&](const CharacterDataRepository::CharacterData &char_data) { + return char_data.id == character_task_timers.front().character_id; + } + ); + + if (it != request.characters.end() && timer_type == TaskTimerType::Replay) { + client_list.SendCharacterMessageID( + character_id, + Chat::Red, + SharedTaskMessage::PLAYER_MUST_WAIT_REPLAY_TIMER, + {it->name, days, hours, mins} + ); + } + else if (it != request.characters.end() && timer_type == TaskTimerType::Request) { + client_list.SendCharacterMessage( + character_id, + Chat::Red, + fmt::format( + SharedTaskMessage::GetEQStr(SharedTaskMessage::PLAYER_MUST_WAIT_REQUEST_TIMER), + it->name, + days, + hours, + mins + ) + ); + } + } + + return false; + } + + return true; +} + +bool SharedTaskManager::CanAddPlayer(SharedTask *s, uint32_t character_id, std::string player_name, bool accepted) +{ + // this attempts to follow live validation order + + bool allow_invite = true; + + // check if task is locked + if (s->GetDbSharedTask().is_locked) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::TASK_NOT_ALLOWING_PLAYERS_AT_TIME); + allow_invite = false; + } + + // check if player is online and in cle (other checks require online) + auto cle = client_list.FindCLEByCharacterID(character_id); + if (!cle || !cle->Server()) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::PLAYER_NOT_ONLINE_TO_ADD, {player_name}); + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::COULD_NOT_BE_INVITED, {player_name}); + return false; + } + + player_name = cle->name(); + + // check if player is already in a shared task + auto shared_task_members = SharedTaskMembersRepository::GetWhere( + *m_database, + fmt::format("character_id = {} LIMIT 1", character_id) + ); + + if (!shared_task_members.empty()) { + auto shared_task_id = shared_task_members.front().shared_task_id; + if (shared_task_id == s->GetDbSharedTask().id) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::CANT_ADD_PLAYER_ALREADY_MEMBER, {player_name}); + } + else { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::CANT_ADD_PLAYER_ALREADY_ASSIGNED, {player_name}); + } + allow_invite = false; + } + + // check if player has an outstanding invite + for (const auto &invite : m_active_invitations) { + if (invite.character_id == character_id) { + if (invite.shared_task_id == s->GetDbSharedTask().id) { + SendLeaderMessageID( + s, + Chat::Red, + SharedTaskMessage::PLAYER_ALREADY_OUTSTANDING_INVITATION_THIS, + {player_name} + ); + } + else { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::PLAYER_ALREADY_OUTSTANDING_ANOTHER, {player_name}); + } + allow_invite = false; + break; + } + } + + // check if player has a replay or request timer lockout + // todo: live allows characters with a request timer to be re-invited if they quit, but only until they zone? (investigate/edge case) + auto task_timers = CharacterTaskTimersRepository::GetWhere( + *m_database, fmt::format( + "character_id = {} AND task_id = {} AND expire_time > NOW() ORDER BY timer_type ASC LIMIT 1", + character_id, s->GetDbSharedTask().task_id + )); + + if (!task_timers.empty()) { + auto timer_type = static_cast(task_timers.front().timer_type); + auto seconds = task_timers.front().expire_time - std::time(nullptr); + auto days = fmt::format_int(seconds / 86400).str(); + auto hours = fmt::format_int((seconds / 3600) % 24).str(); + auto mins = fmt::format_int((seconds / 60) % 60).str(); + + if (timer_type == TaskTimerType::Replay) { + SendLeaderMessageID( + s, + Chat::Red, + SharedTaskMessage::CANT_ADD_PLAYER_REPLAY_TIMER, {player_name, days, hours, mins} + ); + } + else { + SendLeaderMessage( + s, + Chat::Red, + fmt::format( + SharedTaskMessage::GetEQStr(SharedTaskMessage::CANT_ADD_PLAYER_REQUEST_TIMER), + player_name, + days, + hours, + mins + ) + ); + } + + allow_invite = false; + } + + // check if task has maximum players + if (s->GetTaskData().max_players > 0 && s->GetMembers().size() >= s->GetTaskData().max_players) { + auto max = fmt::format_int(s->GetTaskData().max_players).str(); + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::CANT_ADD_PLAYER_MAX_PLAYERS, {max}); + allow_invite = false; + } + + // check if task would exceed max level spread + if (s->GetTaskData().level_spread > 0) { + auto characters = CharacterDataRepository::GetWhere( + *m_database, + fmt::format( + "id IN (select character_id from shared_task_members where shared_task_id = {})", + s->GetDbSharedTask().id + ) + ); + + int lowest_level = cle->level(); + int highest_level = cle->level(); + + for (const auto &character : characters) { + lowest_level = std::min(lowest_level, character.level); + highest_level = std::max(highest_level, character.level); + } + + if ((highest_level - lowest_level) > s->GetTaskData().level_spread) { + auto max_spread = fmt::format_int(s->GetTaskData().level_spread).str(); + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::CANT_ADD_PLAYER_MAX_LEVEL_SPREAD, {max_spread}); + allow_invite = false; + } + } + + // check if player is below minimum level of task (pre-2014 this was average level) + if (s->GetTaskData().minlevel > 0 && cle->level() < s->GetTaskData().minlevel) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::CANT_ADD_PLAYER_FALL_MIN_AVG_LEVEL); + allow_invite = false; + } + + // check if player is above maximum level of task (pre-2014 this was average level) + if (s->GetTaskData().maxlevel > 0 && cle->level() > s->GetTaskData().maxlevel) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::CANT_ADD_PLAYER_MAX_AVERAGE_LEVEL); + allow_invite = false; + } + + if (!allow_invite) { + if (!accepted) { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::COULD_NOT_BE_INVITED, {player_name}); + } + else { + SendLeaderMessageID(s, Chat::Red, SharedTaskMessage::ACCEPTED_OFFER_TO_JOIN_BUT_COULD_NOT, {player_name}); + } + } + + return allow_invite; +} + +void SharedTaskManager::RecordSharedTaskCompletion(SharedTask *s) +{ + // shared task + auto t = s->GetDbSharedTask(); + auto ct = CompletedSharedTasksRepository::NewEntity(); + + ct.id = t.id; + ct.task_id = t.task_id; + ct.accepted_time = t.accepted_time; + ct.expire_time = t.expire_time; + ct.completion_time = t.completion_time; + ct.is_locked = t.is_locked; + + CompletedSharedTasksRepository::InsertOne(*m_database, ct); + + // completed members + std::vector completed_members = {}; + + for (auto &m: s->GetMembers()) { + auto cm = CompletedSharedTaskMembersRepository::NewEntity(); + + cm.shared_task_id = t.id; + cm.character_id = m.character_id; + cm.is_leader = m.is_leader; + + completed_members.emplace_back(cm); + } + + CompletedSharedTaskMembersRepository::InsertMany(*m_database, completed_members); + + // activities + std::vector completed_states = {}; + + for (auto &a: s->GetActivityState()) { + auto cs = CompletedSharedTaskActivityStateRepository::NewEntity(); + + cs.shared_task_id = t.id; + cs.activity_id = (int) a.activity_id; + cs.done_count = (int) a.done_count; + cs.updated_time = a.updated_time; + cs.completed_time = a.completed_time; + + completed_states.emplace_back(cs); + } + + CompletedSharedTaskActivityStateRepository::InsertMany(*m_database, completed_states); + +} + +void SharedTaskManager::AddReplayTimers(SharedTask *s) +{ + if (s->GetTaskData().replay_timer_seconds > 0) { + auto expire_time = s->GetDbSharedTask().accepted_time + s->GetTaskData().replay_timer_seconds; + auto seconds = expire_time - std::time(nullptr); + if (seconds > 0) // not already expired + { + std::vector task_timers; + + // on live past members of the shared task also receive lockouts (use member history) + for (const auto &member_id : s->member_id_history) { + auto timer = CharacterTaskTimersRepository::NewEntity(); + timer.character_id = member_id; + timer.task_id = s->GetTaskData().id; + timer.timer_type = static_cast(TaskTimerType::Replay); + timer.expire_time = expire_time; + + task_timers.emplace_back(timer); + + client_list.SendCharacterMessage( + member_id, + Chat::Yellow, + fmt::format( + SharedTaskMessage::GetEQStr(SharedTaskMessage::RECEIVED_REPLAY_TIMER), + s->GetTaskData().title, + fmt::format_int(seconds / 86400).c_str(), // days + fmt::format_int((seconds / 3600) % 24).c_str(), // hours + fmt::format_int((seconds / 60) % 60).c_str() // minutes + ) + ); + } + + if (!task_timers.empty()) { + // replay timers replace any existing timer (even if it expires sooner) + // this can occur if a player has a timer for being a past member of + // a shared task but joined another before the first was completed + CharacterTaskTimersRepository::DeleteWhere( + *m_database, + fmt::format( + "task_id = {} AND character_id IN ({})", + s->GetTaskData().id, fmt::join(s->member_id_history, ",") + ) + ); + + CharacterTaskTimersRepository::InsertMany(*m_database, task_timers); + } + } + } +} + +// memory search +std::vector SharedTaskManager::FindCharactersInSharedTasks(const std::vector &find_characters) +{ + std::vector characters = {}; + + for (auto &s: m_shared_tasks) { + // loop through members + for (auto &m: s.GetMembers()) { + // compare members with requested characters + for (auto &find_character_id: find_characters) { + // found character, add to list + if (find_character_id == m.character_id) { + characters.emplace_back(m.character_id); + } + } + } + } + + return characters; +} + +void SharedTaskManager::PurgeAllSharedTasks() +{ + for (auto &shared_task : m_shared_tasks) { + RemoveAllMembersFromDynamicZones(&shared_task); + } + + SharedTasksRepository::Truncate(*m_database); + SharedTaskMembersRepository::Truncate(*m_database); + SharedTaskActivityStateRepository::Truncate(*m_database); + SharedTaskDynamicZonesRepository::Truncate(*m_database); + CompletedSharedTasksRepository::Truncate(*m_database); + CompletedSharedTaskMembersRepository::Truncate(*m_database); + CompletedSharedTaskActivityStateRepository::Truncate(*m_database); + + LoadSharedTaskState(); +} + +void SharedTaskManager::RemoveAllMembersFromDynamicZones(SharedTask *s) +{ + for (const auto &dz_id : s->dynamic_zone_ids) { + auto dz = DynamicZone::FindDynamicZoneByID(dz_id); + if (dz) { + dz->RemoveAllMembers(); + } + } +} + +void SharedTaskManager::ChooseNewLeader(SharedTask *s) +{ + // live doesn't prioritize choosing an online player here + auto members = s->GetMembers(); + auto it = std::find_if( + members.begin(), members.end(), + [&](const SharedTaskMember &member) { + return !member.is_leader; + } + ); + + if (it != members.end()) { + MakeLeaderByPlayerName(s, it->character_name); + } +} + +const std::vector &SharedTaskManager::GetSharedTasks() const +{ + return m_shared_tasks; +} + +void SharedTaskManager::SetSharedTasks(const std::vector &shared_tasks) +{ + SharedTaskManager::m_shared_tasks = shared_tasks; +} + +SharedTaskManager *SharedTaskManager::PurgeExpiredSharedTasks() +{ + auto now = std::time(nullptr); + for (auto &s: m_shared_tasks) { + if (s.GetDbSharedTask().expire_time > 0 && s.GetDbSharedTask().expire_time <= now) { + LogTasksDetail("[PurgeExpiredSharedTasks] Deleting expired task [{}]", s.GetDbSharedTask().id); + DeleteSharedTask(s.GetDbSharedTask().id); + } + } + + return this; +} diff --git a/world/shared_task_manager.h b/world/shared_task_manager.h new file mode 100644 index 000000000..1bbd071cd --- /dev/null +++ b/world/shared_task_manager.h @@ -0,0 +1,132 @@ +#ifndef EQEMU_SHARED_TASK_MANAGER_H +#define EQEMU_SHARED_TASK_MANAGER_H + +#include "../common/database.h" +#include "../common/shared_tasks.h" + +class DynamicZone; + +namespace EQ { + namespace Net { + class DynamicPacket; + } +} + +struct SharedTaskActiveInvitation { + uint32 shared_task_id; + uint32 character_id; +}; + +class SharedTaskManager { +public: + SharedTaskManager *SetDatabase(Database *db); + SharedTaskManager *SetContentDatabase(Database *db); + + // loads task data into memory + SharedTaskManager *LoadTaskData(); + + // loads shared task state into memory + void LoadSharedTaskState(); + + // helper, references task memory data + TasksRepository::Tasks GetSharedTaskDataByTaskId(uint32 task_id); + std::vector GetSharedTaskActivityDataByTaskId(uint32 task_id); + + // gets group / raid members belonging to requested character + std::vector GetRequestMembers( + uint32 requestor_character_id, + const std::vector &characters + ); + + // client attempting to create a shared task + void AttemptSharedTaskCreation(uint32 requested_task_id, uint32 requested_character_id, uint32 npc_type_id); + void AttemptSharedTaskRemoval(uint32 requested_task_id, uint32 requested_character_id, bool remove_from_db); + + // shared task activity update middleware + void SharedTaskActivityUpdate( + uint32 source_character_id, + uint32 task_id, + uint32 activity_id, + uint32 done_count, + bool ignore_quest_update + ); + + SharedTask *FindSharedTaskByTaskIdAndCharacterId(uint32 task_id, uint32 character_id); + SharedTask *FindSharedTaskById(int64 shared_task_id); + + void DeleteSharedTask(int64 shared_task_id); + void SaveSharedTaskActivityState(int64 shared_task_id, std::vector activity_state); + + bool IsSharedTaskLeader(SharedTask *s, uint32 character_id); + void SendAcceptNewSharedTaskPacket(uint32 character_id, uint32 task_id, uint32_t npc_context_id, int accept_time); + void SendRemovePlayerFromSharedTaskPacket(uint32 character_id, uint32 task_id, bool remove_from_db); + void SendSharedTaskMemberList(uint32 character_id, const std::vector &members); + void SendSharedTaskMemberList(uint32 character_id, const EQ::Net::DynamicPacket &serialized_members); + void SendSharedTaskMemberChange( + uint32 character_id, + int64 shared_task_id, + const std::string &player_name, + bool removed + ); + void RemovePlayerFromSharedTask(SharedTask *s, uint32 character_id); + void PrintSharedTaskState(); + void RemovePlayerFromSharedTaskByPlayerName(SharedTask *s, const std::string &character_name); + void RemoveEveryoneFromSharedTask(SharedTask *s, uint32 requested_character_id); + + void MakeLeaderByPlayerName(SharedTask *s, const std::string &character_name); + void AddPlayerByCharacterIdAndName(SharedTask *s, int64 character_id, const std::string &character_name); + void InvitePlayerByPlayerName(SharedTask *s, const std::string &player_name); + + // invitations + void QueueActiveInvitation(int64 shared_task_id, int64 character_id); + bool IsInvitationActive(uint32 shared_task_id, uint32 character_id); + void RemoveActiveInvitation(int64 shared_task_id, int64 character_id); + void RemoveActiveInvitationByCharacterID(uint32_t character_id); + + // dz + void CreateDynamicZone(SharedTask *s, DynamicZone &dz_request); + + void PurgeAllSharedTasks(); + + // messages + void SendLeaderMessage(SharedTask *s, int chat_type, const std::string &message); + void SendLeaderMessageID(SharedTask *s, int chat_type, int eqstr_id, std::initializer_list args = {}); + void SendMembersMessage(SharedTask *s, int chat_type, const std::string &message); + void SendMembersMessageID(SharedTask *s, int chat_type, int eqstr_id, std::initializer_list args = {}); + + const std::vector &GetSharedTasks() const; + void SetSharedTasks(const std::vector &shared_tasks); + + SharedTaskManager * PurgeExpiredSharedTasks(); +protected: + // reference to database + Database *m_database; + Database *m_content_database; + + // reference to task data (all) + std::vector m_task_data{}; + std::vector m_task_activity_data{}; + + // internal shared tasks list + std::vector m_shared_tasks{}; + + // store a reference of active invitations that have been sent to players + std::vector m_active_invitations{}; + + void AddReplayTimers(SharedTask *s); + bool CanAddPlayer(SharedTask *s, uint32_t character_id, std::string player_name, bool accepted); + bool CanRequestSharedTask(uint32_t task_id, uint32_t character_id, const SharedTaskRequestCharacters &request); + void ChooseNewLeader(SharedTask *s); + void SendSharedTaskMemberListToAllMembers(SharedTask *s); + void SendSharedTaskMemberAddedToAllMembers(SharedTask *s, const std::string &player_name); + void SendSharedTaskMemberRemovedToAllMembers(SharedTask *s, const std::string &player_name); + void SaveMembers(SharedTask *s, std::vector members); + void SendSharedTaskInvitePacket(SharedTask *s, int64 invited_character_id); + void RecordSharedTaskCompletion(SharedTask *s); + void RemoveAllMembersFromDynamicZones(SharedTask *s); + + // memory search + std::vector FindCharactersInSharedTasks(const std::vector &find_characters); +}; + +#endif //EQEMU_SHARED_TASK_MANAGER_H diff --git a/world/shared_task_world_messaging.cpp b/world/shared_task_world_messaging.cpp new file mode 100644 index 000000000..26da007f2 --- /dev/null +++ b/world/shared_task_world_messaging.cpp @@ -0,0 +1,355 @@ +#include "shared_task_world_messaging.h" +#include "cliententry.h" +#include "worlddb.h" +#include "../common/shared_tasks.h" +#include "../common/eqemu_logsys.h" +#include "../common/repositories/tasks_repository.h" +#include "../common/tasks.h" +#include "cliententry.h" +#include "clientlist.h" +#include "zonelist.h" +#include "zoneserver.h" +#include "shared_task_manager.h" +#include "../common/repositories/shared_task_members_repository.h" +#include "../common/repositories/task_activities_repository.h" +#include "dynamic_zone.h" + +extern ClientList client_list; +extern ZSList zoneserver_list; +extern SharedTaskManager shared_task_manager; + +void SharedTaskWorldMessaging::HandleZoneMessage(ServerPacket *pack) +{ + switch (pack->opcode) { + case ServerOP_SharedTaskRequest: { + auto *r = (ServerSharedTaskRequest_Struct *) pack->pBuffer; + LogTasksDetail( + "[ServerOP_SharedTaskRequest] Received request from character [{}] task_id [{}] npc_type_id [{}]", + r->requested_character_id, + r->requested_task_id, + r->requested_npc_type_id + ); + + shared_task_manager.AttemptSharedTaskCreation( + r->requested_task_id, + r->requested_character_id, + r->requested_npc_type_id + ); + + break; + } + case ServerOP_SharedTaskAttemptRemove: { + auto *r = (ServerSharedTaskAttemptRemove_Struct *) pack->pBuffer; + LogTasksDetail( + "[ServerOP_SharedTaskAttemptRemove] Received request from character [{}] task_id [{}] remove_from_db [{}]", + r->requested_character_id, + r->requested_task_id, + r->remove_from_db + ); + + shared_task_manager.AttemptSharedTaskRemoval( + r->requested_task_id, + r->requested_character_id, + r->remove_from_db + ); + + break; + } + case ServerOP_SharedTaskKickPlayers: { + auto r = reinterpret_cast(pack->pBuffer); + LogTasksDetail( + "[ServerOP_SharedTaskKickPlayers] Received request from character [{}] task_id [{}]", + r->source_character_id, + r->task_id + ); + + auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(r->task_id, r->source_character_id); + if (t) { + auto leader = t->GetLeader(); + if (leader.character_id != r->source_character_id) { + client_list.SendCharacterMessageID( + r->source_character_id, Chat::Red, + SharedTaskMessage::YOU_ARE_NOT_LEADER_COMMAND_ISSUE, {leader.character_name} + ); + } + else { + shared_task_manager.RemoveEveryoneFromSharedTask(t, r->source_character_id); + } + } + + break; + } + case ServerOP_SharedTaskUpdate: { + auto *r = (ServerSharedTaskActivityUpdate_Struct *) pack->pBuffer; + + LogTasksDetail( + "[ServerOP_SharedTaskUpdate] Received request from character [{}] task_id [{}] activity_id [{}] donecount [{}] ignore_quest_update [{}]", + r->source_character_id, + r->task_id, + r->activity_id, + r->done_count, + (r->ignore_quest_update ? "true" : "false") + ); + + shared_task_manager.SharedTaskActivityUpdate( + r->source_character_id, + r->task_id, + r->activity_id, + r->done_count, + r->ignore_quest_update + ); + + break; + } + case ServerOP_SharedTaskRequestMemberlist: { + auto *r = (ServerSharedTaskRequestMemberlist_Struct *) pack->pBuffer; + + LogTasksDetail( + "[ServerOP_SharedTaskRequestMemberlist] Received request from character [{}] task_id [{}]", + r->source_character_id, + r->task_id + ); + + auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(r->task_id, r->source_character_id); + if (t) { + LogTasksDetail( + "[ServerOP_SharedTaskRequestMemberlist] Found shared task character [{}] shared_task_id [{}]", + r->source_character_id, + t->GetDbSharedTask().id + ); + + shared_task_manager.SendSharedTaskMemberList( + r->source_character_id, + t->GetMembers() + ); + } + + break; + } + case ServerOP_SharedTaskRemovePlayer: { + auto *r = (ServerSharedTaskRemovePlayer_Struct *) pack->pBuffer; + + LogTasksDetail( + "[ServerOP_SharedTaskRemovePlayer] Received request from character [{}] task_id [{}] player_name [{}]", + r->source_character_id, + r->task_id, + r->player_name + ); + + auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(r->task_id, r->source_character_id); + if (t) { + LogTasksDetail( + "[ServerOP_SharedTaskRemovePlayer] Found shared task character [{}] shared_task_id [{}]", + r->source_character_id, + t->GetDbSharedTask().id + ); + + auto leader = t->GetLeader(); + if (leader.character_id != r->source_character_id) { + client_list.SendCharacterMessageID( + r->source_character_id, Chat::Red, + SharedTaskMessage::YOU_ARE_NOT_LEADER_COMMAND_ISSUE, {leader.character_name} + ); + } + else { + LogTasksDetail( + "[ServerOP_SharedTaskRemovePlayer] character_id [{}] shared_task_id [{}] is_leader", + r->source_character_id, + t->GetDbSharedTask().id + ); + + std::string character_name = r->player_name; + shared_task_manager.RemovePlayerFromSharedTaskByPlayerName(t, character_name); + } + } + + break; + } + case ServerOP_SharedTaskMakeLeader: { + auto *r = (ServerSharedTaskMakeLeader_Struct *) pack->pBuffer; + + LogTasksDetail( + "[ServerOP_SharedTaskMakeLeader] Received request from character [{}] task_id [{}] player_name [{}]", + r->source_character_id, + r->task_id, + r->player_name + ); + + auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(r->task_id, r->source_character_id); + if (t) { + LogTasksDetail( + "[ServerOP_SharedTaskMakeLeader] Found shared task character [{}] shared_task_id [{}]", + r->source_character_id, + t->GetDbSharedTask().id + ); + + auto leader = t->GetLeader(); + if (leader.character_id != r->source_character_id) { + client_list.SendCharacterMessageID( + r->source_character_id, Chat::Red, + SharedTaskMessage::YOU_ARE_NOT_LEADER_COMMAND_ISSUE, {leader.character_name} + ); + } + else if (strcasecmp(leader.character_name.c_str(), r->player_name) == 0) { + client_list.SendCharacterMessageID( + r->source_character_id, + Chat::Red, + SharedTaskMessage::YOU_ALREADY_LEADER + ); + } + else { + LogTasksDetail( + "[ServerOP_SharedTaskMakeLeader] character_id [{}] shared_task_id [{}] is_leader", + r->source_character_id, + t->GetDbSharedTask().id + ); + + std::string character_name = r->player_name; + shared_task_manager.MakeLeaderByPlayerName(t, character_name); + } + } + + break; + } + case ServerOP_SharedTaskAddPlayer: { + auto *r = (ServerSharedTaskAddPlayer_Struct *) pack->pBuffer; + + LogTasksDetail( + "[ServerOP_SharedTaskAddPlayer] Received request from character [{}] task_id [{}] player_name [{}]", + r->source_character_id, + r->task_id, + r->player_name + ); + + auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(r->task_id, r->source_character_id); + if (t) { + LogTasksDetail( + "[ServerOP_SharedTaskAddPlayer] Found shared task character [{}] shared_task_id [{}]", + r->source_character_id, + t->GetDbSharedTask().id + ); + + auto leader = t->GetLeader(); + if (leader.character_id != r->source_character_id) { + // taskadd is client sided with System color in newer clients, server side might still be red + client_list.SendCharacterMessageID( + r->source_character_id, Chat::Red, + SharedTaskMessage::YOU_ARE_NOT_LEADER_COMMAND_ISSUE, {leader.character_name} + ); + } + else { + LogTasksDetail( + "[ServerOP_SharedTaskAddPlayer] character_id [{}] shared_task_id [{}] is_leader", + r->source_character_id, + t->GetDbSharedTask().id + ); + + std::string character_name = r->player_name; + shared_task_manager.InvitePlayerByPlayerName(t, character_name); + } + } + + break; + } + case ServerOP_SharedTaskInviteAcceptedPlayer: { + auto *r = (ServerSharedTaskInviteAccepted_Struct *) pack->pBuffer; + + LogTasksDetail( + "[ServerOP_SharedTaskInviteAcceptedPlayer] Received request from source_character_id [{}] shared_task_id [{}] accepted [{}]", + r->source_character_id, + r->shared_task_id, + r->accepted + ); + + auto t = shared_task_manager.FindSharedTaskById(r->shared_task_id); + if (t && shared_task_manager.IsInvitationActive(r->shared_task_id, r->source_character_id)) { + LogTasksDetail( + "[ServerOP_SharedTaskInviteAcceptedPlayer] Found shared task character [{}] shared_task_id [{}]", + r->source_character_id, + t->GetDbSharedTask().id + ); + + shared_task_manager.RemoveActiveInvitation(r->shared_task_id, r->source_character_id); + + if (r->accepted) { + shared_task_manager.AddPlayerByCharacterIdAndName(t, r->source_character_id, r->player_name); + } + else { + shared_task_manager.SendLeaderMessageID( + t, + Chat::Red, + SharedTaskMessage::PLAYER_DECLINED_OFFER, + {r->player_name} + ); + } + } + break; + } + case ServerOP_SharedTaskCreateDynamicZone: { + auto buf = reinterpret_cast(pack->pBuffer); + + LogTasksDetail( + "[ServerOP_SharedTaskCreateDynamicZone] Received request from source_character_id [{}] task_id [{}]", + buf->source_character_id, + buf->task_id + ); + + auto t = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(buf->task_id, buf->source_character_id); + if (t) { + DynamicZone dz; + dz.LoadSerializedDzPacket(buf->cereal_data, buf->cereal_size); + + shared_task_manager.CreateDynamicZone(t, dz); + } + break; + } + case ServerOP_SharedTaskPurgeAllCommand: { + LogTasksDetail("[ServerOP_SharedTaskPurgeAllCommand] Received request to purge all shared tasks"); + + shared_task_manager.PurgeAllSharedTasks(); + auto p = std::make_unique( + ServerOP_SharedTaskPurgeAllCommand, + 0 + ); + + zoneserver_list.SendPacket(p.get()); + + break; + } + case ServerOP_SharedTaskPlayerList: { + auto buf = reinterpret_cast(pack->pBuffer); + + LogTasksDetail( + "[ServerOP_SharedTaskPlayerList] Received request from source_character_id [{}] task_id [{}]", + buf->source_character_id, + buf->task_id + ); + + auto s = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(buf->task_id, buf->source_character_id); + if (s) { + std::vector player_names; + + for (const auto &member : s->GetMembers()) { + player_names.emplace_back(member.character_name); + + if (member.is_leader) { + client_list.SendCharacterMessageID( + buf->source_character_id, Chat::Yellow, + SharedTaskMessage::LEADER_PRINT, {member.character_name} + ); + } + } + + std::string player_list = fmt::format("{}", fmt::join(player_names, ", ")); + client_list.SendCharacterMessageID( + buf->source_character_id, Chat::Yellow, + SharedTaskMessage::MEMBERS_PRINT, {player_list} + ); + } + + break; + } + default: + break; + } +} diff --git a/world/shared_task_world_messaging.h b/world/shared_task_world_messaging.h new file mode 100644 index 000000000..e8062e2ec --- /dev/null +++ b/world/shared_task_world_messaging.h @@ -0,0 +1,18 @@ +#ifndef EQEMU_SHARED_TASK_WORLD_MESSAGING_H +#define EQEMU_SHARED_TASK_WORLD_MESSAGING_H + +#include "../common/types.h" +#include "../common/servertalk.h" +#include "../common/shared_tasks.h" +#include "../common/eqemu_logsys.h" +#include "../common/repositories/tasks_repository.h" +#include "../common/tasks.h" + +class SharedTaskWorldMessaging { +public: + static void HandleZoneMessage(ServerPacket *pack); +}; + + +#endif //EQEMU_SHARED_TASK_WORLD_MESSAGING_H + diff --git a/world/worlddb.cpp b/world/worlddb.cpp index 14decb79d..c9cd497ee 100644 --- a/world/worlddb.cpp +++ b/world/worlddb.cpp @@ -25,6 +25,7 @@ #include #include #include "sof_char_create_data.h" +#include "../common/repositories/character_instance_safereturns_repository.h" #include "../common/repositories/criteria/content_filter_criteria.h" #include "world_store.h" @@ -477,6 +478,54 @@ int WorldDatabase::MoveCharacterToBind(int character_id, uint8 bind_number) return zone_id; } +int WorldDatabase::MoveCharacterToInstanceSafeReturn( + int character_id, + int instance_zone_id, + int instance_id +) +{ + int zone_id = 0; + + // only moves if safe return is for specified zone instance + auto entries = CharacterInstanceSafereturnsRepository::GetWhere( + database, + fmt::format( + "character_id = {} AND instance_zone_id = {} AND instance_id = {} AND safe_zone_id > 0", + character_id, instance_zone_id, instance_id + ) + ); + + if (!entries.empty()) { + auto entry = entries.front(); + + auto results = QueryDatabase( + fmt::format( + SQL( + UPDATE character_data + SET zone_id = {}, zone_instance = 0, x = {}, y = {}, z = {}, heading = {} + WHERE id = {}; + ), + entry.safe_zone_id, + entry.safe_x, + entry.safe_y, + entry.safe_z, + entry.safe_heading, + character_id + ) + ); + + if (results.Success() && results.RowsAffected() > 0) { + zone_id = entry.safe_zone_id; + } + } + + if (zone_id == 0) { + zone_id = MoveCharacterToBind(character_id); + } + + return zone_id; +} + bool WorldDatabase::GetStartZone( PlayerProfile_Struct *p_player_profile_struct, CharCreate_Struct *p_char_create_struct, diff --git a/world/worlddb.h b/world/worlddb.h index 6431f175e..ae26b0ff7 100644 --- a/world/worlddb.h +++ b/world/worlddb.h @@ -32,6 +32,7 @@ public: bool GetStartZone(PlayerProfile_Struct* p_player_profile_struct, CharCreate_Struct* p_char_create_struct, bool is_titanium); void GetCharSelectInfo(uint32 account_id, EQApplicationPacket **out_app, uint32 client_version_bit); int MoveCharacterToBind(int character_id, uint8 bind_number = 0); + int MoveCharacterToInstanceSafeReturn(int character_id, int instance_zone_id, int instance_id); void GetLauncherList(std::vector &result); bool GetCharacterLevel(const char *name, int &level); diff --git a/world/zonelist.cpp b/world/zonelist.cpp index 666ed2208..9e1239a6c 100644 --- a/world/zonelist.cpp +++ b/world/zonelist.cpp @@ -43,7 +43,7 @@ ZSList::ZSList() memset(pLockedZones, 0, sizeof(pLockedZones)); m_tick = std::make_unique(5000, true, std::bind(&ZSList::OnTick, this, std::placeholders::_1)); - m_keepalive = std::make_unique(1500, true, std::bind(&ZSList::OnKeepAlive, this, std::placeholders::_1)); + m_keepalive = std::make_unique(1000, true, std::bind(&ZSList::OnKeepAlive, this, std::placeholders::_1)); } ZSList::~ZSList() { diff --git a/world/zoneserver.cpp b/world/zoneserver.cpp index c53b474af..d6f4c1888 100644 --- a/world/zoneserver.cpp +++ b/world/zoneserver.cpp @@ -38,6 +38,8 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #include "world_store.h" #include "dynamic_zone.h" #include "expedition_message.h" +#include "shared_task_world_messaging.h" +#include "../common/shared_tasks.h" extern ClientList client_list; extern GroupLFPList LFPGroupList; @@ -1181,7 +1183,6 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) { adventure_manager.IncrementAssassinationCount(*((uint16*)pack->pBuffer)); break; } - case ServerOP_AdventureZoneData: { adventure_manager.GetZoneData(*((uint16*)pack->pBuffer)); @@ -1368,17 +1369,28 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) { case ServerOP_ExpeditionLockoutDuration: case ServerOP_ExpeditionLockState: case ServerOP_ExpeditionReplayOnJoin: - case ServerOP_ExpeditionExpireWarning: { zoneserver_list.SendPacket(pack); break; } + case ServerOP_SharedTaskRequest: + case ServerOP_SharedTaskAddPlayer: + case ServerOP_SharedTaskAttemptRemove: + case ServerOP_SharedTaskUpdate: + case ServerOP_SharedTaskRequestMemberlist: + case ServerOP_SharedTaskRemovePlayer: + case ServerOP_SharedTaskInviteAcceptedPlayer: + case ServerOP_SharedTaskMakeLeader: + case ServerOP_SharedTaskCreateDynamicZone: + case ServerOP_SharedTaskPurgeAllCommand: + case ServerOP_SharedTaskPlayerList: + case ServerOP_SharedTaskKickPlayers: + { + SharedTaskWorldMessaging::HandleZoneMessage(pack); + break; + } + case ServerOP_ExpeditionCreate: - case ServerOP_ExpeditionGetMemberStatuses: - case ServerOP_ExpeditionMemberChange: - case ServerOP_ExpeditionMemberStatus: - case ServerOP_ExpeditionMemberSwap: - case ServerOP_ExpeditionMembersRemoved: case ServerOP_ExpeditionDzAddPlayer: case ServerOP_ExpeditionDzMakeLeader: case ServerOP_ExpeditionCharacterLockout: @@ -1388,12 +1400,16 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) { ExpeditionMessage::HandleZoneMessage(pack); break; } - case ServerOP_DzAddRemoveCharacter: - case ServerOP_DzRemoveAllCharacters: + case ServerOP_DzCreated: + case ServerOP_DzAddRemoveMember: + case ServerOP_DzSwapMembers: + case ServerOP_DzRemoveAllMembers: + case ServerOP_DzGetMemberStatuses: case ServerOP_DzSetSecondsRemaining: case ServerOP_DzSetCompass: case ServerOP_DzSetSafeReturn: case ServerOP_DzSetZoneIn: + case ServerOP_DzUpdateMemberStatus: { DynamicZone::HandleZoneMessage(pack); break; diff --git a/zone/CMakeLists.txt b/zone/CMakeLists.txt index 554d3e717..909c88e77 100644 --- a/zone/CMakeLists.txt +++ b/zone/CMakeLists.txt @@ -129,6 +129,7 @@ SET(zone_sources quest_parser_collection.cpp raids.cpp raycast_mesh.cpp + shared_task_zone_messaging.cpp spawn2.cpp spawn2.h spawngroup.cpp @@ -255,6 +256,7 @@ SET(zone_headers raids.h raycast_mesh.h skills.h + shared_task_zone_messaging.h spawn2.cpp spawn2.h spawngroup.h diff --git a/zone/attack.cpp b/zone/attack.cpp index 5b2bc8a19..16ee8e69e 100644 --- a/zone/attack.cpp +++ b/zone/attack.cpp @@ -2350,6 +2350,18 @@ bool NPC::Death(Mob* killer_mob, int32 damage, uint16 spell, EQ::skills::SkillTy int32 finalxp = give_exp_client->GetExperienceForKill(this); finalxp = give_exp_client->mod_client_xp(finalxp, this); + // handle task credit on behalf of the killer + if (RuleB(TaskSystem, EnableTaskSystem)) { + LogTasksDetail( + "[NPC::Death] Triggering HandleUpdateTasksOnKill for [{}] npc [{}]", + give_exp_client->GetCleanName(), + GetNPCTypeID() + ); + give_exp_client + ->GetTaskState() + ->HandleUpdateTasksOnKill(give_exp_client, GetNPCTypeID()); + } + if (kr) { if (!IsLdonTreasure && MerchantType == 0) { kr->SplitExp((finalxp), this); @@ -2368,8 +2380,6 @@ bool NPC::Death(Mob* killer_mob, int32 damage, uint16 spell, EQ::skills::SkillTy mod_npc_killed_merit(kr->members[i].member); - if (RuleB(TaskSystem, EnableTaskSystem)) - kr->members[i].member->UpdateTasksOnKill(GetNPCTypeID()); PlayerCount++; } } @@ -2417,9 +2427,6 @@ bool NPC::Death(Mob* killer_mob, int32 damage, uint16 spell, EQ::skills::SkillTy mod_npc_killed_merit(c); - if (RuleB(TaskSystem, EnableTaskSystem)) - c->UpdateTasksOnKill(GetNPCTypeID()); - PlayerCount++; } } @@ -2468,9 +2475,6 @@ bool NPC::Death(Mob* killer_mob, int32 damage, uint16 spell, EQ::skills::SkillTy mod_npc_killed_merit(give_exp_client); - if (RuleB(TaskSystem, EnableTaskSystem)) - give_exp_client->UpdateTasksOnKill(GetNPCTypeID()); - // QueryServ Logging - Solo if (RuleB(QueryServ, PlayerLogNPCKills)) { auto pack = new ServerPacket(ServerOP_QSPlayerLogNPCKills, diff --git a/zone/client.cpp b/zone/client.cpp index 499fc659f..7584a0bd1 100644 --- a/zone/client.cpp +++ b/zone/client.cpp @@ -348,9 +348,10 @@ Client::Client(EQStreamInterface* ieqs) temp_pvp = false; is_client_moving = false; - /** - * GM - */ + // rate limiter + m_list_task_timers_rate_limit.Start(1000); + + // gm SetDisplayMobInfoWindow(true); SetDevToolsEnabled(true); @@ -1550,46 +1551,56 @@ void Client::SendSound(){//Makes a sound. safe_delete(outapp); } -void Client::UpdateWho(uint8 remove) { - if (account_id == 0) +void Client::UpdateWho(uint8 remove) +{ + if (account_id == 0) { return; - if (!worldserver.Connected()) + } + if (!worldserver.Connected()) { return; + } + auto pack = new ServerPacket(ServerOP_ClientList, sizeof(ServerClientList_Struct)); - ServerClientList_Struct* scl = (ServerClientList_Struct*) pack->pBuffer; - scl->remove = remove; - scl->wid = this->GetWID(); - scl->IP = this->GetIP(); - scl->charid = this->CharacterID(); - strcpy(scl->name, this->GetName()); + auto *s = (ServerClientList_Struct *) pack->pBuffer; + s->remove = remove; + s->wid = this->GetWID(); + s->IP = this->GetIP(); + s->charid = this->CharacterID(); + strcpy(s->name, this->GetName()); - scl->gm = GetGM(); - scl->Admin = this->Admin(); - scl->AccountID = this->AccountID(); - strcpy(scl->AccountName, this->AccountName()); - scl->LSAccountID = this->LSAccountID(); - strn0cpy(scl->lskey, lskey, sizeof(scl->lskey)); - scl->zone = zone->GetZoneID(); - scl->instance_id = zone->GetInstanceID(); - scl->race = this->GetRace(); - scl->class_ = GetClass(); - scl->level = GetLevel(); - if (m_pp.anon == 0) - scl->anon = 0; - else if (m_pp.anon == 1) - scl->anon = 1; - else if (m_pp.anon >= 2) - scl->anon = 2; + s->gm = GetGM(); + s->Admin = this->Admin(); + s->AccountID = this->AccountID(); + strcpy(s->AccountName, this->AccountName()); - scl->ClientVersion = static_cast(ClientVersion()); - scl->tellsoff = tellsoff; - scl->guild_id = guild_id; - scl->LFG = LFG; - if(LFG) { - scl->LFGFromLevel = LFGFromLevel; - scl->LFGToLevel = LFGToLevel; - scl->LFGMatchFilter = LFGMatchFilter; - memcpy(scl->LFGComments, LFGComments, sizeof(scl->LFGComments)); + s->LSAccountID = this->LSAccountID(); + strn0cpy(s->lskey, lskey, sizeof(s->lskey)); + + s->zone = zone->GetZoneID(); + s->instance_id = zone->GetInstanceID(); + s->race = this->GetRace(); + s->class_ = GetClass(); + s->level = GetLevel(); + + if (m_pp.anon == 0) { + s->anon = 0; + } + else if (m_pp.anon == 1) { + s->anon = 1; + } + else if (m_pp.anon >= 2) { + s->anon = 2; + } + + s->ClientVersion = static_cast(ClientVersion()); + s->tellsoff = tellsoff; + s->guild_id = guild_id; + s->LFG = LFG; + if (LFG) { + s->LFGFromLevel = LFGFromLevel; + s->LFGToLevel = LFGToLevel; + s->LFGMatchFilter = LFGMatchFilter; + memcpy(s->LFGComments, LFGComments, sizeof(s->LFGComments)); } worldserver.SendPacket(pack); @@ -3368,11 +3379,7 @@ void Client::LinkDead() raid->MemberZoned(this); } - Expedition* expedition = GetExpedition(); - if (expedition) - { - expedition->SetMemberStatus(this, DynamicZoneMemberStatus::LinkDead); - } + SetDynamicZoneMemberStatus(DynamicZoneMemberStatus::LinkDead); // save_timer.Start(2500); linkdead_timer.Start(RuleI(Zone,ClientLinkdeadMS)); @@ -5730,16 +5737,27 @@ void Client::AddPVPPoints(uint32 Points) SendPVPStats(); } -void Client::AddCrystals(uint32 Radiant, uint32 Ebon) +void Client::AddCrystals(uint32 radiant, uint32 ebon) { - m_pp.currentRadCrystals += Radiant; - m_pp.careerRadCrystals += Radiant; - m_pp.currentEbonCrystals += Ebon; - m_pp.careerEbonCrystals += Ebon; + m_pp.currentRadCrystals += radiant; + m_pp.careerRadCrystals += radiant; + m_pp.currentEbonCrystals += ebon; + m_pp.careerEbonCrystals += ebon; SaveCurrency(); SendCrystalCounts(); + + // newer clients handle message client side (older clients likely used eqstr 5967 and 5968, this matches live) + if (radiant > 0) + { + MessageString(Chat::Yellow, YOU_RECEIVE, fmt::format("{} Radiant Crystals", radiant).c_str()); + } + + if (ebon > 0) + { + MessageString(Chat::Yellow, YOU_RECEIVE, fmt::format("{} Ebon Crystals", ebon).c_str()); + } } void Client::SetEbonCrystals(uint32 value) { @@ -9515,28 +9533,25 @@ void Client::SendCrossZoneMessageString( } } -void Client::UpdateExpeditionInfoAndLockouts() +void Client::SendDynamicZoneUpdates() { - // this is processed by client after entering a zone + // bit inefficient since each do lookups but it avoids duplicating code here SendDzCompassUpdate(); + SetDynamicZoneMemberStatus(DynamicZoneMemberStatus::Online); m_expedition_lockouts = ExpeditionDatabase::LoadCharacterLockouts(CharacterID()); + // expeditions are the only dz type that keep the window updated auto expedition = GetExpedition(); if (expedition) { - expedition->SendClientExpeditionInfo(this); + expedition->GetDynamicZone()->SendClientWindowUpdate(this); // live synchronizes lockouts obtained during the active expedition to // members once they zone into the expedition's dynamic zone instance - if (expedition->GetDynamicZone().IsCurrentZoneDzInstance()) + if (expedition->GetDynamicZone()->IsCurrentZoneDzInstance()) { expedition->SyncCharacterLockouts(CharacterID(), m_expedition_lockouts); - expedition->SetMemberStatus(this, DynamicZoneMemberStatus::InDynamicZone); - } - else - { - expedition->SetMemberStatus(this, DynamicZoneMemberStatus::Online); } } @@ -9546,18 +9561,29 @@ void Client::UpdateExpeditionInfoAndLockouts() RequestPendingExpeditionInvite(); } -Expedition* Client::CreateExpedition(DynamicZone& dz_instance, ExpeditionRequest& request) +Expedition* Client::CreateExpedition(DynamicZone& dz, bool disable_messages) { - return Expedition::TryCreate(this, dz_instance, request); + return Expedition::TryCreate(this, dz, disable_messages); } Expedition* Client::CreateExpedition( const std::string& zone_name, uint32 version, uint32 duration, const std::string& expedition_name, uint32 min_players, uint32 max_players, bool disable_messages) { - DynamicZone dz_instance{ ZoneID(zone_name), version, duration, DynamicZoneType::Expedition }; - ExpeditionRequest request{ expedition_name, min_players, max_players, disable_messages }; - return Expedition::TryCreate(this, dz_instance, request); + DynamicZone dz{ ZoneID(zone_name), version, duration, DynamicZoneType::Expedition }; + dz.SetName(expedition_name); + dz.SetMinPlayers(min_players); + dz.SetMaxPlayers(max_players); + + return Expedition::TryCreate(this, dz, disable_messages); +} + +void Client::CreateTaskDynamicZone(int task_id, DynamicZone& dz_request) +{ + if (task_state) + { + task_state->CreateTaskDynamicZone(this, task_id, dz_request); + } } Expedition* Client::GetExpedition() const @@ -9877,24 +9903,59 @@ void Client::GoToDzSafeReturnOrBind(const DynamicZone* dynamic_zone) GoToBind(); } +void Client::AddDynamicZoneID(uint32_t dz_id) +{ + auto it = std::find_if(m_dynamic_zone_ids.begin(), m_dynamic_zone_ids.end(), + [&](uint32_t current_dz_id) { return current_dz_id == dz_id; }); + + if (it == m_dynamic_zone_ids.end()) + { + LogDynamicZonesDetail("Adding dz [{}] to client [{}]", dz_id, GetName()); + m_dynamic_zone_ids.push_back(dz_id); + } +} + +void Client::RemoveDynamicZoneID(uint32_t dz_id) +{ + LogDynamicZonesDetail("Removing dz [{}] from client [{}]", dz_id, GetName()); + m_dynamic_zone_ids.erase(std::remove_if(m_dynamic_zone_ids.begin(), m_dynamic_zone_ids.end(), + [&](uint32_t current_dz_id) { return current_dz_id == dz_id; } + ), m_dynamic_zone_ids.end()); +} + std::vector Client::GetDynamicZones(uint32_t zone_id, int zone_version) { std::vector client_dzs; - // check client systems for any associated dynamic zones optionally filtered by zone - Expedition* expedition = GetExpedition(); - if (expedition && - (zone_id == 0 || expedition->GetDynamicZone().GetZoneID() == zone_id) && - (zone_version < 0 || expedition->GetDynamicZone().GetZoneVersion() == zone_version)) + for (uint32_t dz_id : m_dynamic_zone_ids) { - client_dzs.emplace_back(&expedition->GetDynamicZone()); + auto dz = DynamicZone::FindDynamicZoneByID(dz_id); + if (dz && + (zone_id == 0 || dz->GetZoneID() == zone_id) && + (zone_version < 0 || dz->GetZoneVersion() == zone_version)) + { + client_dzs.emplace_back(dz); + } } - // todo: tasks, missions (shared tasks), and quests with an associated dz to zone_id - return client_dzs; } +void Client::SetDynamicZoneMemberStatus(DynamicZoneMemberStatus status) +{ + // sets status on all associated dzs client may have. if client is online + // inside a dz, only that dz has the "In Dynamic Zone" status set + for (auto& dz : GetDynamicZones()) + { + // the rule to disable this status is handled internally by the dz + if (status == DynamicZoneMemberStatus::Online && dz->IsCurrentZoneDzInstance()) + { + status = DynamicZoneMemberStatus::InDynamicZone; + } + dz->SetMemberStatus(CharacterID(), status); + } +} + void Client::MovePCDynamicZone(uint32 zone_id, int zone_version, bool msg_if_invalid) { if (zone_id == 0) diff --git a/zone/client.h b/zone/client.h index 11cbac385..dcc177e20 100644 --- a/zone/client.h +++ b/zone/client.h @@ -80,6 +80,7 @@ namespace EQ #include #include #include +#include #define CLIENT_TIMEOUT 90000 @@ -1030,6 +1031,9 @@ public: void SendTaskActivityComplete(int task_id, int activity_id, int task_index, TaskType task_type, int task_incomplete=1); void SendTaskFailed(int task_id, int task_index, TaskType task_type); void SendTaskComplete(int task_index); + bool HasTaskRequestCooldownTimer(); + void SendTaskRequestCooldownTimerMessage(); + void StartTaskRequestCooldownTimer(); inline ClientTaskState *GetTaskState() const { return task_state; } inline void CancelTask(int task_index, TaskType task_type) { @@ -1095,7 +1099,7 @@ public: } } inline void UpdateTasksForItem( - ActivityType activity_type, + TaskActivityType activity_type, int item_id, int count = 1 ) @@ -1202,7 +1206,7 @@ public: bool enforce_level_requirement = false ) { if (task_state) { - task_state->AcceptNewTask(this, task_id, npc_id, enforce_level_requirement); + task_state->AcceptNewTask(this, task_id, npc_id, std::time(nullptr), enforce_level_requirement); } } inline int ActiveSpeakTask(int npc_type_id) @@ -1262,6 +1266,15 @@ public: { return (task_state ? task_state->CompletedTasksInSet(task_set_id) : 0); } + void PurgeTaskTimers(); + + // shared task shims / middleware + // these variables are used as a shim to intercept normal localized task functionality + // and pipe it into zone -> world and back to world -> zone + // world is authoritative + bool m_requesting_shared_task = false; + bool m_shared_task_update = false; + bool m_requested_shared_task_removal = false; inline const EQ::versions::ClientVersion ClientVersion() const { return m_ClientVersion; } inline const uint32 ClientVersionBit() const { return m_ClientVersionBit; } @@ -1330,9 +1343,9 @@ public: const std::string& event_Name, int seconds, const std::string& uuid = {}, bool update_db = false); void AddNewExpeditionLockout(const std::string& expedition_name, const std::string& event_name, uint32_t duration, std::string uuid = {}); - Expedition* CreateExpedition(DynamicZone& dz_instance, ExpeditionRequest& request); - Expedition* CreateExpedition( - const std::string& zone_name, uint32 version, uint32 duration, const std::string& expedition_name, + Expedition* CreateExpedition(DynamicZone& dz, bool disable_messages = false); + Expedition* CreateExpedition(const std::string& zone_name, + uint32 version, uint32 duration, const std::string& expedition_name, uint32 min_players, uint32 max_players, bool disable_messages = false); Expedition* GetExpedition() const; uint32 GetExpeditionID() const { return m_expedition_id; } @@ -1350,7 +1363,6 @@ public: void SendExpeditionLockoutTimers(); void SetExpeditionID(uint32 expedition_id) { m_expedition_id = expedition_id; }; void SetPendingExpeditionInvite(ExpeditionInvite&& invite) { m_pending_expedition_invite = invite; } - void UpdateExpeditionInfoAndLockouts(); void DzListTimers(); void SetDzRemovalTimer(bool enable_timer); void SendDzCompassUpdate(); @@ -1360,6 +1372,11 @@ public: std::vector GetDynamicZones(uint32_t zone_id = 0, int zone_version = -1); std::unique_ptr CreateDzSwitchListPacket(const std::vector& dzs); std::unique_ptr CreateCompassPacket(const std::vector& entries); + void AddDynamicZoneID(uint32_t dz_id); + void RemoveDynamicZoneID(uint32_t dz_id); + void SendDynamicZoneUpdates(); + void SetDynamicZoneMemberStatus(DynamicZoneMemberStatus status); + void CreateTaskDynamicZone(int task_id, DynamicZone& dz_request); void CalcItemScale(); bool CalcItemScale(uint32 slot_x, uint32 slot_y); // behavior change: 'slot_y' is now [RANGE]_END and not [RANGE]_END + 1 @@ -1590,6 +1607,9 @@ public: void ShowDevToolsMenu(); CheatManager cheat_manager; + // rate limit + Timer m_list_task_timers_rate_limit = {}; + protected: friend class Mob; void CalcItemBonuses(StatBonuses* newbon); @@ -1821,6 +1841,7 @@ private: Timer position_update_timer; /* Timer used when client hasn't updated within a 10 second window */ Timer consent_throttle_timer; Timer dynamiczone_removal_timer; + Timer task_request_timer; glm::vec3 m_Proximity; glm::vec4 last_position_before_bulk_update; @@ -1855,6 +1876,14 @@ private: ClientTaskState *task_state; int TotalSecondsPlayed; + // we use this very sparingly at the zone level + // used for keeping clients in donecount sync before world sends absolute confirmations of state + int64 m_shared_task_id = 0; +public: + void SetSharedTaskId(int64 shared_task_id); + int64 GetSharedTaskId() const; +private: + //Anti Spam Stuff Timer *KarmaUpdateTimer; uint32 TotalKarma; @@ -1927,6 +1956,7 @@ private: std::vector m_expedition_lockouts; glm::vec3 m_quest_compass; bool m_has_quest_compass = false; + std::vector m_dynamic_zone_ids; #ifdef BOTS diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index a1e3eb9c0..1365dbd56 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -63,7 +63,9 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #include "worldserver.h" #include "zone.h" #include "mob_movement_manager.h" +#include "../common/repositories/character_instance_safereturns_repository.h" #include "../common/repositories/criteria/content_filter_criteria.h" +#include "../common/shared_tasks.h" #ifdef BOTS #include "bot.h" @@ -381,6 +383,7 @@ void MapOpcodes() ConnectedOpcodes[OP_TargetCommand] = &Client::Handle_OP_TargetCommand; ConnectedOpcodes[OP_TargetMouse] = &Client::Handle_OP_TargetMouse; ConnectedOpcodes[OP_TaskHistoryRequest] = &Client::Handle_OP_TaskHistoryRequest; + ConnectedOpcodes[OP_TaskTimers] = &Client::Handle_OP_TaskTimers; ConnectedOpcodes[OP_Taunt] = &Client::Handle_OP_Taunt; ConnectedOpcodes[OP_TestBuff] = &Client::Handle_OP_TestBuff; ConnectedOpcodes[OP_TGB] = &Client::Handle_OP_TGB; @@ -414,6 +417,15 @@ void MapOpcodes() ConnectedOpcodes[OP_ZoneChange] = &Client::Handle_OP_ZoneChange; ConnectedOpcodes[OP_ResetAA] = &Client::Handle_OP_ResetAA; ConnectedOpcodes[OP_UnderWorld] = &Client::Handle_OP_UnderWorld; + + // shared tasks + ConnectedOpcodes[OP_SharedTaskRemovePlayer] = &Client::Handle_OP_SharedTaskRemovePlayer; + ConnectedOpcodes[OP_SharedTaskAddPlayer] = &Client::Handle_OP_SharedTaskAddPlayer; + ConnectedOpcodes[OP_SharedTaskMakeLeader] = &Client::Handle_OP_SharedTaskMakeLeader; + ConnectedOpcodes[OP_SharedTaskInviteResponse] = &Client::Handle_OP_SharedTaskInviteResponse; + ConnectedOpcodes[OP_SharedTaskAcceptNew] = &Client::Handle_OP_SharedTaskAccept; + ConnectedOpcodes[OP_SharedTaskQuit] = &Client::Handle_OP_SharedTaskQuit; + ConnectedOpcodes[OP_SharedTaskPlayerList] = &Client::Handle_OP_SharedTaskPlayerList; } void ClearMappedOpcode(EmuOpcode op) @@ -526,6 +538,9 @@ void Client::CompleteConnect() /* Sets GM Flag if needed & Sends Petition Queue */ UpdateAdmin(false); + // Task Packets + LoadClientTaskState(); + if (IsInAGuild()) { uint8 rank = GuildRank(); if (ClientVersion() >= EQ::versions::ClientVersion::RoF) @@ -899,7 +914,7 @@ void Client::CompleteConnect() guild_mgr.RequestOnlineGuildMembers(this->CharacterID(), this->GuildID()); } - UpdateExpeditionInfoAndLockouts(); + SendDynamicZoneUpdates(); /** Request adventure info **/ auto pack = new ServerPacket(ServerOP_AdventureDataRequest, 64); @@ -940,6 +955,25 @@ void Client::CompleteConnect() ShowDevToolsMenu(); } + // shared tasks memberlist + if (GetTaskState()->HasActiveSharedTask()) { + + // struct + auto p = new ServerPacket( + ServerOP_SharedTaskRequestMemberlist, + sizeof(ServerSharedTaskRequestMemberlist_Struct) + ); + + auto *r = (ServerSharedTaskRequestMemberlist_Struct *) p->pBuffer; + + // fill + r->source_character_id = CharacterID(); + r->task_id = GetTaskState()->GetActiveSharedTask().task_id; + + // send + worldserver.SendPacket(p); + safe_delete(p); + } } // connecting opcode handlers @@ -1716,13 +1750,41 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app) m_inv.SetGMInventory((bool)m_pp.gm); // reset back to current gm state } - /* Task Packets */ - LoadClientTaskState(); - ApplyWeaponsStance(); + auto dynamic_zone_member_entries = DynamicZoneMembersRepository::GetWhere(database, + fmt::format("character_id = {}", CharacterID())); + + for (const auto& entry : dynamic_zone_member_entries) + { + m_dynamic_zone_ids.emplace_back(entry.dynamic_zone_id); + } + m_expedition_id = ExpeditionsRepository::GetIDByMemberID(database, CharacterID()); + auto dz = zone->GetDynamicZone(); + if (dz && dz->GetSafeReturnLocation().zone_id != 0) + { + auto safereturn = dz->GetSafeReturnLocation(); + + auto safereturn_entry = CharacterInstanceSafereturnsRepository::NewEntity(); + safereturn_entry.character_id = CharacterID(); + safereturn_entry.instance_zone_id = zone->GetZoneID(); + safereturn_entry.instance_id = zone->GetInstanceID(); + safereturn_entry.safe_zone_id = safereturn.zone_id; + safereturn_entry.safe_x = safereturn.x; + safereturn_entry.safe_y = safereturn.y; + safereturn_entry.safe_z = safereturn.z; + safereturn_entry.safe_heading = safereturn.heading; + + CharacterInstanceSafereturnsRepository::InsertOneOrUpdate(database, safereturn_entry); + } + else + { + CharacterInstanceSafereturnsRepository::DeleteWhere(database, + fmt::format("character_id = {}", character_id)); + } + /** * DevTools Load Settings */ @@ -1828,7 +1890,7 @@ void Client::Handle_OP_AcceptNewTask(const EQApplicationPacket *app) AcceptNewTask_Struct *ant = (AcceptNewTask_Struct*)app->pBuffer; if (ant->task_id > 0 && RuleB(TaskSystem, EnableTaskSystem) && task_state) - task_state->AcceptNewTask(this, ant->task_id, ant->task_master_id); + task_state->AcceptNewTask(this, ant->task_id, ant->task_master_id, std::time(nullptr)); } void Client::Handle_OP_AdventureInfoRequest(const EQApplicationPacket *app) @@ -9041,9 +9103,9 @@ void Client::Handle_OP_KickPlayers(const EQApplicationPacket *app) expedition->DzKickPlayers(this); } } - else if (buf->kick_task) + else if (buf->kick_task && GetTaskState() && GetTaskState()->HasActiveSharedTask()) { - // todo: shared tasks + GetTaskState()->KickPlayersSharedTask(this); } } @@ -12820,16 +12882,16 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app) While active for the duration of 12 seconds baseline. The 'shield target' will take 50 pct less damage and the 'shielder' will be hit with the damage taken by the 'shield target' after all applicable mitigiont is calculated, the damage on the 'shielder' will be reduced by 25 percent, this reduction can be increased to 50 pct if equiping a shield. - You receive a 1% increase in mitigation for every 2 AC on the shield. + You receive a 1% increase in mitigation for every 2 AC on the shield. Shielder must stay with in a close distance (15 units) to your 'shield target'. If either move out of range, shield ends, no message given. Both duration and shield range can be modified by AA. Recast is 3 minutes. For custom use cases, Mob::ShieldAbility can be used in quests with all parameters being altered. This functional is also used for SPA 201 SE_PetShield, which functions in a simalar manner with pet shielding owner. - + Note: If either the shielder or the shield target die all variables are reset on both. - + */ if (app->size != sizeof(Shielding_Struct)) { @@ -12838,7 +12900,7 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app) } if (GetLevel() < 30) { //Client gives message - return; + return; } if (GetClass() != WARRIOR){ @@ -12854,7 +12916,7 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app) } Shielding_Struct* shield = (Shielding_Struct*)app->pBuffer; - + if (ShieldAbility(shield->target_id, 15, 12000, 50, 25, true, false)) { p_timers.Start(timer, SHIELD_ABILITY_RECAST_TIME); } @@ -15196,20 +15258,266 @@ void Client::Handle_OP_ResetAA(const EQApplicationPacket *app) return; } -void Client::Handle_OP_MovementHistoryList(const EQApplicationPacket* app) { +void Client::Handle_OP_MovementHistoryList(const EQApplicationPacket *app) +{ cheat_manager.ProcessMovementHistory(app); } -void Client::Handle_OP_UnderWorld(const EQApplicationPacket* app) { - UnderWorld* m_UnderWorld = (UnderWorld*)app->pBuffer; - if (app->size != sizeof(UnderWorld)) - { +void Client::Handle_OP_UnderWorld(const EQApplicationPacket *app) +{ + UnderWorld *m_UnderWorld = (UnderWorld *) app->pBuffer; + if (app->size != sizeof(UnderWorld)) { LogDebug("Size mismatch in OP_UnderWorld, expected {}, got [{}]", sizeof(UnderWorld), app->size); DumpPacket(app); return; } - auto dist = Distance(glm::vec3(m_UnderWorld->x, m_UnderWorld->y, zone->newzone_data.underworld), glm::vec3(m_UnderWorld->x, m_UnderWorld->y, m_UnderWorld->z)); + auto dist = Distance( + glm::vec3(m_UnderWorld->x, m_UnderWorld->y, zone->newzone_data.underworld), + glm::vec3(m_UnderWorld->x, m_UnderWorld->y, m_UnderWorld->z)); cheat_manager.MovementCheck(glm::vec3(m_UnderWorld->x, m_UnderWorld->y, m_UnderWorld->z)); - if (m_UnderWorld->spawn_id == GetID() && dist <= 5.0f && zone->newzone_data.underworld_teleport_index != 0) + if (m_UnderWorld->spawn_id == GetID() && dist <= 5.0f && zone->newzone_data.underworld_teleport_index != 0) { cheat_manager.SetExemptStatus(Port, true); + } +} + +void Client::Handle_OP_SharedTaskRemovePlayer(const EQApplicationPacket *app) +{ + if (app->size != sizeof(SharedTaskRemovePlayer_Struct)) { + LogPacketClientServer( + "Wrong size on Handle_OP_SharedTaskRemovePlayer | got [{}] expected [{}]", + app->size, + sizeof(SharedTaskRemovePlayer_Struct) + ); + return; + } + auto *r = (SharedTaskRemovePlayer_Struct *) app->pBuffer; + + LogTasks( + "[Handle_OP_SharedTaskRemovePlayer] field1 [{}] field2 [{}] player_name [{}]", + r->field1, + r->field2, + r->player_name + ); + + // live no-ops this command if not in a shared task + if (GetTaskState()->HasActiveSharedTask()) { + // struct + auto p = new ServerPacket( + ServerOP_SharedTaskRemovePlayer, + sizeof(ServerSharedTaskRemovePlayer_Struct) + ); + + auto *rp = (ServerSharedTaskRemovePlayer_Struct *) p->pBuffer; + + // fill + rp->source_character_id = CharacterID(); + rp->task_id = GetTaskState()->GetActiveSharedTask().task_id; + strn0cpy(rp->player_name, r->player_name, sizeof(r->player_name)); + + LogTasks( + "[Handle_OP_SharedTaskRemovePlayer] source_character_id [{}] task_id [{}] player_name [{}]", + rp->source_character_id, + rp->task_id, + rp->player_name + ); + + // send + worldserver.SendPacket(p); + safe_delete(p); + } +} + +void Client::Handle_OP_SharedTaskAddPlayer(const EQApplicationPacket *app) +{ + if (app->size != sizeof(SharedTaskAddPlayer_Struct)) { + LogPacketClientServer( + "Wrong size on Handle_OP_SharedTaskAddPlayer | got [{}] expected [{}]", + app->size, + sizeof(SharedTaskAddPlayer_Struct) + ); + return; + } + auto *r = (SharedTaskAddPlayer_Struct *) app->pBuffer; + + LogTasks( + "[SharedTaskAddPlayer_Struct] field1 [{}] field2 [{}] player_name [{}]", + r->field1, + r->field2, + r->player_name + ); + + if (!GetTaskState()->HasActiveSharedTask()) { + // this message is generated client-side in newer clients + Message(Chat::System, SharedTaskMessage::GetEQStr(SharedTaskMessage::COULD_NOT_USE_COMMAND)); + } + else { + // struct + auto p = new ServerPacket( + ServerOP_SharedTaskAddPlayer, + sizeof(ServerSharedTaskAddPlayer_Struct) + ); + + auto *rp = (ServerSharedTaskAddPlayer_Struct *) p->pBuffer; + + // fill + rp->source_character_id = CharacterID(); + rp->task_id = GetTaskState()->GetActiveSharedTask().task_id; + strn0cpy(rp->player_name, r->player_name, sizeof(r->player_name)); + + LogTasks( + "[Handle_OP_SharedTaskRemovePlayer] source_character_id [{}] task_id [{}] player_name [{}]", + rp->source_character_id, + rp->task_id, + rp->player_name + ); + + // send + worldserver.SendPacket(p); + safe_delete(p); + } +} + +void Client::Handle_OP_SharedTaskMakeLeader(const EQApplicationPacket *app) +{ + if (app->size != sizeof(SharedTaskMakeLeader_Struct)) { + LogPacketClientServer( + "Wrong size on Handle_OP_SharedTaskMakeLeader | got [{}] expected [{}]", + app->size, + sizeof(SharedTaskMakeLeader_Struct) + ); + return; + } + + auto *r = (SharedTaskMakeLeader_Struct *) app->pBuffer; + LogTasks( + "[SharedTaskMakeLeader_Struct] field1 [{}] field2 [{}] player_name [{}]", + r->field1, + r->field2, + r->player_name + ); + + // live no-ops this command if not in a shared task + if (GetTaskState()->HasActiveSharedTask()) { + // struct + auto p = new ServerPacket( + ServerOP_SharedTaskMakeLeader, + sizeof(ServerSharedTaskMakeLeader_Struct) + ); + + auto *rp = (ServerSharedTaskMakeLeader_Struct *) p->pBuffer; + + // fill + rp->source_character_id = CharacterID(); + rp->task_id = GetTaskState()->GetActiveSharedTask().task_id; + strn0cpy(rp->player_name, r->player_name, sizeof(r->player_name)); + + LogTasks( + "[Handle_OP_SharedTaskRemovePlayer] source_character_id [{}] task_id [{}] player_name [{}]", + rp->source_character_id, + rp->task_id, + rp->player_name + ); + + // send + worldserver.SendPacket(p); + safe_delete(p); + } +} + +void Client::Handle_OP_SharedTaskInviteResponse(const EQApplicationPacket *app) +{ + if (app->size != sizeof(SharedTaskInviteResponse_Struct)) { + LogPacketClientServer( + "Wrong size on SharedTaskInviteResponse | got [{}] expected [{}]", + app->size, + sizeof(SharedTaskInviteResponse_Struct) + ); + return; + } + + auto *r = (SharedTaskInviteResponse_Struct *) app->pBuffer; + LogTasks( + "[SharedTaskInviteResponse] unknown00 [{}] invite_id [{}] accepted [{}]", + r->unknown00, + r->invite_id, + r->accepted + ); + + // struct + auto p = new ServerPacket( + ServerOP_SharedTaskInviteAcceptedPlayer, + sizeof(ServerSharedTaskInviteAccepted_Struct) + ); + + auto *c = (ServerSharedTaskInviteAccepted_Struct *) p->pBuffer; + + // fill + c->source_character_id = CharacterID(); + c->shared_task_id = r->invite_id; + c->accepted = r->accepted; + strn0cpy(c->player_name, GetName(), sizeof(c->player_name)); + + LogTasks( + "[ServerOP_SharedTaskInviteAcceptedPlayer] source_character_id [{}] shared_task_id [{}]", + c->source_character_id, + c->shared_task_id + ); + + // send + worldserver.SendPacket(p); + safe_delete(p); +} + +void Client::Handle_OP_SharedTaskAccept(const EQApplicationPacket* app) +{ + auto buf = reinterpret_cast(app->pBuffer); + + LogTasksDetail( + "[OP_SharedTaskAccept] unknown00 [{}] unknown04 [{}] npc_entity_id [{}] task_id [{}]", + buf->unknown00, + buf->unknown04, + buf->npc_entity_id, + buf->task_id + ); + + if (buf->task_id > 0 && RuleB(TaskSystem, EnableTaskSystem) && task_state) { + task_state->AcceptNewTask(this, buf->task_id, buf->npc_entity_id, std::time(nullptr)); + } +} + +void Client::Handle_OP_SharedTaskQuit(const EQApplicationPacket* app) +{ + if (GetTaskState()->HasActiveSharedTask()) + { + CancelTask(TASKSLOTSHAREDTASK, TaskType::Shared); + } +} + +void Client::Handle_OP_TaskTimers(const EQApplicationPacket* app) +{ + GetTaskState()->ListTaskTimers(this); +} + +void Client::Handle_OP_SharedTaskPlayerList(const EQApplicationPacket* app) +{ + if (GetTaskState()->HasActiveSharedTask()) + { + uint32_t size = sizeof(ServerSharedTaskPlayerList_Struct); + auto pack = std::make_unique(ServerOP_SharedTaskPlayerList, size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->source_character_id = CharacterID(); + buf->task_id = GetTaskState()->GetActiveSharedTask().task_id; + + worldserver.SendPacket(pack.get()); + } +} + +int64 Client::GetSharedTaskId() const +{ + return m_shared_task_id; +} + +void Client::SetSharedTaskId(int64 shared_task_id) +{ + Client::m_shared_task_id = shared_task_id; } diff --git a/zone/client_packet.h b/zone/client_packet.h index e04d43483..ce85e38c5 100644 --- a/zone/client_packet.h +++ b/zone/client_packet.h @@ -282,6 +282,7 @@ void Handle_OP_TargetCommand(const EQApplicationPacket *app); void Handle_OP_TargetMouse(const EQApplicationPacket *app); void Handle_OP_TaskHistoryRequest(const EQApplicationPacket *app); + void Handle_OP_TaskTimers(const EQApplicationPacket *app); void Handle_OP_Taunt(const EQApplicationPacket *app); void Handle_OP_TestBuff(const EQApplicationPacket *app); void Handle_OP_TGB(const EQApplicationPacket *app); @@ -315,3 +316,12 @@ void Handle_OP_ResetAA(const EQApplicationPacket *app); void Handle_OP_MovementHistoryList(const EQApplicationPacket* app); void Handle_OP_UnderWorld(const EQApplicationPacket* app); + + // shared tasks + void Handle_OP_SharedTaskRemovePlayer(const EQApplicationPacket *app); + void Handle_OP_SharedTaskAddPlayer(const EQApplicationPacket *app); + void Handle_OP_SharedTaskMakeLeader(const EQApplicationPacket *app); + void Handle_OP_SharedTaskInviteResponse(const EQApplicationPacket *app); + void Handle_OP_SharedTaskAccept(const EQApplicationPacket *app); + void Handle_OP_SharedTaskQuit(const EQApplicationPacket *app); + void Handle_OP_SharedTaskPlayerList(const EQApplicationPacket *app); diff --git a/zone/client_process.cpp b/zone/client_process.cpp index 428c734ab..0fd418131 100644 --- a/zone/client_process.cpp +++ b/zone/client_process.cpp @@ -181,11 +181,7 @@ bool Client::Process() { myraid->MemberZoned(this); } - Expedition* expedition = GetExpedition(); - if (expedition) - { - expedition->SetMemberStatus(this, DynamicZoneMemberStatus::Offline); - } + SetDynamicZoneMemberStatus(DynamicZoneMemberStatus::Offline); return false; //delete client } @@ -562,11 +558,7 @@ bool Client::Process() { AI_Start(CLIENT_LD_TIMEOUT); SendAppearancePacket(AT_Linkdead, 1); - Expedition* expedition = GetExpedition(); - if (expedition) - { - expedition->SetMemberStatus(this, DynamicZoneMemberStatus::LinkDead); - } + SetDynamicZoneMemberStatus(DynamicZoneMemberStatus::LinkDead); } } @@ -698,10 +690,9 @@ void Client::OnDisconnect(bool hard_disconnect) { } } - Expedition* expedition = GetExpedition(); - if (expedition && !bZoning) + if (!bZoning) { - expedition->SetMemberStatus(this, DynamicZoneMemberStatus::Offline); + SetDynamicZoneMemberStatus(DynamicZoneMemberStatus::Offline); } RemoveAllAuras(); diff --git a/zone/command.cpp b/zone/command.cpp index 665b2098b..4c9bcc0bb 100755 --- a/zone/command.cpp +++ b/zone/command.cpp @@ -61,6 +61,7 @@ #include "data_bucket.h" #include "command.h" +#include "dynamic_zone.h" #include "expedition.h" #include "guild_mgr.h" #include "map.h" @@ -76,6 +77,7 @@ #include "npc_scale_manager.h" #include "../common/content/world_content_service.h" #include "../common/http/httplib.h" +#include "../common/shared_tasks.h" extern QueryServ* QServ; extern WorldServer worldserver; @@ -7143,7 +7145,19 @@ void command_dz(Client* c, const Seperator* sep) return; } - if (strcasecmp(sep->arg[1], "expedition") == 0) + if (strcasecmp(sep->arg[1], "cache") == 0) + { + if (strcasecmp(sep->arg[2], "reload") == 0) + { + DynamicZone::CacheAllFromDatabase(); + Expedition::CacheAllFromDatabase(); + c->Message(Chat::White, fmt::format( + "Reloaded [{}] dynamic zone(s) and [{}] expedition(s) from database", + zone->dynamic_zone_cache.size(), zone->expedition_cache.size() + ).c_str()); + } + } + else if (strcasecmp(sep->arg[1], "expedition") == 0) { if (strcasecmp(sep->arg[2], "list") == 0) { @@ -7161,25 +7175,32 @@ void command_dz(Client* c, const Seperator* sep) c->Message(Chat::White, fmt::format("Total Active Expeditions: [{}]", expeditions.size()).c_str()); for (const auto& expedition : expeditions) { + auto dz = expedition->GetDynamicZone(); + if (!dz) + { + LogExpeditions("Expedition [{}] has an invalid dz [{}] in cache", expedition->GetID(), expedition->GetDynamicZoneID()); + continue; + } + auto leader_saylink = EQ::SayLinkEngine::GenerateQuestSaylink(fmt::format( "#goto {}", expedition->GetLeaderName()), false, expedition->GetLeaderName()); auto zone_saylink = EQ::SayLinkEngine::GenerateQuestSaylink(fmt::format( - "#zoneinstance {}", expedition->GetDynamicZone().GetInstanceID()), false, "zone"); + "#zoneinstance {}", dz->GetInstanceID()), false, "zone"); - auto seconds = expedition->GetDynamicZone().GetSecondsRemaining(); + auto seconds = dz->GetSecondsRemaining(); c->Message(Chat::White, fmt::format( "expedition id: [{}] dz id: [{}] name: [{}] leader: [{}] {}: [{}]:[{}]:[{}]:[{}] members: [{}] remaining: [{:02}:{:02}:{:02}]", expedition->GetID(), - expedition->GetDynamicZone().GetID(), + expedition->GetDynamicZoneID(), expedition->GetName(), leader_saylink, zone_saylink, - ZoneName(expedition->GetDynamicZone().GetZoneID()), - expedition->GetDynamicZone().GetZoneID(), - expedition->GetDynamicZone().GetInstanceID(), - expedition->GetDynamicZone().GetZoneVersion(), - expedition->GetDynamicZone().GetMemberCount(), + ZoneName(dz->GetZoneID()), + dz->GetZoneID(), + dz->GetInstanceID(), + dz->GetZoneVersion(), + dz->GetMemberCount(), seconds / 3600, // hours (seconds / 60) % 60, // minutes seconds % 60 // seconds @@ -7201,7 +7222,7 @@ void command_dz(Client* c, const Seperator* sep) { c->Message(Chat::White, fmt::format("Destroying expedition [{}] ({})", expedition_id, expedition->GetName()).c_str()); - expedition->RemoveAllMembers(); + expedition->GetDynamicZone()->RemoveAllMembers(); } else { @@ -7224,9 +7245,46 @@ void command_dz(Client* c, const Seperator* sep) } } else if (strcasecmp(sep->arg[1], "list") == 0) + { + c->Message(Chat::White, fmt::format("Total Dynamic Zones (cache): [{}]", zone->dynamic_zone_cache.size()).c_str()); + + std::vector dynamic_zones; + for (const auto& dz : zone->dynamic_zone_cache) + { + dynamic_zones.emplace_back(dz.second.get()); + } + + std::sort(dynamic_zones.begin(), dynamic_zones.end(), + [](const DynamicZone* lhs, const DynamicZone* rhs) { + return lhs->GetID() < rhs->GetID(); + }); + + for (const auto& dz : dynamic_zones) + { + auto seconds = dz->GetSecondsRemaining(); + auto zone_saylink = EQ::SayLinkEngine::GenerateQuestSaylink( + fmt::format("#zoneinstance {}", dz->GetInstanceID()), false, "zone"); + + std::string aligned_type = fmt::format("[{}]", DynamicZone::GetDynamicZoneTypeName(static_cast(dz->GetType()))); + c->Message(Chat::White, fmt::format( + "id: [{}] type: {:>10} {}: [{}]:[{}]:[{}] members: [{}] remaining: [{:02}:{:02}:{:02}]", + dz->GetID(), + aligned_type, + zone_saylink, + dz->GetZoneID(), + dz->GetInstanceID(), + dz->GetZoneVersion(), + dz->GetMemberCount(), + seconds / 3600, // hours + (seconds / 60) % 60, // minutes + seconds % 60 // seconds + ).c_str()); + } + } + else if (strcasecmp(sep->arg[1], "listdb") == 0) { auto dz_list = DynamicZonesRepository::AllDzInstancePlayerCounts(database); - c->Message(Chat::White, fmt::format("Total Dynamic Zones: [{}]", dz_list.size()).c_str()); + c->Message(Chat::White, fmt::format("Total Dynamic Zones (database): [{}]", dz_list.size()).c_str()); auto now = std::chrono::system_clock::now(); @@ -7243,7 +7301,7 @@ void command_dz(Client* c, const Seperator* sep) fmt::format("#zoneinstance {}", dz.instance), false, "zone"); c->Message(Chat::White, fmt::format( - "dz id: [{}] type: [{}] {}: [{}]:[{}]:[{}] members: [{}] remaining: [{:02}:{:02}:{:02}]", + "id: [{}] type: [{}] {}: [{}]:[{}]:[{}] members: [{}] remaining: [{:02}:{:02}:{:02}]", dz.id, DynamicZone::GetDynamicZoneTypeName(static_cast(dz.type)), zone_saylink, @@ -7295,11 +7353,13 @@ void command_dz(Client* c, const Seperator* sep) else { c->Message(Chat::White, "#dz usage:"); + c->Message(Chat::White, "#dz cache reload - reload the current zone cache from db (also reloads expedition cache dependency)"); c->Message(Chat::White, "#dz expedition list - list expeditions in current zone cache"); c->Message(Chat::White, "#dz expedition reload - reload expedition zone cache from database"); c->Message(Chat::White, "#dz expedition destroy - destroy expedition globally (must be in cache)"); c->Message(Chat::White, "#dz expedition unlock - unlock expedition"); - c->Message(Chat::White, "#dz list [all] - list dynamic zone instances from database -- 'all' includes expired"); + c->Message(Chat::White, "#dz list - list all dynamic zone instances from current zone cache"); + c->Message(Chat::White, "#dz listdb [all] - list dynamic zone instances from database -- 'all' includes expired"); c->Message(Chat::White, "#dz lockouts remove - delete all of character's expedition lockouts"); c->Message(Chat::White, "#dz lockouts remove \"\" - delete lockouts by expedition"); c->Message(Chat::White, "#dz lockouts remove \"\" \"\" - delete lockout by expedition event"); @@ -10526,6 +10586,25 @@ void command_task(Client *c, const Seperator *sep) { EQ::SayLinkEngine::GenerateQuestSaylink("#task reload sets", false, "reload sets") ).c_str() ); + c->Message( + Chat::White, + fmt::format( + "--- [{}] Purges targeted characters task timers", + EQ::SayLinkEngine::GenerateQuestSaylink("#task purgetimers", false, "purgetimers") + ).c_str() + ); + + c->Message(Chat::White, "------------------------------------------------"); + c->Message(Chat::White, "# Shared Task System Commands"); + c->Message(Chat::White, "------------------------------------------------"); + c->Message( + Chat::White, + fmt::format( + "--- [{}] Purges all active Shared Tasks in memory and database ", + EQ::SayLinkEngine::GenerateQuestSaylink("#task sharedpurge", false, "sharedpurge") + ).c_str() + ); + return; } @@ -10539,6 +10618,15 @@ void command_task(Client *c, const Seperator *sep) { return; } + if (!strcasecmp(sep->arg[1], "purgetimers")) { + c->Message(15, fmt::format("{}'s task timers have been purged", client_target->GetCleanName()).c_str()); + if (client_target != c) { + client_target->Message(15, "[GM] Your task timers have been purged by a GM"); + } + client_target->PurgeTaskTimers(); + return; + } + if (!strcasecmp(sep->arg[1], "update")) { if (sep->argnum >= 3) { int task_id = atoi(sep->arg[2]); @@ -10565,6 +10653,27 @@ void command_task(Client *c, const Seperator *sep) { return; } + if (!strcasecmp(sep->arg[1], "sharedpurge")) { + if (!strcasecmp(sep->arg[2], "confirm")) { + LogTasksDetail("Sending purge request"); + auto pack = new ServerPacket(ServerOP_SharedTaskPurgeAllCommand, 0); + worldserver.SendPacket(pack); + safe_delete(pack); + + return; + } + + c->Message( + Chat::White, + fmt::format( + "[WARNING] This will purge all active Shared Tasks [{}]?", + EQ::SayLinkEngine::GenerateQuestSaylink("#task sharedpurge confirm", false, "confirm") + ).c_str() + ); + + return; + } + if (!strcasecmp(sep->arg[1], "assign")) { int task_id = atoi(sep->arg[2]); if ((task_id > 0) && (task_id < MAXTASKS)) { diff --git a/zone/corpse.cpp b/zone/corpse.cpp index ae123e2da..498780e1f 100644 --- a/zone/corpse.cpp +++ b/zone/corpse.cpp @@ -1261,16 +1261,16 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app) return; } - if (zone && zone->GetInstanceID() != 0) + if (!IsPlayerCorpse()) { - // expeditions may prevent looting based on client's lockouts - auto expedition = Expedition::FindCachedExpeditionByZoneInstance(zone->GetZoneID(), zone->GetInstanceID()); - if (expedition && !expedition->CanClientLootCorpse(client, GetNPCTypeID(), GetID())) + // dynamic zones may prevent looting by non-members or based on lockouts + auto dz = zone->GetDynamicZone(); + if (dz && !dz->CanClientLootCorpse(client, GetNPCTypeID(), GetID())) { - client->MessageString(Chat::Red, LOOT_NOT_ALLOWED, inst->GetItem()->Name); + // note on live this message is only sent once on the first loot attempt of an open corpse + client->MessageString(Chat::Loot, LOOT_NOT_ALLOWED, inst->GetItem()->Name); + lootitem->auto_loot = -1; // generates client eqstr 1370 "You may not loot that item from this corpse." client->QueuePacket(app); - SendEndLootErrorPacket(client); - ResetLooter(); delete inst; return; } @@ -1307,7 +1307,7 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app) /* Update any tasks that have an activity to loot this item */ if (RuleB(TaskSystem, EnableTaskSystem)) - client->UpdateTasksForItem(ActivityLoot, item->ID); + client->UpdateTasksForItem(TaskActivityType::Loot, item->ID); /* Remove it from Corpse */ if (item_data) { diff --git a/zone/dynamic_zone.cpp b/zone/dynamic_zone.cpp index 177d9c04c..a7f2bb822 100644 --- a/zone/dynamic_zone.cpp +++ b/zone/dynamic_zone.cpp @@ -21,6 +21,7 @@ #include "dynamic_zone.h" #include "client.h" #include "expedition.h" +#include "string_ids.h" #include "worldserver.h" #include "../common/eqemu_logsys.h" @@ -43,6 +44,11 @@ Database& DynamicZone::GetDatabase() return database; } +bool DynamicZone::SendServerPacket(ServerPacket* packet) +{ + return worldserver.SendPacket(packet); +} + uint16_t DynamicZone::GetCurrentInstanceID() { return zone ? static_cast(zone->GetInstanceID()) : 0; @@ -53,17 +59,119 @@ uint16_t DynamicZone::GetCurrentZoneID() return zone ? static_cast(zone->GetZoneID()) : 0; } +DynamicZone* DynamicZone::CreateNew(DynamicZone& dz_request, const std::vector& members) +{ + if (!zone || dz_request.GetID() != 0) + { + return nullptr; + } + + // this creates a new dz instance and saves it to both db and cache + uint32_t dz_id = dz_request.Create(); + if (dz_id == 0) + { + LogDynamicZones("Failed to create dynamic zone for zone [{}]", dz_request.GetZoneID()); + return nullptr; + } + + auto dz = std::make_unique(dz_request); + if (!members.empty()) + { + dz->SaveMembers(members); + } + + LogDynamicZones("Created new dz [{}] for zone [{}]", dz_id, dz_request.GetZoneID()); + + // world must be notified before we request async member updates + auto pack = dz->CreateServerDzCreatePacket(zone->GetZoneID(), zone->GetInstanceID()); + worldserver.SendPacket(pack.get()); + + auto inserted = zone->dynamic_zone_cache.emplace(dz_id, std::move(dz)); + + // expeditions invoke their own updates after installing client update callbacks + if (inserted.first->second->GetType() != DynamicZoneType::Expedition) + { + inserted.first->second->DoAsyncZoneMemberUpdates(); + } + + return inserted.first->second.get(); +} + +void DynamicZone::CacheNewDynamicZone(ServerPacket* pack) +{ + auto buf = reinterpret_cast(pack->pBuffer); + + // caching new dz created in world or another zone (has member statuses set by world) + auto dz = std::make_unique(); + dz->LoadSerializedDzPacket(buf->cereal_data, buf->cereal_size); + + uint32_t dz_id = dz->GetID(); + auto inserted = zone->dynamic_zone_cache.emplace(dz_id, std::move(dz)); + + // expeditions invoke their own updates after installing client update callbacks + if (inserted.first->second->GetType() != DynamicZoneType::Expedition) + { + inserted.first->second->DoAsyncZoneMemberUpdates(); + } + + LogDynamicZones("Cached new dynamic zone [{}]", dz_id); +} + +void DynamicZone::CacheAllFromDatabase() +{ + if (!zone) + { + return; + } + + BenchTimer bench; + + auto dynamic_zones = DynamicZonesRepository::AllWithInstanceNotExpired(database); + auto dynamic_zone_members = DynamicZoneMembersRepository::GetAllWithNames(database); + + zone->dynamic_zone_cache.clear(); + zone->dynamic_zone_cache.reserve(dynamic_zones.size()); + + for (auto& entry : dynamic_zones) + { + uint32_t dz_id = entry.id; + auto dz = std::make_unique(std::move(entry)); + + for (auto& member : dynamic_zone_members) + { + if (member.dynamic_zone_id == dz_id) + { + dz->AddMemberFromRepositoryResult(std::move(member)); + } + } + + zone->dynamic_zone_cache.emplace(dz_id, std::move(dz)); + } + + LogDynamicZones("Caching [{}] dynamic zone(s) took [{}s]", zone->dynamic_zone_cache.size(), bench.elapsed()); +} + DynamicZone* DynamicZone::FindDynamicZoneByID(uint32_t dz_id) { - auto expedition = Expedition::FindCachedExpeditionByDynamicZoneID(dz_id); - if (expedition) + if (!zone) { - return &expedition->GetDynamicZone(); + return nullptr; } - // todo: other system caches + + auto dz = zone->dynamic_zone_cache.find(dz_id); + if (dz != zone->dynamic_zone_cache.end()) + { + return dz->second.get(); + } + return nullptr; } +void DynamicZone::RegisterOnClientAddRemove(std::function on_client_addremove) +{ + m_on_client_addremove = std::move(on_client_addremove); +} + void DynamicZone::StartAllClientRemovalTimers() { for (const auto& client_iter : entity_list.GetClientList()) @@ -75,38 +183,6 @@ void DynamicZone::StartAllClientRemovalTimers() } } -void DynamicZone::SendInstanceRemoveAllCharacters() -{ - // just remove all clients in bulk instead of only characters assigned to the instance - if (IsCurrentZoneDzInstance()) - { - DynamicZone::StartAllClientRemovalTimers(); - } - else if (GetInstanceID() != 0) - { - auto pack = CreateServerRemoveAllCharactersPacket(); - worldserver.SendPacket(pack.get()); - } -} - -void DynamicZone::SendInstanceAddRemoveCharacter(uint32_t character_id, bool removed) -{ - // if removing, sets removal timer on client inside the instance - if (IsCurrentZoneDzInstance()) - { - Client* client = entity_list.GetClientByCharID(character_id); - if (client) - { - client->SetDzRemovalTimer(removed); - } - } - else if (GetInstanceID() != 0) - { - auto pack = CreateServerAddRemoveCharacterPacket(character_id, removed); - worldserver.SendPacket(pack.get()); - } -} - bool DynamicZone::IsCurrentZoneDzInstance() const { return (zone && zone->GetInstanceID() != 0 && zone->GetInstanceID() == GetInstanceID()); @@ -129,8 +205,8 @@ void DynamicZone::SetUpdatedDuration(uint32_t new_duration) m_duration = std::chrono::seconds(new_duration); m_expire_time = m_start_time + m_duration; - LogDynamicZones("Updated zone [{}]:[{}] seconds remaining: [{}]", - m_zone_id, m_instance_id, GetSecondsRemaining()); + LogDynamicZones("Updated dz [{}] zone [{}]:[{}] seconds remaining: [{}]", + m_id, m_zone_id, m_instance_id, GetSecondsRemaining()); if (zone && IsCurrentZoneDzInstance()) { @@ -138,31 +214,115 @@ void DynamicZone::SetUpdatedDuration(uint32_t new_duration) } } -void DynamicZone::SendGlobalLocationChange(uint16_t server_opcode, const DynamicZoneLocation& location) -{ - auto pack = CreateServerDzLocationPacket(server_opcode, location); - worldserver.SendPacket(pack.get()); -} - void DynamicZone::HandleWorldMessage(ServerPacket* pack) { switch (pack->opcode) { - case ServerOP_DzAddRemoveCharacter: + case ServerOP_DzCreated: { - auto buf = reinterpret_cast(pack->pBuffer); - Client* client = entity_list.GetClientByCharID(buf->character_id); - if (client) + auto buf = reinterpret_cast(pack->pBuffer); + if (zone && !zone->IsZone(buf->origin_zone_id, buf->origin_instance_id)) { - client->SetDzRemovalTimer(buf->remove); // instance kick timer + DynamicZone::CacheNewDynamicZone(pack); } break; } - case ServerOP_DzRemoveAllCharacters: + case ServerOP_DzDeleted: { - auto buf = reinterpret_cast(pack->pBuffer); - if (buf->remove) + // sent by world when it deletes an expired or empty dz + // any system that held a reference to the dz should have already been notified + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (zone && dz) { + dz->SendUpdatesToZoneMembers(true, true); // members silently removed + + // manually handle expeditions to remove any references before the dz is deleted + if (dz->GetType() == DynamicZoneType::Expedition) + { + auto expedition = Expedition::FindCachedExpeditionByDynamicZoneID(dz->GetID()); + if (expedition) + { + LogExpeditionsModerate("Deleting expedition [{}] from zone cache", expedition->GetID()); + zone->expedition_cache.erase(expedition->GetID()); + } + } + + LogDynamicZonesDetail("Deleting dynamic zone [{}] from zone cache", buf->dz_id); + zone->dynamic_zone_cache.erase(buf->dz_id); + } + break; + } + case ServerOP_DzAddRemoveMember: + { + auto buf = reinterpret_cast(pack->pBuffer); + if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) + { + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + auto status = static_cast(buf->character_status); + dz->ProcessMemberAddRemove({ buf->character_id, buf->character_name, status }, buf->removed); + } + } + + if (zone && zone->IsZone(buf->dz_zone_id, buf->dz_instance_id)) + { + // cache independent redundancy to kick removed members from dz's instance + Client* client = entity_list.GetClientByCharID(buf->character_id); + if (client) + { + client->SetDzRemovalTimer(buf->removed); + } + } + break; + } + case ServerOP_DzSwapMembers: + { + auto buf = reinterpret_cast(pack->pBuffer); + if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) + { + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + auto status = static_cast(buf->add_character_status); + dz->ProcessMemberAddRemove({ buf->remove_character_id, buf->remove_character_name }, true); + dz->ProcessMemberAddRemove({ buf->add_character_id, buf->add_character_name, status }, false); + } + } + + if (zone && zone->IsZone(buf->dz_zone_id, buf->dz_instance_id)) + { + // cache independent redundancy to kick removed members from dz's instance + Client* removed_client = entity_list.GetClientByCharID(buf->remove_character_id); + if (removed_client) + { + removed_client->SetDzRemovalTimer(true); + } + + Client* added_client = entity_list.GetClientByCharID(buf->add_character_id); + if (added_client) + { + added_client->SetDzRemovalTimer(false); + } + } + break; + } + case ServerOP_DzRemoveAllMembers: + { + auto buf = reinterpret_cast(pack->pBuffer); + if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) + { + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + dz->ProcessRemoveAllMembers(); + } + } + + if (zone && zone->IsZone(buf->dz_zone_id, buf->dz_instance_id)) + { + // cache independent redundancy to kick removed members from dz's instance DynamicZone::StartAllClientRemovalTimers(); } break; @@ -203,7 +363,140 @@ void DynamicZone::HandleWorldMessage(ServerPacket* pack) } break; } + case ServerOP_DzGetMemberStatuses: + { + // reply from world for online member statuses request for async zone member updates + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + for (uint32_t i = 0; i < buf->count; ++i) + { + auto status = static_cast(buf->entries[i].online_status); + dz->SetInternalMemberStatus(buf->entries[i].character_id, status); + } + dz->m_has_member_statuses = true; + dz->SendUpdatesToZoneMembers(false, true); + } + break; } + case ServerOP_DzUpdateMemberStatus: + { + auto buf = reinterpret_cast(pack->pBuffer); + if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) + { + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + auto status = static_cast(buf->status); + dz->ProcessMemberStatusChange(buf->character_id, status); + } + } + break; + } + case ServerOP_DzLeaderChanged: + { + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + dz->ProcessLeaderChanged(buf->leader_id); + } + break; + } + case ServerOP_DzExpireWarning: + { + auto buf = reinterpret_cast(pack->pBuffer); + auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id); + if (dz) + { + dz->SendMembersExpireWarning(buf->minutes_remaining); + } + break; + } + } +} + +std::unique_ptr DynamicZone::CreateExpireWarningPacket(uint32_t minutes_remaining) +{ + uint32_t outsize = sizeof(ExpeditionExpireWarning); + auto outapp = std::make_unique(OP_DzExpeditionEndsWarning, outsize); + auto buf = reinterpret_cast(outapp->pBuffer); + buf->minutes_remaining = minutes_remaining; + return outapp; +} + +std::unique_ptr DynamicZone::CreateInfoPacket(bool clear) +{ + constexpr uint32_t outsize = sizeof(DynamicZoneInfo_Struct); + auto outapp = std::make_unique(OP_DzExpeditionInfo, outsize); + if (!clear) + { + auto info = reinterpret_cast(outapp->pBuffer); + info->assigned = true; + strn0cpy(info->dz_name, m_name.c_str(), sizeof(info->dz_name)); + strn0cpy(info->leader_name, m_leader.name.c_str(), sizeof(info->leader_name)); + info->max_players = m_max_players; + } + return outapp; +} + +std::unique_ptr DynamicZone::CreateMemberListPacket(bool clear) +{ + uint32_t member_count = clear ? 0 : static_cast(m_members.size()); + uint32_t member_entries_size = sizeof(DynamicZoneMemberEntry_Struct) * member_count; + uint32_t outsize = sizeof(DynamicZoneMemberList_Struct) + member_entries_size; + auto outapp = std::make_unique(OP_DzMemberList, outsize); + auto buf = reinterpret_cast(outapp->pBuffer); + + buf->member_count = member_count; + + if (!clear) + { + for (auto i = 0; i < m_members.size(); ++i) + { + strn0cpy(buf->members[i].name, m_members[i].name.c_str(), sizeof(buf->members[i].name)); + buf->members[i].online_status = static_cast(m_members[i].status); + } + } + + return outapp; +} + +std::unique_ptr DynamicZone::CreateMemberListNamePacket( + const std::string& name, bool remove_name) +{ + constexpr uint32_t outsize = sizeof(DynamicZoneMemberListName_Struct); + auto outapp = std::make_unique(OP_DzMemberListName, outsize); + auto buf = reinterpret_cast(outapp->pBuffer); + buf->add_name = !remove_name; + strn0cpy(buf->name, name.c_str(), sizeof(buf->name)); + return outapp; +} + +std::unique_ptr DynamicZone::CreateMemberListStatusPacket( + const std::string& name, DynamicZoneMemberStatus status) +{ + // member list status uses member list struct with a single entry + constexpr uint32_t outsize = sizeof(DynamicZoneMemberList_Struct) + sizeof(DynamicZoneMemberEntry_Struct); + auto outapp = std::make_unique(OP_DzMemberListStatus, outsize); + auto buf = reinterpret_cast(outapp->pBuffer); + buf->member_count = 1; + + auto entry = static_cast(buf->members); + strn0cpy(entry->name, name.c_str(), sizeof(entry->name)); + entry->online_status = static_cast(status); + + return outapp; +} + +std::unique_ptr DynamicZone::CreateLeaderNamePacket() +{ + constexpr uint32_t outsize = sizeof(DynamicZoneLeaderName_Struct); + auto outapp = std::make_unique(OP_DzSetLeaderName, outsize); + auto buf = reinterpret_cast(outapp->pBuffer); + strn0cpy(buf->leader_name, m_leader.name.c_str(), sizeof(buf->leader_name)); + return outapp; } void DynamicZone::ProcessCompassChange(const DynamicZoneLocation& location) @@ -223,3 +516,264 @@ void DynamicZone::SendCompassUpdateToZoneMembers() } } } + +void DynamicZone::SendLeaderNameToZoneMembers() +{ + auto outapp_leader = CreateLeaderNamePacket(); + + for (const auto& member : m_members) + { + Client* member_client = entity_list.GetClientByCharID(member.id); + if (member_client) + { + member_client->QueuePacket(outapp_leader.get()); + + if (member.id == m_leader.id && RuleB(Expedition, AlwaysNotifyNewLeaderOnChange)) + { + member_client->MessageString(Chat::Yellow, DZMAKELEADER_YOU); + } + } + } +} + +void DynamicZone::SendMembersExpireWarning(uint32_t minutes_remaining) +{ + // expeditions warn members in all zones not just the dz + auto outapp = CreateExpireWarningPacket(minutes_remaining); + for (const auto& member : GetMembers()) + { + Client* member_client = entity_list.GetClientByCharID(member.id); + if (member_client) + { + member_client->QueuePacket(outapp.get()); + + // live doesn't actually send the chat message with it + member_client->MessageString(Chat::Yellow, EXPEDITION_MIN_REMAIN, + fmt::format_int(minutes_remaining).c_str()); + } + } +} + +void DynamicZone::SendMemberListToZoneMembers() +{ + auto outapp_members = CreateMemberListPacket(false); + + for (const auto& member : m_members) + { + Client* member_client = entity_list.GetClientByCharID(member.id); + if (member_client) + { + member_client->QueuePacket(outapp_members.get()); + } + } +} + +void DynamicZone::SendMemberListNameToZoneMembers(const std::string& char_name, bool remove) +{ + auto outapp_member_name = CreateMemberListNamePacket(char_name, remove); + + for (const auto& member : m_members) + { + Client* member_client = entity_list.GetClientByCharID(member.id); + if (member_client) + { + member_client->QueuePacket(outapp_member_name.get()); + } + } +} + +void DynamicZone::SendMemberListStatusToZoneMembers(const DynamicZoneMember& update_member) +{ + auto outapp_member_status = CreateMemberListStatusPacket(update_member.name, update_member.status); + + for (const auto& member : m_members) + { + Client* member_client = entity_list.GetClientByCharID(member.id); + if (member_client) + { + member_client->QueuePacket(outapp_member_status.get()); + } + } +} + +void DynamicZone::SendClientWindowUpdate(Client* client) +{ + if (client) + { + client->QueuePacket(CreateInfoPacket().get()); + client->QueuePacket(CreateMemberListPacket().get()); + } +} + +void DynamicZone::SendUpdatesToZoneMembers(bool removing_all, bool silent) +{ + // performs a full update on all members (usually for dz creation or removing all) + if (!HasMembers()) + { + return; + } + + std::unique_ptr outapp_info = nullptr; + std::unique_ptr outapp_members = nullptr; + + // only expeditions use the dz window. on live the window is filled by non + // expeditions when first created but never kept updated. that behavior could + // be replicated in the future by flagging this as a creation update + if (m_type == DynamicZoneType::Expedition) + { + // clearing info also clears member list, no need to send both when removing + outapp_info = CreateInfoPacket(removing_all); + outapp_members = removing_all ? nullptr : CreateMemberListPacket(); + } + + for (const auto& member : GetMembers()) + { + Client* client = entity_list.GetClientByCharID(member.id); + if (client) + { + if (removing_all) { + client->RemoveDynamicZoneID(GetID()); + } else { + client->AddDynamicZoneID(GetID()); + } + + client->SendDzCompassUpdate(); + + if (outapp_info) + { + client->QueuePacket(outapp_info.get()); + } + + if (outapp_members) + { + client->QueuePacket(outapp_members.get()); + } + + // callback to the dz system so it can perform any messages or set client data + if (m_on_client_addremove) + { + m_on_client_addremove(client, removing_all, silent); + } + } + } +} + +void DynamicZone::ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed) +{ + DynamicZoneBase::ProcessMemberAddRemove(member, removed); + + // the affected client always gets a full compass update. for expeditions + // client also gets window info update and all members get a member list update + Client* client = entity_list.GetClientByCharID(member.id); + if (client) + { + if (!removed) { + client->AddDynamicZoneID(GetID()); + } else { + client->RemoveDynamicZoneID(GetID()); + } + + client->SendDzCompassUpdate(); + + if (m_type == DynamicZoneType::Expedition) + { + // sending clear info also clears member list for removed members + client->QueuePacket(CreateInfoPacket(removed).get()); + } + + if (m_on_client_addremove) + { + m_on_client_addremove(client, removed, false); + } + } + + if (m_type == DynamicZoneType::Expedition) + { + // send full list when adding (MemberListName adds with "unknown" status) + if (!removed) { + SendMemberListToZoneMembers(); + } else { + SendMemberListNameToZoneMembers(member.name, true); + } + } +} + +void DynamicZone::ProcessRemoveAllMembers(bool silent) +{ + SendUpdatesToZoneMembers(true, silent); + DynamicZoneBase::ProcessRemoveAllMembers(silent); +} + +void DynamicZone::DoAsyncZoneMemberUpdates() +{ + // gets member statuses from world and performs zone member updates on reply + // if we've already received member statuses we can just update immediately + if (m_has_member_statuses) + { + SendUpdatesToZoneMembers(); + return; + } + + constexpr uint32_t pack_size = sizeof(ServerDzID_Struct); + auto pack = std::make_unique(ServerOP_DzGetMemberStatuses, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + buf->dz_id = GetID(); + buf->sender_zone_id = zone ? zone->GetZoneID() : 0; + buf->sender_instance_id = zone ? zone->GetInstanceID() : 0; + worldserver.SendPacket(pack.get()); +} + +bool DynamicZone::ProcessMemberStatusChange(uint32_t member_id, DynamicZoneMemberStatus status) +{ + bool changed = DynamicZoneBase::ProcessMemberStatusChange(member_id, status); + + if (changed && m_type == DynamicZoneType::Expedition) + { + auto member = GetMemberData(member_id); + if (member.IsValid()) + { + SendMemberListStatusToZoneMembers(member); + } + } + + return changed; +} + +void DynamicZone::ProcessLeaderChanged(uint32_t new_leader_id) +{ + auto new_leader = GetMemberData(new_leader_id); + if (!new_leader.IsValid()) + { + LogDynamicZones("Processed invalid new leader id [{}] for dz [{}]", new_leader_id, m_id); + return; + } + + LogDynamicZones("Replaced [{}] leader [{}] with [{}]", m_id, GetLeaderName(), new_leader.name); + + SetLeader(new_leader); + if (GetType() == DynamicZoneType::Expedition) + { + SendLeaderNameToZoneMembers(); + } +} + +bool DynamicZone::CanClientLootCorpse(Client* client, uint32_t npc_type_id, uint32_t entity_id) +{ + // non-members of a dz cannot loot corpses inside the dz + if (!HasMember(client->CharacterID())) + { + return false; + } + + // expeditions may prevent looting based on client's lockouts + if (GetType() == DynamicZoneType::Expedition) + { + auto expedition = Expedition::FindCachedExpeditionByZoneInstance(zone->GetZoneID(), zone->GetInstanceID()); + if (expedition && !expedition->CanClientLootCorpse(client, npc_type_id, entity_id)) + { + return false; + } + } + + return true; +} diff --git a/zone/dynamic_zone.h b/zone/dynamic_zone.h index a56947749..de23ce238 100644 --- a/zone/dynamic_zone.h +++ b/zone/dynamic_zone.h @@ -27,7 +27,9 @@ #include #include +class Client; class Database; +class EQApplicationPacket; class ServerPacket; extern const char* const CREATE_NOT_ALL_ADDED; @@ -40,26 +42,51 @@ public: DynamicZone() = default; DynamicZone(uint32_t zone_id, uint32_t version, uint32_t duration, DynamicZoneType type); + static void CacheAllFromDatabase(); + static void CacheNewDynamicZone(ServerPacket* pack); + static DynamicZone* CreateNew(DynamicZone& dz_details, const std::vector& members); static DynamicZone* FindDynamicZoneByID(uint32_t dz_id); static void HandleWorldMessage(ServerPacket* pack); void SetSecondsRemaining(uint32_t seconds_remaining) override; + void DoAsyncZoneMemberUpdates(); + bool CanClientLootCorpse(Client* client, uint32_t npc_type_id, uint32_t entity_id); bool IsCurrentZoneDzInstance() const; - void SetUpdatedDuration(uint32_t seconds); + void RegisterOnClientAddRemove(std::function on_client_addremove); + void SendClientWindowUpdate(Client* client); + void SendLeaderNameToZoneMembers(); + void SendMemberListToZoneMembers(); + void SendMemberListNameToZoneMembers(const std::string& char_name, bool remove); + void SendMemberListStatusToZoneMembers(const DynamicZoneMember& member); + void SendRemoveAllMembersToZoneMembers(bool silent) { ProcessRemoveAllMembers(silent); } + + std::unique_ptr CreateExpireWarningPacket(uint32_t minutes_remaining); + std::unique_ptr CreateInfoPacket(bool clear = false); + std::unique_ptr CreateLeaderNamePacket(); + std::unique_ptr CreateMemberListPacket(bool clear = false); + std::unique_ptr CreateMemberListNamePacket(const std::string& name, bool remove_name); + std::unique_ptr CreateMemberListStatusPacket(const std::string& name, DynamicZoneMemberStatus status); protected: uint16_t GetCurrentInstanceID() override; uint16_t GetCurrentZoneID() override; Database& GetDatabase() override; void ProcessCompassChange(const DynamicZoneLocation& location) override; - void SendInstanceAddRemoveCharacter(uint32_t character_id, bool remove) override; - void SendInstanceRemoveAllCharacters() override; - void SendGlobalLocationChange(uint16_t server_opcode, const DynamicZoneLocation& location) override; + void ProcessMemberAddRemove(const DynamicZoneMember& member, bool removed) override; + bool ProcessMemberStatusChange(uint32_t member_id, DynamicZoneMemberStatus status) override; + void ProcessRemoveAllMembers(bool silent = false) override; + bool SendServerPacket(ServerPacket* packet) override; private: static void StartAllClientRemovalTimers(); + void ProcessLeaderChanged(uint32_t new_leader_id); void SendCompassUpdateToZoneMembers(); + void SendMembersExpireWarning(uint32_t minutes); + void SendUpdatesToZoneMembers(bool removing_all = false, bool silent = true); + void SetUpdatedDuration(uint32_t seconds); + + std::function m_on_client_addremove; }; #endif diff --git a/zone/expedition.cpp b/zone/expedition.cpp index 728e036d0..8c1b50dfd 100644 --- a/zone/expedition.cpp +++ b/zone/expedition.cpp @@ -29,7 +29,6 @@ #include "../common/expedition_lockout_timer.h" #include "../common/repositories/dynamic_zone_members_repository.h" #include "../common/repositories/expedition_lockouts_repository.h" -#include "../common/util/uuid.h" extern WorldServer worldserver; extern Zone* zone; @@ -48,30 +47,44 @@ constexpr char LOCK_BEGIN[] = "The trial has begun. You cannot const int32_t Expedition::REPLAY_TIMER_ID = -1; const int32_t Expedition::EVENT_TIMER_ID = 1; -Expedition::Expedition( - uint32_t id, const std::string& uuid, DynamicZone&& dz, const std::string& expedition_name, - const DynamicZoneMember& leader -) : ExpeditionBase(id, uuid, expedition_name, leader) +Expedition::Expedition(DynamicZone* dz, uint32_t id, uint32_t dz_id) : + m_dynamic_zone(dz), + m_id(id), + m_dynamic_zone_id(dz_id) { - SetDynamicZone(std::move(dz)); + assert(m_dynamic_zone != nullptr); // dz must remain valid for lifetime of expedition } -void Expedition::SetDynamicZone(DynamicZone&& dz) +void Expedition::LoadRepositoryResult(const ExpeditionsRepository::Expeditions& entry) { - dz.SetName(GetName()); - dz.SetLeader(GetLeader()); - - m_dynamiczone = std::move(dz); + m_id = entry.id; + m_dynamic_zone_id = entry.dynamic_zone_id; + m_add_replay_on_join = entry.add_replay_on_join; + m_is_locked = entry.is_locked; } -Expedition* Expedition::TryCreate( - Client* requester, DynamicZone& dynamiczone, ExpeditionRequest& request) +void Expedition::RegisterDynamicZoneCallbacks() +{ + uint32_t expedition_id = GetID(); + + GetDynamicZone()->RegisterOnClientAddRemove( + [expedition_id](Client* client, bool removed, bool silent) { + auto expedition = Expedition::FindCachedExpeditionByID(expedition_id); + if (expedition) { + expedition->OnClientAddRemove(client, removed, silent); + } + }); +} + +Expedition* Expedition::TryCreate(Client* requester, DynamicZone& dz_request, bool disable_messages) { if (!requester || !zone) { return nullptr; } + ExpeditionRequest request{ dz_request, disable_messages }; + // request parses leader, members list, and lockouts while validating if (!request.Validate(requester)) { @@ -79,11 +92,10 @@ Expedition* Expedition::TryCreate( return nullptr; } - dynamiczone.SetMinPlayers(request.GetMinPlayers()); - dynamiczone.SetMaxPlayers(request.GetMaxPlayers()); + dz_request.SetLeader({ request.GetLeaderID(), request.GetLeaderName(), DynamicZoneMemberStatus::Online }); - auto dynamic_zone_id = dynamiczone.Create(); - if (dynamic_zone_id == 0) + auto dz = DynamicZone::CreateNew(dz_request, request.GetMembers()); + if (!dz) { // live uses this message when trying to enter an instance that isn't ready // we can use it as the client error message if instance creation fails @@ -92,44 +104,29 @@ Expedition* Expedition::TryCreate( return nullptr; } - std::string expedition_uuid = EQ::Util::UUID::Generate().ToString(); - // unique expedition ids are created from database via auto-increment column - auto expedition_id = ExpeditionDatabase::InsertExpedition( - expedition_uuid, - dynamiczone.GetID(), - request.GetExpeditionName(), - request.GetLeaderID(), - request.GetMinPlayers(), - request.GetMaxPlayers() - ); + auto expedition_id = ExpeditionDatabase::InsertExpedition(dz->GetID()); if (expedition_id) { - auto expedition = std::make_unique( - expedition_id, - expedition_uuid, - std::move(dynamiczone), - request.GetExpeditionName(), - DynamicZoneMember{ request.GetLeaderID(), request.GetLeaderName() } - ); + auto expedition = std::make_unique(dz, expedition_id, dz->GetID()); LogExpeditions( - "Created [{}] [{}] instance id: [{}] leader: [{}] minplayers: [{}] maxplayers: [{}]", + "Created [{}] [{}] dz: [{}] instance id: [{}] leader: [{}] minplayers: [{}] maxplayers: [{}]", expedition->GetID(), expedition->GetName(), - expedition->GetDynamicZone().GetInstanceID(), + dz->GetID(), + dz->GetInstanceID(), expedition->GetLeaderName(), - expedition->GetDynamicZone().GetMinPlayers(), - expedition->GetDynamicZone().GetMaxPlayers() + dz->GetMinPlayers(), + dz->GetMaxPlayers() ); - expedition->GetDynamicZone().SaveMembers(request.GetMembers()); expedition->SaveLockouts(request); + expedition->RegisterDynamicZoneCallbacks(); auto inserted = zone->expedition_cache.emplace(expedition_id, std::move(expedition)); - inserted.first->second->SendUpdatesToZoneMembers(); inserted.first->second->SendWorldExpeditionUpdate(ServerOP_ExpeditionCreate); // cache in other zones inserted.first->second->SendLeaderMessage(request.GetLeaderClient(), Chat::System, EXPEDITION_AVAILABLE, { request.GetExpeditionName() }); @@ -140,6 +137,8 @@ Expedition* Expedition::TryCreate( Chat::System, request.GetNotAllAddedMessage()); } + dz->DoAsyncZoneMemberUpdates(); + return inserted.first->second.get(); } @@ -147,48 +146,36 @@ Expedition* Expedition::TryCreate( } void Expedition::CacheExpeditions( - std::vector&& expedition_entries) + std::vector&& expedition_entries) { if (!zone) { return; } - // bulk load expedition dzs, members, and internal lockouts before caching + // bulk load expedition internal lockouts before caching std::vector expedition_ids; - std::vector dynamic_zone_ids; for (const auto& entry : expedition_entries) { expedition_ids.emplace_back(entry.id); - dynamic_zone_ids.emplace_back(entry.dynamic_zone_id); } - auto dynamic_zones = DynamicZonesRepository::GetWithInstance(database, dynamic_zone_ids); - auto dynamic_zone_members = DynamicZoneMembersRepository::GetWithNames(database, dynamic_zone_ids); + // todo: lockouts need be moved to dynamic zone auto expedition_lockouts = ExpeditionLockoutsRepository::GetWithTimestamp(database, expedition_ids); for (auto& entry : expedition_entries) { - auto expedition = std::make_unique(); - expedition->LoadRepositoryResult(std::move(entry)); - - auto dz_entry_iter = std::find_if(dynamic_zones.begin(), dynamic_zones.end(), - [&](const DynamicZonesRepository::DynamicZoneInstance& dz_entry) { - return dz_entry.id == entry.dynamic_zone_id; - }); - - if (dz_entry_iter != dynamic_zones.end()) + // the expedition's dynamic zone and members should already be in cache + auto dynamic_zone = DynamicZone::FindDynamicZoneByID(entry.dynamic_zone_id); + if (!dynamic_zone) { - expedition->SetDynamicZone(std::move(*dz_entry_iter)); + LogExpeditions("[Warning] Expedition [{}] dz [{}] not found during caching", entry.id, entry.dynamic_zone_id); + continue; } - for (auto& member : dynamic_zone_members) - { - if (member.dynamic_zone_id == entry.dynamic_zone_id) - { - expedition->GetDynamicZone().AddMemberFromRepositoryResult(std::move(member)); - } - } + auto expedition = std::make_unique(dynamic_zone); + expedition->LoadRepositoryResult(entry); + expedition->RegisterDynamicZoneCallbacks(); for (auto& lockout_entry : expedition_lockouts) { @@ -207,14 +194,8 @@ void Expedition::CacheExpeditions( } } - // stored on expedition in db but on dz in memory cache - expedition->GetDynamicZone().SetMinPlayers(entry.min_players); - expedition->GetDynamicZone().SetMaxPlayers(entry.max_players); - - expedition->SendWorldExpeditionUpdate(ServerOP_ExpeditionGetMemberStatuses); - - auto inserted = zone->expedition_cache.emplace(entry.id, std::move(expedition)); - inserted.first->second->SendUpdatesToZoneMembers(); + zone->expedition_cache.emplace(entry.id, std::move(expedition)); + dynamic_zone->DoAsyncZoneMemberUpdates(); } } @@ -224,7 +205,7 @@ void Expedition::CacheFromDatabase(uint32_t expedition_id) { BenchTimer benchmark; - auto expedition = ExpeditionsRepository::GetWithLeaderName(database, expedition_id); + auto expedition = ExpeditionsRepository::GetWhere(database, fmt::format("id = {}", expedition_id)); CacheExpeditions({ std::move(expedition) }); LogExpeditions("Caching new expedition [{}] took [{}s]", expedition_id, benchmark.elapsed()); @@ -240,7 +221,7 @@ bool Expedition::CacheAllFromDatabase() BenchTimer benchmark; - auto expeditions = ExpeditionsRepository::GetAllWithLeaderName(database); + auto expeditions = ExpeditionsRepository::All(database); zone->expedition_cache.clear(); zone->expedition_cache.reserve(expeditions.size()); @@ -263,7 +244,8 @@ Expedition* Expedition::FindCachedExpeditionByCharacterID(uint32_t character_id) { for (const auto& expedition : zone->expedition_cache) { - if (expedition.second->GetDynamicZone().HasMember(character_id)) + auto expedition_dz = expedition.second->GetDynamicZone(); + if (expedition_dz && expedition_dz->HasMember(character_id)) { return expedition.second.get(); } @@ -278,7 +260,8 @@ Expedition* Expedition::FindCachedExpeditionByCharacterName(const std::string& c { for (const auto& expedition : zone->expedition_cache) { - if (expedition.second->GetDynamicZone().HasMember(char_name)) + auto expedition_dz = expedition.second->GetDynamicZone(); + if (expedition_dz && expedition_dz->HasMember(char_name)) { return expedition.second.get(); } @@ -293,7 +276,7 @@ Expedition* Expedition::FindCachedExpeditionByDynamicZoneID(uint32_t dz_id) { for (const auto& cached_expedition : zone->expedition_cache) { - if (cached_expedition.second->GetDynamicZone().GetID() == dz_id) + if (cached_expedition.second->GetDynamicZoneID() == dz_id) { return cached_expedition.second.get(); } @@ -321,8 +304,8 @@ Expedition* Expedition::FindCachedExpeditionByZoneInstance(uint32_t zone_id, uin { for (const auto& cached_expedition : zone->expedition_cache) { - if (cached_expedition.second->GetDynamicZone().GetZoneID() == zone_id && - cached_expedition.second->GetDynamicZone().GetInstanceID() == instance_id) + auto expedition_dz = cached_expedition.second->GetDynamicZone(); + if (expedition_dz && expedition_dz->IsSameDz(zone_id, instance_id)) { return cached_expedition.second.get(); } @@ -359,7 +342,8 @@ void Expedition::AddReplayLockout(uint32_t seconds) void Expedition::AddLockout(const std::string& event_name, uint32_t seconds) { - auto lockout = ExpeditionLockoutTimer::CreateLockout(m_expedition_name, event_name, seconds, m_uuid); + auto lockout = ExpeditionLockoutTimer::CreateLockout(GetName(), + event_name, seconds, GetDynamicZone()->GetUUID()); AddLockout(lockout); } @@ -369,7 +353,7 @@ void Expedition::AddLockout(const ExpeditionLockoutTimer& lockout, bool members_ { ExpeditionDatabase::InsertLockout(m_id, lockout); } - ExpeditionDatabase::InsertMembersLockout(GetDynamicZone().GetMembers(), lockout); + ExpeditionDatabase::InsertMembersLockout(GetDynamicZone()->GetMembers(), lockout); ProcessLockoutUpdate(lockout, false, members_only); SendWorldLockoutUpdate(lockout, false, members_only); @@ -379,8 +363,8 @@ void Expedition::AddLockoutDuration(const std::string& event_name, int seconds, { // lockout timers use unsigned durations to define intent but we may need // to insert a new lockout while still supporting timer reductions - auto lockout = ExpeditionLockoutTimer::CreateLockout( - m_expedition_name, event_name, std::max(0, seconds), m_uuid); + auto lockout = ExpeditionLockoutTimer::CreateLockout(GetName(), + event_name, std::max(0, seconds), GetDynamicZone()->GetUUID()); if (!members_only) { @@ -399,7 +383,7 @@ void Expedition::AddLockoutDuration(const std::string& event_name, int seconds, // processing lockout duration applies multiplier again in client methods, // update database with modified value now but pass original on int modified_seconds = static_cast(seconds * RuleR(Expedition, LockoutDurationMultiplier)); - ExpeditionDatabase::AddLockoutDuration(GetDynamicZone().GetMembers(), lockout, modified_seconds); + ExpeditionDatabase::AddLockoutDuration(GetDynamicZone()->GetMembers(), lockout, modified_seconds); ProcessLockoutDuration(lockout, seconds, members_only); SendWorldLockoutDuration(lockout, seconds, members_only); @@ -420,117 +404,20 @@ void Expedition::UpdateLockoutDuration( seconds = static_cast(seconds * RuleR(Expedition, LockoutDurationMultiplier)); uint64_t expire_time = it->second.GetStartTime() + seconds; - AddLockout({ m_uuid, m_expedition_name, event_name, expire_time, seconds }, members_only); + AddLockout({ GetDynamicZone()->GetUUID(), GetName(), event_name, expire_time, seconds }, members_only); } } void Expedition::RemoveLockout(const std::string& event_name) { ExpeditionDatabase::DeleteLockout(m_id, event_name); - ExpeditionDatabase::DeleteMembersLockout(GetDynamicZone().GetMembers(), m_expedition_name, event_name); + ExpeditionDatabase::DeleteMembersLockout(GetDynamicZone()->GetMembers(), GetName(), event_name); - ExpeditionLockoutTimer lockout{m_uuid, m_expedition_name, event_name, 0, 0}; + ExpeditionLockoutTimer lockout{GetDynamicZone()->GetUUID(), GetName(), event_name, 0, 0}; ProcessLockoutUpdate(lockout, true); SendWorldLockoutUpdate(lockout, true); } -bool Expedition::AddMember(const std::string& add_char_name, uint32_t add_char_id) -{ - if (GetDynamicZone().HasMember(add_char_id)) - { - return false; - } - - m_dynamiczone.AddCharacter(add_char_id); - - ProcessMemberAdded(add_char_name, add_char_id); - SendWorldMemberChanged(add_char_name, add_char_id, false); - - return true; -} - -void Expedition::RemoveAllMembers(bool enable_removal_timers) -{ - m_dynamiczone.RemoveAllCharacters(enable_removal_timers); - - SendUpdatesToZoneMembers(true); - SendWorldExpeditionUpdate(ServerOP_ExpeditionMembersRemoved); - - GetDynamicZone().ClearInternalMembers(); -} - -bool Expedition::RemoveMember(const std::string& remove_char_name) -{ - auto member = GetDynamicZone().GetMemberData(remove_char_name); - if (!member.IsValid()) - { - return false; - } - - m_dynamiczone.RemoveCharacter(member.id); - - ProcessMemberRemoved(member.name, member.id); - SendWorldMemberChanged(member.name, member.id, true); - - return true; -} - -void Expedition::SwapMember(Client* add_client, const std::string& remove_char_name) -{ - if (!add_client || remove_char_name.empty()) - { - return; - } - - auto member = GetDynamicZone().GetMemberData(remove_char_name); - if (!member.IsValid()) - { - return; - } - - // make remove and add atomic to avoid racing with separate world messages - m_dynamiczone.RemoveCharacter(member.id); - m_dynamiczone.AddCharacter(add_client->CharacterID()); - - ProcessMemberRemoved(member.name, member.id); - ProcessMemberAdded(add_client->GetName(), add_client->CharacterID()); - SendWorldMemberSwapped(member.name, member.id, add_client->GetName(), add_client->CharacterID()); -} - -void Expedition::SetMemberStatus(Client* client, DynamicZoneMemberStatus status) -{ - if (client) - { - SendMemberStatusToZoneMembers(client->CharacterID(), status); - SendWorldMemberStatus(client->CharacterID(), status); - } -} - -void Expedition::SendMemberStatusToZoneMembers(uint32_t update_member_id, DynamicZoneMemberStatus status) -{ - auto member_data = GetDynamicZone().GetMemberData(update_member_id); - if (!member_data.IsValid()) - { - return; - } - - // if zone already had this member status cached avoid packet update to clients - bool changed = GetDynamicZone().SetInternalMemberStatus(update_member_id, status); - if (changed) - { - member_data = GetDynamicZone().GetMemberData(update_member_id); // rules may override status - auto outapp_member_status = CreateMemberListStatusPacket(member_data.name, member_data.status); - for (auto& member : GetDynamicZone().GetMembers()) - { - Client* member_client = entity_list.GetClientByCharID(member.id); - if (member_client) - { - member_client->QueuePacket(outapp_member_status.get()); - } - } - } -} - void Expedition::SendClientExpeditionInvite( Client* client, const std::string& inviter_name, const std::string& swap_remove_name) { @@ -547,7 +434,7 @@ void Expedition::SendClientExpeditionInvite( client->SetPendingExpeditionInvite({ m_id, inviter_name, swap_remove_name }); client->MessageString(Chat::System, EXPEDITION_ASKED_TO_JOIN, - m_leader.name.c_str(), m_expedition_name.c_str()); + GetLeaderName().c_str(), GetName().c_str()); // live (as of March 11 2020 patch) sends warnings for lockouts added // during current expedition that client would receive on entering dz @@ -556,12 +443,13 @@ void Expedition::SendClientExpeditionInvite( { // live doesn't issue a warning for the dz's replay timer const ExpeditionLockoutTimer& lockout = lockout_iter.second; - if (!lockout.IsReplayTimer() && !lockout.IsExpired() && lockout.IsFromExpedition(m_uuid) && - !client->HasExpeditionLockout(m_expedition_name, lockout.GetEventName())) + if (!lockout.IsReplayTimer() && !lockout.IsExpired() && + lockout.IsFromExpedition(GetDynamicZone()->GetUUID()) && + !client->HasExpeditionLockout(GetName(), lockout.GetEventName())) { if (!warned) { - client->Message(Chat::System, DZADD_INVITE_WARNING, m_expedition_name.c_str()); + client->Message(Chat::System, DZADD_INVITE_WARNING, GetName().c_str()); warned = true; } @@ -583,7 +471,7 @@ void Expedition::SendClientExpeditionInvite( void Expedition::SendLeaderMessage( Client* leader_client, uint16_t chat_type, uint32_t string_id, const std::initializer_list& args) { - Client::SendCrossZoneMessageString(leader_client, m_leader.name, chat_type, string_id, args); + Client::SendCrossZoneMessageString(leader_client, GetLeaderName(), chat_type, string_id, args); } bool Expedition::ProcessAddConflicts(Client* leader_client, Client* add_client, bool swapping) @@ -595,7 +483,7 @@ bool Expedition::ProcessAddConflicts(Client* leader_client, Client* add_client, bool has_conflict = false; - if (m_dynamiczone.IsCurrentZoneDzInstance()) + if (GetDynamicZone()->IsCurrentZoneDzInstance()) { SendLeaderMessage(leader_client, Chat::Red, DZADD_LEAVE_ZONE_FIRST, { add_client->GetName() }); has_conflict = true; @@ -610,13 +498,13 @@ bool Expedition::ProcessAddConflicts(Client* leader_client, Client* add_client, } // check any extra event lockouts for this expedition that the client has and expedition doesn't - auto client_lockouts = add_client->GetExpeditionLockouts(m_expedition_name); + auto client_lockouts = add_client->GetExpeditionLockouts(GetName()); for (const auto& client_lockout : client_lockouts) { if (client_lockout.IsReplayTimer()) { // client with a replay lockout is allowed only if the replay timer was from this expedition - if (client_lockout.GetExpeditionUUID() != GetUUID()) + if (client_lockout.GetExpeditionUUID() != GetDynamicZone()->GetUUID()) { has_conflict = true; @@ -652,15 +540,15 @@ bool Expedition::ProcessAddConflicts(Client* leader_client, Client* add_client, // member swapping integrity is handled by invite response if (!swapping) { - auto member_count = GetDynamicZone().GetDatabaseMemberCount(); + auto member_count = GetDynamicZone()->GetDatabaseMemberCount(); if (member_count == 0) { has_conflict = true; } - else if (member_count >= GetDynamicZone().GetMaxPlayers()) + else if (member_count >= GetDynamicZone()->GetMaxPlayers()) { SendLeaderMessage(leader_client, Chat::Red, DZADD_EXCEED_MAX, { - fmt::format_int(GetDynamicZone().GetMaxPlayers()).str() }); + fmt::format_int(GetDynamicZone()->GetMaxPlayers()).str() }); has_conflict = true; } } @@ -683,14 +571,12 @@ void Expedition::DzInviteResponse(Client* add_client, bool accepted, const std:: return; } - LogExpeditionsModerate( - "Invite response by [{}] accepted [{}] swap_name [{}]", - add_client->GetName(), accepted, swap_remove_name - ); + LogExpeditionsModerate("Invite response by [{}] accepted [{}] swap_name [{}]", + add_client->GetName(), accepted, swap_remove_name); // a null leader_client is handled by SendLeaderMessage fallbacks // note current leader receives invite reply messages (if leader changed) - Client* leader_client = entity_list.GetClientByCharID(m_leader.id); + Client* leader_client = entity_list.GetClientByCharID(GetLeaderID()); if (!accepted) { @@ -713,8 +599,8 @@ void Expedition::DzInviteResponse(Client* add_client, bool accepted, const std:: // error if swapping and character was already removed before the accept if (was_swap_invite) { - auto swap_member = GetDynamicZone().GetMemberData(swap_remove_name); - if (!swap_member.IsValid() || !GetDynamicZone().HasDatabaseMember(swap_member.id)) + auto swap_member = GetDynamicZone()->GetMemberData(swap_remove_name); + if (!swap_member.IsValid() || !GetDynamicZone()->HasDatabaseMember(swap_member.id)) { has_conflicts = true; } @@ -733,8 +619,8 @@ void Expedition::DzInviteResponse(Client* add_client, bool accepted, const std:: { auto replay_lockout = m_lockouts.find(DZ_REPLAY_TIMER_NAME); if (replay_lockout != m_lockouts.end() && - replay_lockout->second.IsFromExpedition(m_uuid) && - !add_client->HasExpeditionLockout(m_expedition_name, DZ_REPLAY_TIMER_NAME)) + replay_lockout->second.IsFromExpedition(GetDynamicZone()->GetUUID()) && + !add_client->HasExpeditionLockout(GetName(), DZ_REPLAY_TIMER_NAME)) { ExpeditionLockoutTimer replay_timer = replay_lockout->second; // copy replay_timer.Reset(); @@ -742,13 +628,20 @@ void Expedition::DzInviteResponse(Client* add_client, bool accepted, const std:: } } - if (was_swap_invite) - { - SwapMember(add_client, swap_remove_name); + auto status = DynamicZoneMemberStatus::Online; + DynamicZoneMember add_member{ add_client->CharacterID(), add_client->GetName(), status }; + + bool success = false; + if (was_swap_invite) { + success = GetDynamicZone()->SwapMember(add_member, swap_remove_name); + } else { + success = GetDynamicZone()->AddMember(add_member); } - else + + if (success) { - AddMember(add_client->GetName(), add_client->CharacterID()); + SendLeaderMessage(leader_client, Chat::Yellow, EXPEDITION_MEMBER_ADDED, + { add_client->GetName(), GetName().c_str() }); } } } @@ -760,15 +653,15 @@ bool Expedition::ConfirmLeaderCommand(Client* requester) return false; } - if (!m_leader.IsValid()) + if (!GetLeader().IsValid()) { requester->MessageString(Chat::Red, UNABLE_RETRIEVE_LEADER); // unconfirmed message return false; } - if (m_leader.id != requester->CharacterID()) + if (GetLeaderID() != requester->CharacterID()) { - requester->MessageString(Chat::System, EXPEDITION_NOT_LEADER, m_leader.name.c_str()); + requester->MessageString(Chat::System, EXPEDITION_NOT_LEADER, GetLeaderName().c_str()); return false; } @@ -831,7 +724,7 @@ void Expedition::DzAddPlayer( } else { - auto member_data = GetDynamicZone().GetMemberData(add_char_name); + auto member_data = GetDynamicZone()->GetMemberData(add_char_name); if (member_data.IsValid()) { // live prioritizes offline message before already a member message @@ -902,14 +795,16 @@ void Expedition::DzRemovePlayer(Client* requester, std::string char_name) } // live only seems to enforce min_players for requesting expeditions, no need to check here - bool removed = RemoveMember(char_name); + // note: on live members removed when inside a dz instance remain "temporary" + // members for kick timer duration and still receive lockouts across zones (unimplemented) + bool removed = GetDynamicZone()->RemoveMember(char_name); if (!removed) { requester->MessageString(Chat::Red, EXPEDITION_NOT_MEMBER, FormatName(char_name).c_str()); } else { - requester->MessageString(Chat::Yellow, EXPEDITION_REMOVED, FormatName(char_name).c_str(), m_expedition_name.c_str()); + requester->MessageString(Chat::Yellow, EXPEDITION_REMOVED, FormatName(char_name).c_str(), GetName().c_str()); } } @@ -917,7 +812,7 @@ void Expedition::DzQuit(Client* requester) { if (requester) { - RemoveMember(requester->GetName()); + GetDynamicZone()->RemoveMember(requester->GetName()); } } @@ -929,7 +824,7 @@ void Expedition::DzSwapPlayer( return; } - if (remove_char_name.empty() || !GetDynamicZone().HasMember(remove_char_name)) + if (remove_char_name.empty() || !GetDynamicZone()->HasMember(remove_char_name)) { requester->MessageString(Chat::Red, DZSWAP_CANNOT_REMOVE, FormatName(remove_char_name).c_str()); return; @@ -942,10 +837,10 @@ void Expedition::DzPlayerList(Client* requester) { if (requester) { - requester->MessageString(Chat::Yellow, EXPEDITION_LEADER, m_leader.name.c_str()); + requester->MessageString(Chat::Yellow, EXPEDITION_LEADER, GetLeaderName().c_str()); std::string member_names; - for (const auto& member : GetDynamicZone().GetMembers()) + for (const auto& member : GetDynamicZone()->GetMembers()) { fmt::format_to(std::back_inserter(member_names), "{}, ", member.name); } @@ -966,8 +861,8 @@ void Expedition::DzKickPlayers(Client* requester) return; } - RemoveAllMembers(); - requester->MessageString(Chat::Red, EXPEDITION_REMOVED, "Everyone", m_expedition_name.c_str()); + GetDynamicZone()->RemoveAllMembers(); + requester->MessageString(Chat::Red, EXPEDITION_REMOVED, "Everyone", GetName().c_str()); } void Expedition::SetLocked( @@ -975,7 +870,7 @@ void Expedition::SetLocked( { m_is_locked = lock_expedition; - if (m_is_locked && lock_msg != ExpeditionLockMessage::None && m_dynamiczone.IsCurrentZoneDzInstance()) + if (m_is_locked && lock_msg != ExpeditionLockMessage::None && GetDynamicZone()->IsCurrentZoneDzInstance()) { auto msg = (lock_msg == ExpeditionLockMessage::Close) ? LOCK_CLOSE : LOCK_BEGIN; for (const auto& client_iter : entity_list.GetClientList()) @@ -994,123 +889,20 @@ void Expedition::SetLocked( } } -void Expedition::ProcessLeaderChanged(uint32_t new_leader_id) +void Expedition::OnClientAddRemove(Client* client, bool removed, bool silent) { - auto new_leader = GetDynamicZone().GetMemberData(new_leader_id); - if (!new_leader.IsValid()) + if (client) { - LogExpeditions("Processed invalid new leader id [{}] for expedition [{}]", new_leader_id, m_id); - return; - } + client->SetExpeditionID(removed ? 0 : GetID()); - LogExpeditionsModerate("Replaced [{}] leader [{}] with [{}]", m_id, m_leader.name, new_leader.name); - - m_leader = new_leader; - m_dynamiczone.SetLeader(m_leader); - - // update each client's expedition window in this zone - auto outapp_leader = CreateLeaderNamePacket(); - for (const auto& member : GetDynamicZone().GetMembers()) - { - Client* member_client = entity_list.GetClientByCharID(member.id); - if (member_client) + if (!silent) { - member_client->QueuePacket(outapp_leader.get()); - - if (member.id == new_leader_id && RuleB(Expedition, AlwaysNotifyNewLeaderOnChange)) - { - member_client->MessageString(Chat::Yellow, DZMAKELEADER_YOU); - } + auto string_id = removed ? EXPEDITION_REMOVED : EXPEDITION_MEMBER_ADDED; + client->MessageString(Chat::Yellow, string_id, client->GetCleanName(), GetName().c_str()); } } } -void Expedition::ProcessMakeLeader(Client* old_leader_client, Client* new_leader_client, - const std::string& new_leader_name, bool is_success, bool is_online) -{ - if (old_leader_client) - { - // success flag is set by world to indicate new leader set to an online member - if (is_success) - { - old_leader_client->MessageString(Chat::Yellow, DZMAKELEADER_NAME, new_leader_name.c_str()); - } - else if (!is_online) - { - old_leader_client->MessageString(Chat::Red, DZMAKELEADER_NOT_ONLINE, new_leader_name.c_str()); - } - else - { - old_leader_client->MessageString(Chat::Red, EXPEDITION_NOT_MEMBER, new_leader_name.c_str()); - } - } - - if (is_success && new_leader_client && !RuleB(Expedition, AlwaysNotifyNewLeaderOnChange)) - { - new_leader_client->MessageString(Chat::Yellow, DZMAKELEADER_YOU); - } -} - -void Expedition::ProcessMemberAdded(const std::string& char_name, uint32_t added_char_id) -{ - GetDynamicZone().AddInternalMember({ added_char_id, char_name, DynamicZoneMemberStatus::Online }); - - // adds the member to this expedition and notifies both leader and new member - Client* leader_client = entity_list.GetClientByCharID(m_leader.id); - if (leader_client) - { - leader_client->MessageString(Chat::Yellow, EXPEDITION_MEMBER_ADDED, char_name.c_str(), m_expedition_name.c_str()); - } - - Client* member_client = entity_list.GetClientByCharID(added_char_id); - if (member_client) - { - member_client->SetExpeditionID(GetID()); - member_client->SendDzCompassUpdate(); - member_client->QueuePacket(CreateInfoPacket().get()); - member_client->MessageString(Chat::Yellow, EXPEDITION_MEMBER_ADDED, char_name.c_str(), m_expedition_name.c_str()); - } - - SendMemberListToZoneMembers(); -} - -void Expedition::ProcessMemberRemoved(const std::string& removed_char_name, uint32_t removed_char_id) -{ - if (GetDynamicZone().GetMembers().empty()) - { - return; - } - - auto outapp_member_name = CreateMemberListNamePacket(removed_char_name, true); - - for (const auto& member : GetDynamicZone().GetMembers()) - { - Client* member_client = entity_list.GetClientByCharID(member.id); - if (member_client) - { - // all members receive the removed player name packet - member_client->QueuePacket(outapp_member_name.get()); - - if (member.id == removed_char_id) - { - // live doesn't clear expedition info on clients removed while inside dz. - // it instead let's the dz kick timer do it even if character zones out - // before it triggers. for simplicity we'll always clear immediately - member_client->SetExpeditionID(0); - member_client->SendDzCompassUpdate(); - member_client->QueuePacket(CreateInfoPacket(true).get()); - member_client->MessageString(Chat::Yellow, EXPEDITION_REMOVED, - member.name.c_str(), m_expedition_name.c_str()); - } - } - } - - GetDynamicZone().RemoveInternalMember(removed_char_id); - - LogExpeditionsDetail("Processed member [{}] ({}) removal from [{}], cache member count: [{}]", - removed_char_name, removed_char_id, m_id, GetDynamicZone().GetMemberCount()); -} - void Expedition::ProcessLockoutDuration( const ExpeditionLockoutTimer& lockout, int seconds, bool members_only) { @@ -1127,17 +919,17 @@ void Expedition::ProcessLockoutDuration( } } - for (const auto& member : GetDynamicZone().GetMembers()) + for (const auto& member : GetDynamicZone()->GetMembers()) { Client* member_client = entity_list.GetClientByCharID(member.id); if (member_client) { - member_client->AddExpeditionLockoutDuration(m_expedition_name, - lockout.GetEventName(), seconds, m_uuid); + member_client->AddExpeditionLockoutDuration(GetName(), + lockout.GetEventName(), seconds, GetDynamicZone()->GetUUID()); } } - if (m_dynamiczone.IsCurrentZoneDzInstance()) + if (GetDynamicZone()->IsCurrentZoneDzInstance()) { AddLockoutDurationClients(lockout, seconds, GetID()); } @@ -1153,8 +945,8 @@ void Expedition::AddLockoutDurationClients( if (client && (exclude_id == 0 || client->GetExpeditionID() != exclude_id)) { lockout_clients.emplace_back(client->CharacterID(), client->GetName()); - client->AddExpeditionLockoutDuration(m_expedition_name, - lockout.GetEventName(), seconds, m_uuid); + client->AddExpeditionLockoutDuration(GetName(), + lockout.GetEventName(), seconds, GetDynamicZone()->GetUUID()); } } @@ -1180,7 +972,7 @@ void Expedition::ProcessLockoutUpdate( } } - for (const auto& member : GetDynamicZone().GetMembers()) + for (const auto& member : GetDynamicZone()->GetMembers()) { Client* member_client = entity_list.GetClientByCharID(member.id); if (member_client) @@ -1191,7 +983,7 @@ void Expedition::ProcessLockoutUpdate( } else { - member_client->RemoveExpeditionLockout(m_expedition_name, lockout.GetEventName()); + member_client->RemoveExpeditionLockout(GetName(), lockout.GetEventName()); } } } @@ -1199,7 +991,7 @@ void Expedition::ProcessLockoutUpdate( // if this is the expedition's dz instance, all clients inside the zone need // to receive added lockouts. this is done on live to avoid exploits where // members leave the expedition but haven't been kicked from zone yet - if (!remove && m_dynamiczone.IsCurrentZoneDzInstance()) + if (!remove && GetDynamicZone()->IsCurrentZoneDzInstance()) { AddLockoutClients(lockout, GetID()); } @@ -1225,56 +1017,6 @@ void Expedition::AddLockoutClients( } } -void Expedition::SendMemberListToZoneMembers() -{ - auto outapp_members = CreateMemberListPacket(false); - - for (const auto& member : GetDynamicZone().GetMembers()) - { - Client* member_client = entity_list.GetClientByCharID(member.id); - if (member_client) - { - member_client->QueuePacket(outapp_members.get()); - } - } -} - -void Expedition::SendUpdatesToZoneMembers(bool clear, bool message_on_clear) -{ - if (GetDynamicZone().HasMembers()) - { - auto outapp_info = CreateInfoPacket(clear); - auto outapp_members = CreateMemberListPacket(clear); - - for (const auto& member : GetDynamicZone().GetMembers()) - { - Client* member_client = entity_list.GetClientByCharID(member.id); - if (member_client) - { - member_client->SetExpeditionID(clear ? 0 : GetID()); - member_client->SendDzCompassUpdate(); - member_client->QueuePacket(outapp_info.get()); - member_client->QueuePacket(outapp_members.get()); - member_client->SendExpeditionLockoutTimers(); - if (clear && message_on_clear) - { - member_client->MessageString(Chat::Yellow, EXPEDITION_REMOVED, - member_client->GetName(), m_expedition_name.c_str()); - } - } - } - } -} - -void Expedition::SendClientExpeditionInfo(Client* client) -{ - if (client) - { - client->QueuePacket(CreateInfoPacket().get()); - client->QueuePacket(CreateMemberListPacket().get()); - } -} - void Expedition::SendWorldPendingInvite(const ExpeditionInvite& invite, const std::string& add_name) { LogExpeditions( @@ -1285,30 +1027,6 @@ void Expedition::SendWorldPendingInvite(const ExpeditionInvite& invite, const st SendWorldAddPlayerInvite(invite.inviter_name, invite.swap_remove_name, add_name, true); } -std::unique_ptr Expedition::CreateExpireWarningPacket(uint32_t minutes_remaining) -{ - uint32_t outsize = sizeof(ExpeditionExpireWarning); - auto outapp = std::make_unique(OP_DzExpeditionEndsWarning, outsize); - auto buf = reinterpret_cast(outapp->pBuffer); - buf->minutes_remaining = minutes_remaining; - return outapp; -} - -std::unique_ptr Expedition::CreateInfoPacket(bool clear) -{ - uint32_t outsize = sizeof(DynamicZoneInfo_Struct); - auto outapp = std::make_unique(OP_DzExpeditionInfo, outsize); - auto info = reinterpret_cast(outapp->pBuffer); - if (!clear) - { - info->assigned = true; - strn0cpy(info->dz_name, m_expedition_name.c_str(), sizeof(info->dz_name)); - strn0cpy(info->leader_name, m_leader.name.c_str(), sizeof(info->leader_name)); - info->max_players = GetDynamicZone().GetMaxPlayers(); - } - return outapp; -} - std::unique_ptr Expedition::CreateInvitePacket( const std::string& inviter_name, const std::string& swap_remove_name) { @@ -1316,70 +1034,11 @@ std::unique_ptr Expedition::CreateInvitePacket( auto outapp = std::make_unique(OP_DzExpeditionInvite, outsize); auto outbuf = reinterpret_cast(outapp->pBuffer); strn0cpy(outbuf->inviter_name, inviter_name.c_str(), sizeof(outbuf->inviter_name)); - strn0cpy(outbuf->expedition_name, m_expedition_name.c_str(), sizeof(outbuf->expedition_name)); + strn0cpy(outbuf->expedition_name, GetName().c_str(), sizeof(outbuf->expedition_name)); strn0cpy(outbuf->swap_name, swap_remove_name.c_str(), sizeof(outbuf->swap_name)); outbuf->swapping = !swap_remove_name.empty(); - outbuf->dz_zone_id = m_dynamiczone.GetZoneID(); - outbuf->dz_instance_id = m_dynamiczone.GetInstanceID(); - return outapp; -} - -std::unique_ptr Expedition::CreateMemberListPacket(bool clear) -{ - uint32_t member_count = clear ? 0 : static_cast(GetDynamicZone().GetMemberCount()); - uint32_t member_entries_size = sizeof(DynamicZoneMemberEntry_Struct) * member_count; - uint32_t outsize = sizeof(DynamicZoneMemberList_Struct) + member_entries_size; - auto outapp = std::make_unique(OP_DzMemberList, outsize); - auto buf = reinterpret_cast(outapp->pBuffer); - - buf->member_count = member_count; - - if (!clear) - { - const auto& members = GetDynamicZone().GetMembers(); - for (auto i = 0; i < members.size(); ++i) - { - strn0cpy(buf->members[i].name, members[i].name.c_str(), sizeof(buf->members[i].name)); - buf->members[i].online_status = static_cast(members[i].status); - } - } - - return outapp; -} - -std::unique_ptr Expedition::CreateMemberListNamePacket( - const std::string& name, bool remove_name) -{ - uint32_t outsize = sizeof(DynamicZoneMemberListName_Struct); - auto outapp = std::make_unique(OP_DzMemberListName, outsize); - auto buf = reinterpret_cast(outapp->pBuffer); - buf->add_name = !remove_name; - strn0cpy(buf->name, name.c_str(), sizeof(buf->name)); - return outapp; -} - -std::unique_ptr Expedition::CreateMemberListStatusPacket( - const std::string& name, DynamicZoneMemberStatus status) -{ - // member list status uses member list struct with a single entry - uint32_t outsize = sizeof(DynamicZoneMemberList_Struct) + sizeof(DynamicZoneMemberEntry_Struct); - auto outapp = std::make_unique(OP_DzMemberListStatus, outsize); - auto buf = reinterpret_cast(outapp->pBuffer); - buf->member_count = 1; - - auto entry = static_cast(buf->members); - strn0cpy(entry->name, name.c_str(), sizeof(entry->name)); - entry->online_status = static_cast(status); - - return outapp; -} - -std::unique_ptr Expedition::CreateLeaderNamePacket() -{ - uint32_t outsize = sizeof(DynamicZoneLeaderName_Struct); - auto outapp = std::make_unique(OP_DzSetLeaderName, outsize); - auto buf = reinterpret_cast(outapp->pBuffer); - strn0cpy(buf->leader_name, m_leader.name.c_str(), sizeof(buf->leader_name)); + outbuf->dz_zone_id = GetDynamicZone()->GetZoneID(); + outbuf->dz_instance_id = GetDynamicZone()->GetInstanceID(); return outapp; } @@ -1448,56 +1107,12 @@ void Expedition::SendWorldMakeLeaderRequest(uint32_t requester_id, const std::st uint32_t pack_size = sizeof(ServerDzCommandMakeLeader_Struct); auto pack = std::make_unique(ServerOP_ExpeditionDzMakeLeader, pack_size); auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); + buf->dz_id = GetDynamicZone()->GetID(); buf->requester_id = requester_id; strn0cpy(buf->new_leader_name, new_leader_name.c_str(), sizeof(buf->new_leader_name)); worldserver.SendPacket(pack.get()); } -void Expedition::SendWorldMemberChanged(const std::string& char_name, uint32_t char_id, bool remove) -{ - // notify other zones of added or removed member - uint32_t pack_size = sizeof(ServerExpeditionMemberChange_Struct); - auto pack = std::make_unique(ServerOP_ExpeditionMemberChange, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - buf->sender_zone_id = zone ? zone->GetZoneID() : 0; - buf->sender_instance_id = zone ? zone->GetInstanceID() : 0; - buf->removed = remove; - buf->char_id = char_id; - strn0cpy(buf->char_name, char_name.c_str(), sizeof(buf->char_name)); - worldserver.SendPacket(pack.get()); -} - -void Expedition::SendWorldMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status) -{ - uint32_t pack_size = sizeof(ServerExpeditionMemberStatus_Struct); - auto pack = std::make_unique(ServerOP_ExpeditionMemberStatus, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - buf->sender_zone_id = zone ? zone->GetZoneID() : 0; - buf->sender_instance_id = zone ? zone->GetInstanceID() : 0; - buf->status = static_cast(status); - buf->character_id = character_id; - worldserver.SendPacket(pack.get()); -} - -void Expedition::SendWorldMemberSwapped( - const std::string& remove_char_name, uint32_t remove_char_id, const std::string& add_char_name, uint32_t add_char_id) -{ - uint32_t pack_size = sizeof(ServerExpeditionMemberSwap_Struct); - auto pack = std::make_unique(ServerOP_ExpeditionMemberSwap, pack_size); - auto buf = reinterpret_cast(pack->pBuffer); - buf->expedition_id = GetID(); - buf->sender_zone_id = zone ? zone->GetZoneID() : 0; - buf->sender_instance_id = zone ? zone->GetInstanceID() : 0; - buf->add_char_id = add_char_id; - buf->remove_char_id = remove_char_id; - strn0cpy(buf->add_char_name, add_char_name.c_str(), sizeof(buf->add_char_name)); - strn0cpy(buf->remove_char_name, remove_char_name.c_str(), sizeof(buf->remove_char_name)); - worldserver.SendPacket(pack.get()); -} - void Expedition::SendWorldSettingChanged(uint16_t server_opcode, bool setting_value) { uint32_t pack_size = sizeof(ServerExpeditionSetting_Struct); @@ -1615,44 +1230,6 @@ void Expedition::HandleWorldMessage(ServerPacket* pack) } break; } - case ServerOP_ExpeditionDeleted: - { - // sent by world when it deletes expired or empty expeditions - auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (zone && expedition) - { - expedition->SendUpdatesToZoneMembers(true, false); // any members silently removed - - LogExpeditionsModerate("Deleting expedition [{}] from zone cache", buf->expedition_id); - zone->expedition_cache.erase(buf->expedition_id); - } - break; - } - case ServerOP_ExpeditionMembersRemoved: - { - auto buf = reinterpret_cast(pack->pBuffer); - if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) - { - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - expedition->SendUpdatesToZoneMembers(true); - expedition->GetDynamicZone().ClearInternalMembers(); - } - } - break; - } - case ServerOP_ExpeditionLeaderChanged: - { - auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - expedition->ProcessLeaderChanged(buf->leader_id); - } - break; - } case ServerOP_ExpeditionLockout: case ServerOP_ExpeditionLockoutDuration: { @@ -1662,7 +1239,7 @@ void Expedition::HandleWorldMessage(ServerPacket* pack) auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); if (expedition) { - ExpeditionLockoutTimer lockout{ expedition->GetUUID(), expedition->GetName(), + ExpeditionLockoutTimer lockout{ expedition->GetDynamicZone()->GetUUID(), expedition->GetName(), buf->event_name, buf->expire_time, buf->duration }; if (pack->opcode == ServerOP_ExpeditionLockout) @@ -1677,54 +1254,6 @@ void Expedition::HandleWorldMessage(ServerPacket* pack) } break; } - case ServerOP_ExpeditionMemberChange: - { - auto buf = reinterpret_cast(pack->pBuffer); - if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) - { - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - if (buf->removed) - { - expedition->ProcessMemberRemoved(buf->char_name, buf->char_id); - } - else - { - expedition->ProcessMemberAdded(buf->char_name, buf->char_id); - } - } - } - break; - } - case ServerOP_ExpeditionMemberSwap: - { - auto buf = reinterpret_cast(pack->pBuffer); - if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) - { - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - expedition->ProcessMemberRemoved(buf->remove_char_name, buf->remove_char_id); - expedition->ProcessMemberAdded(buf->add_char_name, buf->add_char_id); - } - } - break; - } - case ServerOP_ExpeditionMemberStatus: - { - auto buf = reinterpret_cast(pack->pBuffer); - if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id)) - { - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - auto status = static_cast(buf->status); - expedition->SendMemberStatusToZoneMembers(buf->character_id, status); - } - } - break; - } case ServerOP_ExpeditionLockState: { auto buf = reinterpret_cast(pack->pBuffer); @@ -1751,22 +1280,6 @@ void Expedition::HandleWorldMessage(ServerPacket* pack) } break; } - case ServerOP_ExpeditionGetMemberStatuses: - { - // reply from world for online member statuses request - auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - for (uint32_t i = 0; i < buf->count; ++i) - { - auto status = static_cast(buf->entries[i].online_status); - expedition->GetDynamicZone().SetInternalMemberStatus(buf->entries[i].character_id, status); - } - expedition->SendMemberListToZoneMembers(); - } - break; - } case ServerOP_ExpeditionDzAddPlayer: { auto buf = reinterpret_cast(pack->pBuffer); @@ -1793,13 +1306,24 @@ void Expedition::HandleWorldMessage(ServerPacket* pack) case ServerOP_ExpeditionDzMakeLeader: { auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) + auto old_leader_client = entity_list.GetClientByCharID(buf->requester_id); + auto new_leader_client = entity_list.GetClientByName(buf->new_leader_name); + + if (old_leader_client) { - auto old_leader_client = entity_list.GetClientByCharID(buf->requester_id); - auto new_leader_client = entity_list.GetClientByName(buf->new_leader_name); - expedition->ProcessMakeLeader(old_leader_client, new_leader_client, - buf->new_leader_name, buf->is_success, buf->is_online); + // success flag is set by world to indicate new leader set to an online member + if (buf->is_success) { + old_leader_client->MessageString(Chat::Yellow, DZMAKELEADER_NAME, buf->new_leader_name); + } else if (!buf->is_online) { + old_leader_client->MessageString(Chat::Red, DZMAKELEADER_NOT_ONLINE, buf->new_leader_name); + } else { + old_leader_client->MessageString(Chat::Red, EXPEDITION_NOT_MEMBER, buf->new_leader_name); + } + } + + if (buf->is_success && new_leader_client && !RuleB(Expedition, AlwaysNotifyNewLeaderOnChange)) + { + new_leader_client->MessageString(Chat::Yellow, DZMAKELEADER_YOU); } break; } @@ -1826,22 +1350,12 @@ void Expedition::HandleWorldMessage(ServerPacket* pack) } break; } - case ServerOP_ExpeditionExpireWarning: - { - auto buf = reinterpret_cast(pack->pBuffer); - auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id); - if (expedition) - { - expedition->SendMembersExpireWarning(buf->minutes_remaining); - } - break; - } } } bool Expedition::CanClientLootCorpse(Client* client, uint32_t npc_type_id, uint32_t spawn_id) { - if (client && m_dynamiczone.IsCurrentZoneDzInstance()) + if (client && GetDynamicZone()->IsCurrentZoneDzInstance()) { // entity id takes priority, falls back to checking by npc type if not set std::string event_name = GetLootEventBySpawnID(spawn_id); @@ -1853,7 +1367,7 @@ bool Expedition::CanClientLootCorpse(Client* client, uint32_t npc_type_id, uint3 if (!event_name.empty()) { auto client_lockout = client->GetExpeditionLockout(GetName(), event_name); - if (!client_lockout || client_lockout->GetExpeditionUUID() != GetUUID()) + if (!client_lockout || client_lockout->GetExpeditionUUID() != GetDynamicZone()->GetUUID()) { // client lockout not received in this expedition, prevent looting LogExpeditions( @@ -1870,7 +1384,7 @@ bool Expedition::CanClientLootCorpse(Client* client, uint32_t npc_type_id, uint3 void Expedition::SetLootEventByNPCTypeID(uint32_t npc_type_id, const std::string& event_name) { - if (npc_type_id && m_dynamiczone.IsCurrentZoneDzInstance()) + if (npc_type_id && GetDynamicZone()->IsCurrentZoneDzInstance()) { LogExpeditions("Setting loot event [{}] for npc type id [{}]", event_name, npc_type_id); m_npc_loot_events[npc_type_id] = event_name; @@ -1879,7 +1393,7 @@ void Expedition::SetLootEventByNPCTypeID(uint32_t npc_type_id, const std::string void Expedition::SetLootEventBySpawnID(uint32_t spawn_id, const std::string& event_name) { - if (spawn_id && m_dynamiczone.IsCurrentZoneDzInstance()) + if (spawn_id && GetDynamicZone()->IsCurrentZoneDzInstance()) { LogExpeditions("Setting loot event [{}] for entity id [{}]", event_name, spawn_id); m_spawn_loot_events[spawn_id] = event_name; @@ -1890,7 +1404,7 @@ std::string Expedition::GetLootEventByNPCTypeID(uint32_t npc_type_id) { std::string event_name; - if (npc_type_id && m_dynamiczone.IsCurrentZoneDzInstance()) + if (npc_type_id && GetDynamicZone()->IsCurrentZoneDzInstance()) { auto it = m_npc_loot_events.find(npc_type_id); if (it != m_npc_loot_events.end()) @@ -1906,7 +1420,7 @@ std::string Expedition::GetLootEventBySpawnID(uint32_t spawn_id) { std::string event_name; - if (spawn_id && m_dynamiczone.IsCurrentZoneDzInstance()) + if (spawn_id && GetDynamicZone()->IsCurrentZoneDzInstance()) { auto it = m_spawn_loot_events.find(spawn_id); if (it != m_spawn_loot_events.end()) @@ -1939,22 +1453,6 @@ std::vector Expedition::GetExpeditionLockoutsByCharacter return lockouts; } -void Expedition::SendMembersExpireWarning(uint32_t minutes_remaining) -{ - // expeditions warn members in all zones not just the dz - auto outapp = CreateExpireWarningPacket(minutes_remaining); - for (const auto& member : GetDynamicZone().GetMembers()) - { - Client* member_client = entity_list.GetClientByCharID(member.id); - if (member_client) - { - member_client->QueuePacket(outapp.get()); - member_client->MessageString(Chat::Yellow, EXPEDITION_MIN_REMAIN, - fmt::format_int(minutes_remaining).c_str()); - } - } -} - void Expedition::SyncCharacterLockouts( uint32_t character_id, std::vector& client_lockouts) { @@ -1967,7 +1465,8 @@ void Expedition::SyncCharacterLockouts( for (const auto& lockout_iter : m_lockouts) { const ExpeditionLockoutTimer& lockout = lockout_iter.second; - if (lockout.IsReplayTimer() || lockout.IsExpired() || lockout.GetExpeditionUUID() != m_uuid) + if (lockout.IsReplayTimer() || lockout.IsExpired() || + lockout.GetExpeditionUUID() != GetDynamicZone()->GetUUID()) { continue; } @@ -1983,7 +1482,7 @@ void Expedition::SyncCharacterLockouts( client_lockouts.emplace_back(lockout); // insert missing } else if (client_lockout_iter->GetSecondsRemaining() < lockout.GetSecondsRemaining() && - client_lockout_iter->GetExpeditionUUID() != m_uuid) + client_lockout_iter->GetExpeditionUUID() != GetDynamicZone()->GetUUID()) { // only update lockout timer not uuid so loot event apis still work modified = true; diff --git a/zone/expedition.h b/zone/expedition.h index 106035479..73b63ade1 100644 --- a/zone/expedition.h +++ b/zone/expedition.h @@ -22,7 +22,6 @@ #define EXPEDITION_H #include "dynamic_zone.h" -#include "../common/expedition_base.h" #include "../common/expedition_lockout_timer.h" #include "../common/repositories/expeditions_repository.h" #include @@ -47,14 +46,14 @@ enum class ExpeditionLockMessage : uint8_t Begin }; -class Expedition : public ExpeditionBase +class Expedition { public: - Expedition() = default; - Expedition(uint32_t id, const std::string& uuid, DynamicZone&& dz, const std::string& expedition_name, - const DynamicZoneMember& leader); + Expedition() = delete; + Expedition(DynamicZone* dz) : m_dynamic_zone(dz) { assert(m_dynamic_zone != nullptr); } + Expedition(DynamicZone* dz, uint32_t id, uint32_t dz_id); - static Expedition* TryCreate(Client* requester, DynamicZone& dynamiczone, ExpeditionRequest& request); + static Expedition* TryCreate(Client* requester, DynamicZone& dynamiczone, bool disable_messages); static void CacheFromDatabase(uint32_t expedition_id); static bool CacheAllFromDatabase(); @@ -79,14 +78,15 @@ public: const std::string& expedition_name = {}, const std::string& event_name = {}); static void AddLockoutClients(const ExpeditionLockoutTimer& lockout, uint32_t exclude_id = 0); - DynamicZone& GetDynamicZone() { return m_dynamiczone; } + uint32_t GetID() const { return m_id; } + uint32_t GetDynamicZoneID() const { return m_dynamic_zone_id; } + DynamicZone* GetDynamicZone() const { return m_dynamic_zone; } + const DynamicZoneMember& GetLeader() { return GetDynamicZone()->GetLeader(); } + uint32_t GetLeaderID() { return GetDynamicZone()->GetLeaderID(); } + const std::string& GetLeaderName() { return GetDynamicZone()->GetLeaderName(); } const std::unordered_map& GetLockouts() const { return m_lockouts; } - - bool AddMember(const std::string& add_char_name, uint32_t add_char_id); - void RemoveAllMembers(bool enable_removal_timers = true); - bool RemoveMember(const std::string& remove_char_name); - void SetMemberStatus(Client* client, DynamicZoneMemberStatus status); - void SwapMember(Client* add_client, const std::string& remove_char_name); + const std::string& GetName() { return GetDynamicZone()->GetName(); } + void RegisterDynamicZoneCallbacks(); bool IsLocked() const { return m_is_locked; } void SetLocked(bool lock_expedition, ExpeditionLockMessage lock_msg, @@ -109,7 +109,6 @@ public: void SetLootEventByNPCTypeID(uint32_t npc_type_id, const std::string& event_name); void SetLootEventBySpawnID(uint32_t spawn_id, const std::string& event_name); - void SendClientExpeditionInfo(Client* client); void SendWorldMakeLeaderRequest(uint32_t requester_id, const std::string& new_leader_name); void SendWorldPendingInvite(const ExpeditionInvite& invite, const std::string& add_name); @@ -127,29 +126,22 @@ public: static const int32_t EVENT_TIMER_ID; private: - static void CacheExpeditions(std::vector&& expeditions); + static void CacheExpeditions(std::vector&& expeditions); static void SendWorldCharacterLockout(uint32_t character_id, const ExpeditionLockoutTimer& lockout, bool remove); void AddLockout(const ExpeditionLockoutTimer& lockout, bool members_only = false); void AddLockoutDurationClients(const ExpeditionLockoutTimer& lockout, int seconds, uint32_t exclude_id = 0); bool ConfirmLeaderCommand(Client* requester); + void OnClientAddRemove(Client* client, bool removed, bool silent); + void LoadRepositoryResult(const ExpeditionsRepository::Expeditions& entry); bool ProcessAddConflicts(Client* leader_client, Client* add_client, bool swapping); - void ProcessLeaderChanged(uint32_t new_leader_id); void ProcessLockoutDuration(const ExpeditionLockoutTimer& lockout, int seconds, bool members_only = false); void ProcessLockoutUpdate(const ExpeditionLockoutTimer& lockout, bool remove, bool members_only = false); - void ProcessMakeLeader(Client* old_leader, Client* new_leader, - const std::string& new_leader_name, bool is_success, bool is_online); - void ProcessMemberAdded(const std::string& added_char_name, uint32_t added_char_id); - void ProcessMemberRemoved(const std::string& removed_char_name, uint32_t removed_char_id); void SaveLockouts(ExpeditionRequest& request); void SendClientExpeditionInvite( Client* client, const std::string& inviter_name, const std::string& swap_remove_name); void SendLeaderMessage(Client* leader_client, uint16_t chat_type, uint32_t string_id, const std::initializer_list& args = {}); - void SendMemberListToZoneMembers(); - void SendMemberStatusToZoneMembers(uint32_t update_character_id, DynamicZoneMemberStatus status); - void SendMembersExpireWarning(uint32_t minutes); - void SendUpdatesToZoneMembers(bool clear = false, bool message_on_clear = true); void SendWorldExpeditionUpdate(uint16_t server_opcode); void SendWorldAddPlayerInvite(const std::string& inviter_name, const std::string& swap_remove_name, const std::string& add_name, bool pending = false); @@ -157,24 +149,18 @@ private: const ExpeditionLockoutTimer& lockout, int seconds, bool members_only = false); void SendWorldLockoutUpdate( const ExpeditionLockoutTimer& lockout, bool remove, bool members_only = false); - void SendWorldMemberChanged(const std::string& char_name, uint32_t char_id, bool remove); - void SendWorldMemberStatus(uint32_t character_id, DynamicZoneMemberStatus status); - void SendWorldMemberSwapped(const std::string& remove_char_name, uint32_t remove_char_id, - const std::string& add_char_name, uint32_t add_char_id); void SendWorldSettingChanged(uint16_t server_opcode, bool setting_value); void SetDynamicZone(DynamicZone&& dz); void TryAddClient(Client* add_client, const std::string& inviter_name, const std::string& swap_remove_name, Client* leader_client = nullptr); - std::unique_ptr CreateExpireWarningPacket(uint32_t minutes_remaining); - std::unique_ptr CreateInfoPacket(bool clear = false); std::unique_ptr CreateInvitePacket(const std::string& inviter_name, const std::string& swap_remove_name); - std::unique_ptr CreateMemberListPacket(bool clear = false); - std::unique_ptr CreateMemberListNamePacket(const std::string& name, bool remove_name); - std::unique_ptr CreateMemberListStatusPacket(const std::string& name, DynamicZoneMemberStatus status); - std::unique_ptr CreateLeaderNamePacket(); - DynamicZone m_dynamiczone { DynamicZoneType::Expedition }; + uint32_t m_id = 0; + uint32_t m_dynamic_zone_id = 0; + bool m_is_locked = false; + bool m_add_replay_on_join = true; + DynamicZone* m_dynamic_zone = nullptr; // should never be null, will exist for lifetime of expedition std::unordered_map m_lockouts; std::unordered_map m_npc_loot_events; // only valid inside dz zone std::unordered_map m_spawn_loot_events; // only valid inside dz zone diff --git a/zone/expedition_database.cpp b/zone/expedition_database.cpp index eb31c301c..9a3bfb837 100644 --- a/zone/expedition_database.cpp +++ b/zone/expedition_database.cpp @@ -26,25 +26,21 @@ #include "../common/string_util.h" #include -uint32_t ExpeditionDatabase::InsertExpedition( - const std::string& uuid, uint32_t dz_id, const std::string& expedition_name, - uint32_t leader_id, uint32_t min_players, uint32_t max_players) +uint32_t ExpeditionDatabase::InsertExpedition(uint32_t dz_id) { - LogExpeditionsDetail( - "Inserting new expedition [{}] leader [{}] uuid [{}]", expedition_name, leader_id, uuid - ); + LogExpeditionsDetail("Inserting new expedition dz [{}]", dz_id); std::string query = fmt::format(SQL( INSERT INTO expeditions - (uuid, dynamic_zone_id, expedition_name, leader_id, min_players, max_players) + (dynamic_zone_id) VALUES - ('{}', {}, '{}', {}, {}, {}); - ), uuid, dz_id, EscapeString(expedition_name), leader_id, min_players, max_players); + ({}); + ), dz_id); auto results = database.QueryDatabase(query); if (!results.Success()) { - LogExpeditions("Failed to obtain an expedition id for [{}]", expedition_name); + LogExpeditions("Failed to obtain an expedition id for dz [{}]", dz_id); return 0; } diff --git a/zone/expedition_database.h b/zone/expedition_database.h index e83332920..5e35fb7b3 100644 --- a/zone/expedition_database.h +++ b/zone/expedition_database.h @@ -35,9 +35,7 @@ class MySQLRequestResult; namespace ExpeditionDatabase { - uint32_t InsertExpedition( - const std::string& uuid, uint32_t instance_id, const std::string& expedition_name, - uint32_t leader_id, uint32_t min_players, uint32_t max_players); + uint32_t InsertExpedition(uint32_t dz_id); std::vector LoadCharacterLockouts(uint32_t character_id); std::vector LoadCharacterLockouts(uint32_t character_id, const std::string& expedition_name); diff --git a/zone/expedition_request.cpp b/zone/expedition_request.cpp index a1a2aa48e..98cad6050 100644 --- a/zone/expedition_request.cpp +++ b/zone/expedition_request.cpp @@ -30,12 +30,10 @@ constexpr char SystemName[] = "expedition"; -ExpeditionRequest::ExpeditionRequest(std::string expedition_name, - uint32_t min_players, uint32_t max_players, bool disable_messages -) : - m_expedition_name(std::move(expedition_name)), - m_min_players(min_players), - m_max_players(max_players), +ExpeditionRequest::ExpeditionRequest(const DynamicZone& dz, bool disable_messages) : + m_expedition_name(dz.GetName()), + m_min_players(dz.GetMinPlayers()), + m_max_players(dz.GetMaxPlayers()), m_disable_messages(disable_messages) { } diff --git a/zone/expedition_request.h b/zone/expedition_request.h index b5e69e3ef..6f1396a42 100644 --- a/zone/expedition_request.h +++ b/zone/expedition_request.h @@ -35,8 +35,7 @@ class Raid; class ExpeditionRequest { public: - ExpeditionRequest(std::string expedition_name, uint32_t min_players, - uint32_t max_players, bool disable_messages = false); + ExpeditionRequest(const DynamicZone& dz, bool disable_messages = false); bool Validate(Client* requester); diff --git a/zone/forage.cpp b/zone/forage.cpp index 75ae00197..375788420 100644 --- a/zone/forage.cpp +++ b/zone/forage.cpp @@ -367,7 +367,7 @@ void Client::GoFish() PushItemOnCursor(*inst); SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketLimbo); if (RuleB(TaskSystem, EnableTaskSystem)) - UpdateTasksForItem(ActivityFish, food_id); + UpdateTasksForItem(TaskActivityType::Fish, food_id); safe_delete(inst); inst = m_inv.GetItem(EQ::invslot::slotCursor); @@ -487,7 +487,7 @@ void Client::ForageItem(bool guarantee) { PushItemOnCursor(*inst); SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketLimbo); if(RuleB(TaskSystem, EnableTaskSystem)) - UpdateTasksForItem(ActivityForage, foragedfood); + UpdateTasksForItem(TaskActivityType::Forage, foragedfood); safe_delete(inst); inst = m_inv.GetItem(EQ::invslot::slotCursor); diff --git a/zone/lua_client.cpp b/zone/lua_client.cpp index 10f0e372c..6dc02bd66 100644 --- a/zone/lua_client.cpp +++ b/zone/lua_client.cpp @@ -1864,6 +1864,7 @@ Lua_Expedition Lua_Client::CreateExpedition(luabind::object expedition_table) { // luabind will catch thrown cast_failed exceptions for invalid/missing args luabind::object instance_info = expedition_table["instance"]; + luabind::object expedition_info = expedition_table["expedition"]; luabind::object zone = instance_info["zone"]; uint32_t zone_id = 0; @@ -1880,6 +1881,9 @@ Lua_Expedition Lua_Client::CreateExpedition(luabind::object expedition_table) { uint32_t zone_duration = luabind::object_cast(instance_info["duration"]); DynamicZone dz{ zone_id, zone_version, zone_duration, DynamicZoneType::Expedition }; + dz.SetName(luabind::object_cast(expedition_info["name"])); + dz.SetMinPlayers(luabind::object_cast(expedition_info["min_players"])); + dz.SetMaxPlayers(luabind::object_cast(expedition_info["max_players"])); // the dz_info table supports optional hash entries for 'compass', 'safereturn', and 'zonein' data if (luabind::type(expedition_table["compass"]) == LUA_TTABLE) @@ -1900,21 +1904,13 @@ Lua_Expedition Lua_Client::CreateExpedition(luabind::object expedition_table) { dz.SetZoneInLocation(zonein_loc); } - luabind::object expedition_info = expedition_table["expedition"]; - - std::string expedition_name = luabind::object_cast(expedition_info["name"]); - uint32_t min_players = luabind::object_cast(expedition_info["min_players"]); - uint32_t max_players = luabind::object_cast(expedition_info["max_players"]); - bool disable_messages = false; - + bool disable_messages = false; if (luabind::type(expedition_info["disable_messages"]) == LUA_TBOOLEAN) { disable_messages = luabind::object_cast(expedition_info["disable_messages"]); } - ExpeditionRequest request{ expedition_name, min_players, max_players, disable_messages }; - - return self->CreateExpedition(dz, request); + return self->CreateExpedition(dz, disable_messages); } Lua_Expedition Lua_Client::CreateExpedition(std::string zone_name, uint32 version, uint32 duration, std::string expedition_name, uint32 min_players, uint32 max_players) { @@ -2053,6 +2049,55 @@ void Lua_Client::MovePCDynamicZone(std::string zone_name, int zone_version, bool return self->MovePCDynamicZone(zone_name, zone_version, msg_if_invalid); } +void Lua_Client::CreateTaskDynamicZone(int task_id, luabind::object dz_table) { + Lua_Safe_Call_Void(); + + if (luabind::type(dz_table) != LUA_TTABLE) + { + return; + } + + // luabind will catch thrown cast_failed exceptions for invalid/missing args + luabind::object instance_info = dz_table["instance"]; + luabind::object zone = instance_info["zone"]; + + uint32_t zone_id = 0; + if (luabind::type(zone) == LUA_TSTRING) + { + zone_id = ZoneID(luabind::object_cast(zone)); + } + else if (luabind::type(zone) == LUA_TNUMBER) + { + zone_id = luabind::object_cast(zone); + } + + uint32_t zone_version = luabind::object_cast(instance_info["version"]); + + // tasks override dz duration so duration is ignored here + DynamicZone dz{ zone_id, zone_version, 0, DynamicZoneType::None }; + + // the dz_info table supports optional hash entries for 'compass', 'safereturn', and 'zonein' data + if (luabind::type(dz_table["compass"]) == LUA_TTABLE) + { + auto compass_loc = GetDynamicZoneLocationFromTable(dz_table["compass"]); + dz.SetCompass(compass_loc); + } + + if (luabind::type(dz_table["safereturn"]) == LUA_TTABLE) + { + auto safereturn_loc = GetDynamicZoneLocationFromTable(dz_table["safereturn"]); + dz.SetSafeReturn(safereturn_loc); + } + + if (luabind::type(dz_table["zonein"]) == LUA_TTABLE) + { + auto zonein_loc = GetDynamicZoneLocationFromTable(dz_table["zonein"]); + dz.SetZoneInLocation(zonein_loc); + } + + self->CreateTaskDynamicZone(task_id, dz); +} + void Lua_Client::Fling(float value, float target_x, float target_y, float target_z) { Lua_Safe_Call_Void(); self->Fling(value, target_x, target_y, target_z); @@ -2515,6 +2560,7 @@ luabind::scope lua_register_client() { .def("MovePCDynamicZone", (void(Lua_Client::*)(std::string))&Lua_Client::MovePCDynamicZone) .def("MovePCDynamicZone", (void(Lua_Client::*)(std::string, int))&Lua_Client::MovePCDynamicZone) .def("MovePCDynamicZone", (void(Lua_Client::*)(std::string, int, bool))&Lua_Client::MovePCDynamicZone) + .def("CreateTaskDynamicZone", &Lua_Client::CreateTaskDynamicZone) .def("Fling", (void(Lua_Client::*)(float,float,float,float))&Lua_Client::Fling) .def("Fling", (void(Lua_Client::*)(float,float,float,float,bool))&Lua_Client::Fling) .def("Fling", (void(Lua_Client::*)(float,float,float,float,bool,bool))&Lua_Client::Fling) diff --git a/zone/lua_client.h b/zone/lua_client.h index 65219af22..3cc2a5c94 100644 --- a/zone/lua_client.h +++ b/zone/lua_client.h @@ -400,6 +400,7 @@ public: void MovePCDynamicZone(std::string zone_name); void MovePCDynamicZone(std::string zone_name, int zone_version); void MovePCDynamicZone(std::string zone_name, int zone_version, bool msg_if_invalid); + void CreateTaskDynamicZone(int task_id, luabind::object dz_table); void Fling(float value, float target_x, float target_y, float target_z); void Fling(float value, float target_x, float target_y, float target_z, bool ignore_los); void Fling(float value, float target_x, float target_y, float target_z, bool ignore_los, bool clipping); diff --git a/zone/lua_expedition.cpp b/zone/lua_expedition.cpp index b3a442a24..063a68ce9 100644 --- a/zone/lua_expedition.cpp +++ b/zone/lua_expedition.cpp @@ -59,7 +59,7 @@ void Lua_Expedition::AddReplayLockoutDuration(int seconds, bool members_only) { uint32_t Lua_Expedition::GetDynamicZoneID() { Lua_Safe_Call_Int(); - return self->GetDynamicZone().GetID(); + return self->GetDynamicZoneID(); } uint32_t Lua_Expedition::GetID() { @@ -69,7 +69,7 @@ uint32_t Lua_Expedition::GetID() { int Lua_Expedition::GetInstanceID() { Lua_Safe_Call_Int(); - return self->GetDynamicZone().GetInstanceID(); + return self->GetDynamicZone()->GetInstanceID(); } std::string Lua_Expedition::GetLeaderName() { @@ -104,7 +104,7 @@ std::string Lua_Expedition::GetLootEventBySpawnID(uint32_t spawn_id) { uint32_t Lua_Expedition::GetMemberCount() { Lua_Safe_Call_Int(); - return self->GetDynamicZone().GetMemberCount(); + return self->GetDynamicZone()->GetMemberCount(); } luabind::object Lua_Expedition::GetMembers(lua_State* L) { @@ -113,7 +113,7 @@ luabind::object Lua_Expedition::GetMembers(lua_State* L) { if (d_) { auto self = reinterpret_cast(d_); - for (const auto& member : self->GetDynamicZone().GetMembers()) + for (const auto& member : self->GetDynamicZone()->GetMembers()) { lua_table[member.name] = member.id; } @@ -128,27 +128,27 @@ std::string Lua_Expedition::GetName() { int Lua_Expedition::GetSecondsRemaining() { Lua_Safe_Call_Int(); - return self->GetDynamicZone().GetSecondsRemaining(); + return self->GetDynamicZone()->GetSecondsRemaining(); } std::string Lua_Expedition::GetUUID() { Lua_Safe_Call_String(); - return self->GetUUID(); + return self->GetDynamicZone()->GetUUID(); } int Lua_Expedition::GetZoneID() { Lua_Safe_Call_Int(); - return self->GetDynamicZone().GetZoneID(); + return self->GetDynamicZone()->GetZoneID(); } std::string Lua_Expedition::GetZoneName() { Lua_Safe_Call_String(); - return ZoneName(self->GetDynamicZone().GetZoneID()); + return ZoneName(self->GetDynamicZone()->GetZoneID()); } int Lua_Expedition::GetZoneVersion() { Lua_Safe_Call_Int(); - return self->GetDynamicZone().GetZoneVersion(); + return self->GetDynamicZone()->GetZoneVersion(); } bool Lua_Expedition::HasLockout(std::string event_name) { @@ -168,7 +168,7 @@ bool Lua_Expedition::IsLocked() { void Lua_Expedition::RemoveCompass() { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetCompass(0, 0, 0, 0, true); + self->GetDynamicZone()->SetCompass(0, 0, 0, 0, true); } void Lua_Expedition::RemoveLockout(std::string event_name) { @@ -178,12 +178,12 @@ void Lua_Expedition::RemoveLockout(std::string event_name) { void Lua_Expedition::SetCompass(uint32_t zone_id, float x, float y, float z) { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetCompass(zone_id, x, y, z, true); + self->GetDynamicZone()->SetCompass(zone_id, x, y, z, true); } void Lua_Expedition::SetCompass(std::string zone_name, float x, float y, float z) { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetCompass(ZoneID(zone_name), x, y, z, true); + self->GetDynamicZone()->SetCompass(ZoneID(zone_name), x, y, z, true); } void Lua_Expedition::SetLocked(bool lock_expedition) { @@ -218,23 +218,23 @@ void Lua_Expedition::SetReplayLockoutOnMemberJoin(bool enable) { void Lua_Expedition::SetSafeReturn(uint32_t zone_id, float x, float y, float z, float heading) { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetSafeReturn(zone_id, x, y, z, heading, true); + self->GetDynamicZone()->SetSafeReturn(zone_id, x, y, z, heading, true); } void Lua_Expedition::SetSafeReturn(std::string zone_name, float x, float y, float z, float heading) { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetSafeReturn(ZoneID(zone_name), x, y, z, heading, true); + self->GetDynamicZone()->SetSafeReturn(ZoneID(zone_name), x, y, z, heading, true); } void Lua_Expedition::SetSecondsRemaining(uint32_t seconds_remaining) { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetSecondsRemaining(seconds_remaining); + self->GetDynamicZone()->SetSecondsRemaining(seconds_remaining); } void Lua_Expedition::SetZoneInLocation(float x, float y, float z, float heading) { Lua_Safe_Call_Void(); - self->GetDynamicZone().SetZoneInLocation(x, y, z, heading, true); + self->GetDynamicZone()->SetZoneInLocation(x, y, z, heading, true); } void Lua_Expedition::UpdateLockoutDuration(std::string event_name, uint32_t duration) { diff --git a/zone/lua_packet.cpp b/zone/lua_packet.cpp index 0457a8310..15211b097 100644 --- a/zone/lua_packet.cpp +++ b/zone/lua_packet.cpp @@ -675,7 +675,7 @@ luabind::scope lua_register_packet_opcodes() { luabind::value("MobRename", static_cast(OP_MobRename)), luabind::value("TaskDescription", static_cast(OP_TaskDescription)), luabind::value("TaskActivity", static_cast(OP_TaskActivity)), - luabind::value("TaskMemberList", static_cast(OP_TaskMemberList)), + luabind::value("SharedTaskPlayerList", static_cast(OP_SharedTaskPlayerList)), luabind::value("AnnoyingZoneUnknown", static_cast(OP_AnnoyingZoneUnknown)), luabind::value("Some3ByteHPUpdate", static_cast(OP_Some3ByteHPUpdate)), luabind::value("FloatListThing", static_cast(OP_FloatListThing)), @@ -770,7 +770,7 @@ luabind::scope lua_register_packet_opcodes() { luabind::value("ZonePlayerToBind", static_cast(OP_ZonePlayerToBind)), luabind::value("AutoFire", static_cast(OP_AutoFire)), luabind::value("Rewind", static_cast(OP_Rewind)), - luabind::value("OpenNewTasksWindow", static_cast(OP_OpenNewTasksWindow)), + luabind::value("TaskSelectWindow", static_cast(OP_TaskSelectWindow)), luabind::value("TaskActivityComplete", static_cast(OP_TaskActivityComplete)), luabind::value("AcceptNewTask", static_cast(OP_AcceptNewTask)), luabind::value("CancelTask", static_cast(OP_CancelTask)), diff --git a/zone/lua_parser.cpp b/zone/lua_parser.cpp index 148230550..5a0601658 100644 --- a/zone/lua_parser.cpp +++ b/zone/lua_parser.cpp @@ -198,6 +198,7 @@ LuaParser::LuaParser() { PlayerArgumentDispatch[EVENT_PLAYER_PICKUP] = handle_player_pick_up; PlayerArgumentDispatch[EVENT_CAST] = handle_player_cast; PlayerArgumentDispatch[EVENT_CAST_BEGIN] = handle_player_cast; + PlayerArgumentDispatch[EVENT_CAST_ON] = handle_player_cast; PlayerArgumentDispatch[EVENT_TASK_FAIL] = handle_player_task_fail; PlayerArgumentDispatch[EVENT_ZONE] = handle_player_zone; PlayerArgumentDispatch[EVENT_DUEL_WIN] = handle_player_duel_win; diff --git a/zone/perl_expedition.cpp b/zone/perl_expedition.cpp index 3715e754a..2ac7689fa 100644 --- a/zone/perl_expedition.cpp +++ b/zone/perl_expedition.cpp @@ -142,7 +142,7 @@ XS(XS_Expedition_GetDynamicZoneID) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_UV(THIS->GetDynamicZone().GetID()); + XSRETURN_UV(THIS->GetDynamicZone()->GetID()); } XS(XS_Expedition_GetID); @@ -168,7 +168,7 @@ XS(XS_Expedition_GetInstanceID) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_UV(THIS->GetDynamicZone().GetInstanceID()); + XSRETURN_UV(THIS->GetDynamicZone()->GetInstanceID()); } XS(XS_Expedition_GetLeaderName); @@ -247,7 +247,7 @@ XS(XS_Expedition_GetMemberCount) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_UV(THIS->GetDynamicZone().GetMemberCount()); + XSRETURN_UV(THIS->GetDynamicZone()->GetMemberCount()); } XS(XS_Expedition_GetMembers); @@ -262,7 +262,7 @@ XS(XS_Expedition_GetMembers) { HV* hash = newHV(); - for (const auto& member : THIS->GetDynamicZone().GetMembers()) + for (const auto& member : THIS->GetDynamicZone()->GetMembers()) { hv_store(hash, member.name.c_str(), static_cast(member.name.size()), newSVuv(member.id), 0); @@ -295,7 +295,7 @@ XS(XS_Expedition_GetSecondsRemaining) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_UV(THIS->GetDynamicZone().GetSecondsRemaining()); + XSRETURN_UV(THIS->GetDynamicZone()->GetSecondsRemaining()); } XS(XS_Expedition_GetUUID); @@ -308,7 +308,7 @@ XS(XS_Expedition_GetUUID) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_PV(THIS->GetUUID().c_str()); + XSRETURN_PV(THIS->GetDynamicZone()->GetUUID().c_str()); } XS(XS_Expedition_GetZoneID); @@ -321,7 +321,7 @@ XS(XS_Expedition_GetZoneID) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_UV(THIS->GetDynamicZone().GetZoneID()); + XSRETURN_UV(THIS->GetDynamicZone()->GetZoneID()); } XS(XS_Expedition_GetZoneName); @@ -334,7 +334,7 @@ XS(XS_Expedition_GetZoneName) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_PV(ZoneName(THIS->GetDynamicZone().GetZoneID())); + XSRETURN_PV(ZoneName(THIS->GetDynamicZone()->GetZoneID())); } XS(XS_Expedition_GetZoneVersion); @@ -347,7 +347,7 @@ XS(XS_Expedition_GetZoneVersion) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - XSRETURN_UV(THIS->GetDynamicZone().GetZoneVersion()); + XSRETURN_UV(THIS->GetDynamicZone()->GetZoneVersion()); } XS(XS_Expedition_HasLockout); @@ -406,7 +406,7 @@ XS(XS_Expedition_RemoveCompass) { Expedition* THIS = nullptr; VALIDATE_THIS_IS_EXPEDITION; - THIS->GetDynamicZone().SetCompass(0, 0, 0, 0, true); + THIS->GetDynamicZone()->SetCompass(0, 0, 0, 0, true); XSRETURN_EMPTY; } @@ -445,12 +445,12 @@ XS(XS_Expedition_SetCompass) { if (SvTYPE(ST(1)) == SVt_PV) { std::string zone_name(SvPV_nolen(ST(1))); - THIS->GetDynamicZone().SetCompass(ZoneID(zone_name), x, y, z, true); + THIS->GetDynamicZone()->SetCompass(ZoneID(zone_name), x, y, z, true); } else if (SvTYPE(ST(1)) == SVt_IV) { uint32_t zone_id = static_cast(SvUV(ST(1))); - THIS->GetDynamicZone().SetCompass(zone_id, x, y, z, true); + THIS->GetDynamicZone()->SetCompass(zone_id, x, y, z, true); } else { @@ -555,12 +555,12 @@ XS(XS_Expedition_SetSafeReturn) { if (SvTYPE(ST(1)) == SVt_PV) { std::string zone_name(SvPV_nolen(ST(1))); - THIS->GetDynamicZone().SetSafeReturn(ZoneID(zone_name), x, y, z, heading, true); + THIS->GetDynamicZone()->SetSafeReturn(ZoneID(zone_name), x, y, z, heading, true); } else if (SvTYPE(ST(1)) == SVt_IV) { uint32_t zone_id = static_cast(SvUV(ST(1))); - THIS->GetDynamicZone().SetSafeReturn(zone_id, x, y, z, heading, true); + THIS->GetDynamicZone()->SetSafeReturn(zone_id, x, y, z, heading, true); } else { @@ -581,7 +581,7 @@ XS(XS_Expedition_SetSecondsRemaining) { VALIDATE_THIS_IS_EXPEDITION; uint32_t seconds_remaining = static_cast(SvUV(ST(1))); - THIS->GetDynamicZone().SetSecondsRemaining(seconds_remaining); + THIS->GetDynamicZone()->SetSecondsRemaining(seconds_remaining); XSRETURN_EMPTY; } @@ -601,7 +601,7 @@ XS(XS_Expedition_SetZoneInLocation) { float z = static_cast(SvNV(ST(3))); float heading = static_cast(SvNV(ST(4))); - THIS->GetDynamicZone().SetZoneInLocation(x, y, z, heading, true); + THIS->GetDynamicZone()->SetZoneInLocation(x, y, z, heading, true); XSRETURN_EMPTY; } diff --git a/zone/shared_task_zone_messaging.cpp b/zone/shared_task_zone_messaging.cpp new file mode 100644 index 000000000..89e262847 --- /dev/null +++ b/zone/shared_task_zone_messaging.cpp @@ -0,0 +1,176 @@ +#include "shared_task_zone_messaging.h" +#include "../common/shared_tasks.h" +#include "../common/servertalk.h" +#include "client.h" +#include "../common/repositories/character_data_repository.h" +#include "../common/repositories/shared_task_members_repository.h" + +#include +#include +#include +#include +#include + +void SharedTaskZoneMessaging::HandleWorldMessage(ServerPacket *pack) +{ + switch (pack->opcode) { + case ServerOP_SharedTaskAcceptNewTask: { + auto p = reinterpret_cast(pack->pBuffer); + auto c = entity_list.GetClientByCharID(p->requested_character_id); + if (c) { + LogTasks("[ServerOP_SharedTaskAcceptNewTask] We're back in zone and I found [{}]", c->GetCleanName()); + + c->m_requesting_shared_task = true; + c->GetTaskState() + ->AcceptNewTask( + c, + (int) p->requested_task_id, + (int) p->requested_npc_type_id, + p->accept_time + ); + c->LoadClientTaskState(); + c->m_requesting_shared_task = false; + } + + break; + } + case ServerOP_SharedTaskUpdate: { + auto p = reinterpret_cast(pack->pBuffer); + auto c = entity_list.GetClientByCharID(p->source_character_id); + if (c) { + LogTasks("[ServerOP_SharedTaskUpdate] We're back in zone and I found [{}]", c->GetCleanName()); + + c->m_shared_task_update = true; + c->GetTaskState()->SharedTaskIncrementDoneCount( + c, + (int) p->task_id, + (int) p->activity_id, + (int) p->done_count, + p->ignore_quest_update + ); + c->m_shared_task_update = false; + } + + break; + } + case ServerOP_SharedTaskAttemptRemove: { + auto p = reinterpret_cast(pack->pBuffer); + auto c = entity_list.GetClientByCharID(p->requested_character_id); + if (c) { + LogTasks("[ServerOP_SharedTaskAttemptRemove] We're back in zone and I found [{}]", c->GetCleanName()); + + c->m_requested_shared_task_removal = true; + c->GetTaskState()->CancelTask( + c, + TASKSLOTSHAREDTASK, + static_cast((int) TASK_TYPE_SHARED), + p->remove_from_db + ); + c->m_requested_shared_task_removal = false; + + c->SetSharedTaskId(0); + } + + break; + } + case ServerOP_SharedTaskMemberlist: { + auto p = reinterpret_cast(pack->pBuffer); + + LogTasks( + "[ServerOP_SharedTaskMemberlist] We're back in zone and I'm searching for [{}]", + p->destination_character_id + ); + + // find character and route packet + auto c = entity_list.GetClientByCharID(p->destination_character_id); + if (c) { + LogTasks("[ServerOP_SharedTaskMemberlist] We're back in zone and I found [{}]", c->GetCleanName()); + + std::vector members; + + // deserialize members from world + EQ::Util::MemoryStreamReader ss(p->cereal_serialized_members, p->cereal_size); + cereal::BinaryInputArchive archive(ss); + archive(members); + + SerializeBuffer buf(sizeof(SharedTaskMemberList_Struct) + 15 * members.size()); + buf.WriteInt32(0); // unknown ids + buf.WriteInt32(0); + buf.WriteInt32((int32) members.size()); + + for (auto &m : members) { + buf.WriteString(m.character_name); + buf.WriteInt32(0); // monster mission + buf.WriteInt8(m.is_leader ? 1 : 0); + } + + auto outapp = std::make_unique(OP_SharedTaskMemberList, buf); + c->QueuePacket(outapp.get()); + } + + break; + } + case ServerOP_SharedTaskMemberChange: { + auto p = reinterpret_cast(pack->pBuffer); + + LogTasksDetail("[ServerOP_SharedTaskMemberChange] Searching for [{}]", p->destination_character_id); + + auto c = entity_list.GetClientByCharID(p->destination_character_id); + if (c) { + LogTasksDetail("[ServerOP_SharedTaskMemberChange] Found [{}]", c->GetCleanName()); + + SerializeBuffer buf; + buf.WriteInt32(0); // unique character id of receiver, leave 0 for emu + buf.WriteInt32(0); // unknown, seen 50, 4, 0 + buf.WriteInt8(p->removed ? 0 : 1); // 0: removed 1: added + buf.WriteString(p->player_name); + + // live sends more after the name but it might just be garbage from + // a re-used buffer (possibly a former name[64] buffer?) + + auto outapp = std::make_unique(OP_SharedTaskMemberChange, buf); + c->QueuePacket(outapp.get()); + } + + break; + } + case ServerOP_SharedTaskInvitePlayer: { + auto p = reinterpret_cast(pack->pBuffer); + auto c = entity_list.GetClientByCharID(p->requested_character_id); + if (c) { + LogTasks("[ServerOP_SharedTaskInvitePlayer] We're back in zone and I found [{}]", c->GetCleanName()); + + // init packet + auto outapp = new EQApplicationPacket(OP_SharedTaskInvite, sizeof(SharedTaskInvite_Struct)); + auto *i = (SharedTaskInvite_Struct *) outapp->pBuffer; + + // fill + i->unknown00 = 0; + i->invite_id = (int) p->invite_shared_task_id; + strn0cpy(i->inviter_name, p->inviter_name, 64); + strn0cpy(i->task_name, p->task_name, 64); + + // sends + c->QueuePacket(outapp); + safe_delete(outapp); + } + + break; + } + case ServerOP_SharedTaskPurgeAllCommand: { + LogTasksDetail("[ServerOP_SharedTaskPurgeAllCommand] Syncing clients"); + + for (auto &client: entity_list.GetClientList()) { + Client *c = client.second; + task_manager->SyncClientSharedTaskState(c, c->GetTaskState()); + c->RemoveClientTaskState(); + c->LoadClientTaskState(); + } + + break; + } + default: + break; + } + +} diff --git a/zone/shared_task_zone_messaging.h b/zone/shared_task_zone_messaging.h new file mode 100644 index 000000000..492e3ac92 --- /dev/null +++ b/zone/shared_task_zone_messaging.h @@ -0,0 +1,12 @@ +#ifndef EQEMU_SHARED_TASK_ZONE_MESSAGING_H +#define EQEMU_SHARED_TASK_ZONE_MESSAGING_H + +class ServerPacket; + +class SharedTaskZoneMessaging { +public: + static void HandleWorldMessage(ServerPacket *pack); +}; + + +#endif //EQEMU_SHARED_TASK_ZONE_MESSAGING_H diff --git a/zone/string_ids.h b/zone/string_ids.h index eca1f23cf..55cec653c 100644 --- a/zone/string_ids.h +++ b/zone/string_ids.h @@ -173,6 +173,7 @@ #define GENERIC_STRINGID_SAY 554 //%1 says '%T2' #define CANNOT_WAKE 555 //%1 tells you, 'I am unable to wake %2, master.' #define SUMMONING_CORPSE_ZONE 596 //Summoning %1's corpse(s). +#define TASK_NOT_RIGHT_LEVEL 615 //You are not at the right level for this task. #define PET_HOLD_SET_ON 698 //The pet hold mode has been set to on. #define PET_HOLD_SET_OFF 699 //The pet hold mode has been set to off. #define PET_FOCUS_SET_ON 700 //The pet focus mode has been set to on. @@ -295,6 +296,8 @@ #define TRADESKILL_MISSING_ITEM 3455 //You are missing a %1. #define TRADESKILL_MISSING_COMPONENTS 3456 //Sorry, but you don't have everything you need for this recipe in your general inventory. #define TRADESKILL_LEARN_RECIPE 3457 //You have learned the recipe %1! +#define TASK_UPDATED 3471 //Your task '%1' has been updated. +#define YOU_ASSIGNED_TASK 3472 //You have been assigned the task '%1'. #define EXPEDITION_YOU_BELONG 3500 //You cannot create this expedition since you already belong to another. #define EXPEDITION_YOU_PLAYED_HERE 3501 //You cannot create this expedition for another %1d:%2h:%3m since you have recently played here. #define REQUIRED_PLAYER_COUNT 3503 //You do not meet the player count requirement. You have %1 players. You must have at least %2 and no more than %3. @@ -369,7 +372,10 @@ #define FAILED_TAUNT 5811 //You have failed to taunt your target. #define PHYSICAL_RESIST_FAIL 5817 //Your target avoided your %1 ability. #define AA_NO_TARGET 5825 //You must first select a target for this ability! +#define YOU_RECEIVE 5941 //You receive %1. +#define NO_TASK_OFFERS 6009 //Sorry %3, I don't have anything for someone with your abilities. #define MAX_ACTIVE_TASKS 6010 //Sorry %3, you already have the maximum number of active tasks. +#define TASK_REQUEST_COOLDOWN_TIMER 6011 //Sorry, %3, but you can't request another task for %4 minutes and %5 seconds. #define FORAGE_MASTERY 6012 //Your forage mastery has enabled you to find something else! #define GUILD_BANK_CANNOT_DEPOSIT 6097 // Cannot deposit this item. Containers must be empty, and only one of each LORE and no NO TRADE or TEMPORARY items may be deposited. #define GUILD_BANK_FULL 6098 // There is no more room in the Guild Bank. @@ -418,6 +424,7 @@ #define GAIN_GROUP_LEADERSHIP_EXP 8788 // #define GAIN_RAID_LEADERSHIP_EXP 8789 // #define BUFF_MINUTES_REMAINING 8799 //%1 (%2 minutes remaining) +#define YOU_HAVE_BEEN_GIVEN 8994 //You have been given: %1 #define NO_MORE_TRAPS 9002 //You have already placed your maximum number of traps. #define FEAR_TOO_HIGH 9035 //Your target is too high of a level for your fear spell. #define SLOW_MOSTLY_SUCCESSFUL 9029 //Your spell was mostly successful. diff --git a/zone/task_client_state.cpp b/zone/task_client_state.cpp index 3ded9eb27..e00960238 100644 --- a/zone/task_client_state.cpp +++ b/zone/task_client_state.cpp @@ -1,6 +1,7 @@ #include "../common/global_define.h" #include "../common/misc_functions.h" #include "../common/repositories/character_activities_repository.h" +#include "../common/repositories/character_task_timers_repository.h" #include "../common/repositories/character_tasks_repository.h" #include "../common/repositories/completed_tasks_repository.h" #include "../common/rulesys.h" @@ -9,8 +10,13 @@ #include "quest_parser_collection.h" #include "task_client_state.h" #include "zonedb.h" +#include "../common/shared_tasks.h" +#include "worldserver.h" +#include "dynamic_zone.h" +#include "string_ids.h" -extern QueryServ *QServ; +extern WorldServer worldserver; +extern QueryServ *QServ; ClientTaskState::ClientTaskState() { @@ -23,9 +29,13 @@ ClientTaskState::ClientTaskState() m_active_quests[i].task_id = TASKSLOTEMPTY; } + m_active_task = {}; m_active_task.slot = 0; m_active_task.task_id = TASKSLOTEMPTY; - // TODO: shared task + + m_active_shared_task = {}; + m_active_shared_task.slot = 0; + m_active_shared_task.task_id = TASKSLOTEMPTY; } ClientTaskState::~ClientTaskState() @@ -92,7 +102,7 @@ void ClientTaskState::SendTaskHistory(Client *client, int task_index) for (int i = 0; i < p_task_data->activity_count; i++) { if (m_completed_tasks[adjusted_task_index].activity_done[i]) { task_history_reply_data_1 = (TaskHistoryReplyData1_Struct *) reply; - task_history_reply_data_1->ActivityType = p_task_data->activity_information[i].activity_type; + task_history_reply_data_1->ActivityType = static_cast(p_task_data->activity_information[i].activity_type); reply = (char *) task_history_reply_data_1 + sizeof(TaskHistoryReplyData1_Struct); VARSTRUCT_ENCODE_STRING(reply, p_task_data->activity_information[i].target_name.c_str()); VARSTRUCT_ENCODE_STRING(reply, p_task_data->activity_information[i].item_list.c_str()); @@ -321,7 +331,7 @@ bool ClientTaskState::HasSlotForTask(TaskInformation *task) case TaskType::Task: return m_active_task.task_id == TASKSLOTEMPTY; case TaskType::Shared: - return false; // todo + return m_active_shared_task.task_id == TASKSLOTEMPTY; case TaskType::Quest: for (auto &active_quest : m_active_quests) { if (active_quest.task_id == TASKSLOTEMPTY) { @@ -359,20 +369,39 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & { bool all_activities_complete = true; + LogTasksDetail( + "[UnlockActivities] Fetching task info for character_id [{}] task [{}] slot [{}] current_step [{}] accepted_time [{}] updated [{}]", + character_id, + task_info.task_id, + task_info.slot, + task_info.current_step, + task_info.accepted_time, + task_info.updated + ); + TaskInformation *p_task_data = task_manager->m_task_data[task_info.task_id]; if (p_task_data == nullptr) { return true; } + for (int i = 0; i < p_task_data->activity_count; i++) { + if (task_info.activity[i].activity_id >= 0) { + LogTasksDetail( + "[UnlockActivities] character_id [{}] task [{}] activity_id [{}] done_count [{}] activity_state [{}] updated [{}] sequence [{}]", + character_id, + task_info.task_id, + task_info.activity[i].activity_id, + task_info.activity[i].done_count, + task_info.activity[i].activity_state, + task_info.activity[i].updated, + p_task_data->sequence_mode + ); + } + } + // On loading the client state, all activities that are not completed, are // marked as hidden. For Sequential (non-stepped) mode, we mark the first // activity_information as active if not complete. - LogTasks( - "character_id [{}] task_id [{}] sequence_mode [{}]", - character_id, - task_info.task_id, - p_task_data->sequence_mode - ); if (p_task_data->sequence_mode == ActivitiesSequential) { if (task_info.activity[0].activity_state != ActivityCompleted) { @@ -418,15 +447,18 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & } } - CompletedTaskInformation completed_task_information{}; - completed_task_information.task_id = task_info.task_id; - completed_task_information.completed_time = time(nullptr); + if (p_task_data->type != TaskType::Shared) { + CompletedTaskInformation completed_task_information{}; + completed_task_information.task_id = task_info.task_id; + completed_task_information.completed_time = time(nullptr); - for (int i = 0; i < p_task_data->activity_count; i++) { - completed_task_information.activity_done[i] = (task_info.activity[i].activity_state == ActivityCompleted); + for (int i = 0; i < p_task_data->activity_count; i++) { + completed_task_information.activity_done[i] = (task_info.activity[i].activity_state == + ActivityCompleted); + } + + m_completed_tasks.push_back(completed_task_information); } - - m_completed_tasks.push_back(completed_task_information); } LogTasks("Returning sequential task, AllActivitiesComplete is [{}]", all_activities_complete); @@ -505,24 +537,42 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & } } - CompletedTaskInformation completed_task_information{}; - completed_task_information.task_id = task_info.task_id; - completed_task_information.completed_time = time(nullptr); + if (p_task_data->type != TaskType::Shared) { + CompletedTaskInformation completed_task_information{}; + completed_task_information.task_id = task_info.task_id; + completed_task_information.completed_time = time(nullptr); - for (int activity_id = 0; activity_id < p_task_data->activity_count; activity_id++) { - completed_task_information.activity_done[activity_id] = - (task_info.activity[activity_id].activity_state == ActivityCompleted); + for (int activity_id = 0; activity_id < p_task_data->activity_count; activity_id++) { + completed_task_information.activity_done[activity_id] = + (task_info.activity[activity_id].activity_state == ActivityCompleted); + } + + m_completed_tasks.push_back(completed_task_information); } - - m_completed_tasks.push_back(completed_task_information); } return true; } // Mark all non-completed tasks in the current step as active for (int activity = 0; activity < p_task_data->activity_count; activity++) { + LogTasksDetail( + "[UnlockActivities] - Debug task [{}] activity [{}] step_number [{}] current_step [{}]", + task_info.task_id, + activity, + p_task_data->activity_information[activity].step_number, + (int) task_info.current_step + + ); + if ((p_task_data->activity_information[activity].step_number == (int) task_info.current_step) && (task_info.activity[activity].activity_state == ActivityHidden)) { + + LogTasksDetail( + "[UnlockActivities] -- Debug task [{}] activity [{}] (ActivityActive)", + task_info.task_id, + activity + ); + task_info.activity[activity].activity_state = ActivityActive; task_info.activity[activity].updated = true; } @@ -533,21 +583,20 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & void ClientTaskState::UpdateTasksOnKill(Client *client, int npc_type_id) { - UpdateTasksByNPC(client, ActivityKill, npc_type_id); + UpdateTasksByNPC(client, TaskActivityType::Kill, npc_type_id); } bool ClientTaskState::UpdateTasksOnSpeakWith(Client *client, int npc_type_id) { - return UpdateTasksByNPC(client, ActivitySpeakWith, npc_type_id); + return UpdateTasksByNPC(client, TaskActivityType::SpeakWith, npc_type_id); } -bool ClientTaskState::UpdateTasksByNPC(Client *client, int activity_type, int npc_type_id) +bool ClientTaskState::UpdateTasksByNPC(Client *client, TaskActivityType activity_type, int npc_type_id) { int is_updating = false; - // If the client has no tasks, there is nothing further to check. - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!HasActiveTasks()) { return false; } @@ -583,7 +632,7 @@ bool ClientTaskState::UpdateTasksByNPC(Client *client, int activity_type, int np client->GetName(), current_task->task_id, activity_id, - activity_type, + static_cast(activity_type), npc_type_id ); continue; @@ -624,7 +673,7 @@ int ClientTaskState::ActiveSpeakTask(int npc_type_id) // This method is to be used from Perl quests only and returns the task_id of the first // active task found which has an active SpeakWith activity_information for this NPC. - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!HasActiveTasks()) { return 0; } @@ -648,7 +697,7 @@ int ClientTaskState::ActiveSpeakTask(int npc_type_id) if (client_activity->activity_state != ActivityActive) { continue; } - if (activity_info->activity_type != ActivitySpeakWith) { + if (activity_info->activity_type != TaskActivityType::SpeakWith) { continue; } // Is there a zone restriction on the activity_information ? @@ -670,7 +719,7 @@ int ClientTaskState::ActiveSpeakActivity(int npc_type_id, int task_id) // This method is to be used from Perl quests only and returns the activity_id of the first // active activity_information found in the specified task which is to SpeakWith this NPC. - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!HasActiveTasks()) { return -1; } if (task_id <= 0 || task_id >= MAXTASKS) { @@ -697,7 +746,7 @@ int ClientTaskState::ActiveSpeakActivity(int npc_type_id, int task_id) if (client_activity->activity_state != ActivityActive) { continue; } - if (activity_info->activity_type != ActivitySpeakWith) { + if (activity_info->activity_type != TaskActivityType::SpeakWith) { continue; } // Is there a zone restriction on the activity_information ? @@ -715,7 +764,7 @@ int ClientTaskState::ActiveSpeakActivity(int npc_type_id, int task_id) return 0; } -void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_type, int item_id, int count) +void ClientTaskState::UpdateTasksForItem(Client *client, TaskActivityType activity_type, int item_id, int count) { // This method updates the client's task activities of the specified type which relate @@ -727,11 +776,11 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t LogTasks( "[UpdateTasksForItem] activity_type [{}] item_id [{}]", - activity_type, + static_cast(activity_type), item_id ); - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!HasActiveTasks()) { return; } @@ -758,7 +807,7 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t continue; } // We are only interested in the ActivityType we were called with - if (activity_info->activity_type != (int) activity_type) { + if (activity_info->activity_type != activity_type) { continue; } // Is there a zone restriction on the activity_information ? @@ -766,7 +815,7 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t LogTasks( "[UpdateTasksForItem] Error: Character [{}] activity_information type [{}] for Item [{}] failed zone check", client->GetName(), - activity_type, + static_cast(activity_type), item_id ); continue; @@ -800,7 +849,8 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t void ClientTaskState::UpdateTasksOnExplore(Client *client, int explore_id) { LogTasks("[UpdateTasksOnExplore] explore_id [{}]", explore_id); - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + + if (!HasActiveTasks()) { return; } @@ -827,7 +877,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *client, int explore_id) continue; } // We are only interested in explore activities - if (activity_info->activity_type != ActivityExplore) { + if (activity_info->activity_type != TaskActivityType::Explore) { continue; } if (!activity_info->CheckZone(zone->GetZoneID())) { @@ -890,7 +940,8 @@ bool ClientTaskState::UpdateTasksOnDeliver( bool is_updated = false; LogTasks("[UpdateTasksOnDeliver] [{}]", npc_type_id); - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + + if (!HasActiveTasks()) { return false; } @@ -917,8 +968,8 @@ bool ClientTaskState::UpdateTasksOnDeliver( } // We are only interested in Deliver activities - if (activity_info->activity_type != ActivityDeliver && - activity_info->activity_type != ActivityGiveCash) { + if (activity_info->activity_type != TaskActivityType::Deliver && + activity_info->activity_type != TaskActivityType::GiveCash) { continue; } // Is there a zone restriction on the activity_information ? @@ -936,7 +987,7 @@ bool ClientTaskState::UpdateTasksOnDeliver( } // Is the activity_information related to these items ? // - if ((activity_info->activity_type == ActivityGiveCash) && cash) { + if ((activity_info->activity_type == TaskActivityType::GiveCash) && cash) { LogTasks("[UpdateTasksOnDeliver] Increment on GiveCash"); IncrementDoneCount(client, p_task_data, i, activity_id, cash); is_updated = true; @@ -985,7 +1036,8 @@ void ClientTaskState::UpdateTasksOnTouch(Client *client, int zone_id) // If the client has no tasks, there is nothing further to check. LogTasks("[UpdateTasksOnTouch] [{}] ", zone_id); - if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + + if (!HasActiveTasks()) { return; } @@ -1011,7 +1063,7 @@ void ClientTaskState::UpdateTasksOnTouch(Client *client, int zone_id) continue; } // We are only interested in touch activities - if (activity_info->activity_type != ActivityTouch) { + if (activity_info->activity_type != TaskActivityType::Touch) { continue; } if (activity_info->goal_method != METHODSINGLEID) { @@ -1048,13 +1100,58 @@ void ClientTaskState::IncrementDoneCount( bool ignore_quest_update ) { - Log(Logs::General, Logs::Tasks, "[UPDATE] IncrementDoneCount"); - auto info = GetClientTaskInfo(task_information->type, task_index); if (info == nullptr) { return; } + LogTasks( + "[IncrementDoneCount] client [{}] task_id [{}] activity_id [{}] count [{}]", + client->GetCleanName(), + info->task_id, + activity_id, + count + ); + + // shared task shim + // intercept and pass to world first before processing normally + if (!client->m_shared_task_update && task_information->type == TaskType::Shared) { + + // struct + auto pack = new ServerPacket(ServerOP_SharedTaskUpdate, sizeof(ServerSharedTaskActivityUpdate_Struct)); + auto *r = (ServerSharedTaskActivityUpdate_Struct *) pack->pBuffer; + + // fill + r->source_character_id = client->CharacterID(); + r->task_id = info->task_id; + r->activity_id = activity_id; + r->done_count = info->activity[activity_id].done_count + count; + r->ignore_quest_update = ignore_quest_update; + + LogTasksDetail( + "[IncrementDoneCount] shared_task sending client [{}] task_id [{}] activity_id [{}] count [{}] ignore_quest_update [{}]", + r->source_character_id, + r->task_id, + r->activity_id, + r->done_count, + (ignore_quest_update ? "true" : "false") + ); + + SyncSharedTaskZoneClientDoneCountState( + client, + task_information, + task_index, + activity_id, + r->done_count + ); + + // send + worldserver.SendPacket(pack); + safe_delete(pack); + + return; + } + info->activity[activity_id].done_count += count; if (info->activity[activity_id].done_count > task_information->activity_information[activity_id].goal_count) { @@ -1078,8 +1175,7 @@ void ClientTaskState::IncrementDoneCount( info->activity[activity_id].updated = true; // Have we reached the goal count for this activity_information ? if (info->activity[activity_id].done_count >= task_information->activity_information[activity_id].goal_count) { - Log( - Logs::General, Logs::Tasks, "[UPDATE] Done (%i) = Goal (%i) for activity_information %i", + LogTasks("[IncrementDoneCount] done_count [{}] goal_count [{}] activity_id [{}]", info->activity[activity_id].done_count, task_information->activity_information[activity_id].goal_count, activity_id @@ -1089,32 +1185,30 @@ void ClientTaskState::IncrementDoneCount( info->activity[activity_id].activity_state = ActivityCompleted; // Unlock subsequent activities for this task bool task_complete = UnlockActivities(client->CharacterID(), *info); - Log(Logs::General, Logs::Tasks, "[UPDATE] TaskCompleted is %i", task_complete); + LogTasks("[IncrementDoneCount] task_complete is [{}]", task_complete); // and by the 'Task Stage Completed' message client->SendTaskActivityComplete(info->task_id, activity_id, task_index, task_information->type); // Send the updated task/activity_information list to the client task_manager->SendSingleActiveTaskToClient(client, *info, task_complete, false); // Inform the client the task has been updated, both by a chat message - client->Message(Chat::White, "Your task '%s' has been updated.", task_information->title.c_str()); + client->MessageString(Chat::White, TASK_UPDATED, task_information->title.c_str()); - if (task_information->activity_information[activity_id].goal_method != METHODQUEST) { - if (!ignore_quest_update) { - char buf[24]; - snprintf(buf, 23, "%d %d", info->task_id, info->activity[activity_id].activity_id); - buf[23] = '\0'; - parse->EventPlayer(EVENT_TASK_STAGE_COMPLETE, client, buf, 0); - } - /* QS: PlayerLogTaskUpdates :: Update */ - if (RuleB(QueryServ, PlayerLogTaskUpdates)) { - std::string event_desc = StringFormat( - "Task Stage Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", - info->task_id, - info->activity[activity_id].activity_id, - info->activity[activity_id].done_count, - client->GetZoneID(), - client->GetInstanceID()); - QServ->PlayerLogEvent(Player_Log_Task_Updates, client->CharacterID(), event_desc); - } + if (!ignore_quest_update) { + char buf[24]; + snprintf(buf, 23, "%d %d", info->task_id, info->activity[activity_id].activity_id); + buf[23] = '\0'; + parse->EventPlayer(EVENT_TASK_STAGE_COMPLETE, client, buf, 0); + } + /* QS: PlayerLogTaskUpdates :: Update */ + if (RuleB(QueryServ, PlayerLogTaskUpdates)) { + std::string event_desc = StringFormat( + "Task Stage Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", + info->task_id, + info->activity[activity_id].activity_id, + info->activity[activity_id].done_count, + client->GetZoneID(), + client->GetInstanceID()); + QServ->PlayerLogEvent(Player_Log_Task_Updates, client->CharacterID(), event_desc); } // If this task is now complete, the Completed tasks will have been @@ -1145,16 +1239,24 @@ void ClientTaskState::IncrementDoneCount( QServ->PlayerLogEvent(Player_Log_Task_Updates, client->CharacterID(), event_desc); } - task_manager->SendCompletedTasksToClient(client, this); client->SendTaskActivityComplete(info->task_id, 0, task_index, task_information->type, 0); task_manager->SaveClientState(client, this); - //c->SendTaskComplete(TaskIndex); - client->CancelTask(task_index, task_information->type); - //if(Task->reward_method != METHODQUEST) RewardTask(c, Task); + // If Experience and/or cash rewards are set, reward them from the task even if reward_method is METHODQUEST RewardTask(client, task_information); //RemoveTask(c, TaskIndex); + // add replay timer (world adds timers to shared task members) + AddReplayTimer(client, *info, *task_information); + + // shared tasks linger at the completion step and do not get removed from the task window unlike quests/task + if (task_information->type == TaskType::Shared) { + return; + } + + task_manager->SendCompletedTasksToClient(client, this); + + client->CancelTask(task_index, task_information->type); } } @@ -1164,8 +1266,7 @@ void ClientTaskState::IncrementDoneCount( client, info->task_id, activity_id, - task_index, - task_information->activity_information[activity_id].optional + task_index ); task_manager->SaveClientState(client, this); } @@ -1178,6 +1279,10 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati return; } + if (!task_information->completion_emote.empty()) { + client->Message(Chat::Yellow, task_information->completion_emote.c_str()); + } + const EQ::ItemData *item_data; std::vector reward_list; @@ -1187,7 +1292,7 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati client->SummonItem(task_information->reward_id); item_data = database.GetItem(task_information->reward_id); if (item_data) { - client->Message(Chat::Yellow, "You receive %s as a reward.", item_data->Name); + client->MessageString(Chat::Yellow, YOU_HAVE_BEEN_GIVEN, item_data->Name); } } break; @@ -1198,7 +1303,7 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati client->SummonItem(item_id); item_data = database.GetItem(item_id); if (item_data) { - client->Message(Chat::Yellow, "You receive %s as a reward.", item_data->Name); + client->MessageString(Chat::Yellow, YOU_HAVE_BEEN_GIVEN, item_data->Name); } } break; @@ -1209,13 +1314,6 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati } } - if (!task_information->completion_emote.empty()) { - client->SendColoredText( - Chat::Yellow, - task_information->completion_emote - ); - } // unsure if they use this packet or color, should work - // just use normal NPC faction ID stuff if (task_information->faction_reward) { client->SetFactionLevel( @@ -1294,6 +1392,11 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati } } + if (task_information->reward_radiant_crystals > 0 || task_information->reward_ebon_crystals > 0) + { + client->AddCrystals(task_information->reward_radiant_crystals, task_information->reward_ebon_crystals); + } + client->SendSound(); } @@ -1303,6 +1406,10 @@ bool ClientTaskState::IsTaskActive(int task_id) return true; } + if (m_active_shared_task.task_id == task_id) { + return true; + } + if (m_active_task_count == 0 || task_id == 0) { return false; } @@ -1325,10 +1432,20 @@ void ClientTaskState::FailTask(Client *client, int task_id) m_active_task_count ); + + // type: Task if (m_active_task.task_id == task_id) { - client->SendTaskFailed(task_id, 0, TaskType::Task); + client->SendTaskFailed(task_id, TASKSLOTTASK, TaskType::Task); // Remove the task from the client - client->CancelTask(0, TaskType::Task); + client->CancelTask(TASKSLOTTASK, TaskType::Task); + return; + } + + // type: Shared Task + if (m_active_shared_task.task_id == task_id) { + client->SendTaskFailed(task_id, TASKSLOTSHAREDTASK, TaskType::Shared); + // Remove the task from the client + client->CancelTask(TASKSLOTSHAREDTASK, TaskType::Shared); return; } @@ -1357,15 +1474,19 @@ bool ClientTaskState::IsTaskActivityActive(int task_id, int activity_id) if (activity_id < 0) { return false; } - if (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY) { + if (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY && + m_active_shared_task.task_id == TASKSLOTEMPTY) { return false; } int active_task_index = -1; auto task_type = TaskType::Task; - if (m_active_task.task_id == task_id) { - active_task_index = 0; + active_task_index = TASKSLOTTASK; + } + if (m_active_shared_task.task_id == task_id) { + task_type = TaskType::Shared; + active_task_index = TASKSLOTSHAREDTASK; } if (active_task_index == -1) { @@ -1426,7 +1547,8 @@ void ClientTaskState::UpdateTaskActivity( ); // Quick sanity check - if (activity_id < 0 || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { + if (activity_id < 0 || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY && + m_active_shared_task.task_id == TASKSLOTEMPTY)) { return; } @@ -1434,7 +1556,11 @@ void ClientTaskState::UpdateTaskActivity( auto type = TaskType::Task; if (m_active_task.task_id == task_id) { - active_task_index = 0; + active_task_index = TASKSLOTTASK; + } + if (m_active_shared_task.task_id == task_id) { + type = TaskType::Shared; + active_task_index = TASKSLOTSHAREDTASK; } if (active_task_index == -1) { @@ -1494,14 +1620,19 @@ void ClientTaskState::ResetTaskActivity(Client *client, int task_id, int activit ); // Quick sanity check - if (activity_id < 0 || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { + if (activity_id < 0 || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY && + m_active_shared_task.task_id == TASKSLOTEMPTY)) { return; } int active_task_index = -1; auto type = TaskType::Task; if (m_active_task.task_id == task_id) { - active_task_index = 0; + active_task_index = TASKSLOTTASK; + } + if (m_active_shared_task.task_id == task_id) { + type = TaskType::Shared; + active_task_index = TASKSLOTSHAREDTASK; } if (active_task_index == -1) { @@ -1556,32 +1687,67 @@ void ClientTaskState::ResetTaskActivity(Client *client, int task_id, int activit ); } +void ClientTaskState::ShowClientTaskInfoMessage(ClientTaskInformation *task, Client *c) +{ + auto task_data = task_manager->m_task_data[task->task_id]; + + c->Message(Chat::White, "------------------------------------------------"); + c->Message( + Chat::White, "# [%s] | task_id [%i] title [%s] slot (%i)", + Tasks::GetTaskTypeDescription(task_data->type).c_str(), + task->task_id, + task_data->title.c_str(), + task->slot + ); + c->Message(Chat::White, "------------------------------------------------"); + c->Message( + Chat::White, + " -- Description [%s]\n", + task_data->description.c_str() + ); + + for (int activity_id = 0; activity_id < task_manager->GetActivityCount(task->task_id); activity_id++) { + std::vector update_increments = {"1", "5", "50"}; + std::string update_saylinks; + + for (auto &increment: update_increments) { + auto task_update_saylink = EQ::SayLinkEngine::GenerateQuestSaylink( + fmt::format( + "#task update {} {} {}", + task->task_id, + task->activity[activity_id].activity_id, + increment + ), + false, + increment + ); + + update_saylinks += "[" + task_update_saylink + "] "; + } + + c->Message( + Chat::White, + " --- Update %s activity_id [%i] done_count [%i] state [%d] (%s)", + update_saylinks.c_str(), + task->activity[activity_id].activity_id, + task->activity[activity_id].done_count, + task->activity[activity_id].activity_state, + Tasks::GetActivityStateDescription(task->activity[activity_id].activity_state).c_str() + ); + } +} + void ClientTaskState::ShowClientTasks(Client *client) { client->Message(Chat::White, "------------------------------------------------"); client->Message(Chat::White, "# Task Information | Client [%s]", client->GetCleanName()); // client->Message(Chat::White, "------------------------------------------------"); if (m_active_task.task_id != TASKSLOTEMPTY) { - client->Message( - Chat::White, - "Task: %i %s", - m_active_task.task_id, - task_manager->m_task_data[m_active_task.task_id]->title.c_str() - ); - client->Message( - Chat::White, - " description: [%s]\n", - task_manager->m_task_data[m_active_task.task_id]->description.c_str() - ); - for (int activity_id = 0; activity_id < task_manager->GetActivityCount(m_active_task.task_id); activity_id++) { - client->Message( - Chat::White, - " activity_information: %2d, done_count: %2d, Status: %d (0=Hidden, 1=Active, 2=Complete)", - m_active_task.activity[activity_id].activity_id, - m_active_task.activity[activity_id].done_count, - m_active_task.activity[activity_id].activity_state - ); - } + ShowClientTaskInfoMessage(&m_active_task, client); + } + + if (m_active_shared_task.task_id != TASKSLOTEMPTY) { + ShowClientTaskInfoMessage(&m_active_shared_task, client); } for (auto &active_quest : m_active_quests) { @@ -1589,48 +1755,7 @@ void ClientTaskState::ShowClientTasks(Client *client) continue; } - client->Message(Chat::White, "------------------------------------------------"); - client->Message( - Chat::White, "# Quest | task_id [%i] title [%s]", - active_quest.task_id, - task_manager->m_task_data[active_quest.task_id]->title.c_str() - ); - client->Message(Chat::White, "------------------------------------------------"); - - client->Message( - Chat::White, - " -- Description [%s]\n", - task_manager->m_task_data[active_quest.task_id]->description.c_str() - ); - - for (int activity_id = 0; activity_id < task_manager->GetActivityCount(active_quest.task_id); activity_id++) { - std::vector update_increments = {"1", "5", "50"}; - std::string update_saylinks; - - for (auto &increment: update_increments) { - auto task_update_saylink = EQ::SayLinkEngine::GenerateQuestSaylink( - fmt::format( - "#task update {} {} {}", - active_quest.task_id, - active_quest.activity[activity_id].activity_id, - increment - ), - false, - increment - ); - - update_saylinks += "[" + task_update_saylink + "] "; - } - - client->Message( - Chat::White, - " --- activity_id [%i] done_count [%i] state [%d] (0=hidden 1=active 2=complete) | Update %s", - active_quest.activity[activity_id].activity_id, - active_quest.activity[activity_id].done_count, - active_quest.activity[activity_id].activity_state, - update_saylinks.c_str() - ); - } + ShowClientTaskInfoMessage(&active_quest, client); } client->Message(Chat::White, "------------------------------------------------"); @@ -1639,6 +1764,8 @@ void ClientTaskState::ShowClientTasks(Client *client) // TODO: Shared Task int ClientTaskState::TaskTimeLeft(int task_id) { + + // type "task" if (m_active_task.task_id == task_id) { int time_now = time(nullptr); @@ -1656,6 +1783,24 @@ int ClientTaskState::TaskTimeLeft(int task_id) return (time_left > 0 ? time_left : 0); } + // type "shared task" + if (m_active_shared_task.task_id == task_id) { + int time_now = time(nullptr); + + TaskInformation *p_task_data = task_manager->m_task_data[task_id]; + if (p_task_data == nullptr) { + return -1; + } + + if (!p_task_data->duration) { + return -1; + } + + int time_left = (m_active_shared_task.accepted_time + p_task_data->duration - time_now); + + return (time_left > 0 ? time_left : 0); + } + if (m_active_task_count == 0) { return -1; } @@ -1731,12 +1876,14 @@ bool ClientTaskState::TaskOutOfTime(TaskType task_type, int index) void ClientTaskState::TaskPeriodicChecks(Client *client) { + + // type "task" if (m_active_task.task_id != TASKSLOTEMPTY) { - if (TaskOutOfTime(TaskType::Task, 0)) { + if (TaskOutOfTime(TaskType::Task, TASKSLOTTASK)) { // Send Red Task Failed Message - client->SendTaskFailed(m_active_task.task_id, 0, TaskType::Task); + client->SendTaskFailed(m_active_task.task_id, TASKSLOTTASK, TaskType::Task); // Remove the task from the client - client->CancelTask(0, TaskType::Task); + client->CancelTask(TASKSLOTTASK, TaskType::Task); // It is a conscious decision to only fail one task per call to this method, // otherwise the player will not see all the failed messages where multiple // tasks fail at the same time. @@ -1744,7 +1891,19 @@ void ClientTaskState::TaskPeriodicChecks(Client *client) } } - // TODO: shared tasks -- although that will probably be manager in world checking and telling zones to fail us + // type "shared" + if (m_active_shared_task.task_id != TASKSLOTEMPTY) { + if (TaskOutOfTime(TaskType::Shared, TASKSLOTSHAREDTASK)) { + // Send Red Task Failed Message + client->SendTaskFailed(m_active_shared_task.task_id, TASKSLOTSHAREDTASK, TaskType::Shared); + // Remove the task from the client + client->CancelTask(TASKSLOTSHAREDTASK, TaskType::Shared); + // It is a conscious decision to only fail one task per call to this method, + // otherwise the player will not see all the failed messages where multiple + // tasks fail at the same time. + return; + } + } if (m_active_task_count == 0) { return; @@ -1783,12 +1942,15 @@ bool ClientTaskState::IsTaskActivityCompleted(TaskType task_type, int index, int { switch (task_type) { case TaskType::Task: - if (index != 0) { + if (index != TASKSLOTTASK) { return false; } return m_active_task.activity[activity_id].activity_state == ActivityCompleted; case TaskType::Shared: - return false; // TODO: shared tasks + if (index != TASKSLOTSHAREDTASK) { + return false; + } + return m_active_shared_task.activity[activity_id].activity_state == ActivityCompleted; case TaskType::Quest: if (index < MAXACTIVEQUESTS) { return m_active_quests[index].activity[activity_id].activity_state == ActivityCompleted; @@ -1802,33 +1964,58 @@ bool ClientTaskState::IsTaskActivityCompleted(TaskType task_type, int index, int // should we be defaulting to hidden? ActivityState ClientTaskState::GetTaskActivityState(TaskType task_type, int index, int activity_id) { + ActivityState return_state = ActivityHidden; switch (task_type) { case TaskType::Task: - if (index != 0) { - return ActivityHidden; + if (index != TASKSLOTTASK) { + return_state = ActivityHidden; + break; } - return m_active_task.activity[activity_id].activity_state; + return_state = m_active_task.activity[activity_id].activity_state; + break; case TaskType::Shared: - return ActivityHidden; // TODO: shared tasks + if (index != TASKSLOTSHAREDTASK) { + return_state = ActivityHidden; + break; + } + return_state = m_active_shared_task.activity[activity_id].activity_state; + break; case TaskType::Quest: if (index < MAXACTIVEQUESTS) { - return m_active_quests[index].activity[activity_id].activity_state; + return_state = m_active_quests[index].activity[activity_id].activity_state; + break; } + break; default: - return ActivityHidden; + return_state = ActivityHidden; } + + LogTasksDetail( + "-- [GetTaskActivityState] task_type [{}] ({}) index [{}] activity_id [{}] activity_state [{}] ({})", + Tasks::GetTaskTypeIdentifier(task_type), + Tasks::GetTaskTypeDescription(task_type), + index, + activity_id, + Tasks::GetActivityStateIdentifier(return_state), + Tasks::GetActivityStateDescription(return_state) + ); + + return return_state; } int ClientTaskState::GetTaskActivityDoneCount(TaskType task_type, int index, int activity_id) { switch (task_type) { case TaskType::Task: - if (index != 0) { + if (index != TASKSLOTTASK) { return 0; } return m_active_task.activity[activity_id].done_count; case TaskType::Shared: - return 0; // TODO: shared tasks + if (index != TASKSLOTSHAREDTASK) { + return 0; + } + return m_active_shared_task.activity[activity_id].done_count; case TaskType::Quest: if (index < MAXACTIVEQUESTS) { return m_active_quests[index].activity[activity_id].done_count; @@ -1840,11 +2027,16 @@ int ClientTaskState::GetTaskActivityDoneCount(TaskType task_type, int index, int int ClientTaskState::GetTaskActivityDoneCountFromTaskID(int task_id, int activity_id) { + + // type "task" if (m_active_task.task_id == task_id) { return m_active_task.activity[activity_id].done_count; } - // TODO: shared tasks + // type "shared" + if (m_active_shared_task.task_id == task_id) { + return m_active_shared_task.activity[activity_id].done_count; + } int active_task_index = -1; @@ -1874,7 +2066,8 @@ int ClientTaskState::GetTaskStartTime(TaskType task_type, int index) return m_active_task.accepted_time; case TaskType::Quest: return m_active_quests[index].accepted_time; - case TaskType::Shared: // TODO + case TaskType::Shared: + return m_active_shared_task.accepted_time; default: return -1; } @@ -1887,9 +2080,16 @@ void ClientTaskState::CancelAllTasks(Client *client) // It removes tasks from the in-game client state ready for them to be // resent to the client, in case an updated task fails to load - CancelTask(client, 0, TaskType::Task, false); + // task + // these cancels lock up the client for some reason + CancelTask(client, TASKSLOTTASK, TaskType::Task, false); m_active_task.task_id = TASKSLOTEMPTY; + // shared task + CancelTask(client, TASKSLOTSHAREDTASK, TaskType::Shared, false); + m_active_shared_task.task_id = TASKSLOTEMPTY; + + // "quests" for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) if (m_active_quests[task_index].task_id != TASKSLOTEMPTY) { CancelTask(client, task_index, TaskType::Quest, false); @@ -1899,24 +2099,60 @@ void ClientTaskState::CancelAllTasks(Client *client) // TODO: shared } -void ClientTaskState::CancelTask(Client *client, int sequence_number, TaskType task_type, bool remove_from_db) +void ClientTaskState::CancelTask(Client *c, int sequence_number, TaskType task_type, bool remove_from_db) { + LogTasks("CancelTask"); + + // shared task middleware + // intercept and pass to world first before processing normally + if (!c->m_requested_shared_task_removal && task_type == TaskType::Shared && m_active_shared_task.task_id != 0) { + + // struct + auto pack = new ServerPacket(ServerOP_SharedTaskAttemptRemove, sizeof(ServerSharedTaskAttemptRemove_Struct)); + auto *r = (ServerSharedTaskAttemptRemove_Struct *) pack->pBuffer; + + // fill + r->requested_character_id = c->CharacterID(); + r->requested_task_id = m_active_shared_task.task_id; + r->remove_from_db = remove_from_db; + + // send + worldserver.SendPacket(pack); + safe_delete(pack); + + return; + } + + // packet auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); - CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; + // fill + auto *cts = (CancelTask_Struct *) outapp->pBuffer; cts->SequenceNumber = sequence_number; cts->type = static_cast(task_type); - Log(Logs::General, Logs::Tasks, "[UPDATE] CancelTask"); - - client->QueuePacket(outapp); + // send + c->QueuePacket(outapp); safe_delete(outapp); + // persistence if (remove_from_db) { - RemoveTask(client, sequence_number, task_type); + RemoveTask(c, sequence_number, task_type); } } +void ClientTaskState::KickPlayersSharedTask(Client* client) +{ + uint32_t pack_size = sizeof(ServerSharedTaskKickPlayers_Struct); + auto pack = std::make_unique(ServerOP_SharedTaskKickPlayers, pack_size); + auto buf = reinterpret_cast(pack->pBuffer); + + buf->source_character_id = client->CharacterID(); + buf->task_id = m_active_shared_task.task_id; + + worldserver.SendPacket(pack.get()); +} + void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType task_type) { int character_id = client->CharacterID(); @@ -1925,7 +2161,7 @@ void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType t int task_id = -1; switch (task_type) { case TaskType::Task: - if (sequence_number == 0) { + if (sequence_number == TASKSLOTTASK) { task_id = m_active_task.task_id; } break; @@ -1934,7 +2170,11 @@ void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType t task_id = m_active_quests[sequence_number].task_id; } break; - case TaskType::Shared: // TODO: + case TaskType::Shared: + if (sequence_number == TASKSLOTSHAREDTASK) { + task_id = m_active_shared_task.task_id; + } + break; default: break; } @@ -1954,7 +2194,8 @@ void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType t m_active_task.task_id = TASKSLOTEMPTY; break; case TaskType::Shared: - break; // TODO: shared tasks + m_active_shared_task.task_id = TASKSLOTEMPTY; + break; case TaskType::Quest: m_active_quests[sequence_number].task_id = TASKSLOTEMPTY; m_active_task_count--; @@ -1984,7 +2225,7 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) if (m_active_task.task_id == task_id) { auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; - cts->SequenceNumber = 0; + cts->SequenceNumber = TASKSLOTTASK; cts->type = static_cast(task_type); LogTasks("[UPDATE] RemoveTaskByTaskID found Task [{}]", task_id); client->QueuePacket(outapp); @@ -1994,15 +2235,25 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) break; } case TaskType::Shared: { - break; // TODO: shared tasks + if (m_active_shared_task.task_id == task_id) { + auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); + CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; + cts->SequenceNumber = TASKSLOTSHAREDTASK; + cts->type = static_cast(task_type); + LogTasks("[UPDATE] RemoveTaskByTaskID found Task [{}]", task_id); + client->QueuePacket(outapp); + safe_delete(outapp); + m_active_shared_task.task_id = TASKSLOTEMPTY; + } + break; } case TaskType::Quest: { for (int active_quest = 0; active_quest < MAXACTIVEQUESTS; active_quest++) { if (m_active_quests[active_quest].task_id == task_id) { auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; - cts->SequenceNumber = active_quest; - cts->type = static_cast(task_type); + cts->SequenceNumber = active_quest; + cts->type = static_cast(task_type); LogTasks("[UPDATE] RemoveTaskByTaskID found Quest [{}] at index [{}]", task_id, active_quest); m_active_quests[active_quest].task_id = TASKSLOTEMPTY; m_active_task_count--; @@ -2017,7 +2268,13 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) } } -void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id, bool enforce_level_requirement) +void ClientTaskState::AcceptNewTask( + Client *client, + int task_id, + int npc_type_id, + time_t accept_time, + bool enforce_level_requirement +) { if (!task_manager || task_id < 0 || task_id >= MAXTASKS) { client->Message(Chat::Red, "Task system not functioning, or task_id %i out of range.", task_id); @@ -2025,12 +2282,37 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id } auto task = task_manager->m_task_data[task_id]; - if (task == nullptr) { client->Message(Chat::Red, "Invalid task_id %i", task_id); return; } + // shared task + // intercept and pass to world first before processing normally + if (!client->m_requesting_shared_task && task->type == TaskType::Shared) { + LogTasksDetail( + "[AcceptNewTask] Initiating shared_task request | task_id [{}] character_id [{}] name [{}]", + task_id, + client->CharacterID(), + client->GetCleanName() + ); + + // struct + auto pack = new ServerPacket(ServerOP_SharedTaskRequest, sizeof(ServerSharedTaskRequest_Struct)); + auto *r = (ServerSharedTaskRequest_Struct *) pack->pBuffer; + + // fill + r->requested_character_id = client->CharacterID(); + r->requested_task_id = task_id; + r->requested_npc_type_id = npc_type_id; + + // send + worldserver.SendPacket(pack); + safe_delete(pack); + + return; + } + bool max_tasks = false; switch (task->type) { @@ -2040,8 +2322,9 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id } break; case TaskType::Shared: // TODO: shared tasks - // if (something) - max_tasks = true; + if (m_active_shared_task.task_id != TASKSLOTEMPTY) { + max_tasks = true; + } break; case TaskType::Quest: if (m_active_task_count == MAXACTIVEQUESTS) { @@ -2053,11 +2336,7 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id } if (max_tasks) { - client->Message( - Chat::Red, - "You already have the maximum allowable number of active tasks (%i)", - MAXACTIVEQUESTS - ); + client->MessageString(Chat::Yellow, MAX_ACTIVE_TASKS, ".", ".", client->GetName()); return; } @@ -2065,14 +2344,15 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id if (task->type == TaskType::Quest) { for (auto &active_quest : m_active_quests) { if (active_quest.task_id == task_id) { - client->Message(Chat::Red, "You have already been assigned this task."); + // live doesn't have an eqstr for it but this seems to be the string used for this scenario + client->Message(Chat::Yellow, "You are already working on a task for this person, you must finish it before asking for another."); return; } } } if (enforce_level_requirement && !task_manager->ValidateLevel(task_id, client->GetLevel())) { - client->Message(Chat::Red, "You are outside the level range of this task."); + client->MessageString(Chat::Yellow, TASK_NOT_RIGHT_LEVEL); return; } @@ -2080,6 +2360,39 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id return; } + // solo task timer lockout validation + if (task->type != TaskType::Shared) + { + auto task_timers = CharacterTaskTimersRepository::GetWhere(database, fmt::format( + "character_id = {} AND task_id = {} AND expire_time > NOW() ORDER BY timer_type ASC LIMIT 1", + client->CharacterID(), task_id + )); + + if (!task_timers.empty()) + { + auto timer_type = static_cast(task_timers.front().timer_type); + auto seconds = task_timers.front().expire_time - std::time(nullptr); + auto days = fmt::format_int(seconds / 86400).str(); + auto hours = fmt::format_int((seconds / 3600) % 24).str(); + auto mins = fmt::format_int((seconds / 60) % 60).str(); + + // these solo task messages are in SharedTaskMessage for convenience + namespace EQStr = SharedTaskMessage; + if (timer_type == TaskTimerType::Replay) + { + int eqstr_id = EQStr::TASK_ASSIGN_WAIT_REPLAY_TIMER; + client->MessageString(Chat::Red, eqstr_id, days.c_str(), hours.c_str(), mins.c_str()); + } + else if (timer_type == TaskTimerType::Request) + { + int eqstr_id = EQStr::TASK_ASSIGN_WAIT_REQUEST_TIMER; + client->Message(Chat::Red, fmt::format(EQStr::GetEQStr(eqstr_id), days, hours, mins).c_str()); + } + + return; + } + } + // We do it this way, because when the Client cancels a task, it retains the sequence number of the remaining // tasks in it's window, until something causes the TaskDescription packets to be sent again. We could just // resend all the active task data to the client when it cancels a task, but that could be construed as a @@ -2090,9 +2403,11 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id case TaskType::Task: active_slot = &m_active_task; break; - case TaskType::Shared: // TODO: shared - active_slot = nullptr; + + case TaskType::Shared: + active_slot = &m_active_shared_task; break; + case TaskType::Quest: for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) { Log(Logs::General, Logs::Tasks, @@ -2104,22 +2419,19 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id } } break; + default: break; } // This shouldn't happen unless there is a bug in the handling of ActiveTaskCount somewhere if (active_slot == nullptr) { - client->Message( - Chat::Red, - "You already have the maximum allowable number of active tasks (%i)", - MAXACTIVEQUESTS - ); + client->MessageString(Chat::Yellow, MAX_ACTIVE_TASKS, ".", ".", client->GetName()); return; } active_slot->task_id = task_id; - active_slot->accepted_time = time(nullptr); + active_slot->accepted_time = static_cast(accept_time); active_slot->updated = true; active_slot->current_step = -1; @@ -2136,12 +2448,39 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id m_active_task_count++; } + // add request timer (shared task timers are added to members by world) + if (task->request_timer_seconds > 0) + { + auto expire_time = active_slot->accepted_time + task->request_timer_seconds; + + auto seconds = expire_time - std::time(nullptr); + if (seconds > 0) // not already expired + { + if (task->type != TaskType::Shared) + { + auto timer = CharacterTaskTimersRepository::NewEntity(); + timer.character_id = client->CharacterID(); + timer.task_id = task_id; + timer.timer_type = static_cast(TaskTimerType::Request); + timer.expire_time = expire_time; + + CharacterTaskTimersRepository::InsertOne(database, timer); + } + + client->Message(Chat::Yellow, fmt::format( + SharedTaskMessage::GetEQStr(SharedTaskMessage::RECEIVED_REQUEST_TIMER), + task->title, + fmt::format_int(seconds / 86400).c_str(), // days + fmt::format_int((seconds / 3600) % 24).c_str(), // hours + fmt::format_int((seconds / 60) % 60).c_str() // minutes + ).c_str()); + } + } + task_manager->SendSingleActiveTaskToClient(client, *active_slot, false, true); - client->Message( - Chat::White, - "You have been assigned the task '%s'.", - task_manager->m_task_data[task_id]->title.c_str() - ); + client->StartTaskRequestCooldownTimer(); + client->MessageString(Chat::White, YOU_ASSIGNED_TASK, task->title.c_str()); + task_manager->SaveClientState(client, this); std::string buf = std::to_string(task_id); @@ -2175,3 +2514,357 @@ void ClientTaskState::ProcessTaskProximities(Client *client, float x, float y, f UpdateTasksOnExplore(client, explore_id); } } + +void ClientTaskState::SharedTaskIncrementDoneCount( + Client *client, + int task_id, + int activity_id, + int done_count, + bool ignore_quest_update +) +{ + TaskInformation *t = task_manager->m_task_data[task_id]; + + auto info = GetClientTaskInfo(t->type, TASKSLOTSHAREDTASK); + if (info == nullptr) { + return; + } + + // absolute value update + info->activity[activity_id].done_count = done_count; + + LogTasksDetail( + "[SharedTaskIncrementDoneCount] Setting task_id [{}] to absolute done_count value of [{}] via increment [{}]", + task_id, + info->activity[activity_id].done_count, + done_count + ); + + IncrementDoneCount( + client, + t, + TASKSLOTSHAREDTASK, + activity_id, + 0, // no op + ignore_quest_update + ); +} + +const ClientTaskInformation &ClientTaskState::GetActiveSharedTask() const +{ + return m_active_shared_task; +} + +bool ClientTaskState::HasActiveSharedTask() +{ + return GetActiveSharedTask().task_id != 0; +} + +void ClientTaskState::CreateTaskDynamicZone(Client* client, int task_id, DynamicZone& dz_request) +{ + auto task = task_manager->m_task_data[task_id]; + if (!task) + { + return; + } + + // dz should be named the version-based zone name (used in choose zone window and dz window on live) + auto zone_info = zone_store.GetZone(dz_request.GetZoneID(), dz_request.GetZoneVersion()); + dz_request.SetName(zone_info.long_name.empty() ? task->title : zone_info.long_name); + dz_request.SetMinPlayers(task->min_players); + dz_request.SetMaxPlayers(task->max_players); + + // a task might create a dz from an objective so override dz duration to time remaining + // live probably creates the dz with the shared task and just adds members for objectives + std::chrono::seconds seconds(TaskTimeLeft(task_id)); + if (task->duration == 0 || seconds.count() < 0) + { + // todo: maybe add a rule for duration + // cap unlimited duration tasks so instance isn't held indefinitely + // expected behavior is to re-acquire any unlimited tasks that have an expired dz + seconds = std::chrono::duration_cast(std::chrono::hours(24)); + } + + dz_request.SetDuration(static_cast(seconds.count())); + + if (task->type == TaskType::Task || task->type == TaskType::Quest) + { + if (task->type == TaskType::Task) { + dz_request.SetType(DynamicZoneType::Task); + } else { + dz_request.SetType(DynamicZoneType::Quest); + } + + // todo: can enable non-shared task dz creation when dz ids are persisted for them (db also) + //DynamicZoneMember solo_member{ client->CharacterID(), client->GetCleanName() }; + //DynamicZone::CreateNew(dz_request, { solo_member }); + } + else if (task->type == TaskType::Shared) + { + dz_request.SetType(DynamicZoneType::Mission); + + // shared task missions are created in world + EQ::Net::DynamicPacket dyn_pack = dz_request.GetSerializedDzPacket(); + + auto pack_size = sizeof(ServerSharedTaskCreateDynamicZone_Struct) + dyn_pack.Length(); + auto pack = std::make_unique(ServerOP_SharedTaskCreateDynamicZone, static_cast(pack_size)); + auto buf = reinterpret_cast(pack->pBuffer); + buf->source_character_id = client->CharacterID(); + buf->task_id = task_id; + buf->cereal_size = static_cast(dyn_pack.Length()); + memcpy(buf->cereal_data, dyn_pack.Data(), dyn_pack.Length()); + + worldserver.SendPacket(pack.get()); + } + +} + +void ClientTaskState::ListTaskTimers(Client* client) +{ + LogTasksDetail("[ListTaskTimers] Client [{}]", client->GetCleanName()); + + // this isn't live-like but we need to throttle query (alternative is caching timers) + if (!client->m_list_task_timers_rate_limit.Check()) { + client->Message(Chat::White, "Sending messages too fast"); + return; + } + + auto character_task_timers = CharacterTaskTimersRepository::GetWhere( + database, fmt::format( + "character_id = {} AND expire_time > NOW()", + client->CharacterID() + ) + ); + + for (const auto& task_timer : character_task_timers) + { + auto task = task_manager->m_task_data[task_timer.task_id]; + if (task) + { + auto timer_type = static_cast(task_timer.timer_type); + auto seconds = task_timer.expire_time - std::time(nullptr); + auto days = fmt::format_int(seconds / 86400).str(); + auto hours = fmt::format_int((seconds / 3600) % 24).str(); + auto mins = fmt::format_int((seconds / 60) % 60).str(); + + if (timer_type == TaskTimerType::Replay) + { + client->MessageString(Chat::Yellow, SharedTaskMessage::REPLAY_TIMER_REMAINING, + task->title.c_str(), days.c_str(), hours.c_str(), mins.c_str()); + } + else + { + auto eqstr = SharedTaskMessage::GetEQStr(SharedTaskMessage::REQUEST_TIMER_REMAINING); + client->Message(Chat::Yellow, fmt::format(eqstr, task->title, days, hours, mins).c_str()); + } + } + } + + if (character_task_timers.empty()) { + client->MessageString(Chat::Yellow, SharedTaskMessage::YOU_NO_CURRENT_REPLAY_TIMERS); + } +} + +void ClientTaskState::AddReplayTimer(Client* client, ClientTaskInformation& client_task, TaskInformation& task) +{ + // world adds timers for shared tasks and handles messages + if (task.type != TaskType::Shared && task.replay_timer_seconds > 0 && client) + { + int expire_time = client_task.accepted_time + task.replay_timer_seconds; + + auto seconds = expire_time - std::time(nullptr); + if (seconds > 0) // not already expired + { + auto timer = CharacterTaskTimersRepository::NewEntity(); + timer.character_id = client->CharacterID(); + timer.task_id = client_task.task_id; + timer.expire_time = expire_time; + timer.timer_type = static_cast(TaskTimerType::Replay); + + CharacterTaskTimersRepository::InsertOne(database, timer); + + client->Message(Chat::Yellow, fmt::format( + SharedTaskMessage::GetEQStr(SharedTaskMessage::RECEIVED_REPLAY_TIMER), + task.title, + fmt::format_int(seconds / 86400).c_str(), // days + fmt::format_int((seconds / 3600) % 24).c_str(), // hours + fmt::format_int((seconds / 60) % 60).c_str() // minutes + ).c_str()); + } + } +} + +// Sync zone client donecount state +// +// World is always authoritative, but we still need to keep zone state in sync with reality and in this case we need +// to update zone since world hasn't had a chance to let clients at the zone level know it's ok to progress to the next +// donecount +// +// If we send updates too fast and world has not had a chance to confirm and then inform clients to set their +// absolute state we will miss and discard updates because each update sets the same donecount +// +// Example: say we have a 100 kill task and we kill 10 mobs in an AOE, world gets 10 updates at once but they are +// all from the same donecount so world only confirms 1 was actually killed and the task updates only 1 which is not +// intended behavior. +// +// In this case we need to ensure that clients at the zone level increment internally even if they aren't +// necessarily confirmed by world yet because any of them could inform world of the next donecount so we need to sync +// zone-level before sending updates to world +void ClientTaskState::SyncSharedTaskZoneClientDoneCountState( + Client *p_client, + TaskInformation *p_information, + int task_index, + int activity_id, + uint32 done_count +) +{ + for (auto &e : entity_list.GetClientList()) { + auto c = e.second; + if (c->GetSharedTaskId() == p_client->GetSharedTaskId()) { + auto t = c->GetTaskState()->GetClientTaskInfo(p_information->type, task_index); + if (t == nullptr) { + continue; + } + + LogTasksDetail( + "[IncrementDoneCount] Setting internally client [{}] to donecount [{}]", + c->GetCleanName(), + done_count + ); + + t->activity[activity_id].done_count = (int) done_count; + } + } +} + +void ClientTaskState::HandleUpdateTasksOnKill(Client *client, uint32 npc_type_id) +{ + if (!HasActiveTasks()) { + return; + } + + // loop over the union of tasks and quests + for (auto &active_task : m_active_tasks) { + auto current_task = &active_task; + if (current_task->task_id == TASKSLOTEMPTY) { + continue; + } + + // Check if there are any active kill activities for this p_task_data + auto p_task_data = task_manager->m_task_data[current_task->task_id]; + if (p_task_data == nullptr) { + return; + } + + for (int activity_id = 0; activity_id < p_task_data->activity_count; activity_id++) { + ClientActivityInformation *client_activity = ¤t_task->activity[activity_id]; + ActivityInformation *activity_info = &p_task_data->activity_information[activity_id]; + + // We are not interested in completed or hidden activities + if (client_activity->activity_state != ActivityActive) { + continue; + } + + // We are only interested in Kill activities + if (activity_info->activity_type != TaskActivityType::Kill) { + continue; + } + + // Is there a zone restriction on the activity_information ? + if (!activity_info->CheckZone(zone->GetZoneID())) { + LogTasks( + "[HandleUpdateTasksOnKill] character [{}] task_id [{}] activity_id [{}] activity_type [{}] for NPC [{}] failed zone check", + client->GetName(), + current_task->task_id, + activity_id, + static_cast(TaskActivityType::Kill), + npc_type_id + ); + continue; + } + // Is the activity_information to kill this type of NPC ? + switch (activity_info->goal_method) { + case METHODSINGLEID: + if (activity_info->goal_id != npc_type_id) { + LogTasksDetail("[HandleUpdateTasksOnKill] Matched single goal"); + continue; + } + break; + + case METHODLIST: + if (!task_manager->m_goal_list_manager.IsInList( + activity_info->goal_id, + (int) npc_type_id + )) { + LogTasksDetail("[HandleUpdateTasksOnKill] Matched list goal"); + continue; + } + break; + + default: + // If METHODQUEST, don't updated the activity_information here + continue; + } + + LogTasksDetail("[HandleUpdateTasksOnKill] passed checks"); + + // handle actual update + // legacy eqemu task update logic loops through group on kill of npc to update a single task + if (p_task_data->type != TaskType::Shared) { + LogTasksDetail("[HandleUpdateTasksOnKill] Non-Shared Update"); + + Raid *raid = entity_list.GetRaidByClient(client); + if (raid) { + for (auto &e : raid->members) { + if (e.member && e.member->IsClient()) { + Client *c = e.member->CastToClient(); + c->UpdateTasksOnKill(npc_type_id); + } + } + return; + } + + Group *group = entity_list.GetGroupByClient(client); + if (group) { + for (auto &m : group->members) { + if (m && m->IsClient()) { + Client *c = m->CastToClient(); + c->UpdateTasksOnKill(npc_type_id); + } + } + return; + } + } + + LogTasksDetail("[HandleUpdateTasksOnKill] Shared update"); + + // shared tasks only require one client to receive an update to propagate + client->UpdateTasksOnKill(npc_type_id); + } + } +} +bool ClientTaskState::HasActiveTasks() +{ + if (!task_manager) { + return false; + } + + if (m_active_task.task_id != TASKSLOTEMPTY) { + return true; + } + + if (m_active_shared_task.task_id != TASKSLOTEMPTY) { + return true; + } + + bool has_active_quest = false; + for (auto &active_quest : m_active_quests) { + if (active_quest.task_id == TASKSLOTEMPTY) { + continue; + } + + return true; + } + + return false; +} diff --git a/zone/task_client_state.h b/zone/task_client_state.h index 6812e99c6..f45a522c9 100644 --- a/zone/task_client_state.h +++ b/zone/task_client_state.h @@ -20,7 +20,7 @@ public: int GetTaskActivityDoneCount(TaskType task_type, int index, int activity_id); int GetTaskActivityDoneCountFromTaskID(int task_id, int activity_id); int GetTaskStartTime(TaskType task_type, int index); - void AcceptNewTask(Client *client, int task_id, int npc_type_id, bool enforce_level_requirement = false); + void AcceptNewTask(Client *client, int task_id, int npc_type_id, time_t accept_time, bool enforce_level_requirement = false); void FailTask(Client *client, int task_id); int TaskTimeLeft(int task_id); int IsTaskCompleted(int task_id); @@ -29,13 +29,13 @@ public: ActivityState GetTaskActivityState(TaskType task_type, int index, int activity_id); void UpdateTaskActivity(Client *client, int task_id, int activity_id, int count, bool ignore_quest_update = false); void ResetTaskActivity(Client *client, int task_id, int activity_id); - void CancelTask(Client *client, int sequence_number, TaskType task_type, bool remove_from_db = true); + void CancelTask(Client *c, int sequence_number, TaskType task_type, bool remove_from_db = true); void CancelAllTasks(Client *client); void RemoveTask(Client *client, int sequence_number, TaskType task_type); void RemoveTaskByTaskID(Client *client, uint32 task_id); - bool UpdateTasksByNPC(Client *client, int activity_type, int npc_type_id); + bool UpdateTasksByNPC(Client *client, TaskActivityType activity_type, int npc_type_id); void UpdateTasksOnKill(Client *client, int npc_type_id); - void UpdateTasksForItem(Client *client, ActivityType activity_type, int item_id, int count = 1); + void UpdateTasksForItem(Client *client, TaskActivityType activity_type, int item_id, int count = 1); void UpdateTasksOnExplore(Client *client, int explore_id); bool UpdateTasksOnSpeakWith(Client *client, int npc_type_id); bool UpdateTasksOnDeliver(Client *client, std::list &items, int cash, int npc_type_id); @@ -54,13 +54,31 @@ public: int ActiveTasksInSet(int task_set_id); int CompletedTasksInSet(int task_set_id); bool HasSlotForTask(TaskInformation *task); + void CreateTaskDynamicZone(Client* client, int task_id, DynamicZone& dz); + void ListTaskTimers(Client* client); + void KickPlayersSharedTask(Client* client); inline bool HasFreeTaskSlot() { return m_active_task.task_id == TASKSLOTEMPTY; } friend class TaskManager; + // wrapper to call internal IncrementDoneCount + void SharedTaskIncrementDoneCount( + Client *client, + int task_id, + int activity_id, + int done_count, + bool ignore_quest_update = false + ); + + const ClientTaskInformation &GetActiveSharedTask() const; + bool HasActiveSharedTask(); + + + void HandleUpdateTasksOnKill(Client *client, uint32 npc_type_id); private: - bool UnlockActivities(int character_id, ClientTaskInformation &task_info); + void AddReplayTimer(Client *client, ClientTaskInformation& client_task, TaskInformation& task); + void IncrementDoneCount( Client *client, TaskInformation *task_information, @@ -70,16 +88,21 @@ private: bool ignore_quest_update = false ); + bool UnlockActivities(int character_id, ClientTaskInformation &task_info); + inline ClientTaskInformation *GetClientTaskInfo(TaskType task_type, int index) { ClientTaskInformation *info = nullptr; switch (task_type) { case TaskType::Task: - if (index == 0) { + if (index == TASKSLOTTASK) { info = &m_active_task; } break; case TaskType::Shared: + if (index == TASKSLOTSHAREDTASK) { + info = &m_active_shared_task; + } break; case TaskType::Quest: if (index < MAXACTIVEQUESTS) { @@ -95,9 +118,13 @@ private: union { // easier to loop over struct { ClientTaskInformation m_active_task; // only one + + // acts as a read-only "view" of data that is managed by world and the internal task + // system largely behaves like other tasks but shims logic to world where necessary + ClientTaskInformation m_active_shared_task; // only one ClientTaskInformation m_active_quests[MAXACTIVEQUESTS]; }; - ClientTaskInformation m_active_tasks[MAXACTIVEQUESTS + 1]; + ClientTaskInformation m_active_tasks[MAXACTIVEQUESTS + 2] = {}; }; // Shared tasks should be limited to 1 as well int m_active_task_count; @@ -105,6 +132,17 @@ private: std::vector m_completed_tasks; int m_last_completed_task_loaded; bool m_checked_touch_activities; + + static void ShowClientTaskInfoMessage(ClientTaskInformation *task, Client *c); + + void SyncSharedTaskZoneClientDoneCountState( + Client *p_client, + TaskInformation *p_information, + int task_index, + int activity_id, + uint32 done_count + ); + bool HasActiveTasks(); }; diff --git a/zone/task_manager.cpp b/zone/task_manager.cpp index b16d95a4e..7616753e8 100644 --- a/zone/task_manager.cpp +++ b/zone/task_manager.cpp @@ -1,6 +1,7 @@ #include "../common/global_define.h" #include "../common/misc_functions.h" #include "../common/repositories/character_activities_repository.h" +#include "../common/repositories/character_data_repository.h" #include "../common/repositories/character_tasks_repository.h" #include "../common/repositories/completed_tasks_repository.h" #include "../common/repositories/task_activities_repository.h" @@ -9,6 +10,12 @@ #include "client.h" #include "string_ids.h" #include "task_manager.h" +#include "../common/repositories/shared_task_activity_state_repository.h" +#include "../common/repositories/shared_task_members_repository.h" +#include "../common/shared_tasks.h" +#include "worldserver.h" + +extern WorldServer worldserver; TaskManager::TaskManager() { @@ -87,30 +94,38 @@ bool TaskManager::LoadTasks(int single_task) } // load task data - m_task_data[task_id] = new TaskInformation; - m_task_data[task_id]->type = static_cast(task.type); - m_task_data[task_id]->duration = task.duration; - m_task_data[task_id]->duration_code = static_cast(task.duration_code); - m_task_data[task_id]->title = task.title; - m_task_data[task_id]->description = task.description; - m_task_data[task_id]->reward = task.reward; - m_task_data[task_id]->reward_id = task.rewardid; - m_task_data[task_id]->cash_reward = task.cashreward; - m_task_data[task_id]->experience_reward = task.xpreward; - m_task_data[task_id]->reward_method = (TaskMethodType) task.rewardmethod; - m_task_data[task_id]->faction_reward = task.faction_reward; - m_task_data[task_id]->min_level = task.minlevel; - m_task_data[task_id]->max_level = task.maxlevel; - m_task_data[task_id]->repeatable = task.repeatable; - m_task_data[task_id]->completion_emote = task.completion_emote; - m_task_data[task_id]->activity_count = 0; - m_task_data[task_id]->sequence_mode = ActivitiesSequential; - m_task_data[task_id]->last_step = 0; + m_task_data[task_id] = new TaskInformation(); + m_task_data[task_id]->type = static_cast(task.type); + m_task_data[task_id]->duration = task.duration; + m_task_data[task_id]->duration_code = static_cast(task.duration_code); + m_task_data[task_id]->title = task.title; + m_task_data[task_id]->description = task.description; + m_task_data[task_id]->reward = task.reward; + m_task_data[task_id]->reward_id = task.rewardid; + m_task_data[task_id]->cash_reward = task.cashreward; + m_task_data[task_id]->experience_reward = task.xpreward; + m_task_data[task_id]->reward_method = (TaskMethodType) task.rewardmethod; + m_task_data[task_id]->reward_radiant_crystals = task.reward_radiant_crystals; + m_task_data[task_id]->reward_ebon_crystals = task.reward_ebon_crystals; + m_task_data[task_id]->faction_reward = task.faction_reward; + m_task_data[task_id]->min_level = task.minlevel; + m_task_data[task_id]->max_level = task.maxlevel; + m_task_data[task_id]->level_spread = task.level_spread; + m_task_data[task_id]->min_players = task.min_players; + m_task_data[task_id]->max_players = task.max_players; + m_task_data[task_id]->repeatable = task.repeatable; + m_task_data[task_id]->completion_emote = task.completion_emote; + m_task_data[task_id]->replay_timer_seconds = task.replay_timer_seconds; + m_task_data[task_id]->request_timer_seconds = task.request_timer_seconds; + m_task_data[task_id]->activity_count = 0; + m_task_data[task_id]->sequence_mode = ActivitiesSequential; + m_task_data[task_id]->last_step = 0; LogTasksDetail( - "[LoadTasks] (Task) task_id [{}] type [{}] duration [{}] duration_code [{}] title [{}] description [{}] " + "[LoadTasks] (Task) task_id [{}] type [{}] () duration [{}] duration_code [{}] title [{}] description [{}] " " reward [{}] rewardid [{}] cashreward [{}] xpreward [{}] rewardmethod [{}] faction_reward [{}] minlevel [{}] " - " maxlevel [{}] repeatable [{}] completion_emote [{}] ", + " maxlevel [{}] level_spread [{}] min_players [{}] max_players [{}] repeatable [{}] completion_emote [{}]", + " replay_timer_seconds [{}] request_timer_seconds [{}]", task.id, task.type, task.duration, @@ -125,8 +140,13 @@ bool TaskManager::LoadTasks(int single_task) task.faction_reward, task.minlevel, task.maxlevel, + task.level_spread, + task.min_players, + task.max_players, task.repeatable, - task.completion_emote + task.completion_emote, + task.replay_timer_seconds, + task.request_timer_seconds ); } @@ -203,7 +223,7 @@ bool TaskManager::LoadTasks(int single_task) } // set activity data - activity_data->activity_type = task_activity.activitytype; + activity_data->activity_type = static_cast(task_activity.activitytype); activity_data->target_name = task_activity.target_name; activity_data->item_list = task_activity.item_list; activity_data->skill_list = task_activity.skill_list; @@ -231,11 +251,11 @@ bool TaskManager::LoadTasks(int single_task) LogTasksDetail( "[LoadTasks] (Activity) task_id [{}] activity_id [{}] slot [{}] activity_type [{}] goal_id [{}] goal_method [{}] goal_count [{}] zones [{}]" - " target_name [{}] item_list [{}] skill_list [{}] spell_list [{}] description_override [{}]", + " target_name [{}] item_list [{}] skill_list [{}] spell_list [{}] description_override [{}] sequence [{}]", task_id, activity_id, m_task_data[task_id]->activity_count, - activity_data->activity_type, + static_cast(activity_data->activity_type), activity_data->goal_id, activity_data->goal_method, activity_data->goal_count, @@ -244,7 +264,8 @@ bool TaskManager::LoadTasks(int single_task) activity_data->item_list.c_str(), activity_data->skill_list.c_str(), activity_data->spell_list.c_str(), - activity_data->description_override.c_str() + activity_data->description_override.c_str(), + (m_task_data[task_id]->sequence_mode == ActivitiesStepped ? "stepped" : "sequential") ); m_task_data[task_id]->activity_count++; @@ -265,14 +286,15 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s return false; } - const char *ERR_MYSQLERROR = "[TASKS]Error in TaskManager::SaveClientState %s"; + const char *ERR_MYSQLERROR = "[TASKS]Error in TaskManager::SaveClientState {}"; int character_id = client->CharacterID(); LogTasks("[SaveClientState] character_id [{}]", character_id); if (client_task_state->m_active_task_count > 0 || - client_task_state->m_active_task.task_id != TASKSLOTEMPTY) { // TODO: tasks + client_task_state->m_active_task.task_id != TASKSLOTEMPTY || + client_task_state->m_active_shared_task.task_id != TASKSLOTEMPTY) { for (auto &active_task : client_task_state->m_active_tasks) { int task_id = active_task.task_id; if (task_id == TASKSLOTEMPTY) { @@ -361,15 +383,14 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s } active_task.updated = false; - for (int activity_index = 0; - activity_index < m_task_data[task_id]->activity_count; - ++activity_index) + for (int activity_index = 0; activity_index < m_task_data[task_id]->activity_count; ++activity_index) { active_task.activity[activity_index].updated = false; + } } } - if (!RuleB(TaskSystem, RecordCompletedTasks) || - (client_task_state->m_completed_tasks.size() <= (unsigned int) client_task_state->m_last_completed_task_loaded)) { + if (!RuleB(TaskSystem, RecordCompletedTasks) || (client_task_state->m_completed_tasks.size() <= + (unsigned int) client_task_state->m_last_completed_task_loaded)) { client_task_state->m_last_completed_task_loaded = client_task_state->m_completed_tasks.size(); return true; } @@ -387,6 +408,11 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s continue; } + // we don't record completed shared tasks in the task quest log + if (m_task_data[task_id]->type == TaskType::Shared) { + break; + } + // First we save a record with an activity_id of -1. // This indicates this task was completed at the given time. We infer that all // none optional activities were completed. @@ -542,14 +568,22 @@ void TaskManager::TaskSetSelector(Client *client, ClientTaskState *client_task_s return; } + // forward to shared task selector validation if set contains a shared task + for (const auto& task_id : m_task_sets[task_set_id]) + { + if (m_task_data[task_id] && m_task_data[task_id]->type == TaskType::Shared) { + SharedTaskSelector(client, mob, m_task_sets[task_set_id].size(), m_task_sets[task_set_id].data()); + return; + } + } + + if (client->HasTaskRequestCooldownTimer()) { + client->SendTaskRequestCooldownTimerMessage(); + return; + } + if (m_task_sets[task_set_id].empty()) { - // I think this is suppose to be yellow - mob->SayString( - client, - Chat::Yellow, - MAX_ACTIVE_TASKS, - client->GetName() - ); + client->MessageString(Chat::Yellow, NO_TASK_OFFERS, ".", ".", client->GetName()); return; } @@ -584,13 +618,7 @@ void TaskManager::TaskSetSelector(Client *client, ClientTaskState *client_task_s SendTaskSelector(client, mob, task_list_index, task_list); } else { - // TODO: check color, I think this might be only for (Shared) Tasks, w/e -- think should be yellow - mob->SayString( - client, - Chat::Yellow, - MAX_ACTIVE_TASKS, - client->GetName() - ); + client->MessageString(Chat::Yellow, NO_TASK_OFFERS, ".", ".", client->GetName()); } } @@ -614,6 +642,22 @@ void TaskManager::TaskQuestSetSelector( return; } + // live prevents mixing selection types (also uses diff opcodes for solo vs shared tasks) + // to keep shared task validation live-like (and simple), any shared task will + // forward this to shared task validation and non-shared tasks will be dropped + for (int i = 0; i < count; ++i) { + auto task = tasks[i]; + if (m_task_data[task] && m_task_data[task]->type == TaskType::Shared) { + SharedTaskSelector(client, mob, count, tasks); + return; + } + } + + if (client->HasTaskRequestCooldownTimer()) { + client->SendTaskRequestCooldownTimerMessage(); + return; + } + for (int i = 0; i < count; ++i) { auto task = tasks[i]; // verify level, we're not currently on it, repeatable status, if it's a (shared) task @@ -630,24 +674,91 @@ void TaskManager::TaskQuestSetSelector( SendTaskSelector(client, mob, task_list_index, task_list); } else { - // TODO: check color, I think this might be only for (Shared) Tasks, w/e -- think should be yellow - mob->SayString( - client, - Chat::Yellow, - MAX_ACTIVE_TASKS, - client->GetName() - ); + client->MessageString(Chat::Yellow, NO_TASK_OFFERS, ".", ".", client->GetName()); + } +} + +void TaskManager::SharedTaskSelector(Client *client, Mob *mob, int count, const int *tasks) +{ + LogTasks("[UPDATE] SharedTaskSelector called for array size [{}]", count); + + if (count <= 0 || client->HasTaskRequestCooldownTimer()) { + client->SendTaskRequestCooldownTimerMessage(); + return; + } + + // check if requester already has a shared task (no need to query group/raid members if so) + if (client->GetTaskState()->HasActiveSharedTask()) { + client->MessageString(Chat::Red, SharedTaskMessage::NO_REQUEST_BECAUSE_HAVE_ONE); + return; + } + + // get group/raid member character data from db (need to query for character ids) + auto request = SharedTask::GetRequestCharacters(database, client->CharacterID()); + + // check if any group/raid member already has a shared task (already checked solo character) + bool validation_failed = false; + if (request.group_type != SharedTaskRequestGroupType::Solo) { + auto shared_task_members = SharedTaskMembersRepository::GetWhere( + database, + fmt::format("character_id IN ({}) LIMIT 1", fmt::join(request.character_ids, ","))); + + if (!shared_task_members.empty()) { + validation_failed = true; + + auto it = std::find_if( + request.characters.begin(), request.characters.end(), + [&](const CharacterDataRepository::CharacterData &char_data) { + return char_data.id == shared_task_members.front().character_id; + } + ); + + if (it != request.characters.end()) { + if (request.group_type == SharedTaskRequestGroupType::Group) { + client->MessageString( + Chat::Red, + SharedTaskMessage::NO_REQUEST_BECAUSE_GROUP_HAS_ONE, + it->name.c_str()); + } + else { + client->MessageString( + Chat::Red, + SharedTaskMessage::NO_REQUEST_BECAUSE_RAID_HAS_ONE, + it->name.c_str()); + } + } + } + } + + if (!validation_failed) { + // run type and level filters on task selections + int task_list[MAXCHOOSERENTRIES] = {0}; + int task_list_index = 0; + + for (int i = 0; i < count && task_list_index < MAXCHOOSERENTRIES; ++i) { + // todo: are there non repeatable shared tasks? (would need to check all group/raid members) + auto task = tasks[i]; + if (m_task_data[task] && + m_task_data[task]->type == TaskType::Shared && + request.lowest_level >= m_task_data[task]->min_level && + (m_task_data[task]->max_level == 0 || request.highest_level <= m_task_data[task]->max_level)) { + task_list[task_list_index++] = task; + } + } + + // check if any tasks are left to offer after filtering + if (task_list_index > 0) { + SendSharedTaskSelector(client, mob, task_list_index, task_list); + } + else { + client->MessageString(Chat::Red, SharedTaskMessage::YOU_DO_NOT_MEET_REQ_AVAILABLE); + } } } // sends task selector to client void TaskManager::SendTaskSelector(Client *client, Mob *mob, int task_count, int *task_list) { - if (client->ClientVersion() >= EQ::versions::ClientVersion::RoF) { - SendTaskSelectorNew(client, mob, task_count, task_list); - return; - } - // Titanium OpCode: 0x5e7c LogTasks("TaskSelector for [{}] Tasks", task_count); int player_level = client->GetLevel(); @@ -658,98 +769,6 @@ void TaskManager::SendTaskSelector(Client *client, Mob *mob, int task_count, int } } - int valid_task_count = 0; - - for (int i = 0; i < task_count; i++) { - if (!ValidateLevel(task_list[i], player_level)) { - continue; - } - if (client->IsTaskActive(task_list[i])) { - continue; - } - if (!IsTaskRepeatable(task_list[i]) && client->IsTaskCompleted(task_list[i])) { - continue; - } - - valid_task_count++; - } - - if (valid_task_count == 0) { - return; - } - - SerializeBuffer buf(50 * valid_task_count); - - buf.WriteUInt32(valid_task_count); - buf.WriteUInt32(2); // task type, live doesn't let you send more than one type, but we do? - buf.WriteUInt32(mob->GetID()); - - for (int task_index = 0; task_index < task_count; task_index++) { - if (!ValidateLevel(task_list[task_index], player_level)) { - continue; - } - if (client->IsTaskActive(task_list[task_index])) { - continue; - } - if (!IsTaskRepeatable(task_list[task_index]) && client->IsTaskCompleted(task_list[task_index])) { - continue; - } - - buf.WriteUInt32(task_list[task_index]); // task_id - - // affects color, difficulty? - if (client->ClientVersion() != EQ::versions::ClientVersion::Titanium) { - buf.WriteFloat(1.0f); - } - buf.WriteUInt32(m_task_data[task_list[task_index]]->duration); - buf.WriteUInt32(static_cast(m_task_data[task_list[task_index]]->duration_code)); - - buf.WriteString(m_task_data[task_list[task_index]]->title); // max 64 with null - buf.WriteString(m_task_data[task_list[task_index]]->description); // max 4000 with null - - // Has reward set flag - if (client->ClientVersion() != EQ::versions::ClientVersion::Titanium) { - buf.WriteUInt8(0); - } - - buf.WriteUInt32(m_task_data[task_list[task_index]]->activity_count); - - for (int activity_index = 0; - activity_index < m_task_data[task_list[task_index]]->activity_count; - ++activity_index) { - buf.WriteUInt32(activity_index); // ActivityNumber - auto &activity = m_task_data[task_list[task_index]]->activity_information[activity_index]; - buf.WriteUInt32(activity.activity_type); - buf.WriteUInt32(0); // solo, group, raid? - buf.WriteString(activity.target_name); // max length 64, "target name" so like loot x foo from bar (this is bar) - buf.WriteString(activity.item_list); // max length 64 in these clients - buf.WriteUInt32(activity.goal_count); - buf.WriteInt32(activity.skill_id); - buf.WriteInt32(activity.spell_id); - buf.WriteInt32(activity.zone_ids.empty() ? 0 : activity.zone_ids.front()); - buf.WriteString(activity.description_override); - } - } - - auto outapp = new EQApplicationPacket(OP_OpenNewTasksWindow, buf); - - client->QueuePacket(outapp); - safe_delete(outapp); -} - -void TaskManager::SendTaskSelectorNew(Client *client, Mob *mob, int task_count, int *task_list) -{ - LogTasks("SendTaskSelectorNew for [{}] Tasks", task_count); - - int player_level = client->GetLevel(); - - // Check if any of the tasks exist - for (int i = 0; i < task_count; i++) { - if (m_task_data[task_list[i]] != nullptr) { - break; - } - } - int valid_tasks_count = 0; for (int task_index = 0; task_index < task_count; task_index++) { if (!ValidateLevel(task_list[task_index], player_level)) { @@ -788,47 +807,36 @@ void TaskManager::SendTaskSelectorNew(Client *client, Mob *mob, int task_count, continue; } - buf.WriteUInt32(task_list[i]); // task_id - buf.WriteFloat(1.0f); // affects color, difficulty? - buf.WriteUInt32(m_task_data[task_list[i]]->duration); - buf.WriteUInt32(static_cast(m_task_data[task_list[i]]->duration_code)); // 1 = Short, 2 = Medium, 3 = Long, anything else Unlimited - - buf.WriteString(m_task_data[task_list[i]]->title); // max 64 with null - buf.WriteString(m_task_data[task_list[i]]->description); // max 4000 with null - - buf.WriteUInt8(0); // Has reward set flag - buf.WriteUInt32(m_task_data[task_list[i]]->activity_count); // activity_count - - for (int j = 0; j < m_task_data[task_list[i]]->activity_count; ++j) { - buf.WriteUInt32(j); // ActivityNumber - auto &activity = m_task_data[task_list[i]]->activity_information[j]; - buf.WriteUInt32(activity.activity_type); // ActivityType - buf.WriteUInt32(0); // solo, group, raid? - buf.WriteString(activity.target_name); // max length 64, "target name" so like loot x foo from bar (this is bar) - - // this string is item names - buf.WriteLengthString(activity.item_list); - - buf.WriteUInt32(activity.goal_count); // GoalCount - - // this string is skill IDs? probably one of the "use on" tasks - buf.WriteLengthString(activity.skill_list); - - // this string is spell IDs? probably one of the "use on" tasks - buf.WriteLengthString(activity.spell_list); - - //buf.WriteString(itoa(Tasks[TaskList[i]]->activity_information[activity_id].ZoneID)); - buf.WriteString(activity.zones); // Zone number in ascii max length 64, can be multiple with separated by ; - buf.WriteString(activity.description_override); // max length 128 -- overrides the automatic descriptions - // this doesn't appear to be shown to the client at all and isn't the same as zones ... defaults to '0' though - buf.WriteString(activity.zones); // Zone number in ascii max length 64, probably can be separated by ; too, haven't found it used - } + buf.WriteUInt32(task_list[i]); // task_id + m_task_data[task_list[i]]->SerializeSelector(buf, client->ClientVersion()); } - auto outapp = new EQApplicationPacket(OP_OpenNewTasksWindow, buf); + auto outapp = std::make_unique(OP_TaskSelectWindow, buf); + client->QueuePacket(outapp.get()); +} - client->QueuePacket(outapp); - safe_delete(outapp); +void TaskManager::SendSharedTaskSelector(Client *client, Mob *mob, int task_count, int *task_list) +{ + LogTasks("SendSharedTaskSelector for [{}] Tasks", task_count); + + // request timer is only set when shared task selection shown (not for failed validations) + client->StartTaskRequestCooldownTimer(); + + SerializeBuffer buf; + + buf.WriteUInt32(task_count); // number of tasks + // shared task selection (live doesn't mix types) makes client send shared task specific opcode for accepts + buf.WriteUInt32(static_cast(TaskType::Shared)); + buf.WriteUInt32(mob->GetID()); // task giver entity id + + for (int i = 0; i < task_count; ++i) { + int task_id = task_list[i]; + buf.WriteUInt32(task_id); + m_task_data[task_id]->SerializeSelector(buf, client->ClientVersion()); + } + + auto outapp = std::make_unique(OP_SharedTaskSelectWindow, buf); + client->QueuePacket(outapp.get()); } int TaskManager::GetActivityCount(int task_id) @@ -869,7 +877,7 @@ void TaskManager::ExplainTask(Client *client, int task_id) sprintf(ptr, "Act: %3i: ", i); ptr = ptr + strlen(ptr); switch (m_task_data[task_id]->activity_information[i].activity_type) { - case ActivityDeliver: + case TaskActivityType::Deliver: sprintf(ptr, "Deliver"); break; } @@ -953,35 +961,15 @@ void TaskManager::SendTaskActivityShort(Client *client, int task_id, int activit { // This activity_information Packet is sent for activities that have not yet been unlocked and appear as ??? // in the client. - - TaskActivityShort_Struct *task_activity_short; - if (client->ClientVersionBit() & EQ::versions::maskRoFAndLater) { - auto outapp = new EQApplicationPacket(OP_TaskActivity, 25); - outapp->WriteUInt32(client_task_index); - outapp->WriteUInt32(static_cast(m_task_data[task_id]->type)); - outapp->WriteUInt32(task_id); - outapp->WriteUInt32(activity_id); - outapp->WriteUInt32(0); - outapp->WriteUInt32(0xffffffff); - outapp->WriteUInt8(0); - client->FastQueuePacket(&outapp); - - return; - } - - auto outapp = new EQApplicationPacket(OP_TaskActivity, sizeof(TaskActivityShort_Struct)); - - task_activity_short = (TaskActivityShort_Struct *) outapp->pBuffer; - task_activity_short->TaskSequenceNumber = client_task_index; - task_activity_short->unknown2 = static_cast(m_task_data[task_id]->type); - task_activity_short->TaskID = task_id; - task_activity_short->ActivityID = activity_id; - task_activity_short->unknown3 = 0x000000; - task_activity_short->ActivityType = 0xffffffff; - task_activity_short->unknown4 = 0x00000000; - - client->QueuePacket(outapp); - safe_delete(outapp); + auto outapp = std::make_unique(OP_TaskActivity, 25); + outapp->WriteUInt32(client_task_index); + outapp->WriteUInt32(static_cast(m_task_data[task_id]->type)); + outapp->WriteUInt32(task_id); + outapp->WriteUInt32(activity_id); + outapp->WriteUInt32(0); + outapp->WriteUInt32(0xffffffff); + outapp->WriteUInt8(m_task_data[task_id]->activity_information[activity_id].optional ? 1 : 0); + client->QueuePacket(outapp.get()); } void TaskManager::SendTaskActivityLong( @@ -989,85 +977,6 @@ void TaskManager::SendTaskActivityLong( int task_id, int activity_id, int client_task_index, - bool optional, - bool task_complete -) -{ - - if (client->ClientVersion() >= EQ::versions::ClientVersion::RoF) { - SendTaskActivityNew(client, task_id, activity_id, client_task_index, optional, task_complete); - return; - } - - SerializeBuffer buf(100); - - buf.WriteUInt32(client_task_index); - buf.WriteUInt32(static_cast(m_task_data[task_id]->type)); - buf.WriteUInt32(task_id); - buf.WriteUInt32(activity_id); - buf.WriteUInt32(0); // unknown3 - - // We send our 'internal' types as ActivityCastOn. text3 should be set to the activity_information description, so it makes - // no difference to the client. All activity_information updates will be done based on our interal activity_information types. - if ((m_task_data[task_id]->activity_information[activity_id].activity_type > 0) && - m_task_data[task_id]->activity_information[activity_id].activity_type < 100) { - buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].activity_type); - } - else { - buf.WriteUInt32(ActivityCastOn); - } // w/e! - - buf.WriteUInt32(optional); - buf.WriteUInt32(0); // solo, group, raid - - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].target_name); // target name string - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].item_list); // item name list - - if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].goal_count); - } - else { - // For our internal type GiveCash, where the goal count has the amount of cash that must be given, - // we don't want the donecount and goalcount fields cluttered up with potentially large numbers, so we just - // send a goalcount of 1, and a bit further down, a donecount of 1 if the activity_information is complete, 0 otherwise. - // The text3 field should decribe the exact activity_information goal, e.g. give 3500gp to Hasten Bootstrutter. - buf.WriteUInt32(1); - } - - buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].skill_id); - buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].spell_id); - buf.WriteUInt32( - m_task_data[task_id]->activity_information[activity_id].zone_ids.empty() ? 0 - : m_task_data[task_id]->activity_information[activity_id].zone_ids.front()); - buf.WriteUInt32(0); - - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].description_override); - - if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32(client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id)); - } - else { - // For internal activity_information types, done_count is either 1 if the activity_information is complete, 0 otherwise. - buf.WriteUInt32((client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id) >= - m_task_data[task_id]->activity_information[activity_id].goal_count)); - } - - buf.WriteUInt32(1); // unknown - - auto outapp = new EQApplicationPacket(OP_TaskActivity, buf); - - client->QueuePacket(outapp); - safe_delete(outapp); - -} - -// Used only by RoF+ Clients -void TaskManager::SendTaskActivityNew( - Client *client, - int task_id, - int activity_id, - int client_task_index, - bool optional, bool task_complete ) { @@ -1079,66 +988,89 @@ void TaskManager::SendTaskActivityNew( buf.WriteUInt32(activity_id); buf.WriteUInt32(0); // unknown3 - // We send our 'internal' types as ActivityCastOn. text3 should be set to the activity_information description, so it makes - // no difference to the client. All activity_information updates will be done based on our interal activity_information types. - if ((m_task_data[task_id]->activity_information[activity_id].activity_type > 0) && - m_task_data[task_id]->activity_information[activity_id].activity_type < 100) { - buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].activity_type); - } - else { - buf.WriteUInt32(ActivityCastOn); - } // w/e! + const auto &activity = m_task_data[task_id]->activity_information[activity_id]; + int done_count = client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id); - buf.WriteUInt8(optional); - buf.WriteUInt32(0); // solo, group, raid + activity.SerializeObjective(buf, client->ClientVersion(), done_count); - // One of these unknown fields maybe related to the 'Use On' activity_information types - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].target_name); // target name string + auto outapp = std::make_unique(OP_TaskActivity, buf); + client->QueuePacket(outapp.get()); +} - buf.WriteLengthString(m_task_data[task_id]->activity_information[activity_id].item_list); // item name list - - // Goal Count - if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].goal_count); - } - else { - buf.WriteUInt32(1); - } // GoalCount - - // skill ID list ; separated - buf.WriteLengthString(m_task_data[task_id]->activity_information[activity_id].skill_list); - - // spelll ID list ; separated -- unsure wtf we're doing here - buf.WriteLengthString(m_task_data[task_id]->activity_information[activity_id].spell_list); - - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].zones); - buf.WriteUInt32(0); // unknown7 - - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].description_override); // description override - - if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32( - client->GetTaskActivityDoneCount( - m_task_data[task_id]->type, - client_task_index, - activity_id - )); // done_count - } - else { - // For internal activity_information types, done_count is either 1 if the activity_information is complete, 0 otherwise. - buf.WriteUInt32((client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id) >= - m_task_data[task_id]->activity_information[activity_id].goal_count)); +void TaskManager::SendActiveTaskToClient( + ClientTaskInformation *task, + Client *client, + int task_index, + bool task_complete +) +{ + auto state = client->GetTaskState(); + if (!state) { + return; } - buf.WriteUInt8(1); // unknown9 + int start_time = task->accepted_time; + int task_id = task->task_id; + auto task_type = m_task_data[task_id]->type; + auto task_duration = m_task_data[task_id]->duration; - buf.WriteString(m_task_data[task_id]->activity_information[activity_id].zones); + SendActiveTaskDescription( + client, + task_id, + *task, + start_time, + task_duration, + false + ); - auto outapp = new EQApplicationPacket(OP_TaskActivity, buf); + LogTasks("[SendActiveTasksToClient] task_id [{}] activity_count [{}] task_index [{}]", + task_id, + GetActivityCount(task_id), + task_index); - client->QueuePacket(outapp); - safe_delete(outapp); + int sequence = 0; + int fixed_index = task_index; + for (int activity_id = 0; activity_id < GetActivityCount(task_id); activity_id++) { + if (client->GetTaskActivityState(task_type, fixed_index, activity_id) != ActivityHidden) { + LogTasks( + "[SendActiveTasksToClient] (Long Update) task_id [{}] activity_id [{}] fixed_index [{}] task_complete [{}]", + task_id, + activity_id, + fixed_index, + task_complete ? "true" : "false" + ); + if (activity_id == GetActivityCount(task_id) - 1) { + SendTaskActivityLong( + client, + task_id, + activity_id, + fixed_index, + task_complete + ); + } + else { + SendTaskActivityLong( + client, + task_id, + activity_id, + fixed_index, + 0 + ); + } + } + else { + LogTasks( + "[SendActiveTasksToClient] (Short Update) task_id [{}] activity_id [{}] fixed_index [{}]", + task_id, + activity_id, + fixed_index + ); + + SendTaskActivityShort(client, task_id, activity_id, fixed_index); + } + sequence++; + } } void TaskManager::SendActiveTasksToClient(Client *client, bool task_complete) @@ -1148,64 +1080,27 @@ void TaskManager::SendActiveTasksToClient(Client *client, bool task_complete) return; } - for (int task_index = 0; task_index < MAXACTIVEQUESTS + 1; task_index++) { - int task_id = state->m_active_tasks[task_index].task_id; - if ((task_id == 0) || (m_task_data[task_id] == 0)) { + // task + if (state->m_active_task.task_id != TASKSLOTEMPTY) { + SendActiveTaskToClient(&state->m_active_task, client, 0, task_complete); + } + + // shared task + if (state->m_active_shared_task.task_id != TASKSLOTEMPTY) { + SendActiveTaskToClient(&state->m_active_shared_task, client, 0, task_complete); + } + + // quests + for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) { + int task_id = state->m_active_quests[task_index].task_id; + if ((task_id == 0) || (m_task_data[task_id] == nullptr)) { continue; } - int start_time = state->m_active_tasks[task_index].accepted_time; - SendActiveTaskDescription( - client, task_id, state->m_active_tasks[task_index], start_time, m_task_data[task_id]->duration, - false - ); - LogTasks("[SendActiveTasksToClient] task_id [{}] activity_count [{}]", task_id, GetActivityCount(task_id)); + LogTasksDetail("--"); + LogTasksDetail("[SendActiveTasksToClient] Task [{}]", m_task_data[task_id]->title); - int sequence = 0; - int fixed_index = m_task_data[task_id]->type == TaskType::Task ? 0 : task_index - 1; // hmmm fuck - for (int activity_id = 0; activity_id < GetActivityCount(task_id); activity_id++) { - if (client->GetTaskActivityState(m_task_data[task_id]->type, fixed_index, activity_id) != ActivityHidden) { - LogTasks( - "[SendActiveTasksToClient] (Long Update) task_id [{}] activity_id [{}] fixed_index [{}] task_complete [{}]", - task_id, - activity_id, - fixed_index, - task_complete ? "true" : "false" - ); - - if (activity_id == GetActivityCount(task_id) - 1) { - SendTaskActivityLong( - client, - task_id, - activity_id, - fixed_index, - m_task_data[task_id]->activity_information[activity_id].optional, - task_complete - ); - } - else { - SendTaskActivityLong( - client, - task_id, - activity_id, - fixed_index, - m_task_data[task_id]->activity_information[activity_id].optional, - 0 - ); - } - } - else { - LogTasks( - "[SendActiveTasksToClient] (Short Update) task_id [{}] activity_id [{}] fixed_index [{}]", - task_id, - activity_id, - fixed_index - ); - - SendTaskActivityShort(client, task_id, activity_id, fixed_index); - } - sequence++; - } + SendActiveTaskToClient(&state->m_active_quests[task_index], client, task_index, task_complete); } } @@ -1241,16 +1136,10 @@ void TaskManager::SendSingleActiveTaskToClient( activity_id, task_complete); if (activity_id == GetActivityCount(task_id) - 1) { - SendTaskActivityLong( - client, task_id, activity_id, task_info.slot, - m_task_data[task_id]->activity_information[activity_id].optional, task_complete - ); + SendTaskActivityLong(client, task_id, activity_id, task_info.slot, task_complete); } else { - SendTaskActivityLong( - client, task_id, activity_id, task_info.slot, - m_task_data[task_id]->activity_information[activity_id].optional, 0 - ); + SendTaskActivityLong(client, task_id, activity_id, task_info.slot, 0); } } else { @@ -1320,7 +1209,9 @@ void TaskManager::SendActiveTaskDescription( task_description_header->TaskID = task_id; task_description_header->open_window = bring_up_task_journal; task_description_header->task_type = static_cast(m_task_data[task_id]->type); - task_description_header->reward_type = 0; // TODO: 4 says Radiant Crystals else Ebon Crystals when shared task + + constexpr uint32_t reward_radiant_type = 4; // Radiant Crystals, anything else is Ebon for shared tasks + task_description_header->reward_type = m_task_data[task_id]->reward_radiant_crystals > 0 ? reward_radiant_type : 0; Ptr = (char *) task_description_header + sizeof(TaskDescriptionHeader_Struct); @@ -1362,7 +1253,11 @@ void TaskManager::SendActiveTaskDescription( Ptr += m_task_data[task_id]->item_link.length() + 1; tdt = (TaskDescriptionTrailer_Struct *) Ptr; - tdt->Points = 0x00000000; // Points Count TODO: this does have a visible affect on the client ... + // shared tasks show radiant/ebon crystal reward, non-shared tasks show generic points + tdt->Points = m_task_data[task_id]->reward_ebon_crystals; + if (m_task_data[task_id]->reward_radiant_crystals > 0) { + tdt->Points = m_task_data[task_id]->reward_radiant_crystals; + } tdt->has_reward_selection = 0; // TODO: new rewards window client->QueuePacket(outapp); @@ -1375,21 +1270,30 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s return false; } + client->SetSharedTaskId(0); + int character_id = client->CharacterID(); client_task_state->m_active_task_count = 0; LogTasks("[LoadClientState] for character_id [{}]", character_id); + // in a case where a client somehow lost local state with what state exists in world - we need + // to perform an inverse sync where we inject the task + SyncClientSharedTaskStateToLocal(client); + auto character_tasks = CharacterTasksRepository::GetWhere( database, fmt::format("charid = {} ORDER BY acceptedtime", character_id) ); for (auto &character_task: character_tasks) { - int task_id = character_task.taskid; - int slot = character_task.slot; - auto type = static_cast(character_task.type); + int task_id = character_task.taskid; + int slot = character_task.slot; + + // this used to be loaded from character_tasks + // this should just load from the tasks table + auto type = task_manager->GetTaskType(character_task.taskid); if ((task_id < 0) || (task_id >= MAXTASKS)) { LogTasks( @@ -1400,6 +1304,8 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s } // client data bucket pointer + // this actually fetches the proper task type instances to be loaded with data + // whether it be quest / task / shared task auto task_info = client_task_state->GetClientTaskInfo(type, slot); if (task_info == nullptr) { LogTasks( @@ -1423,14 +1329,16 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s i.activity_id = -1; } + // this check keeps a lot of core task updating code from working properly (shared or otherwise) if (type == TaskType::Quest) { ++client_task_state->m_active_task_count; } LogTasks( - "[LoadClientState] character_id [{}] task_id [{}] accepted_time [{}]", + "[LoadClientState] character_id [{}] task_id [{}] slot [{}] accepted_time [{}]", character_id, task_id, + slot, character_task.acceptedtime ); } @@ -1465,12 +1373,18 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s continue; } + // type: task ClientTaskInformation *task_info = nullptr; if (client_task_state->m_active_task.task_id == task_id) { task_info = &client_task_state->m_active_task; } - // wasn't task + // type: shared task + if (client_task_state->m_active_shared_task.task_id == task_id) { + task_info = &client_task_state->m_active_shared_task; + } + + // type: quest if (task_info == nullptr) { for (auto &active_quest : client_task_state->m_active_quests) { if (active_quest.task_id == task_id) { @@ -1511,6 +1425,8 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s ); } + SyncClientSharedTaskState(client, client_task_state); + if (RuleB(TaskSystem, RecordCompletedTasks)) { CompletedTaskInformation completed_task_information{}; @@ -1639,18 +1555,262 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s } } + LogTasksDetail( + "[LoadClientState] m_active_task task_id is [{}] slot [{}]", + client_task_state->m_active_task.task_id, + client_task_state->m_active_task.slot + ); if (client_task_state->m_active_task.task_id != TASKSLOTEMPTY) { client_task_state->UnlockActivities(character_id, client_task_state->m_active_task); + + // purely debugging + LogTasksDetail( + "[LoadClientState] Fetching task info for character_id [{}] task [{}] slot [{}] current_step [{}] accepted_time [{}] updated [{}]", + character_id, + client_task_state->m_active_task.task_id, + client_task_state->m_active_task.slot, + client_task_state->m_active_task.current_step, + client_task_state->m_active_task.accepted_time, + client_task_state->m_active_task.updated + ); + + TaskInformation *p_task_data = task_manager->m_task_data[client_task_state->m_active_task.task_id]; + if (p_task_data != nullptr) { + for (int i = 0; i < p_task_data->activity_count; i++) { + if (client_task_state->m_active_task.activity[i].activity_id >= 0) { + LogTasksDetail( + "[LoadClientState] -- character_id [{}] task [{}] activity_id [{}] done_count [{}] activity_state [{}] updated [{}] sequence [{}]", + character_id, + client_task_state->m_active_task.task_id, + client_task_state->m_active_task.activity[i].activity_id, + client_task_state->m_active_task.activity[i].done_count, + client_task_state->m_active_task.activity[i].activity_state, + client_task_state->m_active_task.activity[i].updated, + p_task_data->sequence_mode + ); + } + } + } } - // TODO: shared + // shared task + LogTasksDetail( + "[LoadClientState] m_active_shared_task task_id is [{}] slot [{}]", + client_task_state->m_active_shared_task.task_id, + client_task_state->m_active_shared_task.slot + ); + if (client_task_state->m_active_shared_task.task_id != TASKSLOTEMPTY) { + client_task_state->UnlockActivities(character_id, client_task_state->m_active_shared_task); + } + + // quests (max 20 or 40 depending on client) for (auto &active_quest : client_task_state->m_active_quests) { if (active_quest.task_id != TASKSLOTEMPTY) { client_task_state->UnlockActivities(character_id, active_quest); } } - LogTasks("[LoadClientState] for Character ID [{}] DONE!", character_id); + LogTasksDetail("[LoadClientState] for Character ID [{}] DONE!", character_id); + LogTasksDetail("---", character_id); return true; } + +void TaskManager::SyncClientSharedTaskState(Client *c, ClientTaskState *cts) +{ + LogTasksDetail( + "[SyncClientSharedTaskState] Syncing client shared task state" + ); + + SyncClientSharedTaskWithPersistedState(c, cts); + SyncClientSharedTaskRemoveLocalIfNotExists(c, cts); +} + +void TaskManager::SyncClientSharedTaskWithPersistedState(Client *c, ClientTaskState *cts) +{ + auto character_tasks = CharacterTasksRepository::GetWhere( + database, + fmt::format("charid = {} ORDER BY acceptedtime", c->CharacterID()) + ); + + for (auto &character_task: character_tasks) { + if (character_task.type == TASK_TYPE_SHARED) { + auto st = SharedTaskMembersRepository::GetWhere( + database, + fmt::format( + "character_id = {}", + c->CharacterID() + ) + ); + + if (!st.empty()) { + int64 shared_task_id = st[0].shared_task_id; + auto activities = SharedTaskActivityStateRepository::GetWhere( + database, + fmt::format( + "shared_task_id = {}", + shared_task_id + ) + ); + + ClientTaskInformation *shared_task = nullptr; + shared_task = &cts->m_active_shared_task; + + // has active shared task + if (cts->HasActiveSharedTask()) { + + LogTasksDetail( + "[SyncClientSharedTaskWithPersistedState] Client [{}] has shared_task, sync with database", + c->GetCleanName() + ); + + bool fell_behind_state = false; + for (auto &a: activities) { + + LogTasksDetail( + "[LoadClientState] shared_task loop local [{}] shared [{}]", + shared_task->activity[a.activity_id].done_count, + a.done_count + ); + + // we're behind shared task state, update self + if (shared_task->activity[a.activity_id].done_count < a.done_count) { + + // update done count + shared_task->activity[a.activity_id].done_count = a.done_count; + + // activity state + shared_task->activity[a.activity_id].activity_state = + (a.completed_time > 0 ? ActivityCompleted : ActivityHidden); + + // set flag to persist later + fell_behind_state = true; + } + } + + // fell behind, force a save of client state + if (fell_behind_state) { + SaveClientState(c, cts); + } + + c->SetSharedTaskId(shared_task_id); + } + } + } + } +} + +void TaskManager::SyncClientSharedTaskRemoveLocalIfNotExists(Client *c, ClientTaskState *cts) +{ + // has active shared task + if (cts->HasActiveSharedTask()) { + auto members = SharedTaskMembersRepository::GetWhere( + database, + fmt::format( + "character_id = {}", + c->CharacterID() + ) + ); + + // if we don't actually have a membership anywhere, remove ourself locally + if (members.empty()) { + LogTasksDetail( + "[SyncClientSharedTaskRemoveLocalIfNotExists] Client [{}] Shared task [{}] doesn't exist in world, removing from local", + c->GetCleanName(), + cts->m_active_shared_task.task_id + ); + + std::string delete_where = fmt::format( + "charid = {} and taskid = {}", + c->CharacterID(), + cts->m_active_shared_task.task_id + ); + CharacterTasksRepository::DeleteWhere(database, delete_where); + CharacterActivitiesRepository::DeleteWhere(database, delete_where); + + c->MessageString(Chat::Yellow, SharedTaskMessage::YOU_ARE_NO_LONGER_A_MEMBER, + m_task_data[cts->m_active_shared_task.task_id]->title.c_str()); + + // remove as active task if doesn't exist + cts->m_active_shared_task = {}; + + // persist removal from local record + SaveClientState(c, cts); + } + } +} + +// in a case where a client somehow lost local state with what state exists in world - we need +// to perform an inverse sync where we inject the task +void TaskManager::SyncClientSharedTaskStateToLocal( + Client *c +) +{ + auto character_tasks = CharacterTasksRepository::GetWhere( + database, + fmt::format("charid = {} ORDER BY acceptedtime", c->CharacterID()) + ); + + bool has_character_shared_task = false; + + for (auto &character_task: character_tasks) { + if (character_task.type == TASK_TYPE_SHARED) { + has_character_shared_task = true; + } + } + + if (!has_character_shared_task) { + LogTasksDetail("[SyncClientSharedTaskStateToLocal] We don't have a shared character task locally"); + auto stm = SharedTaskMembersRepository::GetWhere( + database, + fmt::format( + "character_id = {}", + c->CharacterID() + ) + ); + + if (!stm.empty()) { + LogTasksDetail("[SyncClientSharedTaskStateToLocal] We have membership in database"); + auto s = SharedTasksRepository::FindOne( + database, + (int) stm.front().shared_task_id + ); + + if (s.id > 0) { + LogTasksDetail("[SyncClientSharedTaskStateToLocal] Creating entity"); + + // create task locally + auto ct = CharacterTasksRepository::NewEntity(); + ct.charid = (int) c->CharacterID(); + ct.acceptedtime = (int) s.accepted_time; + ct.taskid = (int) s.task_id; + ct.slot = 0; + ct.type = TASK_TYPE_SHARED; + character_tasks.emplace_back(ct); + CharacterTasksRepository::InsertOne(database, ct); + + // create activities locally + auto activities = SharedTaskActivityStateRepository::GetWhere( + database, + fmt::format( + "shared_task_id = {}", + (int) stm.front().shared_task_id + ) + ); + + std::vector character_activities = {}; + + for (auto &a: activities) { + auto ca = CharacterActivitiesRepository::NewEntity(); + ca.completed = a.completed_time > 0; + ca.charid = (int) c->CharacterID(); + ca.donecount = a.done_count; + ca.taskid = s.task_id; + ca.activityid = a.activity_id; + character_activities.emplace_back(ca); + } + CharacterActivitiesRepository::InsertMany(database, character_activities); + } + } + } +} diff --git a/zone/task_manager.h b/zone/task_manager.h index f1fe41bd9..0914fe888 100644 --- a/zone/task_manager.h +++ b/zone/task_manager.h @@ -6,6 +6,7 @@ #include "task_proximity_manager.h" #include "task_goal_list_manager.h" #include "../common/types.h" +#include "../common/repositories/character_tasks_repository.h" #include #include #include @@ -31,7 +32,6 @@ public: bool LoadClientState(Client *client, ClientTaskState *client_task_state); bool SaveClientState(Client *client, ClientTaskState *client_task_state); void SendTaskSelector(Client *client, Mob *mob, int task_count, int *task_list); - void SendTaskSelectorNew(Client *client, Mob *mob, int task_count, int *task_list); bool ValidateLevel(int task_id, int player_level); std::string GetTaskName(uint32 task_id); TaskType GetTaskType(uint32 task_id); @@ -44,6 +44,7 @@ public: int count, int *tasks ); + void SharedTaskSelector(Client* client, Mob* mob, int count, const int* tasks); void SendActiveTasksToClient(Client *client, bool task_complete = false); void SendSingleActiveTaskToClient( Client *client, @@ -57,15 +58,6 @@ public: int task_id, int activity_id, int client_task_index, - bool optional, - bool task_complete = false - ); - void SendTaskActivityNew( - Client *client, - int task_id, - int activity_id, - int client_task_index, - bool optional, bool task_complete = false ); void SendCompletedTasksToClient(Client *c, ClientTaskState *client_task_state); @@ -77,6 +69,8 @@ public: friend class ClientTaskState; + // shared tasks + void SyncClientSharedTaskState(Client *c, ClientTaskState *cts); private: TaskGoalListManager m_goal_list_manager; @@ -92,6 +86,13 @@ private: bool bring_up_task_journal = false ); + void SendActiveTaskToClient(ClientTaskInformation *task, Client *client, int task_index, bool task_complete); + + // shared tasks + void SyncClientSharedTaskWithPersistedState(Client *c, ClientTaskState *cts); + void SyncClientSharedTaskRemoveLocalIfNotExists(Client *c, ClientTaskState *cts); + void SendSharedTaskSelector(Client* client, Mob* mob, int task_count, int* task_list); + void SyncClientSharedTaskStateToLocal(Client *c); }; diff --git a/zone/tasks.cpp b/zone/tasks.cpp index 4f240bab5..be8a6ca58 100644 --- a/zone/tasks.cpp +++ b/zone/tasks.cpp @@ -5,8 +5,10 @@ #include "client.h" #include "queryserv.h" #include "quest_parser_collection.h" +#include "string_ids.h" #include "tasks.h" #include "zonedb.h" +#include "../common/repositories/character_task_timers_repository.h" extern QueryServ *QServ; @@ -17,7 +19,7 @@ void Client::LoadClientTaskState() safe_delete(task_state); } - task_state = new ClientTaskState; + task_state = new ClientTaskState(); if (!task_manager->LoadClientState(this, task_state)) { safe_delete(task_state); } @@ -118,6 +120,42 @@ void Client::SendTaskFailed(int task_id, int task_index, TaskType task_type) safe_delete(outapp); } +bool Client::HasTaskRequestCooldownTimer() +{ + if (task_request_timer.Check(false)) + { + task_request_timer.Disable(); + } + return (!GetGM() && task_request_timer.Enabled()); +} +void Client::SendTaskRequestCooldownTimerMessage() +{ + if (HasTaskRequestCooldownTimer()) + { + uint32_t seconds = task_request_timer.GetRemainingTime() / 1000; + MessageString(Chat::Yellow, TASK_REQUEST_COOLDOWN_TIMER, + ".", ".", // args start at %3 for this eqstr + GetName(), + fmt::format_int(seconds / 60).c_str(), // minutes + fmt::format_int(seconds % 60).c_str() // seconds + ); + } +} +void Client::StartTaskRequestCooldownTimer() +{ + uint32_t milliseconds = RuleI(TaskSystem, RequestCooldownTimerSeconds) * 1000; + task_request_timer.Start(milliseconds); + + uint32_t size = sizeof(uint32_t); + auto outapp = std::make_unique(OP_TaskRequestTimer, size); + outapp->WriteUInt32(milliseconds); + QueuePacket(outapp.get()); +} + +void Client::PurgeTaskTimers() +{ + CharacterTaskTimersRepository::DeleteWhere(database, fmt::format("character_id = {}", CharacterID())); +} diff --git a/zone/tasks.h b/zone/tasks.h index d3fed2c09..56be4fa8d 100644 --- a/zone/tasks.h +++ b/zone/tasks.h @@ -2,24 +2,12 @@ #define TASKS_H #include "../common/types.h" +#include "../common/tasks.h" #include #include #include #include -#define MAXTASKS 10000 -#define MAXTASKSETS 1000 -#define MAXACTIVEQUESTS 19 // The Client has a hard cap of 19 active quests, 29 in SoD+ -#define MAXCHOOSERENTRIES 40 // The Max Chooser (Task Selector entries) is capped at 40 in the Titanium Client. -#define MAXACTIVITIESPERTASK 20 // The Client has a hard cap of 20 activities per task. -#define TASKSLOTEMPTY 0 // This is used to determine if a client's active task slot is empty. - -// Command Codes for worldserver ServerOP_ReloadTasks -#define RELOADTASKS 0 -#define RELOADTASKGOALLISTS 1 -#define RELOADTASKPROXIMITIES 2 -#define RELOADTASKSETS 3 - class Client; class Mob; @@ -27,123 +15,4 @@ namespace EQ { class ItemInstance; } -typedef enum { - METHODSINGLEID = 0, - METHODLIST = 1, - METHODQUEST = 2 -} TaskMethodType; - -struct ActivityInformation { - int step_number; - int activity_type; - std::string target_name; // name mob, location -- default empty - std::string item_list; // likely defaults to empty - std::string skill_list; // IDs ; separated -- default -1 - std::string spell_list; // IDs ; separated -- default 0 - std::string description_override; // overrides auto generated description -- default empty - int skill_id; // older clients, first id from above - int spell_id; // older clients, first id from above - int goal_id; - TaskMethodType goal_method; - int goal_count; - int deliver_to_npc; - std::vector zone_ids; - std::string zones; // IDs ; searated, ZoneID is the first in this list for older clients -- default empty string - bool optional; - - inline bool CheckZone(int zone_id) - { - if (zone_ids.empty()) { - return true; - } - return std::find(zone_ids.begin(), zone_ids.end(), zone_id) != zone_ids.end(); - } -}; - -typedef enum { - ActivitiesSequential = 0, - ActivitiesStepped = 1 -} SequenceType; - -enum class TaskType { - Task = 0, // can have at max 1 - Shared = 1, // can have at max 1 - Quest = 2, // can have at max 19 or 29 depending on client - E = 3 // can have at max 19 or 29 depending on client, not present in live anymore -}; - -enum class DurationCode { - None = 0, - Short = 1, - Medium = 2, - Long = 3 -}; - -struct TaskInformation { - TaskType type; - int duration; - DurationCode duration_code; // description for time investment for when duration == 0 - std::string title; // max length 64 - std::string description; // max length 4000, 2048 on Tit - std::string reward; - std::string item_link; // max length 128 older clients, item link gets own string - std::string completion_emote; // emote after completing task, yellow. Maybe should make more generic ... but yellow for now! - int reward_id; - int cash_reward; // Expressed in copper - int experience_reward; - int faction_reward; // just a npc_faction_id - TaskMethodType reward_method; - int activity_count; - SequenceType sequence_mode; - int last_step; - short min_level; - short max_level; - bool repeatable; - ActivityInformation activity_information[MAXACTIVITIESPERTASK]; -}; - -typedef enum { - ActivityHidden = 0, - ActivityActive = 1, - ActivityCompleted = 2 -} ActivityState; - -typedef enum { - ActivityDeliver = 1, - ActivityKill = 2, - ActivityLoot = 3, - ActivitySpeakWith = 4, - ActivityExplore = 5, - ActivityTradeSkill = 6, - ActivityFish = 7, - ActivityForage = 8, - ActivityCastOn = 9, - ActivitySkillOn = 10, - ActivityTouch = 11, - ActivityCollect = 13, - ActivityGiveCash = 100 -} ActivityType; - -struct ClientActivityInformation { - int activity_id; - int done_count; - ActivityState activity_state; - bool updated; // Flag so we know if we need to updated the database -}; - -struct ClientTaskInformation { - int slot; // intrusive, but makes things easier :P - int task_id; - int current_step; - int accepted_time; - bool updated; - ClientActivityInformation activity[MAXACTIVITIESPERTASK]; -}; - -struct CompletedTaskInformation { - int task_id; - int completed_time; - bool activity_done[MAXACTIVITIESPERTASK]; -}; - #endif diff --git a/zone/tradeskills.cpp b/zone/tradeskills.cpp index 52423b368..4beaedf52 100644 --- a/zone/tradeskills.cpp +++ b/zone/tradeskills.cpp @@ -1093,7 +1093,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } if (RuleB(TaskSystem, EnableTaskSystem)) { - UpdateTasksForItem(ActivityTradeSkill, itr->first, itr->second); + UpdateTasksForItem(TaskActivityType::TradeSkill, itr->first, itr->second); } ++itr; diff --git a/zone/worldserver.cpp b/zone/worldserver.cpp index ce1cf892c..fb4d0d4bb 100644 --- a/zone/worldserver.cpp +++ b/zone/worldserver.cpp @@ -54,6 +54,8 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #include "zone.h" #include "zone_config.h" #include "zone_reload.h" +#include "../common/shared_tasks.h" +#include "shared_task_zone_messaging.h" extern EntityList entity_list; extern Zone* zone; @@ -3004,38 +3006,50 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) break; } case ServerOP_ExpeditionCreate: - case ServerOP_ExpeditionDeleted: - case ServerOP_ExpeditionLeaderChanged: case ServerOP_ExpeditionLockout: case ServerOP_ExpeditionLockoutDuration: case ServerOP_ExpeditionLockState: - case ServerOP_ExpeditionMemberChange: - case ServerOP_ExpeditionMemberSwap: - case ServerOP_ExpeditionMemberStatus: - case ServerOP_ExpeditionMembersRemoved: case ServerOP_ExpeditionReplayOnJoin: - case ServerOP_ExpeditionGetMemberStatuses: case ServerOP_ExpeditionDzAddPlayer: case ServerOP_ExpeditionDzMakeLeader: case ServerOP_ExpeditionCharacterLockout: - case ServerOP_ExpeditionExpireWarning: { Expedition::HandleWorldMessage(pack); break; } - case ServerOP_DzAddRemoveCharacter: - case ServerOP_DzRemoveAllCharacters: + case ServerOP_DzCreated: + case ServerOP_DzDeleted: + case ServerOP_DzAddRemoveMember: + case ServerOP_DzSwapMembers: + case ServerOP_DzRemoveAllMembers: case ServerOP_DzDurationUpdate: + case ServerOP_DzGetMemberStatuses: case ServerOP_DzSetCompass: case ServerOP_DzSetSafeReturn: case ServerOP_DzSetZoneIn: + case ServerOP_DzUpdateMemberStatus: + case ServerOP_DzLeaderChanged: + case ServerOP_DzExpireWarning: { DynamicZone::HandleWorldMessage(pack); break; } + case ServerOP_SharedTaskAcceptNewTask: + case ServerOP_SharedTaskUpdate: + case ServerOP_SharedTaskAttemptRemove: + case ServerOP_SharedTaskMemberlist: + case ServerOP_SharedTaskMemberChange: + case ServerOP_SharedTaskInvitePlayer: + case ServerOP_SharedTaskPurgeAllCommand: + { + SharedTaskZoneMessaging::HandleWorldMessage(pack); + break; + } default: { - std::cout << " Unknown ZSopcode:" << (int)pack->opcode; - std::cout << " size:" << pack->size << std::endl; + LogInfo("[HandleMessage] Unknown ZS Opcode [{}] size [{}]", (int)pack->opcode, pack->size); + +// std::cout << " Unknown ZSopcode:" << (int)pack->opcode; +// std::cout << " size:" << pack->size << std::endl; break; } } @@ -3200,13 +3214,16 @@ void WorldServer::HandleReloadTasks(ServerPacket *pack) case RELOADTASKS: entity_list.SaveAllClientsTaskState(); + // TODO: Reload at the world level for shared tasks + if (rts->Parameter == 0) { Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload ALL tasks"); safe_delete(task_manager); task_manager = new TaskManager; task_manager->LoadTasks(); - if (zone) + if (zone) { task_manager->LoadProximities(zone->GetZoneID()); + } entity_list.ReloadAllClientsTaskState(); } else { @@ -3428,3 +3445,4 @@ void WorldServer::SetScheduler(ZoneEventScheduler *scheduler) { WorldServer::m_zone_scheduler = scheduler; } + diff --git a/zone/zone.cpp b/zone/zone.cpp index aae61ad23..709803aab 100755 --- a/zone/zone.cpp +++ b/zone/zone.cpp @@ -1184,6 +1184,9 @@ bool Zone::Init(bool iStaticZone) { petition_list.ClearPetitions(); petition_list.ReadDatabase(); + LogInfo("Loading dynamic zones"); + DynamicZone::CacheAllFromDatabase(); + LogInfo("Loading active Expeditions"); Expedition::CacheAllFromDatabase(); @@ -1491,16 +1494,14 @@ bool Zone::Process() { { if(Instance_Timer->Check()) { - // if this is a dynamic zone instance notify system associated with it - auto expedition = Expedition::FindCachedExpeditionByZoneInstance(GetZoneID(), GetInstanceID()); - if (expedition) + auto dz = GetDynamicZone(); + if (dz) { - expedition->RemoveAllMembers(false); // entity list will teleport clients out immediately + dz->RemoveAllMembers(); // entity list will teleport clients out immediately } // instance shutting down, move corpses to graveyard or non-instanced zone at same coords entity_list.MovePlayerCorpsesToGraveyard(true); - entity_list.GateAllClientsToSafeReturn(); database.DeleteInstance(GetInstanceID()); Instance_Shutdown_Timer = new Timer(20000); //20 seconds @@ -2726,13 +2727,14 @@ DynamicZone* Zone::GetDynamicZone() return nullptr; } - auto expedition = Expedition::FindCachedExpeditionByZoneInstance(GetZoneID(), GetInstanceID()); - if (expedition) + // todo: cache dynamic zone id on zone later for faster lookup + for (const auto& dz_iter : zone->dynamic_zone_cache) { - return &expedition->GetDynamicZone(); + if (dz_iter.second->IsSameDz(GetZoneID(), GetInstanceID())) + { + return dz_iter.second.get(); + } } - // todo: tasks, missions, and quests with an associated dz for this instance id - return nullptr; } diff --git a/zone/zone.h b/zone/zone.h index c7c6daf12..af6f571ae 100755 --- a/zone/zone.h +++ b/zone/zone.h @@ -222,6 +222,7 @@ public: std::vector zone_grids; std::vector zone_grid_entries; + std::unordered_map> dynamic_zone_cache; std::unordered_map> expedition_cache; time_t weather_timer;