    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

    use csflow::{enums::PlayerType, structs::Vec3};
    use serde::{Serialize, Deserialize};

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct PlayerData {
        pos: Vec3,
        yaw: f32,
        #[serde(rename = "playerType")]
        player_type: PlayerType,

        #[serde(rename = "hasBomb")]
        has_bomb: bool
    }

    impl PlayerData {
        pub fn new(pos: Vec3, yaw: f32, player_type: PlayerType, has_bomb: bool) -> PlayerData {
            PlayerData { pos, yaw, player_type, has_bomb }
        }
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct BombData {
        pos: Vec3,
        #[serde(rename = "isPlanted")]
        is_planted: bool
    }

    #[allow(dead_code)]
    impl BombData {
        pub fn new(pos: Vec3, is_planted: bool) -> BombData {
            BombData { pos, is_planted }
        }
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub enum EntityData {
        Player(PlayerData),
        Bomb(BombData)
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct RadarData {
        ingame: bool,

        #[serde(rename = "mapName")]
        map_name: String,

        #[serde(rename(serialize = "entityData"))]
        player_data: Vec<EntityData>,

        //#[serde(rename(serialize = "localYaw"))]
        //local_yaw: f32,
    }

    impl RadarData {
        pub fn new(ingame: bool, map_name: String, player_data: Vec<EntityData>) -> RadarData {
            RadarData { ingame, map_name, player_data }
        }

        /// Returns empty RadarData, it's also the same data that gets sent to clients when not ingame
        pub fn empty() -> RadarData {
            RadarData {
                ingame: false,
                map_name: String::new(),
                player_data: Vec::new(),
            }
        }
    }