hiraku-engine 0.1.0

Hiraku visual-novel engine
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

use hiraku_script::{HksHandle, native::NativeError};
use serde::{Deserialize, Serialize};

pub(crate) const NAVIGATION_HANDLE_TYPE: u32 = 4;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum NavigationKind {
    Goto,
    Call,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum NavigationReset {
    #[default]
    None,
    Presentation,
    Session,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NavigationRequest {
    pub path: String,
    pub kind: NavigationKind,
    pub reset: NavigationReset,
    #[serde(default)]
    pub origin: Option<String>,
}

impl NavigationRequest {
    pub fn goto(path: String) -> Result<Self, NativeError> {
        validate_path(&path)?;
        Ok(Self {
            path,
            kind: NavigationKind::Goto,
            reset: NavigationReset::None,
            origin: None,
        })
    }

    pub fn call(path: String) -> Result<Self, NativeError> {
        validate_path(&path)?;
        Ok(Self {
            path,
            kind: NavigationKind::Call,
            reset: NavigationReset::None,
            origin: None,
        })
    }

    pub fn with_origin(mut self, origin: Option<String>) -> Self {
        self.origin = origin;
        self
    }
}

fn validate_path(path: &str) -> Result<(), NativeError> {
    if path.trim().is_empty() {
        return Err(NativeError::message("story path must not be empty"));
    }
    Ok(())
}

#[derive(Clone, Copy, HksHandle)]
#[hks(name = "Navigation", handle_type = NAVIGATION_HANDLE_TYPE)]
pub(crate) struct NavigationHandle(pub(crate) u64);

hiraku_script::hks_define! {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NavigationResetValue {
    None,
    Presentation,
    Session,
}

impl NavigationResetValue {
    #[getter]
    fn none() -> NavigationResetValue { Self::None }
    #[getter]
    fn presentation() -> NavigationResetValue { Self::Presentation }
    #[getter]
    fn session() -> NavigationResetValue { Self::Session }
}
}

impl From<NavigationResetValue> for NavigationReset {
    fn from(value: NavigationResetValue) -> Self {
        match value {
            NavigationResetValue::None => Self::None,
            NavigationResetValue::Presentation => Self::Presentation,
            NavigationResetValue::Session => Self::Session,
        }
    }
}