public List <HighScoreEntry> TryGetEntries(GameModeSetting setting)
{
List <HighScoreEntry> entries;
entryLists.TryGetValue(setting, out entries);
return(entries);
}
public void ToHighScores(PlayModel playModel, GameModeSetting currentSetting)
{
playUI.Unsubscribe(playModel);
playUI.Deactivate();
highScoreUI.Activate(currentSetting, playModel.Score);
}
public void Activate(GameModeSetting setting, int newScore)
{
gameObject.SetActive(true);
settingsDisplayUI.Activate(setting);
nameField.text = "";
scoreDisplay.SetValue(newScore);
}
public static void SendRPCToPlayer(PhotonPlayer player)
{
Hashtable hash = new Hashtable();
string vanillaString = string.Empty;
string anarchyString = string.Empty;
int count = 0;
for (int i = 0; i < allGameSettings.Count; i++)
{
GameModeSetting set = allGameSettings[i];
if (set.Enabled)
{
set.WriteToHashtable(hash);
count++;
if (!player.AnarchySync && set is AnarchyGameModeSetting setting)
{
if (anarchyString.Length > 0)
{
anarchyString += "\n";
}
anarchyString += setting.ToString();
}
else if (!player.RCSync)
{
if (vanillaString.Length > 0)
{
vanillaString += "\n";
}
vanillaString += set.ToString();
}
}
}
if (count <= 0)
{
if (MOTD.Value.Length > 0)
{
FengGameManagerMKII.FGM.BasePV.RPC("Chat", player, new object[] { "MOTD: " + MOTD.Value, string.Empty });
}
return;
}
FengGameManagerMKII.FGM.BasePV.RPC("settingRPC", player, new object[] { hash });
if (!player.RCSync & vanillaString.Length > 0)
{
FengGameManagerMKII.FGM.BasePV.RPC("Chat", player, new object[] { vanillaString, string.Empty });
}
if (!player.AnarchySync && anarchyString.Length > 0)
{
FengGameManagerMKII.FGM.BasePV.RPC("Chat", player, new object[] { anarchyString, string.Empty });
}
if (MOTD.Value != string.Empty)
{
FengGameManagerMKII.FGM.BasePV.RPC("Chat", player, new object[] { "MOTD: " + MOTD.Value, string.Empty });
}
}
public static void AddSetting(GameModeSetting set)
{
if (allGameSettings == null)
{
allGameSettings = new List <GameModeSetting>();
}
if (!allGameSettings.Contains(set))
{
allGameSettings.Add(set);
}
}
public static void SendRPC()
{
StringBuilder bld = new StringBuilder();
Hashtable hash = new Hashtable();
int count = 0;
int countSend = 0;
for (int i = 0; i < allGameSettings.Count; i++)
{
GameModeSetting set = allGameSettings[i];
if (set.Enabled && !set.HasChanged)
{
set.WriteToHashtable(hash);
count++;
continue;
}
if (set.HasChanged)
{
bool oldstate = set.State;
set.Apply();
if (oldstate != set.State && set.State == false)
{
set.Save();
continue;
}
set.WriteToHashtable(hash);
if (countSend > 0)
{
bld.Append("\n");
}
bld.Append(set.ToStringLocal());
set.Save();
count++;
countSend++;
}
}
if (count <= 0)
{
return;
}
if (InfectionMode.Enabled)
{
InfectionUpdate();
}
if (TeamMode.Enabled)
{
SendTeamInfo();
}
FengGameManagerMKII.FGM.BasePV.RPC("settingRPC", PhotonTargets.Others, new object[] { hash });
if (bld.ToString() != string.Empty)
{
Chat.Add(bld.ToString());
}
}
public static void AnarchySettingCallback(GameModeSetting set, bool state, bool received)
{
if (PhotonNetwork.IsMasterClient && !received)
{
PhotonPlayer[] targets = PhotonPlayer.GetNotAnarchyUsers();
if (targets.Length <= 0)
{
return;
}
FengGameManagerMKII.FGM.BasePV.RPC("Chat", targets, new object[] { set.ToString(), string.Empty });
}
}
public void StartGame(int gameDurationInSeconds, int slotCount)
{
playModel = new PlayModel();
currentGameModeSetting = new GameModeSetting(gameDurationInSeconds, slotCount);
targetGenerator.GenerateTargets(slotCount);
List <RoundDefinition> roundDefinitions = roundsGenerator.GenerateRounds(gameDurationInSeconds, slotCount);
roundsController.StartRounds(roundsGenerator.TargetTypeCollection, roundDefinitions, playModel);
roundsController.OnRoundsFinished += EndGame;
platformLoader.SelectionManager.IsBlocked = false;
OnGameStart?.Invoke(playModel, gameDurationInSeconds);
}
public void Activate(List <HighScoreEntry> entries, GameModeSetting setting)
{
gameObject.SetActive(true);
settingsDisplayUI.Activate(setting);
for (int i = 0; i < displayUIs.Count; i++)
{
HighScoreEntry entryToShow = null;
if (entries != null && entries.Count > i)
{
entryToShow = entries[i];
}
displayUIs[i].ShowHighScoreEntry((i + 1).ToString(), entryToShow);
}
}
private static void CheckCustomSpawn(GameModeSetting set, bool state, int selection, float[] floats, int[] integers)
{
if (state)
{
float summ = 0f;
for (int i = 0; i < 5; i++)
{
summ += floats[i];
}
if (summ > 100f)
{
for (int i = 0; i < 5; i++)
{
floats[i] = 20f;
}
}
}
}
private void GameSystem(GameModeSetting setting)
{
switch (setting)
{
case GameModeSetting.BasicMode:
SpawnWave();
break;
case GameModeSetting.MediumMode:
break;
case GameModeSetting.HardMode:
break;
default:
break;
}
}
public void AddHighScore(GameModeSetting setting, HighScoreEntry newEntry, int maxEntries)
{
List <HighScoreEntry> entries;
if (entryLists.ContainsKey(setting))
{
entries = entryLists[setting];
int entryCount = entries.Count;
if (entries[entryCount - 1].Points >= newEntry.Points)
{
entries.Add(newEntry);
entryCount++;
}
else
{
for (int i = 0; i < entryCount; i++)
{
if (entries[i].Points >= newEntry.Points)
{
continue;
}
entries.Insert(i, newEntry);
entryCount++;
break;
}
}
while (entryCount > maxEntries)
{
entries.RemoveAt(maxEntries);
entryCount--;
}
}
else
{
//no entries yet
entries = new List <HighScoreEntry>();
entries.Add(newEntry);
entryLists[setting] = entries;
}
}
public static void HandleRPC(Hashtable hash)
{
if (oldHash.Equals(hash))
{
return;
}
int count = 0;
StringBuilder bld = new StringBuilder();
for (int i = 0; i < allGameSettings.Count; i++)
{
GameModeSetting set = allGameSettings[i];
set.ReadFromHashtable(hash);
if (set.HasChangedReceived)
{
set.ApplyReceived();
if (count > 0)
{
bld.Append("\n");
}
bld.Append(set.ToStringLocal());
count++;
}
}
if (hash.ContainsKey("motd") && oldHash.ContainsKey("motd") && oldHash["motd"] as string != hash["motd"] as string)
{
if (count > 0)
{
bld.Append("\n");
}
bld.Append("MOTD: " + hash["motd"].ToString());
}
oldHash = new Hashtable();
Dictionary <object, object> clone = (Dictionary <object, object>)hash.Clone();
foreach (KeyValuePair <object, object> pair in clone)
{
oldHash.Add(pair.Key, pair.Value);
}
Chat.Add(bld.ToString());
}
public void Activate(GameModeSetting setting, int newScore)
{
gameObject.SetActive(true);
currentSetting = setting;
List <HighScoreEntry> entries = highScoreManager.TryGetEntries(setting);
bool addNewEntry = false;
if (entries != null)
{
if (entries.Count <= 0)
{
addNewEntry = true;
}
else
{
HighScoreEntry lastEntry = entries[entries.Count - 1];
//equal scores can be added after the existing entry
if (lastEntry.Points < newScore || entries.Count < highScoreManager.EntriesSavedPerSetting)
{
addNewEntry = true;
}
}
}
else
{
addNewEntry = true;
}
if (addNewEntry)
{
highScoreNewUI.Activate(currentSetting, newScore);
}
else
{
highScoreListUI.Activate(entries, currentSetting);
}
}
public void Read(BinaryReader reader)
{
entryLists.Clear();
BinaryFormatter formatter = new BinaryFormatter();
//read size
int dictionarySize = reader.ReadInt32();
//read key value pairs
for (int i = 0; i < dictionarySize; i++)
{
GameModeSetting key = (GameModeSetting)formatter.Deserialize(reader.BaseStream);
int listSize = reader.ReadInt32();
List <HighScoreEntry> value = new List <HighScoreEntry>();
for (int j = 0; j < listSize; j++)
{
value.Add((HighScoreEntry)formatter.Deserialize(reader.BaseStream));
}
entryLists[key] = value;
}
}
public void AddEntry(GameModeSetting setting, HighScoreEntry newEntry)
{
highScoreContainer.AddHighScore(setting, newEntry, entriesSavedPerSetting);
saveService.Save(highScoreContainer);
}
public List <HighScoreEntry> TryGetEntries(GameModeSetting setting)
{
return(highScoreContainer.TryGetEntries(setting));
}
public void Activate(GameModeSetting settings)
{
gameObject.SetActive(true);
timeDisplay.SetValue(settings.DurationInS);
holesDisplay.SetValue(settings.Slots);
}
