public override void OnPhotonPlayerConnected(PhotonPlayer newPlayer)
{
List <PlayerEntry> inactive = playerEntries.Where(p => !p.gameObject.activeInHierarchy).ToList();
foreach (var e in inactive)
{
if (e.Info != null && e.Info.Name == newPlayer.NickName)
{
PlayerInfo pInfo = GetPlayerInfoById(e.Info.Id);
if (pInfo != null)
{
pInfo.SetPlayer(newPlayer);
}
e.Info.SetPlayer(newPlayer);
e.Show(true);
Debug.Log("Player rejoined: " + newPlayer.NickName + " with id: " + newPlayer.ID);
gameManager.Resume(newPlayer.ID);
return;
}
}
PlayerEntry entry = inactive[Random.Range(0, inactive.Count)];
var info = new PlayerInfo(newPlayer);
info.sprite = entry.icon;
entry.SetInfo(info);
playerList.Add(info);
entry.Show(true);
Debug.Log("New player joined: " + newPlayer.NickName);
AudioManager.Instance.Play("Yay");
}
public void SetPlayer(PlayerEntry plr)
{
if (InvokeRequired)
{
Invoke(new Action <PlayerEntry>(SetPlayer), plr);
return;
}
Player = plr;
SetTitle(plr);
RemoveAll(p => (p.Tag as string) == "Note");
if (!string.IsNullOrWhiteSpace(plr.Note))
{
SuspendLayout();
var tab = new TabPage("Note")
{
Tag = "Note",
BackColor = this.BackColor
};
var lbl = new Label
{
Font = new Font(Font.FontFamily, Font.SizeInPoints, FontStyle.Bold),
Text = plr.Note
};
tab.Controls.Add(lbl);
AddTab(tab);
ResumeLayout();
}
Invalidate(); //Forces the color change
}
/// <summary>
/// Loader les PlayerEntry à partie d'un fichier texte. S'il n'y a pas de fichier de texte, rien n'est loader.
/// </summary>
public void loadPlayerEntries()
{
if (File.Exists(SCORE_FILE_PATH))
{
try
{
StreamReader scoreFile = new StreamReader(SCORE_FILE_PATH);
//Lire le fichier
string line = scoreFile.ReadLine();
while (line != null)
{
//Créer une entrée
string[] texts = line.Split(PlayerEntry.SEPARATEUR.ToCharArray());
try
{
PlayerEntry entry = new PlayerEntry(texts[0], int.Parse(texts[1].Trim()));
entries.Add(entry);
}
catch (System.Exception e)
{
Debug.LogError(e);
}
line = scoreFile.ReadLine();
}
scoreFile.Close();
}
catch (System.Exception e)
{
Debug.LogError(e);
}
}
}
public override void VRChat_OnUiManagerInit()
{
ClassInjector.RegisterTypeInIl2Cpp <EnableDisableListener>();
Config.RegisterSettings();
// Initialize Constants util
Constants.UIInit();
LoadAssetBundle();
// Initialize UIManager
UIManager.Init();
// Initialize submenu for the list
MenuManager.CreateMainSubMenu();
// TODO: Add opacity options, maybe color too, (maybe even for each stage of ping and fps??)
MenuManager.AddMenuListeners();
MenuManager.CreateSubMenus();
PlayerEntry.Patch(Harmony);
EntryManager.AddGeneralInfoEntries();
MenuManager.CreateGeneralInfoSubMenus();
MenuManager.AdjustSubMenus();
// Initialize on leave and join events
NetworkHooks.NetworkInit();
NetworkHooks.OnPlayerJoin += new Action <Player>((player) => OnPlayerJoin(player));
NetworkHooks.OnPlayerLeave += new Action <Player>((player) => OnPlayerLeave(player));
MelonLogger.Msg("Initialized!");
}
// Calculate the player's rounded health and display it on the UI.
public void SetHealth()
{
List <VehicleHealthManager> vehicles = new List <VehicleHealthManager>(FindObjectsOfType <VehicleHealthManager>());
PlayerEntry entry = gamestateTracker.players.Get((short)PhotonNetwork.LocalPlayer.ActorNumber);
int teamId = entry.teamId;
entry.Release();
foreach (VehicleHealthManager vehicle in vehicles)
{
if (vehicle.teamId == teamId)
{
if (Mathf.CeilToInt(vehicle.health) != previousRoundedHealth)
{
damageTaken = Mathf.CeilToInt(vehicle.health) - previousRoundedHealth;
Instantiate(damageIndicator, damageIndicatorInstantiateTransform);
if (vehicle.health < 0f)
{
vehicle.health = 0f;
}
healthLabel.text = Mathf.CeilToInt(vehicle.health).ToString();
previousRoundedHealth = Mathf.CeilToInt(vehicle.health);
healthBar.SetProgressBar(vehicle.scaledHealth);
healthBar.SetNumber(Mathf.CeilToInt(vehicle.health).ToString());
}
break;
}
}
}
private static ProposedBattle TryToMakeBattle(PlayerEntry player, IList <PlayerEntry> otherPlayers, bool ignoreSizeLimit)
{
var allPlayers = new List <PlayerEntry>();
allPlayers.AddRange(otherPlayers);
allPlayers.Add(player);
var playersByElo =
otherPlayers.Where(x => x != player)
.OrderBy(x => Math.Abs(x.LobbyUser.EffectiveMmElo - player.LobbyUser.EffectiveMmElo))
.ThenBy(x => x.JoinedTime)
.ToList();
var testedBattles = player.GenerateWantedBattles(allPlayers, ignoreSizeLimit);
foreach (var other in playersByElo)
{
foreach (var bat in testedBattles)
{
if (bat.CanBeAdded(other, allPlayers, ignoreSizeLimit))
{
bat.AddPlayer(other, allPlayers);
}
if (bat.Players.Count == bat.Size && bat.VerifyBalance(DynamicConfig.Instance.MmTeamsMinimumWinChance))
{
return(bat);
}
}
}
return(null);
}
public void GamestateApplyMultiplePlayerPacketsTest()
{
short actorNumber = 1;
GamestateCommitTestHelper <PlayerEntry> testHelper = new GamestateCommitTestHelper <PlayerEntry>(actorNumber);
GamestateTable <PlayerEntry> players = testHelper.TestTable(GamestateTracker.Table.Players);
GamestateRandomTestingUnit generator = new GamestateRandomTestingUnit(8);
for (short i = 0; i < 100; i++)
{
PlayerEntry playerEntry = players.Create(i);
generator.RandomisePlayerEntry(playerEntry);
playerEntry.Commit();
GamestatePacket packet = testHelper.commitedPackets[0];
testHelper.Apply(packet);
playerEntry = players.Get(i);
GamestateAssertionUnit.AssertPacketApplied(playerEntry, packet);
generator.RandomisePlayerEntry(playerEntry);
playerEntry.Commit();
packet = testHelper.commitedPackets[1];
testHelper.Apply(packet);
playerEntry = players.Get(i);
GamestateAssertionUnit.AssertPacketApplied(playerEntry, packet);
playerEntry.Release();
testHelper.commitedPackets.Clear();
}
}
public static bool CheckScore(PlayerEntry entry)
{
if (Top10 == null)
{
Top10 = new List <PlayerEntry>();
}
Top10.Sort();
if (Top10.Count < 10)
{
Top10.Add(entry);
return(true);
}
else
{
List <PlayerEntry> copy = new List <PlayerEntry>(Top10);
foreach (PlayerEntry e in copy)
{
if (entry.Score > e.Score)
{
Top10.Remove(Top10[Top10.Count - 1]);
Top10.Add(entry);
return(true);
}
}
}
return(false);
}
void SetReady(bool state)
{
isReady = state;
PlayerEntry playerEntry = gamestateTracker.players.Get((short)PhotonNetwork.LocalPlayer.ActorNumber);
if (playerEntry.role == (short)PlayerEntry.Role.None)
{
isReady = false;
}
lobbySlotMaster.GetComponent <PhotonView>().RPC(nameof(LobbySlotMaster.UpdateCountAndReady), RpcTarget.All);
playerEntry.ready = isReady;
playerEntry.Commit();
if (!isReady)
{
buttonFill.color = new Color32(0xFF, 0x61, 0x61, 0xFF);
buttonText.text = "Ready Up";
}
else
{
buttonFill.color = new Color32(0x65, 0xC5, 0x6B, 0xFF);
buttonText.text = "Unready";
}
}
public static void AddPlayerEntry(PlayerEntry entry)
{
AddEntry(entry);
playerEntries.Add(entry.player.field_Private_APIUser_0.id, entry);
entry.gameObject.SetActive(true);
entry.Refresh();
}
// Start is called before the first frame update
void Start()
{
maxPlayers = PhotonNetwork.CurrentRoom.MaxPlayers;
playersInLobby = PhotonNetwork.CurrentRoom.PlayerCount;
// add ourselves
if (PhotonNetwork.IsMasterClient)
{
PlayerEntry playerEntry = gamestateTracker.players.Create((short)PhotonNetwork.LocalPlayer.ActorNumber);
playerEntry.name = PhotonNetwork.LocalPlayer.NickName;
playerEntry.Commit();
selectMapText.text = "Select a map:";
}
foreach (LobbyButtonScript lobbyButton in lobbyButtons)
{
if (lobbyButton.gameObject.activeInHierarchy)
{
//gamestateTracker.schema.teamsList.Add(new GamestateTracker.TeamDetails(lobbyButton.teamId));
if (PhotonNetwork.IsMasterClient)
{
lobbyButton.CreateTeamEntry();
}
//TeamEntry team = gamestateTracker.teams.Create((short)lobbyButton.teamId);
//team.Commit();
}
}
}
public void DeleteEntry(PlayerEntry player)
{
RemoveActivePlayer(player);
playerEntryList.Remove(player);
SortPlayerList();
player.Destroy();
}
public PlayerEntry[,] CreateEntryMatrix(RaidSlot[] Slots, Player[] Players, PlayerEntry[] PlayersEntries)
{
PlayerEntry[,] PreferenceMatrix = new PlayerEntry[Players.Length, Slots.Length];
for (int i = 0; i < Players.Length; i++)
{
PlayerEntry[] PlayerEntries = (from entries in PlayersEntries
where entries.PlayerId == Players[i].PID
select entries).ToArray();
for (int j = 0; j < Slots.Length; j++)
{
var HighestPreferenceId = FindHighestPreferenceId(Slots[j], PlayerEntries);
PreferenceMatrix[i, j] = HighestPreferenceId >= 0
? PlayersEntries[HighestPreferenceId]
: new PlayerEntry()
{
};
if (PreferenceMatrix[i, j].Preference <= 0)
{
PreferenceMatrix[i, j].Preference = 110;
}
}
}
return(PreferenceMatrix);
}
public List <short> GetSelectedHumanTeamsIds()
{
List <short> idList = new List <short>();
for (int i = 0; i < gamestateTracker.teams.count; i++)
{
bool hasHuman = false;
TeamEntry teamEntry = gamestateTracker.teams.ReadAtIndex((short)i);
PlayerEntry driverEntry = gamestateTracker.players.Read(teamEntry.driverId);
PlayerEntry gunnerEntry = gamestateTracker.players.Read(teamEntry.gunnerId);
if (!driverEntry.isBot)
{
hasHuman = true;
}
if (!gunnerEntry.isBot)
{
hasHuman = true;
}
if (hasHuman && teamEntry.hasSelectedVehicle)
{
idList.Add(teamEntry.id);
}
}
return(idList);
}
public static void OnPlayerJoined(Player player)
{
if (player.name.Contains("Local") && player.prop_APIUser_0 == null)
{
player.prop_APIUser_0 = APIUser.CurrentUser;
}
if (idToEntryTable.ContainsKey(player.prop_APIUser_0.id))
{
return; // If already in list
}
if (player.name.Contains("Local"))
{
if (localPlayerEntry != null)
{
return;
}
GameObject template = Object.Instantiate(Constants.playerListLayout.transform.Find("Template").gameObject, Constants.playerListLayout.transform);
template.SetActive(true);
LeftSidePlayerEntry leftSidePlayerEntry = EntryBase.CreateInstance <LeftSidePlayerEntry>(template.transform.Find("LeftPart").gameObject);
EntryBase.CreateInstance <LocalPlayerEntry>(template.transform.Find("RightPart").gameObject);
AddPlayerLeftPairEntry(EntryBase.CreateInstance <PlayerLeftPairEntry>(template, new object[] { leftSidePlayerEntry, localPlayerEntry }));
}
else
{
GameObject template = Object.Instantiate(Constants.playerListLayout.transform.Find("Template").gameObject, Constants.playerListLayout.transform);
template.SetActive(true);
LeftSidePlayerEntry leftSidePlayerEntry = EntryBase.CreateInstance <LeftSidePlayerEntry>(template.transform.Find("LeftPart").gameObject);
PlayerEntry playerEntry = EntryBase.CreateInstance <PlayerEntry>(template.transform.Find("RightPart").gameObject, new object[] { player });
AddPlayerLeftPairEntry(EntryBase.CreateInstance <PlayerLeftPairEntry>(template, new object[] { leftSidePlayerEntry, playerEntry }));
}
}
private void CopyPlayer(int from, int to)
{
Debug.Log("moved player at " + from + " to " + to);
PlayerEntry p = state.PlayerList[from];
SetPlayer(to, p.UserName, p.Team, p.Connected);
}
private static ProposedBattle TryToMakeBattle(PlayerEntry player, IList <PlayerEntry> otherPlayers)
{
var allPlayers = new List <PlayerEntry>();
allPlayers.AddRange(otherPlayers);
allPlayers.Add(player);
var playersByElo =
otherPlayers.Where(x => x != player)
.OrderBy(x => Math.Abs(x.LobbyUser.EffectiveMmElo - player.LobbyUser.EffectiveMmElo))
.ThenBy(x => x.JoinedTime)
.ToList();
var testedBattles = player.GenerateWantedBattles(allPlayers);
foreach (var other in playersByElo)
{
foreach (var bat in testedBattles)
{
if (bat.CanBeAdded(other, allPlayers))
{
bat.AddPlayer(other, allPlayers);
}
if (bat.Players.Count == bat.Size)
{
return(bat);
}
}
}
return(null);
}
public void AddPlayer(PlayerEntry player, List <PlayerEntry> allPlayers)
{
//Trace.TraceError("MM: proposed battle {0} adding {1}", string.Join(", ", Players.Select(x=>x.Name)), player.Name);
//var minEloOrg = MinElo;
//var maxEloOrg = MaxElo;
if (player.Party != null)
{
foreach (var p in allPlayers.Where(x => x.Party == player.Party))
{
if (!Players.Contains(p))
{
Players.Add(p);
}
}
MinElo = Math.Min(MinElo, GetPartyMaxElo(player.Party, allPlayers));
MaxElo = Math.Max(MaxElo, GetPartyMinElo(player.Party, allPlayers));
hasParty = true;
//Trace.TraceError("MM: added party {6} MinElo: {0}->{1} ({4}), MaxElo: {2}->{3} ({5})", minEloOrg, MinElo, maxEloOrg, MaxElo, GetPartyMaxElo(player.Party, allPlayers), GetPartyMinElo(player.Party, allPlayers), player.Name);
}
else
{
if (!Players.Contains(player))
{
Players.Add(player);
MinElo = Math.Min(MinElo, GetPlayerMaxElo(player));
MaxElo = Math.Max(MaxElo, GetPlayerMinElo(player));
//Trace.TraceError("MM: added player {6} MinElo: {0}->{1} ({4}), MaxElo: {2}->{3} ({5})", minEloOrg, MinElo, maxEloOrg, MaxElo, GetPlayerMaxElo(player), GetPlayerMinElo(player), player.Name);
}
}
}
public void GamestateApplyPlayerPacketErrorCallbackTest()
{
short actorNumber = 1;
GamestateCommitTestHelper <PlayerEntry> testHelper = new GamestateCommitTestHelper <PlayerEntry>(actorNumber);
GamestateTable <PlayerEntry> players = testHelper.TestTable(GamestateTracker.Table.Players);
GamestateRandomTestingUnit generator = new GamestateRandomTestingUnit(9);
for (short i = 0; i < 100; i++)
{
PlayerEntry playerEntry = players.Create(i);
generator.RandomisePlayerEntry(playerEntry);
GamestatePacket packet = GamestatePacketManager.GetPacket();
bool errorCallbackCalled = false;
playerEntry.Commit((PlayerEntry entry, bool succeeded) => {
Assert.That(succeeded, Is.EqualTo(true));
GamestateAssertionUnit.AssertPacketApplied(entry, packet);
entry.Release();
errorCallbackCalled = true;
});
packet = testHelper.commitedPackets[0];
testHelper.Apply(packet);
Assert.That(errorCallbackCalled, Is.EqualTo(true));
testHelper.commitedPackets.Clear();
}
}
/****************************************
* *
* LOAD PLAYER INFO *
* *
***************************************/
public void LoadMyInfo()
{
//Create my new info
Debug.Log("Loading Player info...");
//Load my info
//PlayerPrefs.DeleteKey("playerInfoTable"); //DELETE SCORE DATABASE
string playerInfo = PlayerPrefs.GetString("playerInfoTable");
myInfo = JsonUtility.FromJson <PlayerEntry>(playerInfo);
if (myInfo == null)
{
PlayerEntry myNewInfo = new PlayerEntry {
id = this.id, game = this.game, player = this.playName, score = this.score
};
Debug.Log("No data founded...");
Debug.Log("Creating new Player info...");
// There's no stored table, initialize
myInfo = myNewInfo;//new PlayerEntry { id = this.id, game = "XorD", player = "NewPlayer", score = this.score };
Debug.Log("Info created...");
Debug.Log("[ My Id: " + myInfo.id + "\n My score: " + myInfo.score + " ]");
Debug.Log("My Info loaded...");
string json = JsonUtility.ToJson(myInfo);
PlayerPrefs.SetString("playerInfoTable", json);
PlayerPrefs.Save();
}
else
{
this.id = myInfo.id;
this.playName = myInfo.player;
this.score = myInfo.score;
Debug.Log("[ My Id: " + myInfo.id + "\n My score: " + myInfo.score + " ]");
Debug.Log("My Info loaded...");
}
}
public void LoadPlayer() {
if (System.IO.File.Exists(Application.dataPath + "/StreamingAssets/" + currentSave + "/playerData.xml")) {
XmlSerializer serializer = new XmlSerializer(typeof(PlayerEntry));
FileStream stream = new FileStream(Application.dataPath + "/StreamingAssets/" + currentSave + "/playerData.xml", FileMode.Open);
playerData = serializer.Deserialize(stream) as PlayerEntry;
stream.Close();
}
}
public CrouchState(Enum stateID, PlayerEntry playerEntry) : base(stateID, playerEntry.StateMachine)
{
_animator = playerEntry.GetComponent <Animator>();
_optionBoxCollider2D = playerEntry.GetComponent <BoxCollider2D>();
_rigidbody2D = playerEntry.GetComponent <Rigidbody2D>();
_headPoint = playerEntry.headPoint;
_layerMask = playerEntry.layerMask;
}
private void SetPlayer(int index, string username, int team, bool connected = true)
{
PlayerEntry p = state.PlayerList[index];
p.UserName = username;
p.Team = team;
p.Connected = connected;
}
public void OnClickAdd()
{
Debug.Log("OnClickAdd");
PlayerEntry PlayerEntryClone = Instantiate(playerEntry, playerList.transform);
PlayerEntryClone.EntryInit(this);
playerEntryList.Add(PlayerEntryClone);
PlayerEntryClone.OpenAddPopup();
}
protected void Entry_UnFocussed(object sender, EventArgs e)
{
// Cast
PlayerEntry entry = (PlayerEntry)sender;
PlayerNameViewModel model = (PlayerNameViewModel)BindingContext;
// Set in model
model.SetPlayerName(entry.BoardType, entry.Text);
}
public void GamestateApplyPlayerPacketListenerDeletionTest()
{
short actorNumber = 1;
GamestateCommitTestHelper <PlayerEntry> testHelper = new GamestateCommitTestHelper <PlayerEntry>(actorNumber);
GamestateTable <PlayerEntry> players = testHelper.TestTable(GamestateTracker.Table.Players);
GamestateRandomTestingUnit generator = new GamestateRandomTestingUnit(12);
for (short i = 0; i < 100; i++)
{
PlayerEntry playerEntry = players.Create(i);
generator.RandomisePlayerEntry(playerEntry);
GamestatePacket packet = GamestatePacketManager.GetPacket();
bool listenerACalled = false;
bool listenerBCalled = false;
bool listenerCCalled = false;
bool listenerDCalled = false;
int a = playerEntry.AddListener((PlayerEntry entry) => {
entry.Release();
listenerACalled = true;
});
int b = playerEntry.AddListener((PlayerEntry entry) => {
entry.Release();
listenerBCalled = true;
});
int c = playerEntry.AddListener((PlayerEntry entry) => {
entry.Release();
listenerCCalled = true;
});
playerEntry.RemoveListener(b);
int d = playerEntry.AddListener((PlayerEntry entry) => {
entry.Release();
listenerDCalled = true;
});
playerEntry.RemoveListener(c);
playerEntry.Commit();
packet = testHelper.commitedPackets[0];
testHelper.Apply(packet);
Assert.That(listenerACalled, Is.EqualTo(true));
Assert.That(listenerBCalled, Is.EqualTo(false));
Assert.That(listenerCCalled, Is.EqualTo(false));
Assert.That(listenerDCalled, Is.EqualTo(true));
testHelper.commitedPackets.Clear();
}
}
// called whenever the team stuff changes
// update the graphics of the button
void TeamListenerCallback(TeamEntry teamEntry)
{
// display the player details of the driver and gunner in the buttons
// driver stuff
short driverId = teamEntry.driverId;
if (driverId != 0)
{
PlayerEntry driverEntry = gamestateTracker.players.Get((short)driverId);
driverPlayerText.text = driverEntry.name;
driverEntry.Release();
if (driverId == PhotonNetwork.LocalPlayer.ActorNumber)
{
driverFillImage.color = new Color32(0x65, 0xC5, 0x6B, 0xFF);
}
else
{
driverFillImage.color = new Color32(0x44, 0x91, 0xCA, 0xFF);
}
driverButton.interactable = false;
}
else
{
driverPlayerText.text = "Empty";
driverFillImage.color = new Color32(0xB0, 0xB0, 0xB0, 0xFF);
driverButton.interactable = true;
}
// gunner stuff
short gunnerId = teamEntry.gunnerId;
if (gunnerId != 0)
{
PlayerEntry gunnerEntry = gamestateTracker.players.Get((short)gunnerId);
gunnerPlayerText.text = gunnerEntry.name;
gunnerEntry.Release();
if (gunnerId == PhotonNetwork.LocalPlayer.ActorNumber)
{
gunnerFillImage.color = new Color32(0x65, 0xC5, 0x6B, 0xFF);
}
else
{
gunnerFillImage.color = new Color32(0x44, 0x91, 0xCA, 0xFF);
}
gunnerButton.interactable = false;
}
else
{
gunnerPlayerText.text = "Empty";
gunnerFillImage.color = new Color32(0xB0, 0xB0, 0xB0, 0xFF);
gunnerButton.interactable = true;
}
teamEntry.Release();
}
public IdleState(Enum stateID, PlayerEntry playerEntry) : base(stateID, playerEntry.StateMachine)
{
_animator = playerEntry.GetComponent <Animator>();
_transform = playerEntry.transform;
// 玩家精灵边框的大小
_playerSize = playerEntry.GetComponent <SpriteRenderer>().bounds.size;
// 碰撞检测盒子的大小，使用玩家的大小 40%，同时高度设置为 0.5
_boxSize = new Vector2(_playerSize.x * 0.4f, PlayerVariables.BoxHeight);
_layerMask = playerEntry.layerMask;
}
public EditPlayerForm(PlayerEntry entry)
: this()
{
if (entry == null)
{
return;
}
NoteText.Text = entry.Note ?? "";
ColorBox.SelectedIndex = ColorBox.Items.IndexOf(entry.NoteColor.ToKnownColor().ToString());
}
private void AddPlayerEntry(LobbyPlayer playerData)
{
GameObject obj = Instantiate(playerEntryPrefab);
obj.transform.parent = playerList.transform;
PlayerEntry playerEntry = obj.GetComponent <PlayerEntry>();
playerEntry.playerName.text = playerData.playerName;
}
private void LoadPlayerTable(IReader reader)
{
var chainedNullEntries = 0;
var index = 0;
_players = new List<PlayerEntry>();
while (chainedNullEntries < 2)
{
reader.SeekTo(0x2BBF0 + (0x1E0 * index));
var entry = new PlayerEntry(reader);
if (entry.GamerTag_1 == "" || entry.ServiceTag == "" || entry.GamerTag_2 == "")
chainedNullEntries++;
else
{
_players.Add(entry);
chainedNullEntries = 0;
}
index++;
}
}
/// <summary>
/// Consume players and list matches per player.
/// </summary>
private async Task<IEnumerable<MatchSummary>> ConsumePlayerAsync(PlayerEntry player)
{
// <TEST> download limiting
long count = Interlocked.Read(ref testSynchronizer.Count);
if (count >= testSynchronizer.Limit)
return Enumerable.Empty<MatchSummary>();
// </TEST>
// Get player id
long playerId = long.Parse(player.Player.PlayerOrTeamId);
// Get player data
PlayerData playerData = PlayerDirectory.GetPlayerData(player.Player);
// Retry a number of times to handle server-side rate limit errors
int retriesLeft = 3;
// Get player match list, looping through pages until reaching a match we've seen for this player, or a match from an old patch
// TODO: use the new match history api
int startId = 0;
int endId = MaxMatchesPerQuery - 1;
List<MatchSummary> matches = new List<MatchSummary>();
bool oldMatches = false;
while (!oldMatches)
{
try
{
var newmatches = await api.GetMatchHistoryAsync(player.Region, playerId,
rankedQueues: queryQueues,
beginIndex: startId,
endIndex: endId);
// Prepare for next query
startId += MaxMatchesPerQuery;
endId += MaxMatchesPerQuery;
// Filter out matches that aren't on the current patch
newmatches = newmatches.Where(m => StaticDataStore.Version.IsSamePatch(new RiotVersion(m.MatchVersion))).ToList();
// Check if we've seen any of these matches yet (if so, that's our marker to stop querying)
int foundMatchId = newmatches.FindIndex(m => m.MatchId == playerData.LatestMatchId);
if (foundMatchId != -1)
{
newmatches = newmatches.GetRange(0, foundMatchId).ToList();
oldMatches = true;
}
matches.AddRange(newmatches);
// If we filtered any matches out, we're past matches on the current patch
if (newmatches.Count < MaxMatchesPerQuery)
oldMatches = true;
}
catch (RiotSharpException ex)
{
if (ex.IsRetryable() && retriesLeft > 0)
{
// NOTE: This server-side rate handler is a bit rough, but I don't want to change RiotSharp too much unless I get more time.
// Ideally, the original error code would be attached to the RiotSharp exception so the handler could decide how to deal
// with it based on the status code. Unfortunately, it's not at this time - I'll clean it up in RiotSharp if I have time.
//
// The error seems to be server-side, as there's no retry-after headers of any sort attached to the response. It should
// be safe to just retry after waiting a bit. I'm also retrying 500-series errors, since they seem to be recoverable.
--retriesLeft;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Server error getting matches for player {0} ({1} retries left)", player.Player.PlayerOrTeamName, retriesLeft);
Console.ResetColor();
// Wait half a second
Thread.Sleep(500);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error getting matches for player {0}: {1}", player.Player.PlayerOrTeamName, ex.Message);
Console.ResetColor();
oldMatches = true;
}
}
}
// Store last seen match for this player
if (matches.Count > 0)
{
playerData.LatestMatchId = matches[0].MatchId;
PlayerDirectory.SetPlayerData(player.Player, playerData);
}
return matches;
}
private int GetElo(PlayerEntry entry) => entry.LobbyUser.EffectiveMmElo;
private int GetPlayerMaxElo(PlayerEntry entry)
{
return (int)Math.Round(CutOffFunc(entry.MaxConsideredElo));
}
public bool CanBeAdded(PlayerEntry other)
{
if (!other.GenerateWantedBattles().Any(y => y.Size == Size && y.QueueType == QueueType)) return false;
var width = owner.EloWidth * widthMultiplier;
if ((GetPlayerMinElo(other) - MinElo > width) || (MaxElo - GetPlayerMaxElo(other) > width)) return false;
return true;
}
public void AddPlayer(PlayerEntry player)
{
Players.Add(player);
MinElo = Math.Min(MinElo, GetPlayerMaxElo(player));
MaxElo = Math.Max(MaxElo, GetPlayerMinElo(player));
}
public ProposedBattle(int size, PlayerEntry initialPlayer, MatchMakerSetup.Queue queue, double eloCutOffExponent)
{
Size = size;
owner = initialPlayer;
QueueType = queue;
this.eloCutOffExponent = eloCutOffExponent;
widthMultiplier = Math.Max(1.0, 1.0 + (Size - 4) * 0.1);
AddPlayer(initialPlayer);
}
private async Task UpdatePlayerStatus(string name)
{
ConnectedUser conus;
if (server.ConnectedUsers.TryGetValue(name, out conus))
{
PlayerEntry entry;
players.TryGetValue(name, out entry);
var ret = new MatchMakerStatus()
{
QueueCounts = queuesCounts,
IngameCounts = ingameCounts,
JoinedQueues = entry?.QueueTypes.Select(x => x.Name).ToList(),
CurrentEloWidth = entry?.EloWidth,
JoinedTime = entry?.JoinedTime,
BannedSeconds = BannedSeconds(name),
UserCount = server.ConnectedUsers.Count
};
// check for instant battle start
if (invitationBattles?.Any() != true && players.Count > 0) // nobody invited atm and some in queue
{
var testPlayers = players.Values.Where(x => x != null && x.Name != name).ToList(); // get all currently queued players except for self
var testSelf = new PlayerEntry(conus.User, possibleQueues.ToList()); // readd self but with all queues
testPlayers.Add(testSelf);
var testBattles = ProposeBattles(testPlayers);
ret.InstantStartQueues = testBattles.Where(x => x.Players.Contains(testSelf)).Select(x => x.QueueType.Name).Distinct().ToList();
}
await conus.SendCommand(ret);
}
}
public bool CanBeAdded(PlayerEntry other)
{
if (!other.GenerateWantedBattles().Any(y => (y.Size == Size) && (y.Mode == Mode))) return false;
var widthMultiplier = Math.Max(1.0, 1.0 + (Size - 4) * 0.1);
var width = owner.EloWidth * widthMultiplier;
var elo = GetElo(other);
if ((elo - MinElo > width) || (MaxElo - elo > width)) return false;
return true;
}
private MatchMakerStatus ToMatchMakerStatus(PlayerEntry entry)
{
var ret = new MatchMakerStatus()
{
QueueCounts = queuesCounts,
IngameCounts = ingameCounts,
};
if (entry != null)
{
ret.JoinedQueues = entry.QueueTypes.Select(x => x.Name).ToList();
ret.CurrentEloWidth = entry.EloWidth;
ret.JoinedTime = entry.JoinedTime;
ret.BannedSeconds = BannedSeconds(entry.Name);
}
return ret;
}
public void AddPlayer(PlayerEntry player)
{
Players.Add(player);
var elo = GetElo(player);
MinElo = Math.Min(MinElo, elo);
MaxElo = Math.Max(MaxElo, elo);
}
public static bool isInMyInstance(PlayerEntry pe)
{
using (LokiPoe.AcquireFrame())
{
LokiPoe.ObjectManager.ClearCache();
bool result = false;
try
{
if (LokiPoe.ObjectManager.Objects.OfType<Player>().First(x => x.Name == pe.Name).Distance > 0)
result = true;
}
catch (Exception e)
{
result = false;
//TheFunctions.Debug(e.ToString()); //working now, no need to debugspam
}
return result;
}
}
public static Vector2i getPosition(PlayerEntry pe)
{
using (LokiPoe.AcquireFrame())
{
LokiPoe.ObjectManager.ClearCache();
if (pe.AreaId != LokiPoe.LocalData.WorldAreaId)
return new Vector2i(-1, -1);
if (!isInMyInstance(pe))
return new Vector2i(-2, -2);
return LokiPoe.ObjectManager.Objects.OfType<Player>().First(p => p.Name == pe.Name).Position;
}
}
public static int getDistance(PlayerEntry pe)
{
using (LokiPoe.AcquireFrame())
{
LokiPoe.ObjectManager.ClearCache();
if (pe.AreaId != LokiPoe.LocalData.WorldAreaId)
return -1;
if (!isInMyInstance(pe))
return -2;
return (int)LokiPoe.ObjectManager.Objects.OfType<Player>().First(p => p.Name == pe.Name).Distance;
}
}
public ProposedBattle(int size, PlayerEntry initialPlayer, AutohostMode mode)
{
Size = size;
Mode = mode;
owner = initialPlayer;
AddPlayer(initialPlayer);
}
private static ProposedBattle TryToMakeBattle(PlayerEntry player, IList<PlayerEntry> otherPlayers)
{
var playersByElo =
otherPlayers.Where(x => x != player)
.OrderBy(x => Math.Abs(x.LobbyUser.EffectiveMmElo - player.LobbyUser.EffectiveMmElo))
.ThenBy(x => x.JoinedTime)
.ToList();
var testedBattles = player.GenerateWantedBattles();
foreach (var other in playersByElo)
foreach (var bat in testedBattles)
if (bat.CanBeAdded(other))
{
bat.AddPlayer(other);
if (bat.Players.Count == bat.Size) return bat;
}
return null;
}
