slint-memory-game/src/main.rs

::slint::include_modules!();

fn main() -> Result<(), slint::PlatformError> {
    use ::rand::seq::SliceRandom;
    use ::slint::{Model, Timer, VecModel};
    use std::rc::Rc;
    use std::time::Duration;

    let main_window = MainWindow::new()?;

    // Fetch the tiles from the model, and then duplicate them so we have pairs
    let mut tiles: Vec<TileData> = main_window.get_memory_tiles().iter().collect();
    tiles.extend(tiles.clone());

    // Randomize the tiles
    let mut rng = rand::thread_rng();
    tiles.shuffle(&mut rng);

    // Update the model
    let tiles_model = Rc::new(VecModel::from(tiles));
    main_window.set_memory_tiles(tiles_model.clone().into());

    let main_window_weak = main_window.as_weak();

    main_window.on_check_if_pair_solved(move || {
        let mut flipped_tiles = tiles_model
            .iter()
            .enumerate()
            .filter(|(_, tile)| tile.image_visible && !tile.solved);

        if let (Some((t1_idx, mut t1)), Some((t2_idx, mut t2))) =
            (flipped_tiles.next(), flipped_tiles.next())
        {
            let is_pair_solved = t1 == t2;
            if is_pair_solved {
                t1.solved = true;
                t2.solved = true;
                tiles_model.set_row_data(t1_idx, t1);
                tiles_model.set_row_data(t2_idx, t2);
            } else {
                let main_window = main_window_weak.unwrap();
                let tiles_model = tiles_model.clone();

                main_window.set_disable_tiles(true);

                Timer::single_shot(Duration::from_secs(1), move || {
                    main_window.set_disable_tiles(false);

                    t1.image_visible = false;
                    t2.image_visible = false;
                    tiles_model.set_row_data(t1_idx, t1);
                    tiles_model.set_row_data(t2_idx, t2);
                });
            }
        }
    });

    main_window.run()?;

    Ok(())
}