2ndbeam/squad-quest
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: Added interactions with accounts/quests/map

Browse source 
- Bump version to 0.5.0
- Added Quest::complete_for_account public function
- Added Map::unlock_room_for_account public function
- cli: Added "account unlock" command
- cli: "account complete" now uses Quest::complete_for_account
- cli: refactored logging
This commit is contained in:
Alexey 2025-12-05 15:38:14 +03:00
commit f88e010b4f
9 changed files with 231 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Cargo.lock generated
View file

@ -332,7 +332,7 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "squad-quest"
version = "0.4.0"
version = "0.5.0"
dependencies = [
"serde",
"toml",
@ -340,7 +340,7 @@ dependencies = [
[[package]]
name = "squad-quest-cli"
version = "0.4.0"
version = "0.5.0"
dependencies = [
"chrono",
"clap",

2
Cargo.toml
View file

@ -2,7 +2,7 @@
members = ["cli"]
[workspace.package]
version = "0.4.0"
version = "0.5.0"
edition = "2024"
repository = "https://2ndbeam.ru/git/2ndbeam/squad-quest"
license = "MIT"

2
cli/Cargo.toml
View file

@ -9,5 +9,5 @@ license.workspace = true
chrono = "0.4.42"
clap = { version = "4.5.53", features = ["derive"] }
serde = { version = "1.0.228", features = ["derive"] }
squad-quest = { version = "0.4.0", path = ".." }
squad-quest = { version = "0.5.0", path = ".." }
toml = "0.9.8"

9
cli/src/cli/account.rs
View file

@ -12,6 +12,8 @@ pub enum AccountCommands {
Complete(AccountCompleteArgs),
/// Delete account
Delete(AccountDeleteArgs),
/// Unlock room for account if it has enough balance
Unlock(AccountUnlockArgs),
}
#[derive(Args)]
@ -55,3 +57,10 @@ pub struct AccountDeleteArgs {
pub id: String,
}
#[derive(Args)]
pub struct AccountUnlockArgs {
/// Id of the account
pub account: String,
/// Id of the room to unlock
pub room: u16,
}

3
cli/src/cli/quest.rs
View file

@ -63,7 +63,8 @@ pub struct QuestListArgs {
#[derive(Args)]
pub struct QuestCreateArgs {
/// Difficulty of the quest #[arg(value_enum)]
/// Difficulty of the quest
#[arg(value_enum)]
pub difficulty: QuestDifficulty,
/// Reward for the quest
pub reward: u32,

236
cli/src/main.rs
View file

@ -1,8 +1,8 @@
use std::path::Path;
use std::path::{Path, PathBuf};
use clap::Parser;
use squad_quest_cli::cli::{Cli,Objects,account::*,map::*,quest::*};
use squad_quest::{SquadObject, account::Account, config::Config, map::{Map, Room}, quest::Quest};
use squad_quest::{SquadObject, account::Account, config::Config, error::Error, map::{Map, Room}, quest::Quest};
use toml::value::Date;
use chrono::{Datelike, NaiveDate, Utc};
@ -17,6 +17,14 @@ fn print_quest_long(quest: &Quest) {
println!("Answer:\n{}", quest.answer);
}
fn do_and_log(result: Result<(),Error>, log: bool, ok_text: String) {
match result {
Ok(_) if log => println!("{ok_text}"),
Err(error) if log => eprintln!("Error: {error}"),
_ => {},
}
}
fn main() {
let cli = Cli::parse();
@ -62,19 +70,18 @@ fn main() {
None => 0u16
};
path.push(format!("{next_id}.toml"));
match std::fs::exists(&path) {
let mut check_path = path.clone();
check_path.push(format!("{next_id}.toml"));
match std::fs::exists(&check_path) {
Ok(exists) => {
if exists {
if !cli.quiet {
eprintln!("Error: {:?} is not empty.", path);
}
if !cli.quiet { eprintln!("Error: {:?} is not empty.", path); }
return;
}
},
Err(error) => {
if !cli.quiet {
eprintln!("Error while retrieving {:?}: {}.", path, error);
eprintln!("Error: {error}");
}
return;
}
@ -92,17 +99,11 @@ fn main() {
deadline: args.deadline.clone()
};
match quest.save(path) {
Ok(_) if !cli.quiet => println!("Successfully saved quest #{}", quest.id),
Err(error) if !cli.quiet => eprintln!("Error while saving quest: {error}"),
_ => {},
}
do_and_log(quest.save(path), !cli.quiet, format!("Created quest #{}.", quest.id));
},
QuestCommands::Update(args) => {
let Some(quest) = quests.iter().find(|q| q.id == args.id) else {
if !cli.quiet {
eprintln!("Error: Quest #{} not found.", args.id);
}
if !cli.quiet { eprintln!("Error: Quest #{} not found.", args.id); }
return;
};
let quest = Quest {
@ -119,16 +120,27 @@ fn main() {
available_on: args.available.clone().or(quest.available_on.clone()),
deadline: args.deadline.clone().or(quest.deadline.clone())
};
match quest.save(path) {
Ok(_) if !cli.quiet => println!("Updated quest #{}", quest.id),
Err(error) if !cli.quiet => eprintln!("Error while updating quest: {error}"),
_ => {},
}
do_and_log(quest.save(path), !cli.quiet, format!("Updated quest #{}.", quest.id));
},
QuestCommands::Delete(args) => {
path.push(format!("{}.toml", args.id));
match Quest::delete(path) {
Ok(_) if !cli.quiet => println!("Successfully deleted quest #{}", args.id),
Err(error) if !cli.quiet => eprintln!("Error deleting quest #{}: {}", args.id, error),
Ok(_) => {
if !cli.quiet { println!("Deleted quest #{}.", args.id); }
let mut accounts = config.load_accounts();
let accounts_path = config.full_accounts_path();
for account in accounts.iter_mut() {
if let Some(index) = account.quests_completed.iter().position(|qid| *qid == args.id) {
account.quests_completed.remove(index);
do_and_log(account.save(accounts_path.clone()), !cli.quiet, format!("Removed quest #{} from account \"{}\" completed quests", args.id, account.id));
}
}
},
Err(error) if !cli.quiet => {
eprintln!("Error: {error}");
},
_ => {},
}
},
@ -142,12 +154,7 @@ fn main() {
for quest in quests.iter_mut().filter(|q| !q.public && q.available_on.is_some_and(|date| date.le(&toml_today))) {
quest.public = true;
match quest.save(path.clone()) {
Ok(_) if !cli.quiet => println!("Published quest #{}", quest.id),
Err(error) if !cli.quiet => eprintln!("Error while publishing quest: {error}"),
_ => {},
}
do_and_log(quest.save(path.clone()), !cli.quiet, format!("Published quest #{}.", quest.id));
}
},
QuestCommands::Publish(args) => {
@ -158,23 +165,14 @@ fn main() {
let not_str = if args.reverse {" not "} else {" "};
if quest.public != args.reverse {
if !cli.quiet {
eprintln!("Quest #{} is already{}public", quest.id, not_str);
}
if !cli.quiet { eprintln!("Error: quest #{} is already{}public.", quest.id, not_str); }
return;
}
quest.public = !args.reverse;
match quest.save(path.clone()) {
Ok(_) if !cli.quiet => println!("Published quest #{}", quest.id),
Err(error) if !cli.quiet => eprintln!("Error while publishing quest: {error}"),
_ => {},
}
},
None if !cli.quiet => {
eprintln!("Error: couldn't find quest with id {}.", args.id);
do_and_log(quest.save(path), !cli.quiet, format!("Published quest #{}.", quest.id));
},
None if !cli.quiet => eprintln!("Error: quest #{} not found.", args.id),
_ => {},
}
},
@ -186,7 +184,6 @@ fn main() {
match commands {
AccountCommands::List => {
for account in accounts {
println!("\"{}\": Balance {}", account.id, account.balance);
}
@ -198,27 +195,16 @@ fn main() {
};
if let Some(_) = accounts.iter().find(|a| a.id == account.id) {
if !cli.quiet {
eprintln!("Error: account {} exists.", account.id);
}
if !cli.quiet { eprintln!("Error: account \"{}\" exists.", account.id); }
return;
}
match account.save(path) {
Ok(_) if !cli.quiet => println!("Successfully created account \"{}\"", account.id),
Err(error) if !cli.quiet => eprintln!("Error while saving account: {error}"),
_ => {},
}
do_and_log(account.save(path), !cli.quiet, format!("Created account \"{}\".", account.id));
},
AccountCommands::Balance(args) => {
let account = match accounts.iter_mut().find(|a| a.id == args.id) {
Some(acc) => acc,
None => {
if !cli.quiet {
eprintln!("Could not find account \"{}\"", args.id);
}
return;
}
let Some(account) = accounts.iter_mut().find(|a| a.id == args.id) else {
if !cli.quiet { eprintln!("Error: account \"{}\" not found.", args.id); }
return;
};
match args.action {
@ -233,9 +219,7 @@ fn main() {
if args.negative_ok {
account.balance = 0u32;
} else {
if !cli.quiet {
eprintln!("Error: balance ({}) is less than {}.", account.balance, args.value);
}
if !cli.quiet { eprintln!("Error: account \"{}\" balance is less than {}.", account.id, args.value); }
return;
}
} else {
@ -244,54 +228,54 @@ fn main() {
}
}
match account.save(path) {
Ok(_) if !cli.quiet => println!("Successfully updated account \"{}\" balance", account.id),
Err(error) if !cli.quiet => eprintln!("Error while saving account: {error}"),
_ => {},
}
do_and_log(account.save(path), !cli.quiet, format!("Updated balance of account \"{}\".", account.id));
},
AccountCommands::Complete(args) => {
let account = match accounts.iter_mut().find(|a| a.id == args.account) {
Some(acc) => acc,
None => {
if !cli.quiet {
eprintln!("Could not find account \"{}\"", args.account);
}
return;
}
let Some(account) = accounts.iter_mut().find(|a| a.id == args.account) else {
if !cli.quiet { eprintln!("Error: account \"{}\" not found.", args.account); }
return;
};
let quests = config.load_quests();
if let None = quests.iter().find(|q| q.id == args.quest) {
if !cli.quiet {
eprintln!("Could not find quest #{}", args.quest);
}
return;
}
match account.quests_completed.iter().find(|qid| **qid == args.quest) {
Some(_) if !cli.quiet => {
println!("Quest #{} is already completed on account \"{}\"", args.quest, args.account);
},
let quest = match quests.iter().find(|q| q.id == args.quest) {
Some(quest) => quest,
None => {
account.quests_completed.push(args.quest);
match account.save(path) {
Ok(_) if !cli.quiet => println!("Successfully completed quest #{} on account \"{}\".", args.quest, account.id),
Err(error) if !cli.quiet => eprintln!("Error while saving account: {error}"),
_ => {},
}
if !cli.quiet { eprintln!("Error: quest #{} not found.", args.quest); }
return;
},
};
match quest.complete_for_account(account) {
Err(error) if !cli.quiet => println!("Error: {error}"),
Ok(_) => do_and_log(account.save(path), !cli.quiet, format!("Completed quest #{} on account \"{}\".", args.quest, account.id)),
_ => {},
}
},
AccountCommands::Delete(args) => {
path.push(format!("{}.toml", args.id));
match Account::delete(path) {
Ok(_) if !cli.quiet => println!("Successfully deleted account \"{}\".", args.id),
Err(error) if !cli.quiet => eprintln!("Error while deleting account: {error}"),
_ => {},
do_and_log(Account::delete(path), !cli.quiet, format!("Deleted account \"{}\".", args.id))
},
AccountCommands::Unlock(args) => {
let Some(account) = accounts.iter_mut().find(|a| a.id == args.account) else {
if !cli.quiet { eprintln!("Error: account \"{}\" not found.", args.account) };
return;
};
let map = match Map::load(config.full_map_path()) {
Ok(map) => map,
Err(error) => {
if !cli.quiet { eprintln!("Error: {error}"); }
return;
}
};
if let Err(error) = map.unlock_room_for_account(args.room, account) {
eprintln!("Error: {error}");
return;
}
do_and_log(account.save(path), !cli.quiet, format!("Unlocked room #{} for account \"{}\"", args.room, args.account));
},
}
},
@ -300,12 +284,12 @@ fn main() {
let mut map = match Map::load(map_path.clone()) {
Ok(map) => map,
Err(error) => {
if !cli.quiet {
eprintln!("Error while loading map: {error}");
}
if !cli.quiet { eprintln!("Error: {error}"); }
return;
}
};
let map_save = |map: Map, map_path: PathBuf| { map.save(map_path.parent().unwrap_or(Path::new("")).to_owned()) };
match commands {
MapCommands::List => {
for room in map.room {
@ -321,22 +305,17 @@ fn main() {
let room = Room {
id: last_id,
name: args.name.clone(),
value: args.value,
description: args.description.clone(),
..Default::default()
};
let r_id = room.id;
map.room.push(room);
match map.save(map_path.parent().unwrap_or(Path::new("")).to_owned()) {
Ok(_) if !cli.quiet => println!("Created room #{}.", r_id),
Err(error) if !cli.quiet => eprintln!("Error while saving map: {error}"),
_ => {},
}
do_and_log(map_save(map, map_path), !cli.quiet, format!("Created room #{r_id}."))
},
MapCommands::Delete(args) => {
let Some(room) = map.room.iter().find(|r| r.id == args.id) else {
if !cli.quiet {
eprintln!("Error: Room #{} not found", args.id);
}
if !cli.quiet { eprintln!("Error: room #{} not found.", args.id); }
return;
};
@ -351,17 +330,29 @@ fn main() {
room.children.remove(idx);
}
match map.save(map_path.parent().unwrap_or(Path::new("")).to_owned()) {
Ok(_) if !cli.quiet => println!("Deleted room #{}.", r_id),
Err(error) if !cli.quiet => eprintln!("Error while saving map: {error}"),
match map_save(map, map_path) {
Ok(_) => {
if !cli.quiet { println!("Deleted room #{r_id}."); }
let mut accounts = config.load_accounts();
let accounts_path = config.full_accounts_path();
for account in accounts.iter_mut() {
if let Some(index) = account.rooms_unlocked.iter().position(|rid| *rid == r_id) {
account.rooms_unlocked.remove(index);
do_and_log(account.save(accounts_path.clone()), !cli.quiet, format!("Removed room #{r_id} from account \"{}\" unlocked rooms.", account.id));
}
}
},
Err(error) if !cli.quiet => {
eprintln!("Error: {error}");
},
_ => {},
}
},
MapCommands::Update(args) => {
let Some(room) = map.room.iter_mut().find(|r| r.id == args.id) else {
if !cli.quiet {
eprintln!("Error: Room #{} not found", args.id);
}
if !cli.quiet { eprintln!("Error: room #{} not found", args.id); }
return;
};
@ -377,11 +368,7 @@ fn main() {
room.value = value;
}
match map.save(map_path.parent().unwrap_or(Path::new("")).to_owned()) {
Ok(_) if !cli.quiet => println!("Updated room #{}.", args.id),
Err(error) if !cli.quiet => eprintln!("Error while saving map: {error}"),
_ => {},
}
do_and_log(map_save(map, map_path), !cli.quiet, format!("Updated room #{}.", args.id))
},
MapCommands::Connect(args) | MapCommands::Disconnect(args) => {
let connect = match commands {
@ -392,28 +379,21 @@ fn main() {
// We iterate twice to make references first->second and second->first
for (first, second) in [(args.first, args.second),(args.second, args.first)] {
let Some(room) = map.room.iter_mut().find(|r| r.id == first) else {
if !cli.quiet {
eprintln!("Error: Room #{} not found", first);
}
if !cli.quiet { eprintln!("Error: room #{} not found.", first); }
return;
};
match room.children.iter().position(|id| *id == second) {
Some(_) if connect && !cli.quiet => println!("Room #{} already has reference to #{}", first, second),
Some(_) if connect && !cli.quiet => println!("Room #{} already has reference to #{}.", first, second),
None if connect => room.children.push(second),
Some(id) if !connect => {room.children.remove(id as usize);},
None if !connect && !cli.quiet => println!("Room #{} has no reference to #{}", first, second),
None if !connect && !cli.quiet => println!("Room #{} has no reference to #{}.", first, second),
_ => {},
}
}
let connected = if connect { "Connected" } else { "Disconnected" };
match map.save(map_path.parent().unwrap_or(Path::new("")).to_owned()) {
Ok(_) if !cli.quiet => println!("{connected} rooms #{} <-> #{}.", args.first, args.second),
Err(error) if !cli.quiet => eprintln!("Error while saving map: {error}"),
_ => {},
}
do_and_log(map_save(map, map_path), !cli.quiet, format!("{connected} rooms #{} <-> #{}.", args.first, args.second));
},
}
}

38
src/error.rs
View file

@ -26,3 +26,41 @@ impl fmt::Display for Error {
}
}
}
/// Error related to quest logic
#[derive(Debug)]
#[non_exhaustive]
pub enum QuestError {
/// Quest (self.0) is already completed for given account (self.1)
AlreadyCompleted(u16, String),
}
impl fmt::Display for QuestError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::AlreadyCompleted(quest_id, account_id) => write!(f, "quest #{quest_id} is already completed for account \"{account_id}\""),
}
}
}
/// Error related to map logic
#[derive(Debug)]
#[non_exhaustive]
pub enum MapError {
/// Room not found in map file
RoomNotFound(u16),
/// Room (self.0) is already unlocked on account (self.1)
RoomAlreadyUnlocked(u16, String),
/// Account (self.1) does not have much money (self.0)
InsufficientFunds(u16, String),
}
impl fmt::Display for MapError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::RoomNotFound(id) => write!(f, "could not find room #{id}"),
Self::RoomAlreadyUnlocked(room_id, account_id) => write!(f, "room #{room_id} is already unlocked on account \"{account_id}\""),
Self::InsufficientFunds(room_id, account_id) => write!(f, "account \"{account_id}\" does not have enough money to unlock room #{room_id}"),
}
}
}

38
src/map/mod.rs
View file

@ -4,7 +4,7 @@ use std::{fs, io::Write, path::PathBuf};
use serde::{Deserialize, Serialize};
use crate::{SquadObject, error::Error};
use crate::{SquadObject, account::Account, error::{Error, MapError}};
/// THE Graph. Actually, this is a Vec.
#[derive(Serialize, Deserialize)]
@ -71,7 +71,43 @@ impl SquadObject for Map {
Ok(())
}
}
impl Map {
/// Try to unlock room for account, or return [MapError]
///
/// # Examples
/// ```rust
/// use squad_quest::{account::Account,map::{Map,Room},error::MapError};
///
/// let map = Map {
/// room: vec![Room { id: 0, value: 100, ..Default::default() }],
/// };
///
/// let mut account = Account { balance: 100, ..Default::default() };
///
/// if let Err(error) = map.unlock_room_for_account(0, &mut account) {
/// // handle error
/// }
/// ```
pub fn unlock_room_for_account(&self, room_id: u16, account: &mut Account) -> Result<(), MapError> {
let Some(room) = self.room.iter().find(|r| r.id == room_id) else {
return Err(MapError::RoomNotFound(room_id));
};
if let Some(_) = account.rooms_unlocked.iter().find(|rid| **rid == room_id) {
return Err(MapError::RoomAlreadyUnlocked(room_id, account.id.clone()));
}
if account.balance < room.value {
return Err(MapError::InsufficientFunds(room_id, account.id.clone()));
}
account.balance -= room.value;
account.rooms_unlocked.push(room_id);
Ok(())
}
}
/// Component of the map

31
src/quest/mod.rs
View file

@ -3,7 +3,7 @@
use std::{fs, io::Write, path::PathBuf};
use serde::{ Serialize, Deserialize };
use crate::{SquadObject, error::Error};
use crate::{SquadObject, account::Account, error::{Error, QuestError}};
use toml::value::Date;
/// Difficulty of the quest
@ -137,3 +137,32 @@ impl SquadObject for Quest {
Ok(())
}
}
impl Quest {
/// Complete quest for account and add reward to it's balance.
/// Does nothing and returns [QuestError::AlreadyCompleted]
/// if it is already completed.
///
/// # Examples
///
/// ```rust
/// use squad_quest::{account::Account,quest::Quest};
///
/// let quest = Quest::default();
/// let mut account = Account::default();
///
/// if let Err(error) = quest.complete_for_account(&mut account) {
/// // handle error
/// }
/// ```
pub fn complete_for_account(&self, account: &mut Account) -> Result<(),QuestError> {
match account.quests_completed.iter().find(|qid| **qid == self.id) {
Some(_) => Err(QuestError::AlreadyCompleted(self.id, account.id.clone())),
None => {
account.quests_completed.push(self.id);
account.balance += self.reward;
Ok(())
},
}
}
}