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:
Дмитрий committed 2026-11-16 00:52:15 +05:00
commit 326a4fe3d3
12 files changed
+2691 -327

No files matched your search

File diff suppressed because it is too large. Load diff
+50 -1
View File
@@ -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(),
+58
View File
@@ -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()
+27 -10
View 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,
+52 -2
View File
@@ -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)?;
+40 -53
View File
@@ -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());
}
}