You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: game.rs
    path of file: ./repos/CallOfFerris/src/screens/game
    
    the code of the file until where you have to start completion: use std::{collections::HashMap, process::exit, rc::Rc, sync::Mutex};

use ggez::{
    audio::SoundSource,
    event::KeyCode,
    graphics::{self, Color, DrawParam, Drawable, Shader, Text},
    mint,
    nalgebra::Point2,
    timer, Context, GameResult,
};
use ggez_goodies::{camera::Camera, nalgebra_glm::Vec2};
use graphics::{GlBackendSpec, Scale, ShaderGeneric, TextFragment};
use mint::Vector2;
use rand::Rng;

use crate::{
    game::components::{
        bullet::{PlayerWeapon, WeaponType},
        cloud::Cloud,
        player::Direction,
    },
    game::map::Map,
    game::physics::Physics,
    play,
    utils::{lerp, remap, AssetManager, ParticleSystem},
    Screen,
};

use gfx::*;

gfx_defines! {
    constant Dim {
        rate: f32 = "u_Rate",
    }
}

pub struct Game {
    /// The game map.
    map: Map,
    /// Physics system for the game.
    physics: Physics,
    /// Camera to see the world.
    camera: Camera,

    // TODO: Refactor the rest of the fields
    clouds: Vec<Cloud>,

    /// Reference to the asset manager.
    asset_manager: Rc<AssetManager>,

    elapsed_shake: Option<(f32, Vec2, f32)>,
    tics: Option<i32>,
    particles: Vec<ParticleSystem>,
    ui_lerp: HashMap<String, f32>,

    dim_shader: ShaderGeneric<GlBackendSpec, Dim>,
    dim_constant: Dim,

    draw_end_text: (bool, Option<usize>, bool, bool), // Thread Sleeped?, Current Iters, Done?, Win?
    can_die: bool,
}

impl Game {
    pub fn create(ctx: &mut Context, asset_manager: Rc<AssetManager>) -> Mutex<Self> {
        let (width, height) = graphics::drawable_size(ctx);

        let mut camera = Camera::new(width as u32, height as u32, width, height);

        let mut rng = rand::thread_rng();

        let mut physics = Physics::new();
        let mut map = Map::parse(ctx, "01", &mut physics, &asset_manager);

        let mut clouds = vec![];

        let dim_constant = Dim { rate: 1.0 };

        let dim_shader = Shader::new(
            ctx,
            "/shaders/dim.basic.glslf",
            "/shaders/dim.glslf",
            dim_constant,
            "Dim",
            None,
        )
        .unwrap();

        let mut ui_lerp = HashMap::new();

        ui_lerp.insert(String::from("ammo"), map.player.ammo as f32);
        ui_lerp.insert(String::from("health"), map.player.health as f32);
        ui_lerp.insert(String::from("using"), map.using.as_ref().unwrap().1);

      
    
    fn draw_ui(&mut self, ctx: &mut Context) -> GameResult<()> {
        let (width, _) = graphics::drawable_size(ctx);

        let profile = self.asset_manager.get_image("Some(profile).png");
        let fish = self.asset_manager.get_image("Some(fish).png");

        let consolas = self.asset_manager.get_font("Consolas.ttf");

        graphics::draw(
            ctx,
            &profile,
            DrawParam::default()
                .dest(Point2::new(10.0, 10.0))
                .scale(Vector2 { x: 0.5, y: 0.5 }),
        )?;

        let ammo_rect = graphics::Mesh::new_rectangle(
            ctx,
            graphics::DrawMode::fill(),
            graphics::Rect::new(
                ((profile.width() / 2) + 10) as f32,
                (profile.height() / 3) as f32,
                150.,
                15.,
            ),
            Color::from_rgb(54, 50, 49),
        )?;

        let hp_rect = graphics::Mesh::new_rectangle(
            ctx,
            graphics::DrawMode::fill(),
            graphics::Rect::new(
                ((profile.width() / 2) + 10) as f32,
                (profile.height() / 5) as f32,
                150.,
                15.,
            ),
            Color::from_rgb(54, 50, 49),
        )?;

        let cur_ammo_rect = graphics::Mesh::new_rectangle(
            ctx,
            graphics::DrawMode::fill(),
            graphics::Rect::new(
                ((profile.width() / 2) + 10) as f32,
                (profile.height() / 3) as f32,
                remap(self.map.player.ammo as f32, 0., 10., 0., 150.),
                15.,
            ),
            Color::from_rgb(21, 156, 228),
        )?;

        let cur_hp_rect = graphics::Mesh::new_rectangle(
            ctx,
            graphics::DrawMode::fill(),
            graphics::Rect::new(
                ((profile.width() / 2) + 10) as f32,
                (profile.height() / 5) as f32,
                remap(self.map.player.health as f32, 0., 100., 0., 150.),
                15.,
            ),
            Color::from_rgb(34, 205, 124),
        )?;

        graphics::draw(ctx, &ammo_rect, DrawParam::default())?;

        graphics::draw(ctx, &hp_rect, DrawParam::default())?;

        graphics::draw(ctx, &cur_ammo_rect, DrawParam::default())?;

        graphics::draw(ctx, &cur_hp_rect, DrawParam::default())?;

        graphics::draw(
            ctx,
            &fish,
            DrawParam::default()
                .dest(Point2::new(
                    ((profile.width() / 2) - 10) as f32,
                    (profile.height() / 3) as f32,
                ))
                .scale(Vector2 { x: 0.7, y: 0.7 }),
        )?;

        let evildoers = &Text::new(
            TextFragment::new(format!(
                "Evildoers {}/{}",
                self.map.enemies.len(),
                self.map.total_enemies
            ))
            .font(consolas)
            .scale(Scale::uniform(20.)),
        );

        let evildoers_dim = evildoers.dimensions(ctx);

        graphics::draw(
            ctx,
            evildoers,
            DrawParam::default().dest(Point2::new((width - evildoers_dim.0 as f32) - 40., 20.)),
        )?;

        let info = &Text::new(
            TextFragment::new(format!("Using {}", self.map.using.as_ref().unwrap().0))
                .font(consolas)
                .color([1.0, 1.0, 1.0, self.map.using.as_ref().unwrap().1].into()),
        );

        let info_dim = info.dimensions(ctx);

        graphics::draw(
            ctx,
            info,
            DrawParam::default().dest(Point2::new((width / 2.) - (info_dim.0 / 2) as f32, 150.)),
        )?;

        Ok(())
    }