chiropterm 0.2.0

bat-themed fake terminal in the style of libtcod
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
135
136
137

use crate::rendering::{Bevels, Interactor, InteractorFmt, SemanticContent};

pub struct FString(pub Vec<FChar>);

#[derive(Clone, Copy)]
pub struct FChar {
    pub sprite: Option<u16>,
    pub bg: Option<u8>,
    pub fg: Option<u8>,
    pub interactor: Option<InteractorFmt>,
    pub scroll_interactor: Option<Interactor>,
    pub bevels: FBevels,
}

impl FChar {
    pub(crate) fn new() -> FChar {
        FChar { 
            sprite: None,
            bg: None,
            fg: None,
            interactor: None,
            scroll_interactor: None,
            bevels: FBevels::new(),
        }
    }


    pub(crate) fn sem(&self, semantic: impl Fn(u16) -> SemanticContent) -> FSem {
        FSem { 
            sem: self.sprite.map(semantic),
            bg: self.bg,
            fg: self.fg,
            interactor: self.interactor,
            scroll_interactor: self.scroll_interactor,
            bevels: self.bevels,
        }
    }

    pub(crate) fn sprite(mut self, u: u16) -> FChar {
        self.sprite = Some(u);
        self
    }
}

#[derive(Clone, Copy, Debug)]
pub struct FSem {
    pub sem: Option<SemanticContent>,
    pub bg: Option<u8>,
    pub fg: Option<u8>,
    pub interactor: Option<InteractorFmt>, // if None, then don't _change_ the interactor
    pub scroll_interactor: Option<Interactor>, // if None, then don't _change_ the interactor
    pub bevels: FBevels,
}

impl FSem {
    pub fn new() -> FSem {
        FSem {
            sem: None,
            bg: None,
            fg: None,
            interactor: None,
            scroll_interactor: None,
            bevels: FBevels::new(),
        }
    }

    pub fn superimposed_on(self, below: FSem) -> FSem {
        FSem { 
            sem: self.sem.or(below.sem), 
            bg: self.bg.or(below.bg),
            fg: self.fg.or(below.fg),
            interactor: self.interactor.or(below.interactor),
            scroll_interactor: self.scroll_interactor.or(below.scroll_interactor),
            bevels: self.bevels.superimposed_on(below.bevels)
        }
    }

    pub fn sem(mut self, sem: SemanticContent) -> FSem {
        self.sem = Some(sem);
        self
    }

    pub fn bg(mut self, bg: u8) -> FSem {
        self.bg = Some(bg);
        self
    }

    pub fn fg(mut self, fg: u8) -> FSem {
        self.fg = Some(fg);
        self
    }

    pub fn color(mut self, (bg, fg): (u8, u8)) -> FSem {
        self.bg = Some(bg);
        self.fg = Some(fg);
        self
    }

    pub fn interactor(mut self, interactor: Interactor, bg: u8, fg: u8) -> FSem {
        self.interactor = Some(InteractorFmt { interactor, bg, fg });
        self
    }

    pub fn scroll_interactor(mut self, interactor: Interactor) -> FSem {
        self.scroll_interactor = Some(interactor);
        self
    }
    // TODO: Don't set bevels here? Probably use rectangle drawing etc and set internally
}

#[derive(Clone, Copy, Debug)]
pub struct FBevels {
    pub top: Option<u8>,
    pub left: Option<u8>,
    pub right: Option<u8>,
    pub bottom: Option<u8>,
}
impl FBevels {
    pub(crate) fn new() -> FBevels {
        FBevels { top: None, left: None, right: None, bottom: None }
    }

    fn superimposed_on(&self, mut bevels: FBevels) -> FBevels {
        if let Some(t) = self.top { bevels.top = Some(t) }
        if let Some(l) = self.left { bevels.left = Some(l) }
        if let Some(r) = self.right { bevels.right = Some(r) }
        if let Some(b) = self.bottom { bevels.bottom = Some(b) }
        bevels
    }

    pub(crate) fn update(&self, bevels: &mut Bevels) {
        if let Some(t) = self.top { bevels.top = t }
        if let Some(l) = self.left { bevels.left = l }
        if let Some(r) = self.right { bevels.right = r }
        if let Some(b) = self.bottom { bevels.bottom = b; }
    }
}