244 match inanteroom::handle(server, client_id, response, message) { |
250 match inanteroom::handle(server, client_id, response, message) { |
245 LoginResult::Unchanged => (), |
251 LoginResult::Unchanged => (), |
246 LoginResult::Complete => { |
252 LoginResult::Complete => { |
247 if let Some(client) = server.anteroom.remove_client(client_id) { |
253 if let Some(client) = server.anteroom.remove_client(client_id) { |
248 server.add_client(client_id, client); |
254 server.add_client(client_id, client); |
249 common::join_lobby(server, response); |
255 common::get_lobby_join_data(server, response); |
250 } |
256 } |
251 } |
257 } |
252 LoginResult::Exit => { |
258 LoginResult::Exit => { |
253 server.anteroom.remove_client(client_id); |
259 server.anteroom.remove_client(client_id); |
254 response.remove_client(client_id); |
260 response.remove_client(client_id); |
266 if let Some(client) = server.find_client(&nick) { |
272 if let Some(client) = server.find_client(&nick) { |
267 let admin_sign = if client.is_admin() { "@" } else { "" }; |
273 let admin_sign = if client.is_admin() { "@" } else { "" }; |
268 let master_sign = if client.is_master() { "+" } else { "" }; |
274 let master_sign = if client.is_master() { "+" } else { "" }; |
269 let room_info = match client.room_id { |
275 let room_info = match client.room_id { |
270 Some(room_id) => { |
276 Some(room_id) => { |
271 let room = &server.rooms[room_id]; |
277 let room = server.room(room_id); |
272 let status = match room.game_info { |
278 let status = match room.game_info { |
273 Some(_) if client.teams_in_game == 0 => "(spectating)", |
279 Some(_) if client.teams_in_game == 0 => "(spectating)", |
274 Some(_) => "(playing)", |
280 Some(_) => "(playing)", |
275 None => "", |
281 None => "", |
276 }; |
282 }; |
288 utils::protocol_version_string(client.protocol_number).to_string(), |
294 utils::protocol_version_string(client.protocol_number).to_string(), |
289 room_info, |
295 room_info, |
290 ]; |
296 ]; |
291 response.add(Info(info).send_self()) |
297 response.add(Info(info).send_self()) |
292 } else { |
298 } else { |
293 response |
299 response.add(server_chat(USER_OFFLINE.to_string()).send_self()) |
294 .add(server_chat("Player is not online.".to_string()).send_self()) |
|
295 } |
300 } |
296 } |
301 } |
297 HwProtocolMessage::ToggleServerRegisteredOnly => { |
302 HwProtocolMessage::ToggleServerRegisteredOnly => { |
298 if !server.clients[client_id].is_admin() { |
303 if !server.is_admin(client_id) { |
299 response.add(Warning("Access denied.".to_string()).send_self()); |
304 response.warn(ACCESS_DENIED); |
300 } else { |
305 } else { |
301 server.set_is_registered_only(server.is_registered_only()); |
306 server.set_is_registered_only(!server.is_registered_only()); |
302 let msg = if server.is_registered_only() { |
307 let msg = if server.is_registered_only() { |
303 "This server no longer allows unregistered players to join." |
308 REGISTERED_ONLY_ENABLED |
304 } else { |
309 } else { |
305 "This server now allows unregistered players to join." |
310 REGISTERED_ONLY_DISABLED |
306 }; |
311 }; |
307 response.add(server_chat(msg.to_string()).send_all()); |
312 response.add(server_chat(msg.to_string()).send_all()); |
308 } |
313 } |
309 } |
314 } |
310 HwProtocolMessage::Global(msg) => { |
315 HwProtocolMessage::Global(msg) => { |
311 if !server.clients[client_id].is_admin() { |
316 if !server.is_admin(client_id) { |
312 response.add(Warning("Access denied.".to_string()).send_self()); |
317 response.warn(ACCESS_DENIED); |
313 } else { |
318 } else { |
314 response.add(global_chat(msg).send_all()) |
319 response.add(global_chat(msg).send_all()) |
315 } |
320 } |
316 } |
321 } |
317 HwProtocolMessage::SuperPower => { |
322 HwProtocolMessage::SuperPower => { |
318 if !server.clients[client_id].is_admin() { |
323 let client = server.client_mut(client_id); |
319 response.add(Warning("Access denied.".to_string()).send_self()); |
324 if !client.is_admin() { |
|
325 response.warn(ACCESS_DENIED); |
320 } else { |
326 } else { |
321 server.clients[client_id].set_has_super_power(true); |
327 client.set_has_super_power(true); |
322 response |
328 response.add(server_chat(SUPER_POWER.to_string()).send_self()) |
323 .add(server_chat("Super power activated.".to_string()).send_self()) |
|
324 } |
329 } |
325 } |
330 } |
326 HwProtocolMessage::Watch(id) => { |
331 HwProtocolMessage::Watch(id) => { |
327 #[cfg(feature = "official-server")] |
332 #[cfg(feature = "official-server")] |
328 { |
333 { |
329 response.request_io(IoTask::GetReplay { id }) |
334 response.request_io(IoTask::GetReplay { id }) |
330 } |
335 } |
331 |
336 |
332 #[cfg(not(feature = "official-server"))] |
337 #[cfg(not(feature = "official-server"))] |
333 { |
338 { |
334 response.add( |
339 response.warn(REPLAY_NOT_SUPPORTED); |
335 Warning("This server does not support replays!".to_string()) |
340 } |
336 .send_self(), |
341 } |
337 ); |
342 _ => match server.client(client_id).room_id { |
338 } |
|
339 } |
|
340 _ => match server.clients[client_id].room_id { |
|
341 None => inlobby::handle(server, client_id, response, message), |
343 None => inlobby::handle(server, client_id, response, message), |
342 Some(room_id) => { |
344 Some(room_id) => { |
343 inroom::handle(server, client_id, response, room_id, message) |
345 inroom::handle(server, client_id, response, room_id, message) |
344 } |
346 } |
345 }, |
347 }, |
378 io_result: IoResult, |
380 io_result: IoResult, |
379 ) { |
381 ) { |
380 match io_result { |
382 match io_result { |
381 IoResult::AccountRegistered(is_registered) => { |
383 IoResult::AccountRegistered(is_registered) => { |
382 if !is_registered && server.is_registered_only() { |
384 if !is_registered && server.is_registered_only() { |
383 response.add( |
385 response.add(Bye(REGISTRATION_REQUIRED.to_string()).send_self()); |
384 Bye("This server only allows registered users to join.".to_string()) |
|
385 .send_self(), |
|
386 ); |
|
387 response.remove_client(client_id); |
386 response.remove_client(client_id); |
388 } else if is_registered { |
387 } else if is_registered { |
389 let salt = server.anteroom.clients[client_id].server_salt.clone(); |
388 let salt = server.anteroom.clients[client_id].server_salt.clone(); |
390 response.add(AskPassword(salt).send_self()); |
389 response.add(AskPassword(salt).send_self()); |
391 } else if let Some(client) = server.anteroom.remove_client(client_id) { |
390 } else if let Some(client) = server.anteroom.remove_client(client_id) { |
392 server.add_client(client_id, client); |
391 server.add_client(client_id, client); |
393 common::join_lobby(server, response); |
392 common::get_lobby_join_data(server, response); |
394 } |
393 } |
395 } |
394 } |
396 IoResult::Account(Some(info)) => { |
395 IoResult::Account(Some(info)) => { |
397 response.add(ServerAuth(format!("{:x}", info.server_hash)).send_self()); |
396 response.add(ServerAuth(format!("{:x}", info.server_hash)).send_self()); |
398 if let Some(client) = server.anteroom.remove_client(client_id) { |
397 if let Some(mut client) = server.anteroom.remove_client(client_id) { |
|
398 client.is_registered = info.is_registered; |
|
399 client.is_admin = info.is_admin; |
|
400 client.is_contributor = info.is_contributor; |
399 server.add_client(client_id, client); |
401 server.add_client(client_id, client); |
400 let client = &mut server.clients[client_id]; |
402 common::get_lobby_join_data(server, response); |
401 client.set_is_registered(info.is_registered); |
|
402 client.set_is_admin(info.is_admin); |
|
403 client.set_is_contributor(info.is_contributor); |
|
404 common::join_lobby(server, response); |
|
405 } |
403 } |
406 } |
404 } |
407 IoResult::Account(None) => { |
405 IoResult::Account(None) => { |
408 response.add(Error("Authentication failed.".to_string()).send_self()); |
406 response.error(AUTHENTICATION_FAILED); |
409 response.remove_client(client_id); |
407 response.remove_client(client_id); |
410 } |
408 } |
411 IoResult::Replay(Some(replay)) => { |
409 IoResult::Replay(Some(replay)) => { |
412 let protocol = server.clients[client_id].protocol_number; |
410 let client = server.client(client_id); |
|
411 let protocol = client.protocol_number; |
413 let start_msg = if protocol < 58 { |
412 let start_msg = if protocol < 58 { |
414 RoomJoined(vec![server.clients[client_id].nick.clone()]) |
413 RoomJoined(vec![client.nick.clone()]) |
415 } else { |
414 } else { |
416 ReplayStart |
415 ReplayStart |
417 }; |
416 }; |
418 response.add(start_msg.send_self()); |
417 response.add(start_msg.send_self()); |
419 |
418 |
425 if protocol < 58 { |
424 if protocol < 58 { |
426 response.add(Kicked.send_self()); |
425 response.add(Kicked.send_self()); |
427 } |
426 } |
428 } |
427 } |
429 IoResult::Replay(None) => { |
428 IoResult::Replay(None) => { |
430 response.add(Warning("Could't load the replay".to_string()).send_self()) |
429 response.warn(REPLAY_LOAD_FAILED); |
431 } |
430 } |
432 IoResult::SaveRoom(_, true) => { |
431 IoResult::SaveRoom(_, true) => { |
433 response.add(server_chat("Room configs saved successfully.".to_string()).send_self()); |
432 response.add(server_chat(ROOM_CONFIG_SAVED.to_string()).send_self()); |
434 } |
433 } |
435 IoResult::SaveRoom(_, false) => { |
434 IoResult::SaveRoom(_, false) => { |
436 response.add(Warning("Unable to save the room configs.".to_string()).send_self()); |
435 response.warn(ROOM_CONFIG_SAVE_FAILED); |
437 } |
436 } |
438 IoResult::LoadRoom(room_id, Some(contents)) => { |
437 IoResult::LoadRoom(room_id, Some(contents)) => { |
439 if let Some(ref mut room) = server.rooms.get_mut(room_id) { |
438 if let Some(ref mut room) = server.rooms.get_mut(room_id) { |
440 match room.set_saves(&contents) { |
439 match room.set_saves(&contents) { |
441 Ok(_) => response.add( |
440 Ok(_) => response.add(server_chat(ROOM_CONFIG_LOADED.to_string()).send_self()), |
442 server_chat("Room configs loaded successfully.".to_string()).send_self(), |
|
443 ), |
|
444 Err(e) => { |
441 Err(e) => { |
445 warn!("Error while deserializing the room configs: {}", e); |
442 warn!("Error while deserializing the room configs: {}", e); |
446 response.add( |
443 response.warn(ROOM_CONFIG_DESERIALIZE_FAILED); |
447 Warning("Unable to deserialize the room configs.".to_string()) |
|
448 .send_self(), |
|
449 ); |
|
450 } |
444 } |
451 } |
445 } |
452 } |
446 } |
453 } |
447 } |
454 IoResult::LoadRoom(_, None) => { |
448 IoResult::LoadRoom(_, None) => { |
455 response.add(Warning("Unable to load the room configs.".to_string()).send_self()); |
449 response.warn(ROOM_CONFIG_LOAD_FAILED); |
456 } |
450 } |
457 } |
451 } |
458 } |
452 } |
459 |
453 |
460 #[cfg(test)] |
454 #[cfg(test)] |