Flamefire
aa0579a4f1
Move PartyModeIds into Partymodes Fix bug where wrong text size is used (CalculatedFont is now used) Fix bug where text of the main table in partymodes is displayed wrong
767 lines
27 KiB
C#
767 lines
27 KiB
C#
#region license
|
|
// This file is part of Vocaluxe.
|
|
//
|
|
// Vocaluxe is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Vocaluxe is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Vocaluxe. If not, see <http://www.gnu.org/licenses/>.
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Runtime.InteropServices;
|
|
using VocaluxeLib.Game;
|
|
using VocaluxeLib.Menu;
|
|
using VocaluxeLib.Songs;
|
|
using VocaluxeLib.Profile;
|
|
|
|
[assembly: ComVisible(false)]
|
|
|
|
namespace VocaluxeLib.PartyModes.ChallengeMedley
|
|
{
|
|
|
|
#region Communication
|
|
|
|
#region ToScreen
|
|
public struct SDataToScreenConfig
|
|
{
|
|
public int NumPlayer;
|
|
public int NumPlayerAtOnce;
|
|
public int NumRounds;
|
|
}
|
|
|
|
public struct SDataToScreenNames
|
|
{
|
|
public int NumPlayer;
|
|
public List<int> ProfileIDs;
|
|
}
|
|
|
|
public struct SDataToScreenMain
|
|
{
|
|
public int CurrentRoundNr;
|
|
public int NumPlayerAtOnce;
|
|
public List<CCombination> Combs;
|
|
public int[,] Results;
|
|
public List<CResultTableRow> ResultTable;
|
|
public List<int> ProfileIDs;
|
|
}
|
|
|
|
public class CResultTableRow : IComparable
|
|
{
|
|
public int Position;
|
|
public int PlayerID;
|
|
public int NumPlayed;
|
|
public int NumWon;
|
|
public int NumSingPoints;
|
|
public int NumGamePoints;
|
|
|
|
public int CompareTo(object obj)
|
|
{
|
|
CResultTableRow row = obj as CResultTableRow;
|
|
if (row != null)
|
|
{
|
|
int res = row.NumGamePoints.CompareTo(NumGamePoints);
|
|
if (res == 0)
|
|
{
|
|
res = row.NumSingPoints.CompareTo(NumSingPoints);
|
|
if (res == 0)
|
|
res = row.NumWon.CompareTo(NumWon);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
throw new ArgumentException("object is not a ResultTableRow");
|
|
}
|
|
}
|
|
#endregion ToScreen
|
|
|
|
#region FromScreen
|
|
public struct SDataFromScreen
|
|
{
|
|
public SFromScreenConfig ScreenConfig;
|
|
public SFromScreenNames ScreenNames;
|
|
public SFromScreenMain ScreenMain;
|
|
}
|
|
|
|
public struct SFromScreenConfig
|
|
{
|
|
public int NumPlayer;
|
|
public int NumPlayerAtOnce;
|
|
public int NumRounds;
|
|
}
|
|
|
|
public struct SFromScreenNames
|
|
{
|
|
public bool FadeToConfig;
|
|
public List<int> ProfileIDs;
|
|
}
|
|
|
|
public struct SFromScreenMain
|
|
{
|
|
public bool FadeToSongSelection;
|
|
public bool FadeToNameSelection;
|
|
}
|
|
#endregion FromScreen
|
|
|
|
#endregion Communication
|
|
|
|
public sealed class CPartyModeChallengeMedley : CPartyMode
|
|
{
|
|
private const int _MaxPlayer = 12;
|
|
private const int _MinPlayer = 1;
|
|
private const int _MaxTeams = 0;
|
|
private const int _MinTeams = 0;
|
|
private const int _MaxNumRounds = 100;
|
|
private const int _NumSongs = 5;
|
|
|
|
private enum EStage
|
|
{
|
|
NotStarted,
|
|
Config,
|
|
Names,
|
|
Main,
|
|
Singing
|
|
}
|
|
|
|
private struct SData
|
|
{
|
|
public int NumPlayer;
|
|
public int NumPlayerAtOnce;
|
|
public int NumRounds;
|
|
public List<int> ProfileIDs;
|
|
|
|
public CChallengeRounds Rounds;
|
|
public List<CResultTableRow> ResultTable;
|
|
public int[,] Results;
|
|
|
|
public int CurrentRoundNr;
|
|
|
|
public int[] CatSongIndices;
|
|
}
|
|
|
|
private struct SStats
|
|
{
|
|
public int ProfileID;
|
|
public int SingPoints;
|
|
public int GamePoints;
|
|
public int Won;
|
|
}
|
|
|
|
private SDataToScreenConfig _ToScreenConfig;
|
|
private SDataToScreenNames _ToScreenNames;
|
|
private SDataToScreenMain _ToScreenMain;
|
|
|
|
private SData _GameData;
|
|
private EStage _Stage;
|
|
|
|
public CPartyModeChallengeMedley(int id, string folder)
|
|
: base(id, folder)
|
|
{
|
|
_ScreenSongOptions.Selection.RandomOnly = false;
|
|
_ScreenSongOptions.Selection.PartyMode = true;
|
|
_ScreenSongOptions.Selection.CategoryChangeAllowed = true;
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {5, 5};
|
|
_ScreenSongOptions.Selection.TeamNames = new string[] {"foo", "bar"};
|
|
|
|
_ScreenSongOptions.Sorting.SearchString = String.Empty;
|
|
_ScreenSongOptions.Sorting.SearchActive = false;
|
|
_ScreenSongOptions.Sorting.DuetOptions = EDuetOptions.NoDuets;
|
|
|
|
_Stage = EStage.NotStarted;
|
|
|
|
_ToScreenConfig = new SDataToScreenConfig();
|
|
_ToScreenNames = new SDataToScreenNames();
|
|
_ToScreenMain = new SDataToScreenMain();
|
|
|
|
_GameData = new SData {NumPlayer = 4, NumPlayerAtOnce = 2, NumRounds = 2, CurrentRoundNr = 1, ProfileIDs = new List<int>(), CatSongIndices = null, Results = null};
|
|
}
|
|
|
|
public override bool Init()
|
|
{
|
|
_Stage = EStage.NotStarted;
|
|
|
|
_ScreenSongOptions.Sorting.IgnoreArticles = EOffOn.TR_CONFIG_OFF;
|
|
_ScreenSongOptions.Sorting.SongSorting = ESongSorting.TR_CONFIG_NONE;
|
|
_ScreenSongOptions.Sorting.Tabs = EOffOn.TR_CONFIG_OFF;
|
|
_ScreenSongOptions.Selection.SongIndex = -1;
|
|
|
|
_ToScreenMain.ResultTable = new List<CResultTableRow>();
|
|
_GameData.ResultTable = new List<CResultTableRow>();
|
|
|
|
CBase.Songs.SortSongs(ESongSorting.TR_CONFIG_NONE, EOffOn.TR_CONFIG_OFF, EOffOn.TR_CONFIG_OFF, String.Empty, EDuetOptions.NoDuets);
|
|
CBase.Songs.SetCategory(0);
|
|
|
|
return true;
|
|
}
|
|
|
|
public override void DataFromScreen(string screenName, Object data)
|
|
{
|
|
SDataFromScreen dataFrom;
|
|
switch (screenName)
|
|
{
|
|
case "PartyScreenChallengeMedleyConfig":
|
|
|
|
try
|
|
{
|
|
dataFrom = (SDataFromScreen)data;
|
|
_GameData.NumPlayer = dataFrom.ScreenConfig.NumPlayer;
|
|
_GameData.NumPlayerAtOnce = dataFrom.ScreenConfig.NumPlayerAtOnce;
|
|
_GameData.NumRounds = dataFrom.ScreenConfig.NumRounds;
|
|
|
|
_Stage = EStage.Config;
|
|
CBase.Graphics.FadeTo(EScreens.ScreenPartyDummy);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
CBase.Log.LogError("Error in party mode challenge. Can't cast received data from screen " + screenName + ". " + e.Message);
|
|
}
|
|
break;
|
|
|
|
case "PartyScreenChallengeMedleyNames":
|
|
try
|
|
{
|
|
dataFrom = (SDataFromScreen)data;
|
|
if (dataFrom.ScreenNames.FadeToConfig)
|
|
_Stage = EStage.NotStarted;
|
|
else
|
|
{
|
|
_GameData.ProfileIDs = dataFrom.ScreenNames.ProfileIDs;
|
|
_Stage = EStage.Names;
|
|
}
|
|
|
|
CBase.Graphics.FadeTo(EScreens.ScreenPartyDummy);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
CBase.Log.LogError("Error in party mode challenge. Can't cast received data from screen " + screenName + ". " + e.Message);
|
|
}
|
|
break;
|
|
|
|
case "PartyScreenChallengeMedleyMain":
|
|
try
|
|
{
|
|
dataFrom = (SDataFromScreen)data;
|
|
if (dataFrom.ScreenMain.FadeToSongSelection)
|
|
_Stage = EStage.Singing;
|
|
if (dataFrom.ScreenMain.FadeToNameSelection)
|
|
_Stage = EStage.Config;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
CBase.Log.LogError("Error in party mode challenge. Can't cast received data from screen " + screenName + ". " + e.Message);
|
|
}
|
|
|
|
|
|
if (_Stage == EStage.Singing)
|
|
_StartNextRound();
|
|
if (_Stage == EStage.Config)
|
|
CBase.Graphics.FadeTo(EScreens.ScreenPartyDummy);
|
|
break;
|
|
|
|
default:
|
|
CBase.Log.LogError("Error in party mode challenge. Wrong screen is sending: " + screenName);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public override void UpdateGame()
|
|
{
|
|
/*
|
|
if (CBase.Songs.IsInCategory() || _ScreenSongOptions.Sorting.Tabs == EOffOn.TR_CONFIG_OFF)
|
|
_ScreenSongOptions.Selection.RandomOnly = true;
|
|
else
|
|
_ScreenSongOptions.Selection.RandomOnly = false;*/
|
|
}
|
|
|
|
public override CMenuParty GetNextPartyScreen(out EScreens alternativeScreen)
|
|
{
|
|
CMenuParty screen = null;
|
|
alternativeScreen = EScreens.ScreenSong;
|
|
|
|
switch (_Stage)
|
|
{
|
|
case EStage.NotStarted:
|
|
_Screens.TryGetValue("CPartyScreenChallengeMedleyConfig", out screen);
|
|
if (screen != null)
|
|
{
|
|
_ToScreenConfig.NumPlayer = _GameData.NumPlayer;
|
|
_ToScreenConfig.NumPlayerAtOnce = _GameData.NumPlayerAtOnce;
|
|
_ToScreenConfig.NumRounds = _GameData.NumRounds;
|
|
screen.DataToScreen(_ToScreenConfig);
|
|
}
|
|
break;
|
|
case EStage.Config:
|
|
_Screens.TryGetValue("CPartyScreenChallengeMedleyNames", out screen);
|
|
if (screen != null)
|
|
{
|
|
_ToScreenNames.NumPlayer = _GameData.NumPlayer;
|
|
_ToScreenNames.ProfileIDs = _GameData.ProfileIDs;
|
|
screen.DataToScreen(_ToScreenNames);
|
|
}
|
|
break;
|
|
case EStage.Names:
|
|
_Screens.TryGetValue("CPartyScreenChallengeMedleyMain", out screen);
|
|
if (screen != null)
|
|
{
|
|
CBase.Songs.ResetSongSung();
|
|
_ToScreenMain.ResultTable = new List<CResultTableRow>();
|
|
_GameData.ResultTable = new List<CResultTableRow>();
|
|
_GameData.Rounds = new CChallengeRounds(_GameData.NumRounds, _GameData.NumPlayer, _GameData.NumPlayerAtOnce);
|
|
_GameData.CurrentRoundNr = 1;
|
|
_ToScreenMain.CurrentRoundNr = 1;
|
|
_ToScreenMain.NumPlayerAtOnce = _GameData.NumPlayerAtOnce;
|
|
_ToScreenMain.Combs = _GameData.Rounds.Rounds;
|
|
_ToScreenMain.ProfileIDs = _GameData.ProfileIDs;
|
|
_UpdateScores();
|
|
_ToScreenMain.ResultTable = _GameData.ResultTable;
|
|
_ToScreenMain.Results = _GameData.Results;
|
|
screen.DataToScreen(_ToScreenMain);
|
|
}
|
|
break;
|
|
case EStage.Main:
|
|
//nothing to do
|
|
break;
|
|
case EStage.Singing:
|
|
_Screens.TryGetValue("CPartyScreenChallengeMedleyMain", out screen);
|
|
if (screen != null)
|
|
{
|
|
_UpdateScores();
|
|
_ToScreenMain.CurrentRoundNr = _GameData.CurrentRoundNr;
|
|
_ToScreenMain.Combs = _GameData.Rounds.Rounds;
|
|
_ToScreenMain.Results = _GameData.Results;
|
|
screen.DataToScreen(_ToScreenMain);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return screen;
|
|
}
|
|
|
|
public override EScreens GetStartScreen()
|
|
{
|
|
return EScreens.ScreenPartyDummy;
|
|
}
|
|
|
|
public override EScreens GetMainScreen()
|
|
{
|
|
return EScreens.ScreenPartyDummy;
|
|
}
|
|
|
|
public override SScreenSongOptions GetScreenSongOptions()
|
|
{
|
|
_ScreenSongOptions.Sorting.SongSorting = CBase.Config.GetSongSorting();
|
|
_ScreenSongOptions.Sorting.Tabs = CBase.Config.GetTabs();
|
|
_ScreenSongOptions.Sorting.IgnoreArticles = CBase.Config.GetIgnoreArticles();
|
|
|
|
return _ScreenSongOptions;
|
|
}
|
|
|
|
// ReSharper disable RedundantAssignment
|
|
public override void OnSongChange(int songIndex, ref SScreenSongOptions screenSongOptions)
|
|
// ReSharper restore RedundantAssignment
|
|
{
|
|
_ScreenSongOptions.Selection.SongIndex = -1;
|
|
|
|
if (_ScreenSongOptions.Selection.SelectNextRandomSong && songIndex != -1)
|
|
{
|
|
_ScreenSongOptions.Selection.SelectNextRandomSong = false;
|
|
_CreateCatSongIndices();
|
|
|
|
if (_GameData.CatSongIndices != null)
|
|
{
|
|
if (_GameData.CatSongIndices[CBase.Songs.GetCurrentCategoryIndex()] == -1)
|
|
_GameData.CatSongIndices[CBase.Songs.GetCurrentCategoryIndex()] = songIndex;
|
|
}
|
|
}
|
|
|
|
screenSongOptions = _ScreenSongOptions;
|
|
}
|
|
|
|
// ReSharper disable RedundantAssignment
|
|
public override void OnCategoryChange(int categoryIndex, ref SScreenSongOptions screenSongOptions)
|
|
// ReSharper restore RedundantAssignment
|
|
{
|
|
if (_GameData.CatSongIndices != null && categoryIndex != -1)
|
|
{
|
|
if (_GameData.CatSongIndices[categoryIndex] == -1)
|
|
_ScreenSongOptions.Selection.SelectNextRandomSong = true;
|
|
else
|
|
_ScreenSongOptions.Selection.SongIndex = _GameData.CatSongIndices[categoryIndex];
|
|
}
|
|
|
|
if (_GameData.CatSongIndices == null && categoryIndex != -1)
|
|
_ScreenSongOptions.Selection.SelectNextRandomSong = true;
|
|
|
|
if (categoryIndex == -1)
|
|
_ScreenSongOptions.Selection.RandomOnly = false;
|
|
|
|
if (_ScreenSongOptions.Sorting.Tabs == EOffOn.TR_CONFIG_OFF || categoryIndex != -1)
|
|
_ScreenSongOptions.Selection.RandomOnly = true;
|
|
|
|
screenSongOptions = _ScreenSongOptions;
|
|
}
|
|
|
|
public override void SetSearchString(string searchString, bool visible)
|
|
{
|
|
_ScreenSongOptions.Sorting.SearchString = searchString;
|
|
_ScreenSongOptions.Sorting.SearchActive = visible;
|
|
}
|
|
|
|
public override int GetMaxPlayer()
|
|
{
|
|
return _MaxPlayer;
|
|
}
|
|
|
|
public override int GetMinPlayer()
|
|
{
|
|
return _MinPlayer;
|
|
}
|
|
|
|
public override int GetMaxTeams()
|
|
{
|
|
return _MaxTeams;
|
|
}
|
|
|
|
public override int GetMinTeams()
|
|
{
|
|
return _MinTeams;
|
|
}
|
|
|
|
public override int GetMaxNumRounds()
|
|
{
|
|
return _MaxNumRounds;
|
|
}
|
|
|
|
public override void JokerUsed(int teamNr)
|
|
{
|
|
if (_ScreenSongOptions.Selection.NumJokers == null)
|
|
return;
|
|
|
|
if (teamNr >= _ScreenSongOptions.Selection.NumJokers.Length)
|
|
return;
|
|
|
|
_ScreenSongOptions.Selection.NumJokers[teamNr]--;
|
|
_ScreenSongOptions.Selection.RandomOnly = true;
|
|
_ScreenSongOptions.Selection.CategoryChangeAllowed = false;
|
|
}
|
|
|
|
public override void SongSelected(int songID) {}
|
|
|
|
public override void LeavingHighscore()
|
|
{
|
|
for (int i = 0; i < CBase.Game.GetNumSongs(); i++)
|
|
CBase.Songs.AddPartySongSung(CBase.Game.GetSong(i).ID);
|
|
_GameData.CurrentRoundNr++;
|
|
CBase.Graphics.FadeTo(EScreens.ScreenPartyDummy);
|
|
}
|
|
|
|
private void _StartNextRound()
|
|
{
|
|
_ScreenSongOptions.Selection.RandomOnly = _ScreenSongOptions.Sorting.Tabs != EOffOn.TR_CONFIG_ON;
|
|
_ScreenSongOptions.Selection.CategoryChangeAllowed = _ScreenSongOptions.Sorting.Tabs == EOffOn.TR_CONFIG_ON;
|
|
_SetNumJokers();
|
|
_SetTeamNames();
|
|
_GameData.CatSongIndices = null;
|
|
|
|
if (_RandomizeSongs())
|
|
CBase.Graphics.FadeTo(EScreens.ScreenSing);
|
|
}
|
|
|
|
private bool _RandomizeSongs()
|
|
{
|
|
CBase.Game.Reset();
|
|
CBase.Game.ClearSongs();
|
|
|
|
#region PlayerNames
|
|
CBase.Game.SetNumPlayer(_GameData.NumPlayerAtOnce);
|
|
SPlayer[] players = CBase.Game.GetPlayers();
|
|
if (players == null)
|
|
return false;
|
|
|
|
if (players.Length < _GameData.NumPlayerAtOnce)
|
|
return false;
|
|
|
|
CCombination c = _GameData.Rounds.GetRound(_GameData.CurrentRoundNr - 1);
|
|
|
|
for (int i = 0; i < _GameData.NumPlayerAtOnce; i++)
|
|
{
|
|
//try to fill with the right data
|
|
if (c != null)
|
|
players[i].ProfileID = _GameData.ProfileIDs[c.Player[i]];
|
|
else
|
|
players[i].ProfileID = -1;
|
|
}
|
|
#endregion PlayerNames
|
|
|
|
#region SongQueue
|
|
if (CBase.Songs.GetNumSongsVisible() < _NumSongs)
|
|
CBase.Songs.ResetSongSung();
|
|
|
|
List<int> ids = new List<int>();
|
|
|
|
ReadOnlyCollection<CSong> visibleSongs = CBase.Songs.GetVisibleSongs();
|
|
if (visibleSongs.Count == 0)
|
|
{
|
|
CBase.Log.LogError("CPartyChallengeMedleyMode Error: There are no songs!");
|
|
CBase.Graphics.FadeTo(EScreens.ScreenParty);
|
|
return false;
|
|
}
|
|
|
|
//Calc avarage sing-count
|
|
int totalCounts = 0;
|
|
foreach (CSong song in visibleSongs)
|
|
totalCounts += song.NumPlayedSession;
|
|
int averageCount = totalCounts / visibleSongs.Count;
|
|
|
|
// ReSharper disable LoopCanBeConvertedToQuery
|
|
foreach (CSong song in visibleSongs)
|
|
{
|
|
foreach (EGameMode mode in song.AvailableGameModes)
|
|
{
|
|
if (mode == EGameMode.TR_GAMEMODE_MEDLEY && song.NumPlayedSession <= averageCount)
|
|
ids.Add(song.ID);
|
|
}
|
|
}
|
|
// ReSharper restore LoopCanBeConvertedToQuery
|
|
|
|
if (ids.Count == 0)
|
|
{
|
|
CBase.Log.LogError("CPartyChallengeMedleyMode Error: There are no medley songs!");
|
|
CBase.Graphics.FadeTo(EScreens.ScreenParty);
|
|
return false;
|
|
}
|
|
|
|
int s = 0;
|
|
while (s < _NumSongs && ids.Count > 0)
|
|
{
|
|
int songID = ids[CBase.Game.GetRandom(ids.Count)];
|
|
CBase.Game.AddSong(songID, EGameMode.TR_GAMEMODE_MEDLEY);
|
|
ids.Remove(songID);
|
|
s++;
|
|
}
|
|
return true;
|
|
#endregion SongQueue
|
|
}
|
|
|
|
private void _SetNumJokers()
|
|
{
|
|
switch (_GameData.NumPlayerAtOnce)
|
|
{
|
|
case 1:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {10};
|
|
break;
|
|
|
|
case 2:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {5, 5};
|
|
break;
|
|
|
|
case 3:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {4, 4, 4};
|
|
break;
|
|
|
|
case 4:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {3, 3, 3, 3};
|
|
break;
|
|
|
|
case 5:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {2, 2, 2, 2, 2};
|
|
break;
|
|
|
|
case 6:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {2, 2, 2, 2, 2, 2};
|
|
break;
|
|
default:
|
|
_ScreenSongOptions.Selection.NumJokers = new int[] {5, 5};
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void _SetTeamNames()
|
|
{
|
|
CProfile[] profiles = CBase.Profiles.GetProfiles();
|
|
|
|
if (_GameData.NumPlayerAtOnce < 1 || _GameData.ProfileIDs.Count < _GameData.NumPlayerAtOnce || profiles.Length < _GameData.NumPlayerAtOnce)
|
|
{
|
|
_ScreenSongOptions.Selection.TeamNames = new string[] {"foo", "bar"};
|
|
return;
|
|
}
|
|
|
|
_ScreenSongOptions.Selection.TeamNames = new string[_GameData.NumPlayerAtOnce];
|
|
CCombination c = _GameData.Rounds.GetRound(_GameData.CurrentRoundNr - 1);
|
|
|
|
for (int i = 0; i < _GameData.NumPlayerAtOnce; i++)
|
|
{
|
|
if (c != null)
|
|
{
|
|
if (_GameData.ProfileIDs[c.Player[i]] < profiles.Length)
|
|
_ScreenSongOptions.Selection.TeamNames[i] = profiles[_GameData.ProfileIDs[c.Player[i]]].PlayerName;
|
|
else
|
|
_ScreenSongOptions.Selection.TeamNames[i] = "foobar";
|
|
}
|
|
else
|
|
_ScreenSongOptions.Selection.TeamNames[i] = "foobar";
|
|
}
|
|
}
|
|
|
|
private void _UpdateScores()
|
|
{
|
|
if (_GameData.ResultTable.Count == 0)
|
|
{
|
|
for (int i = 0; i < _GameData.NumPlayer; i++)
|
|
{
|
|
CResultTableRow row = new CResultTableRow {PlayerID = _GameData.ProfileIDs[i], NumPlayed = 0, NumWon = 0, NumSingPoints = 0, NumGamePoints = 0};
|
|
_GameData.ResultTable.Add(row);
|
|
}
|
|
|
|
_GameData.Results = new int[_GameData.NumRounds,_GameData.NumPlayerAtOnce];
|
|
for (int i = 0; i < _GameData.NumRounds; i++)
|
|
{
|
|
for (int j = 0; j < _GameData.NumPlayerAtOnce; j++)
|
|
_GameData.Results[i, j] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CPoints gamePoints = CBase.Game.GetPoints();
|
|
if (gamePoints == null || gamePoints.NumPlayer < _GameData.NumPlayerAtOnce)
|
|
return;
|
|
|
|
SPlayer[] results = gamePoints.GetPlayer(0, _GameData.NumPlayerAtOnce);
|
|
if (results == null)
|
|
return;
|
|
|
|
if (results.Length < _GameData.NumPlayerAtOnce)
|
|
return;
|
|
|
|
if (gamePoints.NumRounds == 0)
|
|
return;
|
|
|
|
for (int i = 1; i < gamePoints.NumRounds; i++)
|
|
{
|
|
SPlayer[] temp = gamePoints.GetPlayer(i, _GameData.NumPlayerAtOnce);
|
|
for (int p = 0; p < _GameData.NumPlayerAtOnce; p++)
|
|
results[p].Points += temp[p].Points;
|
|
}
|
|
|
|
for (int j = 0; j < _GameData.NumPlayerAtOnce; j++)
|
|
{
|
|
results[j].Points = results[j].Points / gamePoints.NumRounds;
|
|
_GameData.Results[_GameData.CurrentRoundNr - 2, j] = (int)Math.Round(results[j].Points);
|
|
}
|
|
|
|
List<SStats> points = _GetPointsForPlayer(results);
|
|
|
|
for (int i = 0; i < _GameData.NumPlayerAtOnce; i++)
|
|
{
|
|
int index = -1;
|
|
for (int j = 0; j < _GameData.ResultTable.Count; j++)
|
|
{
|
|
if (points[i].ProfileID == _GameData.ResultTable[j].PlayerID)
|
|
{
|
|
index = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (index != -1)
|
|
{
|
|
CResultTableRow row = _GameData.ResultTable[index];
|
|
|
|
row.NumPlayed++;
|
|
row.NumWon += points[i].Won;
|
|
row.NumSingPoints += points[i].SingPoints;
|
|
row.NumGamePoints += points[i].GamePoints;
|
|
|
|
_GameData.ResultTable[index] = row;
|
|
}
|
|
}
|
|
}
|
|
|
|
_GameData.ResultTable.Sort();
|
|
|
|
//Update position-number
|
|
int pos = 1;
|
|
int lastPoints = 0;
|
|
int lastSingPoints = 0;
|
|
foreach (CResultTableRow resultRow in _GameData.ResultTable)
|
|
{
|
|
if (lastPoints > resultRow.NumGamePoints || lastSingPoints > resultRow.NumSingPoints)
|
|
pos++;
|
|
resultRow.Position = pos;
|
|
lastPoints = resultRow.NumGamePoints;
|
|
lastSingPoints = resultRow.NumSingPoints;
|
|
}
|
|
}
|
|
|
|
private List<SStats> _GetPointsForPlayer(SPlayer[] results)
|
|
{
|
|
List<SStats> result = new List<SStats>();
|
|
for (int i = 0; i < _GameData.NumPlayerAtOnce; i++)
|
|
{
|
|
SStats stat = new SStats {ProfileID = results[i].ProfileID, SingPoints = (int)Math.Round(results[i].Points), Won = 0, GamePoints = 0};
|
|
result.Add(stat);
|
|
}
|
|
|
|
result.Sort((s1, s2) => s1.SingPoints.CompareTo(s2.SingPoints));
|
|
|
|
int current = result[result.Count - 1].SingPoints;
|
|
int points = result.Count;
|
|
bool wonset = false;
|
|
|
|
for (int i = result.Count - 1; i >= 0; i--)
|
|
{
|
|
SStats res = result[i];
|
|
|
|
if (i < result.Count - 1)
|
|
{
|
|
if (current > res.SingPoints)
|
|
{
|
|
res.GamePoints = i * 2;
|
|
wonset = true;
|
|
points = res.GamePoints;
|
|
}
|
|
else
|
|
{
|
|
if (!wonset)
|
|
res.Won = 1;
|
|
res.GamePoints = points;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
res.GamePoints = i * 2;
|
|
res.Won = 1;
|
|
}
|
|
|
|
current = res.SingPoints;
|
|
|
|
result[i] = res;
|
|
}
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
private void _CreateCatSongIndices()
|
|
{
|
|
if (_GameData.CatSongIndices == null && CBase.Songs.GetNumCategories() > 0 && _ScreenSongOptions.Sorting.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
_GameData.CatSongIndices = new int[CBase.Songs.GetNumCategories()];
|
|
for (int i = 0; i < _GameData.CatSongIndices.Length; i++)
|
|
_GameData.CatSongIndices[i] = -1;
|
|
}
|
|
|
|
if (CBase.Songs.GetNumCategories() == 0 || _ScreenSongOptions.Sorting.Tabs == EOffOn.TR_CONFIG_OFF)
|
|
_GameData.CatSongIndices = null;
|
|
}
|
|
}
|
|
} |