rsnaker/game_logic/
playing_logic.rs

1use crate::controls::direction::Direction;
2use crate::controls::speed::Speed;
3use crate::game_logic::fruits_manager::FruitsManager;
4use crate::game_logic::high_score::{HighScore, HighScoreManager};
5use crate::game_logic::state::{GameOverMenu, GameState, GameStatus};
6use crate::graphics::sprites::fruit::Fruit;
7use crate::graphics::sprites::map::Map;
8use crate::graphics::sprites::snake_body::SnakeBody;
9use std::sync::{Arc, RwLock};
10use std::thread::sleep;
11use std::time::{Duration, Instant};
12use tracing::{debug, error, info, trace, trace_span, warn};
13
14/// # Panics
15/// if Arc panics while holding the resources (poisoning),
16/// no recovery mechanism implemented better crash  
17pub fn playing_logic_loop(
18    direction: &Arc<RwLock<Direction>>,
19    snake: &Arc<RwLock<SnakeBody>>,
20    gs: &Arc<RwLock<GameState>>,
21    carte: &Arc<RwLock<Map>>,
22    fruits_manager: &Arc<RwLock<FruitsManager>>,
23    (game_speed, snake_symbols, classic_mode): (Speed, String, bool),
24) {
25    let mut gsc;
26    debug!(fruits = ?fruits_manager.read().unwrap().get_fruits(), "Initial fruits on map");
27    loop {
28        let _span = trace_span!("logic_iteration").entered();
29        let loop_start = Instant::now();
30        //do not want to keep the lock for too long + cannot hold in the same thread 2 times the same hold
31        // so match a clone or use a let
32        gsc = gs.read().unwrap().status.clone();
33        //dead snakes tell no tales, nor move :p
34        match gsc {
35            GameStatus::Playing => {
36                let mut write_guard = snake.write().unwrap();
37                //Move the snake!
38                let position = write_guard.ramp(&direction.read().unwrap(), &carte.read().unwrap());
39                debug!(?position, "Snake moved");
40                // Check if we eat a fruit
41                let fruits = fruits_manager.read().unwrap().eat_some_fruits(position);
42                // fruits effects
43                if let Some(fruits) = fruits {
44                    debug!(count = fruits.len(), "Fruits eaten by snake");
45                    let score_fruits = fruits.iter().map(Fruit::get_score).sum::<i32>();
46                    let size_effect = fruits.iter().map(Fruit::get_grow_snake).sum::<i16>();
47                    info!(?fruits, "Fruit characteristics");
48                    // in all cases except classic mode with negative size, we always apply size modifiers
49                    if !(classic_mode && size_effect <= 0) {
50                        write_guard.relative_size_change(size_effect);
51                    }
52                    //NB:Converting an u16 to an i32 is always safe in Rust because the range of u16 (0 to 65,535)
53                    // fits entirely within the range of i32 (−2,147,483,648 to 2,147,483,647).
54                    //So no need to do: speed_score_modifier.try_into().expect("too much")/match for conversion
55                    let fruit_impact = score_fruits * i32::from(game_speed.score_modifier());
56                    info!(
57                        fruit_impact = fruit_impact,
58                        "Fruit impact on score because of speed score modifier"
59                    );
60                    let mut state_guard_gs = gs.write().unwrap();
61                    // to always keep the score positive and between bounds
62                    if fruit_impact < 0 {
63                        state_guard_gs.score = state_guard_gs
64                            .score
65                            .saturating_sub(fruit_impact.unsigned_abs());
66                    } else {
67                        state_guard_gs.score = state_guard_gs
68                            .score
69                            .saturating_add(fruit_impact.unsigned_abs());
70                    }
71                    info!(
72                        score = state_guard_gs.score,
73                        snake_size = write_guard.body.len(),
74                        "Current game metrics"
75                    );
76                    fruits_manager.write().unwrap().replace_fruits(&fruits);
77                    debug!(fruits = ?fruits_manager.read().unwrap().get_fruits(), "Current fruits on map");
78                }
79                // Check if the gamer will lose one life
80                if write_guard.is_snake_eating_itself() {
81                    //Ouch. You bite yourself
82                    let mut state_guard = gs.write().unwrap();
83                    if (state_guard.life) >= 1 {
84                        state_guard.life -= 1;
85                        warn!(
86                            remaining_life = state_guard.life,
87                            "Ouch! Did that taste good? You bit yourself!",
88                        );
89                    }
90                    if state_guard.life == 0 {
91                        error!(
92                            score = state_guard.score,
93                            "FATAL: Snake succumbed to its injuries. Game Over!"
94                        );
95                        //The GameOverMenu option will be used to store the user selection of what to do
96                        state_guard.status = GameStatus::GameOver(GameOverMenu::default());
97
98                        // Save High Score
99                        if let Ok(manager) = HighScoreManager::new() {
100                            let score_value: u32 = state_guard.score;
101                            let rank = manager.save_score(&HighScore::new(
102                                snake_symbols.clone(),
103                                score_value,
104                                //using Display implementation
105                                game_speed.to_string(),
106                            ));
107                            state_guard.rank = rank.unwrap_or(None);
108                        }
109                    }
110                }
111            }
112            GameStatus::Restarting => {
113                //let some time for the restarting screen to appear
114                sleep(Duration::from_secs(1));
115                gs.write().unwrap().reset();
116                snake.write().unwrap().reset();
117                *direction.write().unwrap() = Direction::Right;
118                fruits_manager.write().unwrap().reset();
119                //graphical resize on rendering part (not really a game_logic constant)
120            }
121            GameStatus::ByeBye | GameStatus::Menu => break,
122            GameStatus::Paused | GameStatus::GameOver(_) => {}
123        }
124        let elapsed = loop_start.elapsed();
125        trace!(?elapsed, "Logic loop iteration finished");
126        sleep(Duration::from_millis(game_speed.ms_value()));
127    }
128}
rsnaker/game_logic/playing_logic.rs

rsnaker/game_logic/
playing_logic.rs
