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
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

#[macro_use]
extern crate serde_derive;

pub const OP_TAKE_TURN: &str = "wdTakeTurn";

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MechInfo {
    pub name: String,
    pub avatar: String,
    pub team: String,
    pub id: String,
}

pub mod events {
    use chrono::prelude::*;
    use domain::events::EndCause;
    use wasmdome_domain as domain;

    pub fn events_subject(match_id: Option<&str>) -> String {
        if let Some(match_id) = match_id {
            format!("wasmdome.match.{}.events", match_id)
        } else {
            "wasmdome.public.arena.events".to_string()
        }
    }

    #[derive(Clone, Debug, Serialize, Deserialize)]
    pub enum ArenaEvent {
        MechConnected {
            actor: String,
            name: String,
            avatar: String,
            team: String,
            time: DateTime<Utc>,
        },
        MechDisconnected {
            actor: String,
            time: DateTime<Utc>,
        },
        MatchStarted {
            match_id: String,
            actors: Vec<String>,
            board_height: u32,
            board_width: u32,
            start_time: DateTime<Utc>,
        },
        MatchCompleted {
            match_id: String,
            cause: EndCause,
            time: DateTime<Utc>,
        },
    }

    #[derive(Clone, Debug, Serialize, Deserialize)]
    pub enum MatchEvent {
        /// Emitted by the core engine so that downstream listeners (e.g. historian, leaderboard) can process
        TurnEvent {
            actor: String,
            match_id: String,
            turn: u32,
            turn_event: domain::events::GameEvent,
        },
    }
}

pub mod commands {
    use crate::MechInfo;
    use wasmdome_domain as domain;

    pub fn arena_control_subject() -> String {
        "wasmdome.internal.arena.control".to_string()
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub enum ArenaControlCommand {
        StartMatch(CreateMatch),
        QueryMechs,
    }

    /// Sent on a match subject to tell a given mech to take its turn. The response
    /// to this should be an acknowledgement containing the list of commands performed
    /// by that mech.
    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct TakeTurn {
        pub actor: String,
        pub match_id: String,
        pub turn: u32,
        pub state: domain::state::MatchState,
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct TakeTurnResponse {
        pub commands: Vec<domain::commands::MechCommand>,
    }

    /// Signals the desire to create a new match
    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct CreateMatch {
        pub match_id: String,
        pub actors: Vec<String>,
        pub board_height: u32,
        pub board_width: u32,
        pub max_turns: u32,
        pub aps_per_turn: u32,
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct MechQueryResponse {
        pub mechs: Vec<MechInfo>,
    }
}

pub mod tools {
    #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
    pub struct TokenRequest {
        pub account_key: String,
    }

    #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
    pub struct CredentialsRequest {
        pub account_key: String,
        pub token: String,
    }

    #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
    pub enum CredentialsResponse {
        Valid {
            user_jwt: String,
            user_secret: String,
        },
        Error(String),
    }
}

pub mod scheduler {
    use chrono::DateTime;
    use chrono::Utc;

    #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
    pub struct MatchScheduleEntry {
        pub max_actors: u32,
        pub board_height: u32,
        pub board_width: u32,
        pub max_turns: u32,
        pub match_start: DateTime<Utc>,
    }

    #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
    pub struct MatchIdentifier {
        pub match_id: String,
    }

    #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
    pub struct StoredMatch {
        pub match_id: String,
        pub entry: MatchScheduleEntry,
        pub aps_per_turn: u32,
    }
}