bioslobbyservice.c

Go to the documentation of this file.

// ip, name, connection port, queryPort
typedef Param4<string, string, int, int> CachedServerInfo;
 
// Script File
 
enum ESortType
{
 HOST, 
 TIME,
 POPULATION,
 SLOTS,
 PING
 FAVORITE,
 PASSWORDED,
 QUEUE
};
 
enum ESortOrder
{
 ASCENDING, 
 DESCENDING,
};
 
class GetServerModListResult
{
 string m_Id; // server id (IP:Port)
 array<string> m_Mods;
}
 
class GetServersResultRow
{
 string m_Id; // PC is IP:Port
 int m_Priority; // PC something is working -> 667223046
 string m_Name; // PC is name of server
 string m_Description; // PC not work
 string m_HostIp; // PC not work
 int m_HostPort; // PC is works
 bool m_Invisible;
 bool m_Official;
 string m_MapNameToRun; // PC not work always 0
 bool m_Modded; // PC not work always 0
 int m_ModeId; // identifies if third person is allowed on a CONSOLE server. On PC always 0
 bool m_AntiCheat;
 int m_RegionId; // PC not work always 0
 int m_MinPlayers;
 int m_MaxPlayers; // PC - max players
 int m_FreeSlots; // PC - max players
 int m_CurrentNumberPlayers;
 int m_PlayersInQueue;
 string m_GameVersion; // PC not work alway ""
 bool m_IsPasswordProtected; // PC work
 string m_CreatedAt;
 string m_UpdatedAt;
 bool m_MouseAndKeyboardEnabled;
 bool m_WhitelistEnabled;
 bool m_IsDLC;
 
 //Scripted
 bool m_IsExpanded;
 int m_SortName; 
 int m_SortTime;
 bool m_IsSelected;
 
 //characters alive
 string m_CharactersAlive;
 //steam friends - list of names separated by comma
 string m_SteamFriends;
 
 int m_Ping; 
 string m_TimeOfDay;
 int m_Disable3rdPerson; //1 for disabled, ie. hardcore
 float m_EnvironmentTimeMul;
 float m_EnvironmentNightTimeMul;
 bool m_AllowedFilePatching;
 string m_ShardId;
 int m_SteamQueryPort;
 
 bool m_Favorite;
 
 string GetIpPort()
 {
#ifdef PLATFORM_WINDOWS
 return m_Id;
#else
 return GetIP() + ":" + m_HostPort;
#endif
 }
 
 string GetIP()
 {
#ifdef PLATFORM_WINDOWS
 // Hack - In new Serverborwser on PC has bad m_HostIp but ID contains correct IP
 array<string> parts = new array<string>;
 m_Id.Split(":", parts);
 return parts[0];
#else
 return m_HostIp;
#endif
 }
 
 bool IsSelected()
 {
 return m_IsSelected;
 }
 
 string GetValueStr(ESortType sort_type)
 {
 switch( sort_type )
 {
 case ESortType.HOST:
 {
 return m_Name;
 }
 }
 
 return "";
 } 
 
 int GetValueInt(ESortType sort_type)
 {
 switch( sort_type )
 {
 case ESortType.TIME:
 {
 return m_SortTime;
 }
 case ESortType.POPULATION:
 {
 return m_CurrentNumberPlayers;
 }
 case ESortType.SLOTS:
 {
 return m_MaxPlayers;
 }
 case ESortType.PING:
 {
 return m_Ping;
 }
 case ESortType.QUEUE:
 {
 return m_PlayersInQueue;
 }
 } 
 return 0;
 }
 
 // Returns 0 if values are equal, 
 // a positive number if this entry is "greater than" other,
 // and a negative number if this entry is "less than" other 
 int CompareTo(GetServersResultRow other, ESortType sortType)
 { 
 // string comparison
 if (sortType == ESortType.HOST)
 {
 string val1 = this.GetValueStr(ESortType.HOST);
 string val2 = other.GetValueStr(ESortType.HOST);
 
 if (val1 == val2)
 return 0;
 
 if (val1 < val2)
 return 1;
 
 return -1;
 }
 
 // int comparison
 int comparisonResult = other.GetValueInt(sortType) - this.GetValueInt(sortType);
 if (comparisonResult == 0)
 {
 // if sorting by POPULATION, break ties using QUEUE size
 if (sortType == ESortType.POPULATION)
 {
 comparisonResult = this.CompareTo(other, ESortType.QUEUE); 
 }
 }
 
 return comparisonResult;
 }
};
 
 
typedef array<ref GetServersResultRow> GetServersResultRowArray;
 
class GetFirstServerWithEmptySlotResult
{
 GetServersResult m_Result;
};
 
class GetFirstServerWithEmptySlotInput
{
 bool m_Official;
 string m_GameVersion;
 int m_RegionId;
 
 bool m_UseOfficial;
 bool m_UseGameVersion;
 bool m_UseRegionId;
 
 void SetOfficial( bool Official )
 {
 m_Official = Official;
 m_UseOfficial = true;
 }
 
 void SetGameVersion( string GameVersion )
 {
 m_GameVersion = GameVersion;
 m_UseGameVersion = true;
 }
 
 void SetRegionId( int RegionId )
 {
 m_RegionId = RegionId;
 m_UseRegionId = true;
 }
};
 
class GetServersResult
{
 int m_Page;
 int m_Pages;
 ref GetServersResultRowArray m_Results;
 
 int m_NumServers;
};
 
class GetServersInput
{
 bool m_AntiCheat;
 int m_RowsPerPage;
 string m_SortBy; //na of property
 ESortOrder m_SortOrder;
 string m_Name;
 string m_GameType;
 int m_Platform; // 1 - PC, 2 - xbox, 3 - PSN
 int m_ModeId; // identifies if third person is allowed on a CONSOLE server. On PC always 0
 int m_Page;
 string m_GameVersion;
 bool m_Official;
 bool m_Joinable;
 string m_MapNameToRun;
 bool m_IsModded;
 int m_MinPlayers; // minimum 1
 int m_MaxPlayers; // maximum 99
 bool m_IsPasswordProtected;
 int m_RegionId; // 1 - Americas, 2 - Europe, 3 - Asia
 int m_Priority;
 int m_FreeSlotsMin;
 int m_FreeSlotsMax;
 string m_HostIp;
 int m_HostPort;
 string m_FavoriteServers;
 bool m_MouseAndKeyboardEnabled;
 bool m_WhitelistEnabled;
 bool m_IsDLC;
 
 bool m_UseAntiCheat;
 bool m_UseName;
 bool m_UseGameType;
 bool m_UseModeId;
 bool m_UseGameVersion;
 bool m_UseOfficial;
 bool m_UseJoinable;
 bool m_UseMapNameToRun;
 bool m_UseIsModded;
 bool m_UseMinPlayers; 
 bool m_UseMaxPlayers; 
 bool m_UseIsPasswordProtected;
 bool m_UseRegionId; 
 bool m_UsePriority;
 bool m_UseFreeSlotsMin;
 bool m_UseFreeSlotsMax;
 bool m_UseHostIp;
 bool m_UseHostPort;
 bool m_UseHostIps;
 bool m_UseMouseAndKeyboardEnabled;
 bool m_UseWhitelistEnabled;
 bool m_UseIsDLC;
 
 void SetAntiCheatFilter( bool anti_cheat )
 {
 m_AntiCheat = anti_cheat;
 m_UseAntiCheat = true;
 }
 
 void SetNameFilter( string name )
 {
 m_Name = name;
 m_UseName = true;
 }
 
 void SetGameTypeFilter( string game_type )
 {
 m_GameType = game_type;
 m_UseGameType = true;
 }
 
 void SetModeIdFilter( int mode_id )
 {
 m_ModeId = mode_id;
 m_UseModeId = true;
 }
 
 void SetGameVersionFilter( string game_version )
 {
 m_GameVersion = game_version;
 m_UseGameVersion = true;
 }
 
 void SetOfficialFilter( bool official )
 {
 m_Official = official;
 m_UseOfficial = true;
 }
 
 void SetJoinableFilter( bool joinable )
 {
 m_Joinable = joinable;
 m_UseJoinable = true;
 }
 
 void SetMapNameToRun( string mapNameToRun )
 {
 m_MapNameToRun = mapNameToRun;
 m_UseMapNameToRun = true;
 }
 
 void SetIsModdedFilter( bool is_modded )
 {
 m_IsModded = is_modded;
 m_UseIsModded = true;
 }
 
 void SetMinPlayersFilter( int min_players )
 {
 m_MinPlayers = min_players;
 m_UseMinPlayers = true;
 }
 
 void SetMaxPlayersFilter( int max_players )
 {
 m_MaxPlayers = max_players;
 m_UseMaxPlayers = true;
 }
 
 void SetIsPasswordProtectedFilter( bool password_protected )
 {
 m_IsPasswordProtected = password_protected;
 m_UseIsPasswordProtected = true;
 }
 
 void SetRegionIdFilter( int region )
 {
 m_RegionId = region;
 m_UseRegionId = true;
 }
 
 void SetPriorityFilter( int priority )
 {
 m_Priority = priority;
 m_UsePriority = true;
 }
 
 void SetFreeSlotsMin( int freeSlotsMin )
 {
 m_FreeSlotsMin = freeSlotsMin;
 m_UseFreeSlotsMin = true;
 }
 
 void SetFreeSlotsMax( int freeSlotsMax )
 {
 m_FreeSlotsMax = freeSlotsMax;
 m_UseFreeSlotsMax = true;
 }
 
 void SetHostIp( string hostIp )
 {
 m_HostIp = hostIp;
 m_UseHostIp = true;
 }
 
 void SetHostPort( int hostPort )
 {
 m_HostPort = hostPort;
 m_UseHostPort = true;
 }
 
 void SetMouseAndKeyboardEnabled(bool enabledMouseAndKeyboard)
 {
 m_MouseAndKeyboardEnabled = enabledMouseAndKeyboard;
 m_UseMouseAndKeyboardEnabled = true;
 }
 
 void SetFavorited( bool show )
 {
 m_SortBy += "F";
 AddShow( show );
 
 }
 
 void SetFriendsPlaying( bool show )
 {
 m_SortBy += "P";
 AddShow( show );
 }
 
 void SetPreviouslyPlayed( bool show )
 {
 m_SortBy += "R";
 AddShow( show );
 }
 
 void SetProperVersionMatch( bool show )
 {
 m_SortBy += "V";
 AddShow( show );
 }
 
 void SetFullServer( bool show )
 {
 m_SortBy += "S";
 AddShow( show );
 }
 
 void SetThirdPerson( bool show )
 {
 m_SortBy += "3";
 AddShow( show );
 }
 
 void SetPublic( bool show )
 {
 m_SortBy += "L";
 AddShow( show );
 }
 
 void SetAcceleratedTime( bool show )
 {
 m_SortBy += "A";
 AddShow( show );
 }
 
 void SetAllowedFilePatching( bool show )
 {
 m_SortBy += "7";
 AddShow( show );
 }
 
 void SetLAN()
 {
 m_SortBy += "N";
 }
 
 void SetPingFilter( int pingMaxValue )
 {
 m_SortBy += "M" + pingMaxValue + ";";
 }
 
 void SetBattleyeProtection(bool show)
 {
 m_SortBy += "B";
 AddShow(show);
 }
 
 void SetPassworded(bool show)
 {
 m_SortBy += "C";
 AddShow(show);
 }
 
 void AddShow( bool show )
 {
 if( show )
 m_SortBy += "+";
 else
 m_SortBy += "-";
 }
 
 void AddFavourite(string ip, int port)
 {
 m_FavoriteServers += ip + ";" + port + ";";
 }
 
 void SetWhitelistEnabled(bool whitelistEnabled)
 {
 m_WhitelistEnabled = whitelistEnabled;
 m_UseWhitelistEnabled = true;
 
 m_SortBy += "W";
 AddShow(whitelistEnabled);
 }
 
 void SetIsDLC(bool isDLC)
 {
 m_IsDLC = isDLC;
 m_UseIsDLC = true;
 
 m_SortBy += "D";
 AddShow(isDLC);
 }
};
 
class BiosLobbyService
{
 
 proto native EBiosError GetServers(GetServersInput inputValues);
 
 
 proto native EBiosError GetFirstServerWithEmptySlot(GetFirstServerWithEmptySlotInput inputValues);
 
 proto native void AddServerFavorite(string ipAddress, int port, int steamQueryPort);
 proto native void RemoveServerFavorite(string ipAddress, int port, int steamQueryPort);
 proto native void GetFavoriteServers(TStringArray favServers);
 
 
 proto native void GetCachedFavoriteServerInfo(array<ref CachedServerInfo> favServersInfoCache);
 
 proto native EBiosError GetServerModList(string serverId);
 
 
 void OnDoneAsync(GetServersResult result_list, EBiosError error, string response)
 {
 /*
 if (result_list.m_Results != null && result_list.m_Results.Count() > 0)
 Print(result_list.m_Results[0].m_TimeOfDay);
 */
 OnlineServices.OnLoadServersAsync( result_list, error, response );
 }
 
 void OnGetFirstServerWithEmptySlot(GetFirstServerWithEmptySlotResult result_list, EBiosError error)
 {
 OnlineServices.OnAutoConnectToEmptyServer( result_list, error );
 }
 
 void OnServerModList(GetServerModListResult result_list, EBiosError error)
 {
 OnlineServices.OnGetServerModList( result_list, error );
 }
};