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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
use super::*;
#[cfg(test)]
use serial_test_derive::serial;
/// Access to the steam matchmaking interface
pub struct Matchmaking<Manager> {
pub(crate) mm: *mut sys::ISteamMatchmaking,
pub(crate) inner: Arc<Inner<Manager>>,
}
const CALLBACK_BASE_ID: i32 = 500;
/// The visibility of a lobby
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum LobbyType {
Private,
FriendsOnly,
Public,
Invisible,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct LobbyId(pub(crate) u64);
impl LobbyId {
/// Creates a `LobbyId` from a raw 64 bit value.
///
/// May be useful for deserializing lobby ids from
/// a network or save format.
pub fn from_raw(id: u64) -> LobbyId {
LobbyId(id)
}
/// Returns the raw 64 bit value of the lobby id
///
/// May be useful for serializing lobby ids over a
/// network or to a save format.
pub fn raw(&self) -> u64 {
self.0
}
}
impl <Manager> Matchmaking<Manager> {
pub fn request_lobby_list<F>(&self, cb: F)
where F: FnOnce(SResult<Vec<LobbyId>>) + 'static + Send
{
unsafe {
let api_call = sys::SteamAPI_ISteamMatchmaking_RequestLobbyList(self.mm);
register_call_result::<sys::LobbyMatchList_t, _, _>(
&self.inner, api_call, CALLBACK_BASE_ID + 10,
move |v, io_error| {
cb(if io_error {
Err(SteamError::IOFailure)
} else {
let mut out = Vec::with_capacity(v.m_nLobbiesMatching as usize);
for idx in 0 .. v.m_nLobbiesMatching {
out.push(LobbyId(sys::SteamAPI_ISteamMatchmaking_GetLobbyByIndex(sys::SteamAPI_SteamMatchmaking_v009(), idx as _)));
}
Ok(out)
})
}
);
}
}
/// Attempts to create a new matchmaking lobby
///
/// The lobby with have the visibility of the of the passed
/// `LobbyType` and a limit of `max_members` inside it.
/// The `max_members` may not be higher than 250.
///
/// # Triggers
///
/// * `LobbyEnter`
/// * `LobbyCreated`
pub fn create_lobby<F>(&self, ty: LobbyType, max_members: u32, cb: F)
where F: FnOnce(SResult<LobbyId>) + 'static + Send
{
assert!(max_members <= 250); // Steam API limits
unsafe {
let ty = match ty {
LobbyType::Private => sys::ELobbyType::k_ELobbyTypePrivate,
LobbyType::FriendsOnly => sys::ELobbyType::k_ELobbyTypeFriendsOnly,
LobbyType::Public => sys::ELobbyType::k_ELobbyTypePublic,
LobbyType::Invisible => sys::ELobbyType::k_ELobbyTypeInvisible,
};
let api_call = sys::SteamAPI_ISteamMatchmaking_CreateLobby(self.mm, ty, max_members as _);
register_call_result::<sys::LobbyCreated_t, _, _>(
&self.inner, api_call, CALLBACK_BASE_ID + 13,
move |v, io_error| {
cb(if io_error {
Err(SteamError::IOFailure)
} else if v.m_eResult != sys::EResult::k_EResultOK {
Err(v.m_eResult.into())
} else {
Ok(LobbyId(v.m_ulSteamIDLobby))
})
}
);
}
}
/// Tries to join the lobby with the given ID
pub fn join_lobby<F>(&self, lobby: LobbyId, cb: F)
where F: FnOnce(Result<LobbyId, ()>) + 'static + Send
{
unsafe {
let api_call = sys::SteamAPI_ISteamMatchmaking_JoinLobby(self.mm, lobby.0);
register_call_result::<sys::LobbyEnter_t, _, _>(
&self.inner, api_call, CALLBACK_BASE_ID + 4,
move |v, io_error| {
cb(if io_error {
Err(())
} else if v.m_EChatRoomEnterResponse != 1 {
Err(())
} else {
Ok(LobbyId(v.m_ulSteamIDLobby))
})
}
);
}
}
/// Exits the passed lobby
pub fn leave_lobby(&self, lobby: LobbyId) {
unsafe {
sys::SteamAPI_ISteamMatchmaking_LeaveLobby(self.mm, lobby.0);
}
}
/// Returns the steam id of the current owner of the passed lobby
pub fn lobby_owner(&self, lobby: LobbyId) -> SteamId {
unsafe {
SteamId(sys::SteamAPI_ISteamMatchmaking_GetLobbyOwner(self.mm, lobby.0))
}
}
/// Returns the number of players in a lobby.
///
/// Useful if you are not currently in the lobby
pub fn lobby_member_count(&self, lobby: LobbyId) -> usize {
unsafe {
let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, lobby.0);
count as usize
}
}
/// Returns a list of members currently in the lobby
pub fn lobby_members(&self, lobby: LobbyId) -> Vec<SteamId> {
unsafe {
let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, lobby.0);
let mut members = Vec::with_capacity(count as usize);
for idx in 0 .. count {
members.push(SteamId(
sys::SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(self.mm, lobby.0, idx)
))
}
members
}
}
/// Sets whether or not a lobby is joinable by other players. This always defaults to enabled
/// for a new lobby.
///
/// If joining is disabled, then no players can join, even if they are a friend or have been
/// invited.
///
/// Lobbies with joining disabled will not be returned from a lobby search.
///
/// Returns true on success, false if the current user doesn't own the lobby.
pub fn set_lobby_joinable(&self, lobby: LobbyId, joinable: bool) -> bool {
unsafe {
sys::SteamAPI_ISteamMatchmaking_SetLobbyJoinable(
self.mm, lobby.0, joinable
)
}
}
}
#[test]
#[serial]
fn test_lobby() {
let (client, single) = Client::init().unwrap();
let mm = client.matchmaking();
mm.request_lobby_list(|v| {
println!("List: {:?}", v);
});
mm.create_lobby(LobbyType::Private, 4, |v| {
println!("Create: {:?}", v);
});
for _ in 0 .. 100 {
single.run_callbacks();
::std::thread::sleep(::std::time::Duration::from_millis(100));
}
}
|