232 lines
14 KiB
Rust
232 lines
14 KiB
Rust
//! Data and actions for in-game plugins: what the SCOPENET Developer API, the
|
|
//! PlaceholderAPI expansion and other plugins read and change for a player.
|
|
|
|
use crate::error::{AppError, AppResult};
|
|
use crate::routes::economy::{begin_operation, finish_operation};
|
|
use crate::routes::servers::GameServer;
|
|
use crate::state::AppState;
|
|
use axum::extract::State;
|
|
use axum::Json;
|
|
use serde::Deserialize;
|
|
use serde_json::{json, Value};
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct Who {
|
|
pub uuid: String,
|
|
}
|
|
|
|
fn dashed_or_err(uuid: &str) -> AppResult<String> {
|
|
crate::yggdrasil::dashed(uuid).ok_or_else(|| AppError::bad_request("invalid player UUID"))
|
|
}
|
|
|
|
/// Everything a placeholder or `getPlayer()` needs in one round trip.
|
|
pub async fn player_info(GameServer(server): GameServer, State(state): State<AppState>, Json(p): Json<Who>) -> AppResult<Json<Value>> {
|
|
let uuid = dashed_or_err(&p.uuid)?;
|
|
let user: Option<(String, String, String)> = sqlx::query_as("SELECT username, role, created_at FROM users WHERE uuid = ?").bind(&uuid).fetch_optional(&state.db).await?;
|
|
let Some((name, role, joined)) = user else {
|
|
return Ok(Json(json!({ "exists": false, "uuid": uuid })));
|
|
};
|
|
let levels = crate::routes::leveling::get_user_levels_by_uuid(&state, &uuid).await?;
|
|
let here = levels.server_levels.iter().find(|s| s.server_id == server.id);
|
|
let guild: Option<(String, String, String, String, i64)> = sqlx::query_as(
|
|
"SELECT g.id, g.name, g.tag, gm.role, (SELECT COUNT(*) FROM guild_claims gc WHERE gc.guild_id = g.id)
|
|
FROM guild_members gm JOIN guilds g ON g.id = gm.guild_id WHERE gm.uuid = ? AND g.instance_id = ?",
|
|
)
|
|
.bind(&uuid)
|
|
.bind(&server.instance_id)
|
|
.fetch_optional(&state.db)
|
|
.await?;
|
|
let balance = crate::routes::economy::balance_for(&state, server.id, &uuid).await?;
|
|
let (playtime, kills, deaths): (Option<i64>, Option<i64>, Option<i64>) =
|
|
sqlx::query_as("SELECT SUM(playtime_secs), SUM(player_kills + mob_kills), SUM(deaths) FROM player_stats WHERE uuid = ?").bind(&uuid).fetch_one(&state.db).await?;
|
|
let (server_playtime,): (Option<i64>,) = sqlx::query_as("SELECT SUM(playtime_secs) FROM player_stats WHERE uuid = ? AND server_id = ?").bind(&uuid).bind(server.id).fetch_one(&state.db).await?;
|
|
let friends: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM friendships WHERE status = 'accepted' AND (user_uuid = ?1 OR friend_uuid = ?1)").bind(&uuid).fetch_one(&state.db).await?;
|
|
let achievements: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM user_achievements WHERE user_uuid = ?").bind(&uuid).fetch_one(&state.db).await?;
|
|
|
|
// Quest progress for this period: how many of the player's quests are done.
|
|
let cfg = crate::progression::load_pool(&state.db).await?;
|
|
let mut conn = state.db.acquire().await?;
|
|
let mut quests = serde_json::Map::new();
|
|
for (period, key) in [("daily", crate::routes::quests::current_daily_key()), ("weekly", crate::routes::quests::current_weekly_key())] {
|
|
let ids = crate::progression::assigned_quest_ids(&mut conn, &cfg, &uuid, period, &key).await?;
|
|
let (done, claimed): (i64, i64) = if ids.is_empty() {
|
|
(0, 0)
|
|
} else {
|
|
sqlx::query_as(
|
|
"SELECT COALESCE(SUM(completed), 0), COALESCE(SUM(claimed), 0) FROM user_quests
|
|
WHERE user_uuid = ? AND period_key = ? AND quest_id IN (SELECT value FROM json_each(?))",
|
|
)
|
|
.bind(&uuid)
|
|
.bind(&key)
|
|
.bind(serde_json::to_string(&ids)?)
|
|
.fetch_one(&mut *conn)
|
|
.await?
|
|
};
|
|
quests.insert(period.into(), json!({ "total": ids.len(), "completed": done, "claimed": claimed }));
|
|
}
|
|
drop(conn); // give the connection back before the pool is used again
|
|
let rank: Option<(String, String, String)> = sqlx::query_as("SELECT primary_group, display, prefix FROM player_ranks WHERE server_id = ? AND uuid = ?").bind(server.id).bind(&uuid).fetch_optional(&state.db).await?;
|
|
let online: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM server_online WHERE uuid = ?)").bind(&uuid).fetch_one(&state.db).await?;
|
|
|
|
Ok(Json(json!({
|
|
"exists": true,
|
|
"uuid": uuid,
|
|
"name": name,
|
|
"role": role,
|
|
"joined": joined,
|
|
"online": online,
|
|
"global": { "level": levels.global_level, "xp": levels.global_xp, "next_level_xp": levels.next_level_xp, "current_level_xp": levels.current_level_xp, "progress_pct": levels.progress_pct, "title": levels.title, "rank": levels.rank, "badges": levels.badges },
|
|
"server": here.map(|s| json!({ "level": s.server_level, "xp": s.server_xp, "next_level_xp": s.next_level_xp, "current_level_xp": s.current_level_xp, "progress_pct": s.progress_pct, "rank_name": s.rank_name }))
|
|
.unwrap_or(json!({ "level": 1, "xp": 0, "next_level_xp": 0, "current_level_xp": 0, "progress_pct": 0.0, "rank_name": null })),
|
|
"guild": guild.map(|(id, name, tag, role, claims)| json!({ "id": id, "name": name, "tag": tag, "role": role, "claims": claims })),
|
|
"balance": balance,
|
|
"playtime_secs": playtime.unwrap_or(0),
|
|
"server_playtime_secs": server_playtime.unwrap_or(0),
|
|
"kills": kills.unwrap_or(0),
|
|
"deaths": deaths.unwrap_or(0),
|
|
"friends": friends,
|
|
"achievements": achievements,
|
|
"quests": quests,
|
|
"rank": rank.map(|(primary, display, prefix)| json!({ "group": primary, "display": display, "prefix": prefix })),
|
|
})))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct XpPayload {
|
|
pub operation_id: String,
|
|
pub uuid: String,
|
|
/// `global` or `server` (the calling server).
|
|
#[serde(default = "global")]
|
|
pub scope: String,
|
|
/// Positive grants XP, negative takes it away.
|
|
pub amount: i64,
|
|
#[serde(default)]
|
|
pub reason: String,
|
|
}
|
|
fn global() -> String {
|
|
"global".into()
|
|
}
|
|
|
|
/// `addXP()`: grant (or remove) XP on behalf of a plugin. Idempotent on `operation_id`.
|
|
pub async fn add_xp(GameServer(server): GameServer, State(state): State<AppState>, Json(p): Json<XpPayload>) -> AppResult<Json<Value>> {
|
|
let uuid = dashed_or_err(&p.uuid)?;
|
|
if p.amount == 0 || p.amount.abs() > 10_000_000 {
|
|
return Err(AppError::bad_request("amount must be between -10,000,000 and 10,000,000 and not zero"));
|
|
}
|
|
let (mut tx, previous) = begin_operation(&state, server.id, &p.operation_id).await?;
|
|
if let Some(previous) = previous {
|
|
return Ok(Json(previous));
|
|
}
|
|
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM users WHERE uuid = ?)").bind(&uuid).fetch_one(&mut *tx).await?;
|
|
if !exists {
|
|
return Err(AppError::not_found("player not found"));
|
|
}
|
|
let now = chrono::Utc::now().to_rfc3339();
|
|
let (mode, amount) = if p.amount > 0 { (crate::progression::Mode::Add, p.amount) } else { (crate::progression::Mode::Remove, -p.amount) };
|
|
let change = match p.scope.as_str() {
|
|
"global" => crate::progression::adjust_global(&mut tx, &uuid, mode, amount, &now).await?,
|
|
"server" => crate::progression::adjust_server(&mut tx, server.id, &uuid, mode, amount, &now).await?,
|
|
_ => return Err(AppError::bad_request("scope must be global or server")),
|
|
};
|
|
if change.new_xp > change.old_xp {
|
|
crate::routes::leveling::grant_rewards(&mut tx, &uuid, &now).await?;
|
|
}
|
|
let detail = format!("{} XP {} → {} (level {} → {}) via {}: {}", p.scope, change.old_xp, change.new_xp, change.old_level, change.new_level, server.name, p.reason.chars().filter(|c| !c.is_control()).take(100).collect::<String>());
|
|
sqlx::query("INSERT INTO server_events (server_id, uuid, name, kind, detail, created_at) VALUES (?, ?, NULL, 'xp', ?, ?)").bind(server.id).bind(&uuid).bind(detail).bind(crate::db::now()).execute(&mut *tx).await?;
|
|
finish_operation(tx, server.id, &p.operation_id, json!({ "ok": true, "scope": p.scope, "xp": change.new_xp, "level": change.new_level, "previous_level": change.old_level })).await
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct ObjectivePayload {
|
|
pub operation_id: String,
|
|
pub uuid: String,
|
|
/// A quest id (`q_d_mine_coal`), or an action such as `block_broken:DIAMOND_ORE`.
|
|
pub objective: String,
|
|
/// Progress to add. `0` completes the quest outright.
|
|
#[serde(default)]
|
|
pub amount: i64,
|
|
}
|
|
|
|
/// `completeQuestObjective()`: move a player's quest forward from another plugin.
|
|
pub async fn quest_objective(GameServer(server): GameServer, State(state): State<AppState>, Json(p): Json<ObjectivePayload>) -> AppResult<Json<Value>> {
|
|
let uuid = dashed_or_err(&p.uuid)?;
|
|
if !(0..=1_000_000).contains(&p.amount) || p.objective.is_empty() || p.objective.len() > 120 {
|
|
return Err(AppError::bad_request("invalid objective"));
|
|
}
|
|
let (mut tx, previous) = begin_operation(&state, server.id, &p.operation_id).await?;
|
|
if let Some(previous) = previous {
|
|
return Ok(Json(previous));
|
|
}
|
|
let now = crate::db::now();
|
|
let quest: Option<(String, i64)> = sqlx::query_as("SELECT period, target_count FROM quests WHERE id = ? AND enabled = 1").bind(&p.objective).fetch_optional(&mut *tx).await?;
|
|
let advanced = if let Some((period, target)) = quest {
|
|
let cfg = crate::progression::load(&mut tx).await?;
|
|
let key = if period == "weekly" { crate::routes::quests::current_weekly_key() } else { crate::routes::quests::current_daily_key() };
|
|
if !crate::progression::is_assigned(&mut tx, &cfg, &uuid, &period, &key, &p.objective).await? {
|
|
return Err(AppError::bad_request("that quest isn't one of the player's quests this period"));
|
|
}
|
|
let add = if p.amount == 0 { target } else { p.amount };
|
|
sqlx::query(
|
|
"INSERT INTO user_quests (user_uuid, quest_id, period_key, progress, completed, claimed, updated_at) VALUES (?, ?, ?, ?, ?, 0, ?)
|
|
ON CONFLICT (user_uuid, quest_id, period_key) DO UPDATE SET progress = progress + excluded.progress,
|
|
completed = CASE WHEN progress + excluded.progress >= ? THEN 1 ELSE completed END, updated_at = excluded.updated_at",
|
|
)
|
|
.bind(&uuid).bind(&p.objective).bind(&key).bind(add).bind(add >= target).bind(&now).bind(target)
|
|
.execute(&mut *tx)
|
|
.await?;
|
|
true
|
|
} else {
|
|
// Not a quest id: treat it as an action ("block_broken:STONE") like the plugin's own events.
|
|
let before: i64 = sqlx::query_scalar("SELECT COALESCE(SUM(progress), 0) FROM user_quests WHERE user_uuid = ?").bind(&uuid).fetch_one(&mut *tx).await?;
|
|
crate::routes::quests::advance_action_quests(&mut tx, &uuid, &p.objective, p.amount.max(1), &now).await?;
|
|
let after: i64 = sqlx::query_scalar("SELECT COALESCE(SUM(progress), 0) FROM user_quests WHERE user_uuid = ?").bind(&uuid).fetch_one(&mut *tx).await?;
|
|
after > before
|
|
};
|
|
finish_operation(tx, server.id, &p.operation_id, json!({ "ok": true, "advanced": advanced })).await
|
|
}
|
|
|
|
/// `getFriends()`: accepted friends with where they are playing.
|
|
pub async fn friends(GameServer(_): GameServer, State(state): State<AppState>, Json(p): Json<Who>) -> AppResult<Json<Value>> {
|
|
let uuid = dashed_or_err(&p.uuid)?;
|
|
let rows: Vec<(String, String, bool, Option<String>)> = sqlx::query_as(
|
|
"SELECT u.uuid, u.username, EXISTS(SELECT 1 FROM server_online so WHERE so.uuid = u.uuid),
|
|
(SELECT gs.name FROM server_online so JOIN game_servers gs ON gs.id = so.server_id WHERE so.uuid = u.uuid LIMIT 1)
|
|
FROM friendships f JOIN users u ON u.uuid = (CASE WHEN f.user_uuid = ?1 THEN f.friend_uuid ELSE f.user_uuid END)
|
|
WHERE f.status = 'accepted' AND (f.user_uuid = ?1 OR f.friend_uuid = ?1) ORDER BY 3 DESC, u.username COLLATE NOCASE LIMIT 500",
|
|
)
|
|
.bind(&uuid)
|
|
.fetch_all(&state.db)
|
|
.await?;
|
|
Ok(Json(json!({ "friends": rows.into_iter().map(|(uuid, name, online, playing_on)| json!({ "uuid": uuid, "name": name, "online": online, "playing_on": playing_on })).collect::<Vec<_>>() })))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct GuildQuery {
|
|
/// Look a guild up by id, tag or name — or by one of its members.
|
|
#[serde(default)]
|
|
pub guild: String,
|
|
#[serde(default)]
|
|
pub member: String,
|
|
}
|
|
|
|
/// `getGuild()`.
|
|
pub async fn guild(GameServer(server): GameServer, State(state): State<AppState>, Json(q): Json<GuildQuery>) -> AppResult<Json<Value>> {
|
|
let id: Option<String> = if !q.member.is_empty() {
|
|
let uuid = dashed_or_err(&q.member)?;
|
|
sqlx::query_scalar("SELECT g.id FROM guild_members gm JOIN guilds g ON g.id = gm.guild_id WHERE gm.uuid = ? AND g.instance_id = ?").bind(uuid).bind(&server.instance_id).fetch_optional(&state.db).await?
|
|
} else {
|
|
sqlx::query_scalar("SELECT id FROM guilds WHERE instance_id = ?2 AND (id = ?1 OR tag = ?1 COLLATE NOCASE OR name = ?1 COLLATE NOCASE)").bind(q.guild.trim()).bind(&server.instance_id).fetch_optional(&state.db).await?
|
|
};
|
|
let Some(id) = id else { return Ok(Json(json!({ "exists": false }))) };
|
|
let (name, tag, desc, leader, created): (String, String, String, String, String) =
|
|
sqlx::query_as("SELECT name, tag, description, leader_uuid, created_at FROM guilds WHERE id = ?").bind(&id).fetch_one(&state.db).await?;
|
|
let members: Vec<(String, String, String)> = sqlx::query_as("SELECT uuid, name, role FROM guild_members WHERE guild_id = ? ORDER BY joined_at").bind(&id).fetch_all(&state.db).await?;
|
|
let claims: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM guild_claims WHERE guild_id = ? AND server_id = ?").bind(&id).bind(server.id).fetch_one(&state.db).await?;
|
|
let balance: f64 = sqlx::query_scalar("SELECT COALESCE((SELECT balance FROM guild_wallets WHERE guild_id = ? AND server_id = ?), 0.0)").bind(&id).bind(server.id).fetch_one(&state.db).await?;
|
|
Ok(Json(json!({
|
|
"exists": true, "id": id, "name": name, "tag": tag, "description": desc, "leader": leader, "created": created,
|
|
"claims": claims, "balance": balance,
|
|
"members": members.into_iter().map(|(uuid, name, role)| json!({ "uuid": uuid, "name": name, "role": role })).collect::<Vec<_>>(),
|
|
})))
|
|
}
|