terrr 0.1.0

a linux horror game
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

use crossterm::event::{Event, KeyCode, KeyEvent};
use ratatui::style::{Color, Style};
use std::time::{Duration, Instant};
use rand::Rng;

/// Represents a menu item in the game
pub struct MenuItem {
    pub label: String,
    pub action: MenuAction,
    pub highlighted: bool,
    pub glitch_intensity: f32,
    last_glitch: Instant,
}

impl MenuItem {
    pub fn new(label: &str, action: MenuAction) -> Self {
        Self {
            label: label.to_string(),
            action,
            highlighted: false,
            glitch_intensity: 0.0,
            last_glitch: Instant::now(),
        }
    }
    
    pub fn update(&mut self) {
        // Randomly apply glitch effects to menu items
        if self.last_glitch.elapsed() > Duration::from_millis(500) {
            let mut rng = rand::thread_rng();
            if rng.gen::<f32>() < self.glitch_intensity {
                // Apply subtle glitch effect
                self.last_glitch = Instant::now();
            }
        }
    }
    
    pub fn select(&mut self) {
        self.highlighted = true;
        self.glitch_intensity = 0.1; // Increase glitch when selected
    }
    
    pub fn deselect(&mut self) {
        self.highlighted = false;
        self.glitch_intensity = 0.0;
    }
    
    pub fn get_style(&self) -> Style {
        if self.highlighted {
            Style::default().fg(Color::Red)
        } else {
            Style::default().fg(Color::White)
        }
    }
}

/// Represents actions that can be performed from the menu
#[derive(Clone)]
pub enum MenuAction {
    StartGame,
    ShowRules,
    ShowAbout,
    Quit,
}

/// Main menu of the game
pub struct MainMenu {
    pub items: Vec<MenuItem>,
    pub selected: usize,
    pub last_update: Instant,
}

impl MainMenu {
    pub fn new() -> Self {
        let mut menu = Self {
            items: vec![
                MenuItem::new("PLAY", MenuAction::StartGame),
                MenuItem::new("RULES", MenuAction::ShowRules),
                MenuItem::new("ABOUT", MenuAction::ShowAbout),
                MenuItem::new("QUIT", MenuAction::Quit),
            ],
            selected: 0,
            last_update: Instant::now(),
        };
        
        // Set the first item as selected by default
        menu.items[0].select();
        
        menu
    }
    
    pub fn update(&mut self) {
        // Update all menu items
        for item in &mut self.items {
            item.update();
        }
    }
    
    pub fn handle_input(&mut self, event: Event) -> Option<MenuAction> {
        match event {
            Event::Key(KeyEvent { code, .. }) => match code {
                KeyCode::Up => self.select_prev(),
                KeyCode::Down => self.select_next(),
                KeyCode::Enter => return Some(self.items[self.selected].action.clone()),
                _ => {}
            },
            _ => {}
        }
        None
    }
    
    fn select_next(&mut self) {
        self.items[self.selected].deselect();
        self.selected = (self.selected + 1) % self.items.len();
        self.items[self.selected].select();
    }
    
    fn select_prev(&mut self) {
        self.items[self.selected].deselect();
        self.selected = if self.selected == 0 {
            self.items.len() - 1
        } else {
            self.selected - 1
        };
        self.items[self.selected].select();
    }
}