Display combo while game playing

game/src/constants.rs

@@ -1,4 +1,5 @@
 use const_format::concatcp;
+use sdl2::pixels::Color;
 
 // file path
 // asset path
@@ -44,3 +45,19 @@ pub const ACCURACY_DISPLAY_DURATION: u32 = 800;
 
 // default bpm
 pub const DEFAULT_BPM: u32 = 4;
+
+// font size
+pub const DEFAULT_FONT_SIZE: u16 = 20;
+pub const CREDIT_FONT_SIZE: u16 = 30;
+pub const GAME_RESULT_FONT_SIZE: u16 = 35;
+pub const COMBO_FONT_SIZE: u16 = 40;
+
+// font outline size
+pub const DEFAULT_FONT_OUTLINE_SIZE: u16 = 4;
+
+// font color
+pub const DEFAULT_FONT_COLOR: Color = Color::WHITE;
+pub const SELECT_SONG_FONT_COLOR: Color = Color::BLACK;
+
+// font outline color
+pub const DEFAULT_FONT_OUTLINE_COLOR: Color = Color::BLACK;

game/src/game/common.rs

@@ -3,7 +3,10 @@ use sdl2::{event::Event, keyboard::Keycode, pixels::Color, rect::Rect, render::T
 use super::{
     game_common_context::GameCommonContext, util::create_outlined_font_texture::create_font_texture,
 };
-use crate::constants::DEFAULT_FONT_PATH as FONT_PATH;
+use crate::constants::{CREDIT_FONT_SIZE, DEFAULT_FONT_OUTLINE_SIZE};
+use crate::constants::{
+    DEFAULT_FONT_COLOR, DEFAULT_FONT_OUTLINE_COLOR, DEFAULT_FONT_PATH as FONT_PATH,
+};
 
 pub(crate) fn event_loop_common(event: &Event, coins: &mut u32) -> bool {
     match event {
@@ -51,10 +54,10 @@ pub(crate) fn render_common(context: &mut GameCommonContext) {
         &texture_creator,
         &mut font,
         text.as_str(),
-        2,
-        0,
-        Color::WHITE,
-        Some(Color::GRAY),
+        CREDIT_FONT_SIZE,
+        DEFAULT_FONT_OUTLINE_SIZE,
+        DEFAULT_FONT_COLOR,
+        Some(DEFAULT_FONT_OUTLINE_COLOR),
     )
     .unwrap();
 

game/src/game/display_result.rs

@@ -9,7 +9,10 @@ use sdl2::{
     video::Window,
 };
 
-use crate::constants::DEFAULT_FONT_PATH as FONT_PATH;
+use crate::constants::{
+    DEFAULT_FONT_COLOR, DEFAULT_FONT_OUTLINE_COLOR, DEFAULT_FONT_PATH as FONT_PATH,
+};
+use crate::constants::{DEFAULT_FONT_OUTLINE_SIZE, GAME_RESULT_FONT_SIZE};
 
 use super::{
     common::{event_loop_common, render_common},
@@ -47,10 +50,10 @@ fn render_game_result(
             &texture_creator,
             &font,
             text,
-            35,
-            2,
-            Color::WHITE,
-            Some(Color::GRAY),
+            GAME_RESULT_FONT_SIZE,
+            DEFAULT_FONT_OUTLINE_SIZE,
+            DEFAULT_FONT_COLOR,
+            Some(DEFAULT_FONT_OUTLINE_COLOR),
         )
         .unwrap();
 

game/src/game/game_player/chart_player.rs

@@ -29,6 +29,7 @@ pub struct ChartPlayer<'a> {
     ui: ChartPlayerUI<'a>,
     processed_notes: Vec<ProcessedNote>,
     accuracy: Option<(NoteAccuracy, i128)>,
+    combo: Option<u64>,
 }
 
 impl ChartPlayer<'_> {
@@ -42,6 +43,7 @@ impl ChartPlayer<'_> {
             ui: ChartPlayerUI::new(texture_creator),
             processed_notes: vec![],
             accuracy: None,
+            combo: None,
         }
     }
 
@@ -157,15 +159,18 @@ impl ChartPlayer<'_> {
         overall_tick: u128,
         janggu_state_with_tick: &JangguStateWithTick,
     ) {
-        // set ui accuracy effect
+        // set ui accuracy and combo effect
         self.ui.accuracy = None;
-        self.ui.accuracy_time_progress = None;
+        self.ui.combo = None;
+        self.ui.accuracy_and_combo_time_progress = None;
         if let Some(accuracy) = self.accuracy {
             if accuracy.1.abs_diff(tick) > ACCURACY_DISPLAY_DURATION.into() {
                 self.accuracy = None;
+                self.combo = None;
             } else {
                 self.ui.accuracy = Some(accuracy.0);
-                self.ui.accuracy_time_progress =
+                self.ui.combo = Some(self.timing_judge.get_game_result().combo);
+                self.ui.accuracy_and_combo_time_progress =
                     Some(accuracy.1.abs_diff(tick) as f32 / ACCURACY_DISPLAY_DURATION as f32)
             }
         }

game/src/game/game_player/chart_player_ui.rs

@@ -8,11 +8,17 @@ use num_rational::Rational32;
 use sdl2::{
     pixels::Color,
     rect::Rect,
-    render::{Canvas, TextureCreator},
+    render::{Canvas, TextureCreator, TextureQuery},
     video::{Window, WindowContext},
 };
 
-use crate::constants::{NOTE_ACCURACY_WIDTH, NOTE_HEIGHT};
+use crate::{
+    constants::{
+        COMBO_FONT_SIZE, DEFAULT_FONT_COLOR, DEFAULT_FONT_OUTLINE_COLOR, DEFAULT_FONT_OUTLINE_SIZE,
+        NOTE_ACCURACY_WIDTH, NOTE_HEIGHT,
+    },
+    game::util::create_outlined_font_texture::create_font_texture,
+};
 
 use bidrum_data_struct_lib::janggu::{JangguFace, JangguStick};
 
@@ -26,7 +32,8 @@ use super::timing_judge::NoteAccuracy;
 pub struct ChartPlayerUI<'a> {
     pub notes: Vec<DisplayedSongNote>,
     pub accuracy: Option<NoteAccuracy>,
-    pub accuracy_time_progress: Option<f32>,
+    pub combo: Option<u64>,
+    pub accuracy_and_combo_time_progress: Option<f32>,
     pub input_effect: InputEffect,
     pub overall_effect_tick: u128,
     pub disappearing_note_effects: DisapearingNoteEffect,
@@ -44,7 +51,8 @@ impl ChartPlayerUI<'_> {
         return ChartPlayerUI {
             notes: vec![],
             accuracy: None,
-            accuracy_time_progress: None,
+            combo: None,
+            accuracy_and_combo_time_progress: None,
             input_effect: InputEffect::new(),
             overall_effect_tick: 0,
             disappearing_note_effects: DisapearingNoteEffect::new(),
@@ -372,11 +380,13 @@ impl ChartPlayerUI<'_> {
                 (viewport.height() - background_height_with_border) as i32 / 2 - (height / 2);
             let y_end = y_start - height as i32 - 10;
             let y = y_start
-                + ((y_end - y_start) as f32 * expo_out(self.accuracy_time_progress.unwrap()))
+                + ((y_end - y_start) as f32
+                    * expo_out(self.accuracy_and_combo_time_progress.unwrap()))
                     as i32;
 
-            accuracy_texture
-                .set_alpha_mod((expo_out(self.accuracy_time_progress.unwrap()) * 255.0) as u8);
+            accuracy_texture.set_alpha_mod(
+                (expo_out(self.accuracy_and_combo_time_progress.unwrap()) * 255.0) as u8,
+            );
 
             canvas
                 .copy(
@@ -386,5 +396,38 @@ impl ChartPlayerUI<'_> {
                 )
                 .unwrap();
         }
+
+        // draw combo
+        if let Some(combo) = self.combo {
+            let texture_creator = &canvas.texture_creator();
+            let mut combo_texture = create_font_texture(
+                texture_creator,
+                &self.resources.combo_font,
+                &format!("COMBO: {}", combo),
+                COMBO_FONT_SIZE,
+                DEFAULT_FONT_OUTLINE_SIZE,
+                DEFAULT_FONT_COLOR,
+                Some(DEFAULT_FONT_OUTLINE_COLOR),
+            )
+            .unwrap();
+
+            let TextureQuery { width, height, .. } = combo_texture.query();
+            let x = (viewport.width() - width) as i32 / 2;
+            let y_start = (viewport.height() - background_height_with_border) as i32 / 2
+                - (height as i32 / 2);
+            let y_end = y_start - height as i32 + 300;
+            let y = y_start
+                + ((y_end - y_start) as f32
+                    * expo_out(self.accuracy_and_combo_time_progress.unwrap()))
+                    as i32;
+
+            combo_texture.set_alpha_mod(
+                (expo_out(self.accuracy_and_combo_time_progress.unwrap()) * 255.0) as u8,
+            );
+
+            canvas
+                .copy(&combo_texture, None, Rect::new(x, y, width, height))
+                .unwrap();
+        }
     }
 }

game/src/game/game_player/chart_player_ui/resources.rs

@@ -1,9 +1,11 @@
+use cairo::freetype::Face;
 use sdl2::{
     image::LoadTexture,
     render::{Texture, TextureCreator},
     video::WindowContext,
 };
 
+use crate::constants::DEFAULT_FONT_PATH as FONT_PATH;
 use crate::constants::DEFAULT_IMG_PATH as IMG_PATH;
 
 pub struct NoteTextures<'a> {
@@ -21,8 +23,9 @@ pub struct AccuracyTextures<'a> {
 pub struct ChartPlayerUIResources<'a> {
     pub judgement_line_texture: Texture<'a>,
     pub note_textures: NoteTextures<'a>,
-    pub accuray_textures: AccuracyTextures<'a>,
     pub janggu_texture: Texture<'a>,
+    pub accuray_textures: AccuracyTextures<'a>,
+    pub combo_font: Face,
 }
 
 fn load_note_textures(
@@ -57,12 +60,18 @@ impl ChartPlayerUIResources<'_> {
             .load_texture(IMG_PATH.to_owned() + "/play_ui/janggu.png")
             .expect("Failed to load janggu image");
         let accuray_textures = load_accuracy_textures(texture_creator).unwrap();
+        let library =
+            cairo::freetype::Library::init().expect("Failed to initialize FreeType library");
+        let combo_font = library
+            .new_face(FONT_PATH.to_owned() + "/coin.ttf", 0)
+            .expect("Failed to load combo font");
 
         return ChartPlayerUIResources {
             judgement_line_texture: judgement_line_texture,
             note_textures: note_textures,
             janggu_texture: janggu_texture,
             accuray_textures: accuray_textures,
+            combo_font: combo_font,
         };
     }
 }

game/src/game/select_song.rs

@@ -7,6 +7,7 @@ use sdl2::{
 
 use crate::constants::DEFAULT_FONT_PATH as FONT_PATH;
 use crate::constants::DEFAULT_IMG_PATH as IMG_PATH;
+use crate::constants::SELECT_SONG_FONT_COLOR;
 
 use super::util::create_outlined_font_texture::create_font_texture;
 use super::{
@@ -292,7 +293,7 @@ pub(crate) fn select_song(
                 &song_selection_items[real_song_selection_idx as usize].title,
                 title_font_size,
                 0,
-                Color::BLACK,
+                SELECT_SONG_FONT_COLOR,
                 None,
             )
             .unwrap();
@@ -317,7 +318,7 @@ pub(crate) fn select_song(
                 &song_selection_items[real_song_selection_idx as usize].artist,
                 artist_font_size,
                 0,
-                Color::BLACK,
+                SELECT_SONG_FONT_COLOR,
                 None,
             )
             .unwrap();

game/src/game/title.rs

@@ -6,6 +6,7 @@ use sdl2::{
     video::Window,
 };
 
+use crate::constants::DEFAULT_FONT_COLOR;
 use crate::constants::DEFAULT_FONT_PATH as FONT_PATH;
 use crate::constants::DEFAULT_IMG_PATH as IMG_PATH;
 use crate::constants::DEFAULT_VIDEO_PATH as VIDEO_PATH;
@@ -77,7 +78,7 @@ fn render_text(common_context: &mut GameCommonContext) {
         },
         35,
         2,
-        Color::WHITE,
+        DEFAULT_FONT_COLOR,
         Some(Color::RGB(160, 160, 160)),
     )
     .expect("Font rendering failure");

game/src/game/util/confirm_dialog.rs

@@ -5,7 +5,9 @@ use sdl2::{
     render::Texture,
 };
 
+use crate::constants::DEFAULT_FONT_COLOR;
 use crate::constants::DEFAULT_FONT_PATH as FONT_PATH;
+
 use crate::game::util::create_outlined_font_texture::measure_text_size;
 use crate::{
     constants::DEFAULT_DIALOG_PATH as DIALOG_PATH,
@@ -69,7 +71,7 @@ macro_rules! create_button_texture {
             $button_text,
             $button_font_size,
             0,
-            Color::WHITE,
+            DEFAULT_FONT_COLOR,
             None,
         )
         .expect("Failed to render font");
@@ -109,7 +111,6 @@ pub fn render_confirm_dialog(
     // Set font-size, line-height and load font
     let font_size = 38;
     let button_font_size = 32;
-    let font_color = Color::WHITE;
     let line_height = 40;
     let font = common_context
         .freetype_library
@@ -125,8 +126,16 @@ pub fn render_confirm_dialog(
         .split('\n')
         .into_iter()
         .map(|x| {
-            create_font_texture(&texture_creator, &font, x, font_size, 0, font_color, None)
-                .expect("Failed to render text")
+            create_font_texture(
+                &texture_creator,
+                &font,
+                x,
+                font_size,
+                0,
+                DEFAULT_FONT_COLOR,
+                None,
+            )
+            .expect("Failed to render text")
         })
         .collect();