private void HandleLobbyUpdate(CSODOTALobby lobby)
{
if (Lobby == null && lobby != null)
{
log.DebugFormat("Entered lobby {0} with state {1}.", lobby.lobby_id, lobby.state.ToString("G"));
}
else if (Lobby != null && lobby == null)
{
log.DebugFormat("Exited lobby {0}.", Lobby.lobby_id);
}
if (lobby != null)
{
_state.Fire(lobby.state == CSODOTALobby.State.UI || string.IsNullOrEmpty(lobby.connect)
? Trigger.DotaEnteredLobbyUI
: Trigger.DotaEnteredLobbyPlay);
}
else
{
_state.Fire(Trigger.DotaNoLobby);
}
LobbyUpdate?.Invoke(Lobby, lobby);
Lobby = lobby;
}
private void HandleLobbySnapshot(byte[] data)
{
using (var stream = new MemoryStream(data))
{
var lob = Serializer.Deserialize <CSODOTALobby>(stream);
CSODOTALobby oldLob = Lobby;
Lobby = lob;
Client.PostCallback(new PracticeLobbySnapshot(lob, oldLob));
}
UploadRichPresence();
}
/// <summary>
/// Parse the extra data on a lobby.
/// </summary>
/// <param name="lobby">Lobby containing extra messages.</param>
/// <returns></returns>
public static LobbyExtraData ParseExtraMessages(this CSODOTALobby lobby)
{
var extra = new LobbyExtraData();
foreach (var msg in lobby.extra_messages)
{
switch (msg.id)
{
case (uint)EDOTAGCMsg.k_EMsgGCLeagueAdminList:
extra.LeagueAdminList = msg.contents.DeserializeProtobuf <CMsgLeagueAdminList>();
break;
}
}
return(extra);
}
private void HandleLobbySnapshot(byte[] data, bool update = false)
{
using (var stream = new MemoryStream(data))
{
var lob = Serializer.Deserialize <CSODOTALobby>(stream);
CSODOTALobby oldLob = Lobby;
Lobby = lob;
if (update)
{
Client.PostCallback(new PracticeLobbyUpdate(lob, oldLob));
}
else
{
Client.PostCallback(new PracticeLobbySnapshot(lob));
}
}
}
private static void OnLobbyUpdate(CSODOTALobby lobby)
{
try {
if (!_hostingLobby)
{
_dotaClient.LeaveLobby();
return;
}
_lobbyMembersCount = lobby.members.Count;
if (!_lobbyShared)
{
_lobbyShared = true;
_lobbyId = lobby.lobby_id;
SendMessage(new Message()
{
Id = MessageIds.In.LOBBY_CREATED,
Payload = JsonConvert.SerializeObject(new LobbyCreated()
{
CustomMapName = _map.MapId,
SeverId = _game.ServerId,
LobbyId = _lobbyId
})
});
_dotaClient.JoinChat("Lobby_" + lobby.lobby_id, DOTAChatChannelType_t.DOTAChannelType_Lobby);
}
if (lobby.members.Count == _map.MaxPlayers)
{
_lobbyWasStarted = true;
}
else if (_lobbyWasStarted)
{
_lobbyWasStarted = false;
foreach (var playerId in _playersToKick)
{
try {
_logger.Info("Re-kicking player: " + playerId);
_dotaClient.KickLobbyMember(playerId);
} catch (Exception e) {
_logger.Error("Error while re-kicking player - Account ID: " + playerId, e);
}
}
}
lock (_lobbyMembers) { //Not sure if SteamKit is multithreaded under the hood and because of that hold a lock just in case
if (!_test)
{
if (_infoMessagesSent == 0 && lobby.members.Count >= _map.MaxPlayers / 2)
{
_infoMessagesSent++;
SendChatMessage(_game?.LobbyInfoMessage, true);
}
if (_infoMessagesSent == 2 && lobby.members.Count < _map.MaxPlayers)
{
_infoMessagesSent = 1;
}
if (_infoMessagesSent == 1 && lobby.members.Count == _map.MaxPlayers)
{
_infoMessagesSent++;
SendChatMessage(_game?.LobbyInfoMessage, true);
SendChatMessage(_game?.BotLeaveMessage, true);
}
}
foreach (var member in lobby.members)
{
var player = _lobbyMembers.Where(m => m.AccountId == member.id.ToString()).SingleOrDefault();
if (player == null)
{
_lobbyMembers.Add(new Player()
{
AccountId = member.id.ToString(),
Name = member.name,
Active = true
});
_logger.Info("Lobby joined (" + lobby.members.Count + "/" + _map.MaxPlayers + "): " + member.name);
}
else if (player.Active == false)
{
player.Active = true;
_logger.Info("Lobby re-joined (" + lobby.members.Count + "/" + _map.MaxPlayers + "): " + member.name);
if (player.Kicked)
{
var playerId = SteamHelper.ConvertIDToUint32(ulong.Parse(player.AccountId));
if (_lobbyMembersCount < _map.MaxPlayers)
{
_dotaClient.KickLobbyMember(playerId);
}
_playersToKick.Add(playerId);
}
}
}
var playerIds = lobby.members.Select(m => m.id.ToString());
var leftPlayers = _lobbyMembers.Where(m => !playerIds.Contains(m.AccountId) && m.Active == true);
foreach (var leftPlayer in leftPlayers)
{
leftPlayer.Active = false;
_playersToKick.Remove(SteamHelper.ConvertIDToUint32(ulong.Parse(leftPlayer.AccountId)));
_logger.Info("Lobby left (" + lobby.members.Count + "/" + _map.MaxPlayers + "): " + leftPlayer.Name);
}
if (_botUserId == 0 && lobby.members.Count > 0)
{
_botUserId = lobby.members.First().id;
}
}
} catch (Exception e) {
_logger.Error("Error occurred while processing lobby update", e);
}
}
private void FormMain_Load(object sender, EventArgs e)
{
var sdd = new CSODOTALobby();
}
private void OnMessage(SteamGameCoordinator.MessageCallback callback)
{
CSODOTALobby was = Client.Lobby;
Client.OnMessage(callback);
CSODOTALobby now = Client.Lobby;
if (callback.EMsg == (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome)
{
var pb = new ClientGCMsgProtobuf <CMsgClientWelcome>(callback.Message);
HandleWelcome(pb);
}
else if (callback.EMsg == (uint)EDOTAGCMsg.k_EMsgGCJoinChatChannelResponse)
{
Machine.Trigger(Event.JOINED_CHAT);
}
else if ((uint)EDOTAGCMsg.k_EMsgGCWatchGameResponse == callback.EMsg)
{
var pb = new ClientGCMsgProtobuf <CMsgWatchGameResponse>(callback.Message);
HandleWatchResponse(pb);
}
else if (was == null && now != null) // Probably due to Create
{
Machine.Trigger(Event.CREATED_LOBBY);
}
else if (was != null && now == null) // Probably due to CacheUnsubsribed.
{
Machine.Trigger(Event.LEFT_LOBBY);
}
else if (was != null && now != null)
{
if (was.members.Count < now.members.Count)
{
Machine.Trigger(Event.PLAYER_JOINED);
}
else if (was.members.Count > now.members.Count && now.members.Count == 1)
{
Machine.Trigger(Event.EMPTIED);
}
if (was.state != now.state)
{
if (now.state == CSODOTALobby.State.RUN)
{
Machine.Trigger(Event.SERVER_RUNNING);
}
}
if (was.game_state != now.game_state)
{
if (now.game_state == DOTA_GameState.DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD)
{
Machine.Trigger(Event.SERVER_WAITING_FOR_PLAYERS);
}
}
int valid = now.members.Count((member) =>
member.team == DOTA_GC_TEAM.DOTA_GC_TEAM_BAD_GUYS ||
member.team == DOTA_GC_TEAM.DOTA_GC_TEAM_GOOD_GUYS);
if (valid >= 2)
{
Machine.Trigger(Event.LOBBY_READY);
}
else
{
Machine.Trigger(Event.LOBBY_NOT_READY);
}
}
}
/// <summary>
/// Connect to the game server. Will use existing lobby on default.
/// </summary>
/// <param name="lobb"></param>
public void Connect(CSODOTALobby lobb = null)
{
if (_connectDetails != null)
{
Disconnect();
}
lobb = lobb ?? DotaGc.Lobby;
if (lobb == null)
{
Log("No lobby so not connecting.");
return;
}
_connectLobby = lobb;
if (_appOwnershipTicket == null)
{
Log("Waiting for ownership ticket...");
_waitingForAuthTicket = true;
FetchAppTicket();
return;
}
_authTicket = AuthTicket.CreateAuthTicket(_gameConnectTokens.Dequeue(), publicIP);
var ver = new CMsgAuthTicket
{
gameid = (uint)DotaGc.GameID,
h_steam_pipe = 327684,
ticket = _authTicket
};
using (var stream = Bitstream.CreateWith(_authTicket))
ver.ticket_crc = CrcUtils.Compute32(stream);
_connectDetails = new DOTAConnectDetails
{
AuthTicket = _authTicket,
ServerAuthTicket = AuthTicket.CreateServerTicket(DotaGc.SteamClient.SteamID, _authTicket, _appOwnershipTicket),
ConnectInfo = lobb.connect,
ConnectID = _connectAttempt++,
AuthTicketCRC = ver.ticket_crc,
Name = DotaGc.SteamClient.GetHandler <SteamFriends>().GetPersonaName(),
PassKey = lobb.pass_key,
SteamId = DotaGc.SteamClient.SteamID.ConvertToUInt64()
};
var msg = new ClientMsgProtobuf <CMsgClientAuthList>(EMsg.ClientAuthList)
{
Body =
{
tokens_left = (uint)_gameConnectTokens.Count,
app_ids = { (uint)DotaGc.GameID },
tickets = { ver },
message_sequence = 2 // Second in sequence.
}
};
DotaGc.SteamClient.Send(msg);
Log("Sent crc ticket auth list, hash: " + ver.ticket_crc + ".");
}
internal PracticeLobbySnapshot(CSODOTALobby msg, CSODOTALobby oldLob)
{
lobby = msg;
oldLobby = oldLob;
}
internal PracticeLobbyUpdate(CSODOTALobby msg, CSODOTALobby oldLob)
{
lobby = msg;
oldLobby = oldLob;
}
internal PracticeLobbySnapshot(CSODOTALobby msg)
{
lobby = msg;
}
