damdara 0.5.0

Dragon Quest Core Module, created in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use clap::Parser;
use std::str::FromStr;

use crate::constants::status::Flags;
use crate::constants::text::DEFAULT_NAME;
use crate::player::PlayerArgs;
pub const DEFAULT_MODE: &str = "start";
pub const DEFAULT_MAX_PARAMETER_PASSWORD: &str = "へへみぞあうぞてえきいおくらちきこぜくゆ";

#[derive(Parser, Debug)]
pub struct Cli {
    #[clap(short, long, default_value_t = String::from(DEFAULT_NAME))]
    pub name: String,
    #[clap(short, long, default_value_t = 0)]
    pub exp: u16,
    #[clap(short, long, default_value_t = 0)]
    pub gold: u16,
    #[clap(short, long, default_value_t = 0)]
    pub weapon: u8,
    #[clap(short, long, default_value_t = 0)]
    pub armor: u8,
    #[clap(short, long, default_value_t = 0)]
    pub shield: u8,
    #[clap(short, long)]
    pub item: Vec<u8>,
    #[clap(short = 'y', long, default_value_t = 0)]
    pub herbs: u8,
    #[clap(short, long, default_value_t = 0)]
    pub keys: u8,
    #[arg(long, default_value_t = Flags::default())]
    pub flags: Flags,
    #[clap(
        short,
        long,
        default_value_t = String::from(DEFAULT_MAX_PARAMETER_PASSWORD)
    )]
    pub password: String,
    #[clap(short, long, default_value_t = String::from(DEFAULT_MODE))]
    pub mode: String,
    #[clap(long)]
    pub format: Option<String>,
    #[clap(long, num_args = 1..)]
    pub view: Option<Vec<String>>,
    #[clap(short, long)]
    pub option: Vec<String>,
}

impl Cli {
    pub fn mode(&self) -> Mode {
        Mode::from_str(&self.mode).unwrap_or_else(|_| Mode::default())
    }

    pub fn to_player_args(&self) -> PlayerArgs {
        PlayerArgs {
            name: Some(self.name.clone()),
            exp: Some(self.exp),
            gold: Some(self.gold),
            weapon: Some(self.weapon),
            armor: Some(self.armor),
            shield: Some(self.shield),
            items: {
                let mut arr = [0; 8];
                for (i, item) in self.item.iter().enumerate().take(8) {
                    arr[i] = *item;
                }
                Some(arr)
            },
            herbs: Some(self.herbs),
            keys: Some(self.keys),
            flags: Some(self.flags.clone()),
            ..Default::default()
        }
    }
}

#[derive(Debug)]
pub enum Mode {
    Start,
    Save,
    Load,
    Status,
    Display,
}

impl Mode {
    pub const fn default() -> Mode {
        Mode::Start
    }
}

impl FromStr for Mode {
    type Err = ();

    fn from_str(input: &str) -> Result<Mode, Self::Err> {
        match input.to_lowercase().as_str() {
            "start" => Ok(Mode::Start),
            "save" => Ok(Mode::Save),
            "load" => Ok(Mode::Load),
            "status" => Ok(Mode::Status),
            "display" => Ok(Mode::Display),
            _ => Err(()),
        }
    }
}