mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-20 03:25:56 +00:00
Merge feat/companions-realms: companion bots on Wildcard and Warcraft Reborn
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> # Conflicts: # crates/coa-core/src/ra.rs
This commit is contained in:
commit
326a4fe3d3
12 files changed
+2691
-327
No files matched your search
File diff suppressed because it is too large.
Load diff
@@ -176,6 +176,32 @@ fn installed_module_commits(root: &Path) -> BTreeMap<String, String> {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
/// The companion bots of this server build play Wildcard and Warcraft Reborn: their bot profiles for the standard
|
||||
/// classes are in the world server or its bots plugin. Older builds only know Conquest of Azeroth characters.
|
||||
pub fn companions_on_other_realms(root: &Path) -> bool {
|
||||
use std::collections::HashMap;
|
||||
use std::sync::{Mutex, OnceLock};
|
||||
static SEEN: OnceLock<Mutex<HashMap<(PathBuf, u64, Option<std::time::SystemTime>), bool>>> = OnceLock::new();
|
||||
const MARKER: &[u8] = b"Druid_Guardian_Tank";
|
||||
let mut files = vec![crate::layout::executables(root).0];
|
||||
if let Ok(plugins) = fs::read_dir(root.join("Core/plugins")) {
|
||||
files.extend(plugins.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x.eq_ignore_ascii_case("dll"))));
|
||||
}
|
||||
files.into_iter().any(|file| {
|
||||
let Ok(meta) = fs::metadata(&file) else { return false };
|
||||
let key = (file.clone(), meta.len(), meta.modified().ok());
|
||||
let seen = SEEN.get_or_init(Mutex::default);
|
||||
if let Some(found) = seen.lock().ok().and_then(|s| s.get(&key).copied()) {
|
||||
return found;
|
||||
}
|
||||
let found = fs::read(&file).is_ok_and(|bytes| bytes.windows(MARKER.len()).any(|w| w == MARKER));
|
||||
if let Ok(mut s) = seen.lock() {
|
||||
s.insert(key, found);
|
||||
}
|
||||
found
|
||||
})
|
||||
}
|
||||
|
||||
fn list_in(cat: &[Entry], root: &Path) -> Vec<ModuleView> {
|
||||
let installed_commits = installed_module_commits(root);
|
||||
let wildcard = crate::realms::state(root)
|
||||
@@ -208,7 +234,9 @@ fn list_in(cat: &[Entry], root: &Path) -> Vec<ModuleView> {
|
||||
.map(|enabled| !enabled)
|
||||
.unwrap_or(true);
|
||||
let blocked = dependency_missing
|
||||
|| (wildcard && matches!(e.id.as_str(), "companions" | "playerbots" | "dungeon-clear"));
|
||||
|| (wildcard
|
||||
&& (matches!(e.id.as_str(), "playerbots" | "dungeon-clear")
|
||||
|| (e.id == "companions" && !companions_on_other_realms(root))));
|
||||
let version = if e.id == "playerbots" {
|
||||
crate::squid::release(root).map(|release| {
|
||||
[
|
||||
@@ -722,6 +750,27 @@ mod tests {
|
||||
assert!(meta.join("backups").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn companions_open_on_other_realms_only_with_a_build_that_plays_them() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path().join("server");
|
||||
fs::create_dir_all(dir(&root)).unwrap();
|
||||
fs::create_dir_all(root.join("Settings")).unwrap();
|
||||
fs::write(root.join("Settings/realm-profile.json"), r#"{"active":"wildcard","wildcard_created":true}"#).unwrap();
|
||||
for e in catalog().iter().filter(|e| matches!(e.id.as_str(), "companions" | "playerbots")) {
|
||||
fs::write(dir(&root).join(format!("{}.dist", e.conf)), format!("{} = 0\n", e.enable_key)).unwrap();
|
||||
}
|
||||
let exe = crate::layout::executables(&root).0;
|
||||
fs::write(&exe, b"an old world server").unwrap();
|
||||
let view = |id: &str| list(&root).into_iter().find(|m| m.id == id).unwrap();
|
||||
assert_eq!(view("companions").compatibility, "unsupported");
|
||||
fs::write(&exe, b"profiles ... Druid_Guardian_Tank ... a new world server").unwrap();
|
||||
assert!(companions_on_other_realms(&root));
|
||||
assert_eq!(view("companions").compatibility, "experimental");
|
||||
assert!(view("companions").switchable);
|
||||
assert_eq!(view("playerbots").compatibility, "unsupported", "SQUID stays CoA-only");
|
||||
}
|
||||
|
||||
fn test_catalog() -> Vec<Entry> {
|
||||
let one = |id: &str, name: &str, conf: &str, key: &str| Entry {
|
||||
id: id.into(),
|
||||
|
||||
@@ -97,6 +97,58 @@ pub fn world_root(main: &Path, mode: Mode) -> PathBuf {
|
||||
.map_or_else(|| main.to_path_buf(), |t| tree_root(main, t))
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct BotOperationTarget {
|
||||
pub world_root: PathBuf,
|
||||
pub chars_db: &'static str,
|
||||
pub ra_port: u16,
|
||||
pub running: bool,
|
||||
pub realm: Mode,
|
||||
}
|
||||
|
||||
pub fn resolve_bot_operation_target(main: &Path, realm: Mode) -> Result<BotOperationTarget> {
|
||||
let state = realms::state(main)?;
|
||||
let chars_db = realm.schema("characters")?;
|
||||
|
||||
if realm == state.active {
|
||||
let ports = crate::layout::read_ports(main);
|
||||
let ra_port = ports.ra;
|
||||
let status = process::observe(main, &ports);
|
||||
let running = status.world.state != ServiceState::Stopped;
|
||||
return Ok(BotOperationTarget {
|
||||
world_root: main.to_path_buf(),
|
||||
chars_db,
|
||||
ra_port,
|
||||
running,
|
||||
realm,
|
||||
});
|
||||
}
|
||||
|
||||
let tree = Tree::ALL
|
||||
.into_iter()
|
||||
.find(|t| t.enabled(&state) && t.mode(state.active) == realm)
|
||||
.ok_or_else(|| Error::Invalid(format!("Realm {} is not enabled in multiworld configuration.", realm.label())))?;
|
||||
|
||||
let root = tree_root(main, tree);
|
||||
if !root.exists() {
|
||||
return Err(Error::Invalid(format!("Multiworld directory for {} does not exist: {}", realm.label(), root.display())));
|
||||
}
|
||||
|
||||
let ports = crate::layout::read_ports(&root);
|
||||
let (_, default_ra) = tree.ports(&state);
|
||||
let ra_port = if ports.ra != 0 { ports.ra } else { default_ra.unwrap_or(3444) };
|
||||
let status = process::observe(&root, &ports);
|
||||
let running = status.world.state != ServiceState::Stopped;
|
||||
|
||||
Ok(BotOperationTarget {
|
||||
world_root: root,
|
||||
chars_db,
|
||||
ra_port,
|
||||
running,
|
||||
realm,
|
||||
})
|
||||
}
|
||||
|
||||
/// Any of the extra worlds is running or still stopping.
|
||||
pub fn is_running(main: &Path) -> bool {
|
||||
Tree::ALL.into_iter().any(|t| tree_running(main, t))
|
||||
@@ -261,6 +313,12 @@ fn prepare(main: &Path, tree: Tree) -> Result<PathBuf> {
|
||||
&fsx::ensure_within(&second, &second.join("Core/reference"))?,
|
||||
)?;
|
||||
}
|
||||
if main.join("Core/plugins").is_dir() {
|
||||
copy_tree(
|
||||
&main.join("Core/plugins"),
|
||||
&fsx::ensure_within(&second, &second.join("Core/plugins"))?,
|
||||
)?;
|
||||
}
|
||||
for entry in fs::read_dir(main.join("Core"))? {
|
||||
let entry = entry?;
|
||||
if entry.file_type()?.is_file()
|
||||
|
||||
@@ -49,17 +49,19 @@ fn parse_counts(out: &str) -> Result<Population> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Read-only query with the game's own database account. Requires the database to be running.
|
||||
/// Read-only query with the game's own database account. Routes automatically to the active realm's characters database.
|
||||
pub fn query(root: &Path) -> Result<Population> {
|
||||
let db = Db::from_repack(root, Account::App)?;
|
||||
query_with(
|
||||
&db,
|
||||
&bot_account_prefix(root),
|
||||
&crate::accounts::squid_bot_prefix(root),
|
||||
)
|
||||
let mode = crate::realms::state(root)
|
||||
.map(|s| s.active)
|
||||
.unwrap_or(crate::realms::Mode::Coa);
|
||||
query_for_realm(root, mode)
|
||||
}
|
||||
|
||||
fn counts_sql(prefix: &str, squid_prefix: &str) -> Result<String> {
|
||||
counts_sql_for_db("acore_characters", prefix, squid_prefix)
|
||||
}
|
||||
|
||||
pub fn counts_sql_for_db(chars_db: &str, prefix: &str, squid_prefix: &str) -> Result<String> {
|
||||
if [prefix, squid_prefix]
|
||||
.iter()
|
||||
.any(|prefix| prefix.is_empty() || !prefix.chars().all(|c| c.is_ascii_alphanumeric()))
|
||||
@@ -74,9 +76,9 @@ fn counts_sql(prefix: &str, squid_prefix: &str) -> Result<String> {
|
||||
let bots =
|
||||
format!("(UPPER(a.username) LIKE '{prefix}%' OR UPPER(a.username) LIKE '{squid_prefix}%')");
|
||||
Ok(format!(
|
||||
"SELECT (SELECT COUNT(*) FROM acore_characters.characters WHERE online=1), \
|
||||
(SELECT COUNT(*) FROM acore_characters.characters c JOIN acore_auth.account a ON a.id=c.account WHERE c.online=1 AND {bots}), \
|
||||
(SELECT COUNT(*) FROM acore_characters.characters c JOIN acore_auth.account a ON a.id=c.account WHERE {bots});"
|
||||
"SELECT (SELECT COUNT(*) FROM {chars_db}.characters WHERE online=1), \
|
||||
(SELECT COUNT(*) FROM {chars_db}.characters c JOIN acore_auth.account a ON a.id=c.account WHERE c.online=1 AND {bots}), \
|
||||
(SELECT COUNT(*) FROM {chars_db}.characters c JOIN acore_auth.account a ON a.id=c.account WHERE {bots});"
|
||||
))
|
||||
}
|
||||
|
||||
@@ -85,6 +87,21 @@ pub fn query_with(db: &Db, prefix: &str, squid_prefix: &str) -> Result<Populatio
|
||||
parse_counts(&db.query(&counts_sql(prefix, squid_prefix)?)?)
|
||||
}
|
||||
|
||||
pub fn query_for_schema(db: &Db, chars_db: &str, prefix: &str, squid_prefix: &str) -> Result<Population> {
|
||||
parse_counts(&db.query(&counts_sql_for_db(chars_db, prefix, squid_prefix)?)?)
|
||||
}
|
||||
|
||||
pub fn query_for_realm(root: &Path, mode: crate::realms::Mode) -> Result<Population> {
|
||||
let db = Db::from_repack(root, Account::App)?;
|
||||
let schema = mode.schema("characters")?;
|
||||
query_for_schema(
|
||||
&db,
|
||||
schema,
|
||||
&bot_account_prefix(root),
|
||||
&crate::accounts::squid_bot_prefix(root),
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct Hardware {
|
||||
pub cores: u32,
|
||||
|
||||
@@ -58,6 +58,23 @@ impl Ra {
|
||||
Self::connect_to(read_ports(root).ra, &cfg.ra_username, &cfg.ra_password)
|
||||
}
|
||||
|
||||
/// Connect to the loopback RA port of the target realm world server.
|
||||
pub fn connect_target(main: &Path, realm: Option<crate::realms::Mode>) -> Result<Ra> {
|
||||
let mode = realm.unwrap_or_else(|| {
|
||||
crate::realms::view(main).map(|v| v.active).unwrap_or_default()
|
||||
});
|
||||
let target = crate::multiworld::resolve_bot_operation_target(main, mode)?;
|
||||
if !target.running {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Realm {} worldserver is stopped; cannot execute online bot operation.",
|
||||
target.realm.label()
|
||||
)));
|
||||
}
|
||||
let cfg: RaSettings = fsx::read_json(&main.join("Settings/repack.json"))
|
||||
.map_err(|_| Error::Invalid("The server console settings could not be read.".into()))?;
|
||||
Self::connect_to(target.ra_port, &cfg.ra_username, &cfg.ra_password)
|
||||
}
|
||||
|
||||
pub fn connect_to(port: u16, user: &str, password: &str) -> Result<Ra> {
|
||||
let addr: SocketAddr = ([127, 0, 0, 1], port).into();
|
||||
let mut stream =
|
||||
@@ -87,7 +104,6 @@ impl Ra {
|
||||
let c = crate::console::check_command(cmd)?;
|
||||
self.command(c)
|
||||
}
|
||||
|
||||
/// Send a command whose answer does not matter (`server shutdown`). The reply is still read (up to the next
|
||||
/// prompt, the end of the connection, or a few seconds): closing a socket that holds unread data resets the
|
||||
/// connection, and the server can then drop the command it has not processed yet.
|
||||
@@ -110,7 +126,6 @@ impl Ra {
|
||||
let _ = self.stream.shutdown(std::net::Shutdown::Both);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn command(&mut self, cmd: &str) -> Result<String> {
|
||||
debug_assert!(!cmd.contains(['\r', '\n']));
|
||||
self.stream.write_all(format!("{cmd}\r\n").as_bytes())?;
|
||||
@@ -277,6 +292,41 @@ impl Ra {
|
||||
Ok(out.lines().last().unwrap_or("").to_string())
|
||||
}
|
||||
|
||||
/// Ask the bot module to spawn a fleet of bots of specific race and level (.botcmd spawnfleet <race> <level>).
|
||||
pub fn spawn_fleet(&mut self, race: u8, level: u8) -> Result<String> {
|
||||
let out = self.bot_command(&format!("botcmd spawnfleet {race} {level}"))?;
|
||||
Ok(out.lines().last().unwrap_or("").to_string())
|
||||
}
|
||||
|
||||
pub fn spawn_custom(
|
||||
&mut self,
|
||||
count: u32,
|
||||
level: u8,
|
||||
class_id: Option<u8>,
|
||||
spec_id: Option<u32>,
|
||||
archetype: Option<&str>,
|
||||
) -> Result<String> {
|
||||
let c = class_id.unwrap_or(0);
|
||||
let s = spec_id.unwrap_or(0);
|
||||
let a = archetype.unwrap_or("").trim();
|
||||
let mut cmd = format!("botcmd spawncustom {count} {level}");
|
||||
if !a.is_empty() {
|
||||
cmd.push_str(&format!(" {c} {s} {a}"));
|
||||
} else if s > 0 {
|
||||
cmd.push_str(&format!(" {c} {s}"));
|
||||
} else if c > 0 {
|
||||
cmd.push_str(&format!(" {c}"));
|
||||
}
|
||||
let out = self.bot_command(&cmd)?;
|
||||
Ok(out.lines().last().unwrap_or("").to_string())
|
||||
}
|
||||
|
||||
/// Bring all offline bots online gradually (.botcmd loginall).
|
||||
pub fn login_all(&mut self) -> Result<String> {
|
||||
let out = self.bot_command("botcmd loginall")?;
|
||||
Ok(out.lines().last().unwrap_or("").to_string())
|
||||
}
|
||||
|
||||
/// Set a new password for an existing account.
|
||||
pub fn set_account_password(&mut self, name: &str, password: &str) -> Result<()> {
|
||||
validate_account(name, password)?;
|
||||
|
||||
@@ -185,8 +185,20 @@ pub fn view(root: &Path) -> Result<View> {
|
||||
}
|
||||
|
||||
pub fn guard_module(root: &Path, id: &str) -> Result<()> {
|
||||
if state(root)?.active != Mode::Coa && matches!(id, "companions" | "playerbots") {
|
||||
return Err(Error::Invalid("Bot class mechanics have not been validated for this realm. This module is unavailable on this realm.".into()));
|
||||
let s = state(root)?;
|
||||
if matches!(id, "companions" | "playerbots") {
|
||||
if let Ok(v) = view(root) {
|
||||
if s.active == Mode::Wildcard && !v.supported {
|
||||
return Err(Error::Invalid(
|
||||
"The installed server binary does not support Wildcard mode.".into(),
|
||||
));
|
||||
}
|
||||
if s.active == Mode::Reborn && !v.reborn_supported {
|
||||
return Err(Error::Invalid(
|
||||
"The installed server binary does not support Warcraft Reborn mode.".into(),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -296,20 +308,14 @@ fn wildcard_configs(mut files: Files) -> Result<Files> {
|
||||
}
|
||||
}
|
||||
}
|
||||
for (key, value) in [("CoaBots.Enable", "0"), ("CoaBots.AutoLoginOnStartup", "0")] {
|
||||
set(
|
||||
&mut files,
|
||||
"Core/configs/modules/mod_coa_playerbots.conf",
|
||||
key,
|
||||
value,
|
||||
)?;
|
||||
// Preserve existing CoaBots.Enable if present; do not force enable or alter alternative bot systems
|
||||
if let Some(bytes) = files.get("Core/configs/modules/mod_coa_playerbots.conf") {
|
||||
if let Ok(conf) = ConfFile::parse_bytes(bytes) {
|
||||
if conf.get("CoaBots.Enable") == Some("1") {
|
||||
set(&mut files, "Core/configs/modules/mod_coa_playerbots.conf", "CoaBots.Enable", "1")?;
|
||||
}
|
||||
}
|
||||
}
|
||||
set(
|
||||
&mut files,
|
||||
"Core/configs/modules/playerbots.conf",
|
||||
"AiPlayerbot.Enabled",
|
||||
"0",
|
||||
)?;
|
||||
Ok(files)
|
||||
}
|
||||
|
||||
@@ -337,20 +343,14 @@ fn reborn_configs(mut files: Files) -> Result<Files> {
|
||||
set(&mut files, path, "RealmID", "3")?;
|
||||
}
|
||||
}
|
||||
for (key, value) in [("CoaBots.Enable", "0"), ("CoaBots.AutoLoginOnStartup", "0")] {
|
||||
set(
|
||||
&mut files,
|
||||
"Core/configs/modules/mod_coa_playerbots.conf",
|
||||
key,
|
||||
value,
|
||||
)?;
|
||||
// Preserve existing CoaBots.Enable if present; do not force enable or alter alternative bot systems
|
||||
if let Some(bytes) = files.get("Core/configs/modules/mod_coa_playerbots.conf") {
|
||||
if let Ok(conf) = ConfFile::parse_bytes(bytes) {
|
||||
if conf.get("CoaBots.Enable") == Some("1") {
|
||||
set(&mut files, "Core/configs/modules/mod_coa_playerbots.conf", "CoaBots.Enable", "1")?;
|
||||
}
|
||||
}
|
||||
}
|
||||
set(
|
||||
&mut files,
|
||||
"Core/configs/modules/playerbots.conf",
|
||||
"AiPlayerbot.Enabled",
|
||||
"0",
|
||||
)?;
|
||||
Ok(files)
|
||||
}
|
||||
|
||||
@@ -681,19 +681,7 @@ pub fn before_start(root: &Path) -> Result<()> {
|
||||
"The installed server build does not support Wildcard.".into(),
|
||||
));
|
||||
}
|
||||
let path = root.join("Core/configs/modules/mod_coa_playerbots.conf");
|
||||
let mut conf = ConfFile::parse_bytes(&fs::read(&path)?)?;
|
||||
conf.set("CoaBots.Enable", "0", &[]);
|
||||
fsx::atomic_write(&path, conf.to_text().as_bytes())?;
|
||||
let path = root.join("Core/configs/modules/playerbots.conf");
|
||||
let bytes = if path.exists() {
|
||||
fs::read(&path)?
|
||||
} else {
|
||||
b"[worldserver]\n".to_vec()
|
||||
};
|
||||
let mut conf = ConfFile::parse_bytes(&bytes)?;
|
||||
conf.set("AiPlayerbot.Enabled", "0", &[]);
|
||||
fsx::atomic_write(&path, conf.to_text().as_bytes())?;
|
||||
// Multi-realm Playerbots 1.0: bots are supported and enabled on all realms
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -813,11 +801,12 @@ mod tests {
|
||||
.get("RealmID"),
|
||||
Some("3")
|
||||
);
|
||||
// Requirement 6: Never alter alternative bot system settings (AiPlayerbot.Enabled) without explicit user choice
|
||||
assert_eq!(
|
||||
ConfFile::parse_bytes(&reborn["Core/configs/modules/playerbots.conf"])
|
||||
.unwrap()
|
||||
.get("AiPlayerbot.Enabled"),
|
||||
Some("0")
|
||||
Some("1")
|
||||
);
|
||||
write_configs(t.path(), &reborn).unwrap();
|
||||
write_configs(t.path(), &coa).unwrap();
|
||||
@@ -831,8 +820,8 @@ mod tests {
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
assert!(guard_module(t.path(), "companions").is_err());
|
||||
assert!(guard_module(t.path(), "playerbots").is_err());
|
||||
assert!(guard_module(t.path(), "companions").is_ok());
|
||||
assert!(guard_module(t.path(), "playerbots").is_ok());
|
||||
assert!(guard_module(t.path(), "content-scaling").is_ok());
|
||||
}
|
||||
|
||||
@@ -1020,6 +1009,10 @@ CoA.GameModeMask = 0
|
||||
"Core/configs/modules/mod-coa-content-scaling.conf".into(),
|
||||
b"[worldserver]\nCoAContentScaling.Enable = 1\n".to_vec(),
|
||||
);
|
||||
f.insert(
|
||||
"Core/configs/modules/mod_coa_playerbots.conf".into(),
|
||||
b"[worldserver]\nCoaBots.Enable = 1\n".to_vec(),
|
||||
);
|
||||
f.insert(
|
||||
"Settings/worldserver.conf.template".into(),
|
||||
b"[worldserver]\nRealmID = 1\n".to_vec(),
|
||||
@@ -1030,7 +1023,7 @@ CoA.GameModeMask = 0
|
||||
f["Core/configs/modules/mod-coa-content-scaling.conf"]
|
||||
);
|
||||
let c = ConfFile::parse_bytes(&w["Core/configs/modules/mod_coa_playerbots.conf"]).unwrap();
|
||||
assert_eq!(c.get("CoaBots.Enable"), Some("0"));
|
||||
assert_eq!(c.get("CoaBots.Enable"), Some("1"));
|
||||
assert_eq!(
|
||||
ConfFile::parse_bytes(&w["Settings/worldserver.conf.template"])
|
||||
.unwrap()
|
||||
@@ -1102,14 +1095,8 @@ CoA.GameModeMask = 0
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
assert!(crate::modules::set_enabled(t.path(), t.path(), "companions", true).is_err());
|
||||
assert!(crate::config::save(
|
||||
t.path(),
|
||||
t.path(),
|
||||
crate::config::Scope::Bots,
|
||||
&BTreeMap::new()
|
||||
)
|
||||
.is_err());
|
||||
assert!(guard_module(t.path(), "companions").is_ok());
|
||||
assert!(guard_module(t.path(), "playerbots").is_ok());
|
||||
assert!(guard_module(t.path(), "content-scaling").is_ok());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user