hgame 0.26.4

CG production management structs, e.g. of assets, personnels, progress, etc.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use super::*;

// ----------------------------------------------------------------------------
#[derive(Debug, Clone, Default)]
#[cfg_attr(feature = "mongo", derive(Serialize, Deserialize))]
/// LEGACY DESIGN: DO NOT change field names or `serde(rename)` values.
pub struct SubTicketRawNote {
    #[serde(rename = "EN", skip_serializing_if = "Option::is_none")]
    pub(crate) en: Option<String>,

    #[serde(rename = "VI", skip_serializing_if = "Option::is_none")]
    pub(crate) vi: Option<String>,

    #[serde(rename = "ZH", skip_serializing_if = "Option::is_none")]
    pub(crate) zh: Option<String>,

    #[serde(rename = "FR", skip_serializing_if = "Option::is_none")]
    pub(crate) fr: Option<String>,
}

impl SubTicketRawNote {
    pub fn empty() -> Self {
        Default::default()
    }
}

// ----------------------------------------------------------------------------
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
/// LEGACY DESIGN: DO NOT change field names.
pub struct SubTicketRawStatus {
    #[serde(skip_serializing_if = "Option::is_none")]
    is_addressed: Option<bool>,

    #[serde(skip_serializing_if = "Option::is_none")]
    is_closed: Option<bool>,

    #[serde(skip_serializing_if = "Option::is_none")]
    last_modified_by: Option<String>,
}

impl SubTicketRawStatus {
    pub(super) fn empty() -> Self {
        Self {
            is_addressed: None,
            is_closed: None,
            last_modified_by: None,
        }
    }

    /// Makes a `SubTicket` whose status is "open", i.e. neither addressed nor closed.
    pub fn as_open(modified_by: &str) -> Self {
        Self {
            // from deserialization logic, leaving this as `None` suffices
            is_addressed: None,
            // from deserialization logic, leaving this as `None` suffices
            is_closed: None,
            last_modified_by: Some(modified_by.to_owned()),
        }
    }

    /// If a `SubTicket`'s Closed status `is_none`, it's considered NOT closed.
    ///
    /// CAUTION: this is "baked" and its data is not synced with database.
    pub(super) fn is_literal_closed(&self) -> bool {
        self.is_closed.unwrap_or(false)
    }

    /// If a `SubTicket`'s Addressed status `is_none`, it's considered NOT addressed.
    ///
    /// CAUTION: this is "baked" and its data is not synced with database.
    fn is_literal_addressed(&self) -> bool {
        self.is_addressed.unwrap_or(false)
    }

    /// CAUTION: this is "baked" and its data is not synced with database.
    pub(super) fn is_literal_open(&self) -> bool {
        match self.is_addressed {
            None => true,
            Some(addressed) => !addressed,
        }
    }
}

// ----------------------------------------------------------------------------
#[derive(Debug, Clone, Default, PartialEq, Eq, strum::AsRefStr)]
pub enum SubTicketStatus {
    #[strum(serialize = "💬 Open")]
    #[default]
    Open,

    #[strum(serialize = "🙋 Addressed")]
    Addressed,

    #[strum(serialize = "✅ Closed")]
    Closed,
}

#[cfg(feature = "gui")]
impl SubTicketStatus {
    fn color_rgb<'a>(&self, palette: &'a Palette) -> &'a Rgb {
        match &self {
            SubTicketStatus::Open => &palette.dark.rgb.TICKET_OPEN,
            SubTicketStatus::Addressed => &palette.dark.rgb.TICKET_ADDRESSED,
            SubTicketStatus::Closed => &palette.dark.rgb.TICKET_CLOSED,
        }
    }

    pub fn color32(&self, palette: &Palette) -> Color32 {
        let color = self.color_rgb(palette);
        Color32::from_rgb(color.r, color.g, color.b)
    }

    pub(super) fn mark_open_button(&self, idx: &u8) -> egui::Button {
        match &self {
            SubTicketStatus::Addressed => egui::Button::new(&format!("#{} Not Addressed", idx)),
            SubTicketStatus::Closed => egui::Button::new(&format!("Reopen #{}", idx)),
            SubTicketStatus::Open => unreachable!(), // shouldn't be used
        }
    }
}

impl From<&SubTicketRawStatus> for SubTicketStatus {
    /// CAUTION: Both `SubTicketRawStatus::is_literal_closed()` and `SubTicketRawStatus::is_addressed()`
    /// are "baked" and thus `SubTicketStatus` converted here is NOT automatically synced with database.
    fn from(status: &SubTicketRawStatus) -> Self {
        match status.is_literal_closed() {
            true => SubTicketStatus::Closed,
            false => match status.is_literal_addressed() {
                true => SubTicketStatus::Addressed,
                false => SubTicketStatus::Open,
            },
        }
    }
}