/// <summary>
/// Called when the local player joins the lobby.
/// </summary>
/// <param name="connection"></param>
private void OnLobbyLocalPeerConnected(SteamConnection connection)
{
network.LocalConnection = connection;
network.MaxPlayers = SteamMatchmaking.GetLobbyMemberLimit(connection.LobbyID);
network.OnSetDefaultLobbyMemberData(connection);
// Get Lobby Member Data
int numMembers = SteamMatchmaking.GetNumLobbyMembers(connection.LobbyID);
for (int i = 0; i < numMembers; i++)
{
CSteamID id = SteamMatchmaking.GetLobbyMemberByIndex(connection.LobbyID, i);
if (id == connection.SteamID)
{
continue;
}
connection.AddConnection(id);
}
//GetModule<AuthModule>().BeginAuthentication(authenticationLevel);
if (connection.IsHost)
{
HostSetup?.Invoke(connection);
}
else
{
ClientSetup?.Invoke(connection);
}
connection.IsConnected = true;
}
void SpawnPlayer(NetworkConnection conn)
{
Debug.Log("trying to add player");
GameObject player = (GameObject)Instantiate(playerPrefab, new Vector3(0f, 1.001f, 0f), Quaternion.identity);
NetworkServer.AddPlayerForConnection(conn, player);
Debug.Log("player spawned");
int highestId = 0;
foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Player"))
{
if (obj.GetComponent <BasePlayer> ().id > highestId)
{
highestId = obj.GetComponent <BasePlayer> ().id;
}
}
player.GetComponent <BasePlayer> ().id = highestId + 1;
//Steam id of person who just joined
CSteamID steamId = SteamMatchmaking.GetLobbyMemberByIndex(SteamLobby.lobbyId, numPlayers - 1);
//Get Component of that player
var playerInfo = conn.identity.GetComponent <PlayerInfo> ();
//Set the steam id ulong
playerInfo.SetSteamId(steamId.m_SteamID);
}
bool ExpectingClient(CSteamID id)
{
if (Config == null || currentLobbyId == CSteamID.Nil)
{
return(false);
}
if (Config.Type == NetworkInterfaceType.Client)
{
// Only allow the lobby owner (the host/server) to connect to you if you are a client
return(lobbyOwner == id);
}
else
{
// Allow any user in the lobby to connect to the server
var playerCount = SteamMatchmaking.GetNumLobbyMembers(currentLobbyId);
for (var i = 0; i < playerCount; i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(currentLobbyId, i) == id)
{
return(true);
}
}
return(false);
}
}
// Update is called once per frame
void OnGUI()
{
SteamAPI.RunCallbacks();
if (GUI.Button(new Rect(120, 20, 140, 20), "Create Lobby"))
{
print("Create lobby");
SteamAPICall_t host = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 4);
}
if (GUI.Button(new Rect(120, 20, 280, 20), "lobbies list"))
{
print("list lobbies");
SteamAPICall_t getList = SteamMatchmaking.RequestLobbyList();
}
if (GUI.Button(new Rect(120, 20, 420, 20), "change first lobby"))
{
print("change first lobby");
SteamAPICall_t joinLobby = SteamMatchmaking.JoinLobby(SteamMatchmaking.GetLobbyByIndex(0));
}
if (GUI.Button(new Rect(120, 20, 560, 20), "Num Players"))
{
int numPlayers = SteamMatchmaking.GetNumLobbyMembers((CSteamID)currentID);
print("Number of players" + numPlayers);
for (int i = 0; i < numPlayers; i++)
{
print("\t Player(" + i + ")==" + SteamFriends.GetFriendPersonaName(SteamMatchmaking.GetLobbyMemberByIndex((CSteamID)currentID, i)));
}
}
}
// Event Handlers
void OnP2PSessionRequest(P2PSessionRequest_t evt)
{
var myId = SteamUser.GetSteamID();
var remoteId = evt.m_steamIDRemote;
foreach (var lobbyId in _connectedLobbies.Keys)
{
var count = SteamMatchmaking.GetNumLobbyMembers(lobbyId);
bool hasMe = false;
bool hasRemote = false;
for (var i = 0; i < count; i++)
{
var memberId = SteamMatchmaking.GetLobbyMemberByIndex(lobbyId, i);
hasMe |= memberId == myId;
hasRemote |= memberId == remoteId;
}
if (hasMe && hasRemote)
{
Assert.IsTrue(SteamNetworking.AcceptP2PSessionWithUser(remoteId));
Debug.Log($"[Steam] Established connection with {remoteId}");
return;
}
}
// Did not find a matching lobby close the session.
Debug.LogError($"[Steam] Unexpected connection with {remoteId}");
Assert.IsTrue(SteamNetworking.CloseP2PSessionWithUser(remoteId));
}
public void LobbyEntered(LobbyEnter_t enterLobby)
{
connectedPlayers.Clear();
otherPlayers.Clear();
lobbyID = (CSteamID)enterLobby.m_ulSteamIDLobby;
int playerCount = SteamMatchmaking.GetNumLobbyMembers(lobbyID);
MultiplayerChat.chatStrings.Add("Entered Lobby!");
//Send packets to all players, to establish P2P connections with them
if (playerCount > 1)
{
for (int i = 0; i < playerCount; i++)
{
CSteamID lobbyMember = SteamMatchmaking.GetLobbyMemberByIndex(lobbyID, i);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 0);
connectedPlayers.Add(lobbyMember.m_SteamID);
if (lobbyMember != SteamUser.GetSteamID())
{
otherPlayers.Add(lobbyMember.m_SteamID);
}
}
}
//Set up network data
NetworkGameManager.managerID = ulong.Parse(SteamMatchmaking.GetLobbyData(lobbyID, MANAGER_ID));
NetworkGameManager.playerID = SteamUser.GetSteamID().m_SteamID;
connectedPlayers.Add(SteamUser.GetSteamID().m_SteamID);
MultiplayerChat.chatStrings.Add("This game's manager is " + SteamFriends.GetFriendPersonaName((CSteamID)NetworkGameManager.managerID));
isInGame = true;
}
void InitLobby(CSteamID id)
{
lobby.LobbyID = id;
if (Users == null)
{
lobby.Users = new List <User>();
}
else
{
Users.Clear();
}
int num = SteamMatchmaking.GetNumLobbyMembers(lobby.LobbyID);
for (int i = 0; i < num; i++)
{
CSteamID userID = SteamMatchmaking.GetLobbyMemberByIndex(lobby.LobbyID, i);
lobby.Users.Add(new User(userID));
}
SendPacketToLobby(new byte[] { }, PacketType.Test, EP2PSend.k_EP2PSendReliable, false);
#if UNITY_EDITOR
Debug.Log("Num members in the lobby: " + num);
Debug.Log("My steam ID: " + MyID.ToString());
#endif
if (OnLobbyInitializationEvent != null)
{
OnLobbyInitializationEvent.Invoke();
}
}
void SetBasic()
{
int Mcount = SteamMatchmaking.GetNumLobbyMembers(Sender.roomid);
ULS.CreateDs(Mcount);
for (int i = 0; i < Mcount; i++)
{
ULS.UDs[i].GetComponent <UserDetailScript>().HomeWork(SteamMatchmaking.GetLobbyMemberByIndex(Sender.roomid, i));
}
PlayersJoined.text = Mcount + " players joined";
Roomname.text = SteamMatchmaking.GetLobbyData(Sender.roomid, "name");
if (SteamMatchmaking.GetLobbyOwner(Sender.roomid) == SteamUser.GetSteamID())
{
MPanel.SetActive(true);
}
else
{
MPanel.SetActive(false);
}
DataShowScript[] dss = GetComponentsInChildren <DataShowScript>(DPanel);
foreach (DataShowScript d in dss)
{
d.GetMyData();
}
//if (Mcount == 2) GameStart();
}
void InitLobby(CSteamID id)
{
lobby.LobbyID = id;
if (Users == null)
{
lobby.Users = new List <User>();
}
else
{
Users.Clear();
}
int num = SteamMatchmaking.GetNumLobbyMembers(lobby.LobbyID);
for (int i = 0; i < num; i++)
{
CSteamID userID = SteamMatchmaking.GetLobbyMemberByIndex(lobby.LobbyID, i);
lobby.Users.Add(new User(userID));
}
SendPacketToLobby(emptyArray, 0, 0, PacketType.Test, EP2PSend.k_EP2PSendReliable, false);
if (OnLobbyInitializationEvent)
{
OnLobbyInitializationEvent.Raise();
}
}
void GameStart(int r)
{
//NetWriter.rs = r;
//准备SkillCode交错数组
Readytoggle.interactable = false;
SenderSC.PrepareTemp(r, (int)SkillCode.SelfExplodeScript);
//设置clientNum
CSteamID tid;
Sender.TOmb = new CSteamID[r];
for (int i = 0; i < r; i++)
{
tid = SteamMatchmaking.GetLobbyMemberByIndex(Sender.roomid, i);
Sender.TOmb[i] = tid;
if (tid == SteamUser.GetSteamID())
{
Sender.clientNum = i;
}
}
SenderPanel.SetActive(true);
CVS2.SetActive(true);
SenderSC.SendHello(3);
if (SteamMatchmaking.GetLobbyOwner(Sender.roomid) == SteamUser.GetSteamID())
{
Startbutton.gameObject.SetActive(true);
}
}
void OnLobbyEnter(LobbyEnter_t cb)
{
INetworkIdentity id = GameObject.Instantiate(voiceUserPrefab.gameObject).GetComponent <INetworkIdentity>();
id.IsLocalPlayer = true;
id.NetworkId = self.m_SteamID;
if ((EChatRoomEnterResponse)cb.m_EChatRoomEnterResponse == EChatRoomEnterResponse.k_EChatRoomEnterResponseSuccess)
{
CSteamID lobbyId = new CSteamID(cb.m_ulSteamIDLobby);
int n = SteamMatchmaking.GetNumLobbyMembers(lobbyId);
for (int i = 0; i < n; i++)
{
CSteamID client = SteamMatchmaking.GetLobbyMemberByIndex(lobbyId, i);
if (client.m_SteamID != self.m_SteamID)
{
others.Add(client.m_SteamID, client);
id = GameObject.Instantiate(voiceUserPrefab.gameObject).GetComponent <INetworkIdentity>();
id.IsLocalPlayer = false;
id.NetworkId = client.m_SteamID;
}
}
}
}
public void LobbyEntered(LobbyEnter_t enterLobby)
{
connectedPlayers.Clear();
otherPlayers.Clear();
ResetManagers();
{
if (!(RainWorldHK.mainRW.processManager.currentMainLoop is SteamMultiplayerMenu))
{
ProcessManagerHK.ImmediateSwitchCustom(RainWorldHK.mainRW.processManager, new SteamMultiplayerMenu(RainWorldHK.mainRW.processManager));
}
}
joining = false;
lobbyID = (CSteamID)enterLobby.m_ulSteamIDLobby;
int playerCount = SteamMatchmaking.GetNumLobbyMembers((CSteamID)enterLobby.m_ulSteamIDLobby);
MultiplayerChat.AddChat("Entered Lobby!");
//Send packets to all players, to establish P2P connections with them
if (playerCount > 1)
{
for (int i = 0; i < playerCount; i++)
{
CSteamID lobbyMember = SteamMatchmaking.GetLobbyMemberByIndex(lobbyID, i);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 0);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 1);
SteamNetworking.SendP2PPacket(lobbyMember, new byte[] { 255 }, 1, EP2PSend.k_EP2PSendReliable, 2);
if (!connectedPlayers.Contains(lobbyMember.m_SteamID))
{
connectedPlayers.Add(lobbyMember.m_SteamID);
PlayerJoinedManagers(lobbyMember.m_SteamID);
}
if (lobbyMember != SteamUser.GetSteamID())
{
otherPlayers.Add(lobbyMember.m_SteamID);
}
}
}
//Set up network data
NetworkGameManager.managerID = ulong.Parse(SteamMatchmaking.GetLobbyData(lobbyID, MANAGER_ID));
NetworkGameManager.playerID = SteamUser.GetSteamID().m_SteamID;
if (NetworkGameManager.managerID != NetworkGameManager.playerID)
{
lobbyInfo = new LobbyInfo((CSteamID)enterLobby.m_ulSteamIDLobby);
lobbyInfo.UpdateLobbyInfo((CSteamID)enterLobby.m_ulSteamIDLobby);
lobbyInfo.owner = new CSteamID(NetworkGameManager.managerID);
}
if (!connectedPlayers.Contains(SteamUser.GetSteamID().m_SteamID))
{
connectedPlayers.Add(SteamUser.GetSteamID().m_SteamID);
PlayerJoinedManagers(SteamUser.GetSteamID().m_SteamID);
}
MultiplayerChat.AddChat("This game's manager is " + SteamFriends.GetFriendPersonaName((CSteamID)NetworkGameManager.managerID));
isInGame = true;
Log("Entered Lobby! \nThis game's manager is " + SteamFriends.GetFriendPersonaName((CSteamID)NetworkGameManager.managerID));
}
public static void CreateConnections(CSteamID lobby)
{
for (var i = 0; i < SteamMatchmaking.GetNumLobbyMembers(lobby); i++)
{
PlayerList.Add(SteamMatchmaking.GetLobbyMemberByIndex(lobby, i));
CreateConnection(PlayerList[PlayerList.Count - 1]);
}
}
void update_lobby_labels()
{
for (int i = 0; i < players_in_lobby; i++)
{
CSteamID tmpID = SteamMatchmaking.GetLobbyMemberByIndex(lobbyID, i);
player_labels[i].text = SteamFriends.GetFriendPersonaName(tmpID);
}
}
public IEnumerable <string> GetMembersData(string key)
{
for (int i = 0; i < this.MemberCount; i++)
{
CSteamID j = SteamMatchmaking.GetLobbyMemberByIndex(this.Info.LobbyId, i);
yield return(SteamMatchmaking.GetLobbyMemberData(this.Info.LobbyId, j, key));
}
yield break;
}
public unsafe static User GetLobbyMemberAtIndex(Lobby which, int member)
{
if (!_initialized)
{
return(null);
}
return(which != null && member < GetNumLobbyMembers(which) ? null :
User.GetUser(SteamMatchmaking.GetLobbyMemberByIndex(new CSteamID(which.id), member)));
}
public override void OnServerAddPlayer(NetworkConnection conn)
{
base.OnServerAddPlayer(conn);
CSteamID steamId = SteamMatchmaking.GetLobbyMemberByIndex(SteamLobby.LobbyId, numPlayers - 1);
var player = conn.identity.GetComponent <Player>();
player.SetSteamId(steamId.m_SteamID);
}
public void UpdateLobbyInformation()
{
RemoteUsers.Clear();
var num = SteamMatchmaking.GetNumLobbyMembers(Lobby);
for (var i = 0; i < num; i++)
{
var id = SteamMatchmaking.GetLobbyMemberByIndex(Lobby, i);
RemoteUsers.Add(id);
}
}
bool LobbyHasUser()
{
for (int i = 0; i < SteamMatchmaking.GetNumLobbyMembers(Listener.CLobbyID); i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(Listener.CLobbyID, i).m_SteamID == RemoteID.m_SteamID)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Generates string message with premade team members' IDs to be posted in game lobby.
/// Necessary for host to process premade teams
/// </summary>
public string GeneratePremadeMessage()
{
string msg = "";
for (int i = 0; i < SteamMatchmaking.GetNumLobbyMembers(teambuilderLobbyId); i++)
{
msg += SteamMatchmaking.GetLobbyMemberByIndex(teambuilderLobbyId, i).m_SteamID.ToString();
msg += ".";
}
return(msg);
}
private static void OnLobbyChatUpdate(LobbyChatUpdate_t result)
{
Console.WriteLine("Lobby chat update");
int lobbyMemberCount = SteamMatchmaking.GetNumLobbyMembers(new CSteamID(LobbyId));
PlayerList.Clear();
_playerNames.Clear();
for (int i = 0; i < lobbyMemberCount; i++)
{
PlayerList.Add(SteamMatchmaking.GetLobbyMemberByIndex(new CSteamID(LobbyId), i));
_playerNames.Add(SteamFriends.GetFriendPersonaName(PlayerList[i]));
}
}
public static void SendToAllInLobby(byte[] bytes)
{
int numMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyInfo.LobbyID);
for (int i = 0; i < numMembers; i++)
{
CSteamID member = SteamMatchmaking.GetLobbyMemberByIndex(_lobbyInfo.LobbyID, i);
if (member.m_SteamID != SteamAPI.GetUserID())
{
SteamNetworking.SendP2PPacket(member, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable);
}
}
}
public static String GetMemberName(int Index)
{
if (SteamCore.InOfflineMode())
{
return("Local player");
}
//REMOVE//if ( s_CurrentLobby.m_handle == null ) return "";
CSteamID steamIDLobbyMember = (CSteamID)SteamMatchmaking.GetLobbyMemberByIndex(s_CurrentLobby.m_handle, Index);
return(SteamFriends.GetFriendPersonaName(steamIDLobbyMember));
}
public static UInt64 GetMemberId(int Index)
{
if (SteamCore.InOfflineMode())
{
return(SteamCore.PlayerId());
}
//REMOVE//if ( s_CurrentLobby.m_handle == null ) return 0;
CSteamID steamIDLobbyMember = (CSteamID)SteamMatchmaking.GetLobbyMemberByIndex(s_CurrentLobby.m_handle, Index);
return((UInt64)steamIDLobbyMember);
}
/// <summary>
/// Loads the lobby and its related data
/// </summary>
/// <param name="lobbyId">The lobby to load data for</param>
/// <remarks>
/// <see cref="SteamLobby"/> should only be initalized for a lobby that the user is a member of e.g. on create or join of a lobby.
/// Constructing a <see cref="SteamLobby"/> for a lobby you are not a member of will cause some data to be missing due to security on Valve's side.
/// </remarks>
public SteamLobby(CSteamID lobbyId)
{
id = lobbyId;
var memberCount = SteamMatchmaking.GetNumLobbyMembers(id);
for (int i = 0; i < memberCount; i++)
{
var memberId = SteamMatchmaking.GetLobbyMemberByIndex(id, i);
members.Add(new SteamworksLobbyMember(id, memberId));
}
previousOwner = Owner;
}
public virtual bool ShouldAcceptSteamId(CSteamID id)
{
int count = SteamMatchmaking.GetNumLobbyMembers(steamLobbyId);
for (int i = 0; i < count; i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(steamLobbyId, i) == id)
{
return(true);
}
}
return(false);
}
private bool IsMemberInSteamLobby(CSteamID steamUser)
{
if (SteamManager.Initialized)
{
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(this.m_LobbyId);
for (int i = 0; i < numLobbyMembers; i++)
{
if (SteamMatchmaking.GetLobbyMemberByIndex(this.m_LobbyId, i).m_SteamID == steamUser.m_SteamID)
{
return(true);
}
}
}
return(false);
}
void CloseAllConnections()
{
if (currentLobbyId == CSteamID.Nil)
{
return;
}
SteamMatchmaking.LeaveLobby(currentLobbyId);
var playerCount = SteamMatchmaking.GetNumLobbyMembers(currentLobbyId);
for (var i = 0; i < playerCount; i++)
{
var id = SteamMatchmaking.GetLobbyMemberByIndex(currentLobbyId, i);
SteamNetworking.CloseP2PSessionWithUser(id);
}
Debug.Log($"[Steam] Left lobby {currentLobbyId}");
currentLobbyId = CSteamID.Nil;
}
void OnLobbyEntered(LobbyEnter_t result)
{
if (current_lobbyID == result.m_ulSteamIDLobby)
{
return;
}
current_lobbyID = result.m_ulSteamIDLobby;
if (result.m_EChatRoomEnterResponse == 1)
{
if (SteamMatchmaking.GetLobbyData((CSteamID)current_lobbyID, "status") != "open" || SteamMatchmaking.GetNumLobbyMembers((CSteamID)current_lobbyID) > 2)
{
SetText("joinfail");
initializedStatus = -2;
SteamMatchmaking.LeaveLobby((CSteamID)current_lobbyID);
return;
}
otherUsr = SteamMatchmaking.GetLobbyMemberByIndex((CSteamID)current_lobbyID, 0);
if ((CSteamID)otherUsr == SteamUser.GetSteamID())
{
Debug.Log("F**K!");
return;
}
initializedStatus = 5;
SetUpReadyButtons();
lastTimeMessageReceived = Time.time;
//Debug.Log ("OTHERUSR: "******"player", ((int)PD.p1Char).ToString());
int score = 0;
SteamUserStats.GetUserStat(otherUsr, "GAMESCORE", out score);
if (player2Rank == null)
{
FontData f = PD.mostCommonFont.Clone(); f.color = Color.white;
player2Rank = GetMeshText(new Vector3(0.745f, 1.8f), SteamFriends.GetFriendPersonaName(otherUsr), f);
SteamUserStats.RequestUserStats(otherUsr);
}
parent.ForcePlayer2(int.Parse(SteamMatchmaking.GetLobbyData((CSteamID)current_lobbyID, "playerone")));
myMesh.gameObject.SetActive(false);
}
else
{
SetText("joinfail");
initializedStatus = -2;
current_lobbyID = 0;
}
}
public bool IsMemberInSteamLobby(CSteamID steamUser)
{
if (SteamManager.Initialized)
{
int numMembers = SteamMatchmaking.GetNumLobbyMembers(steamLobbyId);
for (int i = 0; i < numMembers; i++)
{
var member = SteamMatchmaking.GetLobbyMemberByIndex(steamLobbyId, i);
if (member.m_SteamID == steamUser.m_SteamID)
{
return(true);
}
}
}
return(false);
}
