private static PlayerIndex parsePlayerIndexField(string sPlayerIndexValue)
{
sPlayerIndexValue = sPlayerIndexValue.Trim();
if (sPlayerIndexValue == "0")
{
return(PlayerIndex.Survivor1);
}
else if (sPlayerIndexValue == "1")
{
return(PlayerIndex.Survivor2);
}
else if (sPlayerIndexValue == "2")
{
return(PlayerIndex.Survivor3);
}
else if (sPlayerIndexValue == "3")
{
return(PlayerIndex.Survivor4);
}
else if (sPlayerIndexValue == "4")
{
return(PlayerIndex.Killer);
}
else
{
Dbg.onDebugError("Loaded invalid player index: " + sPlayerIndexValue);
}
return(PlayerIndex.Error);
}
private static EndgameSurvivorIcon parsePlayerResultField(string sPlayerResultValue)
{
sPlayerResultValue = sPlayerResultValue.Trim();
if (sPlayerResultValue == gameLineSurvivorResultEscaped)
{
return(EndgameSurvivorIcon.Escaped);
}
else if (sPlayerResultValue == gameLineSurvivorResultSacrificed)
{
return(EndgameSurvivorIcon.KilledSacrificed);
}
else if (sPlayerResultValue == gameLineSurvivorResultMoried)
{
return(EndgameSurvivorIcon.KilledBleedoutOrMoried);
}
else if (sPlayerResultValue == gameLineSurvivorResultStillPlaying)
{
return(EndgameSurvivorIcon.SurvIconStillPlaying);
}
else if (sPlayerResultValue == gameLineSurvivorResultDCed)
{
return(EndgameSurvivorIcon.DCed);
}
else if (sPlayerResultValue == gameLineSurvivorResultNoPlayer)
{
return(EndgameSurvivorIcon.NoPlayer);
}
else
{
Dbg.onDebugError("Wrong surv result loaded: " + sPlayerResultValue);
}
return(EndgameSurvivorIcon.Error);
}
public void loadSettingValueFromConfig(string key, string value)
{
switch (key)
{
case Config.keyActionBringGameToFront:
setBringGameToFront(bool.Parse(value));
break;
case Config.keyActionMustPlaySound:
setMustPlaySound(bool.Parse(value));
break;
case Config.keyActionSoundName:
var soundEnum = Sound.getSoundsEnumFromSoundsEnumString(value);
Dbg.assert(soundEnum != null);
setSoundName((SoundsEnum)soundEnum);
break;
case Config.keyActionPlayLooped:
setPlaySoundLooped(bool.Parse(value));
break;
default:
Dbg.onDebugError("Unknown action setting: " + key);
break;
}
}
public static object getConfigValue(string sFieldName)
{
sFieldName = sFieldName.Trim();
if (!settingValues.ContainsKey(sFieldName))
{
Dbg.onDebugError("No such config key: " + sFieldName);
return(null);
}
return(settingValues[sFieldName]);
}
public static void load()
{
// Exit if no stats file
if (!File.Exists(filePath))
{
return;
}
Dbg.assert(Stats.getGames().Count == 0, "Trying to load stats while they are already loaded, " +
"might lose loaded stats");
if (Stats.getGames().Count > 0)
{
return;
}
List <GameResult> games = new List <GameResult>();
GameResult game = null;
using (StreamReader file = new StreamReader(filePath))
{
while (!file.EndOfStream)
{
var line = file.ReadLine();
game = null;
try
{
game = parseGameLine(line);
}
catch (Exception e)
{
Dbg.onDebugError("Error loading stats line: " + e.ToString());
}
if (game != null)
{
games.Add(game);
}
}
}
Stats.setGames(games);
bStatsLoaded = true;
}
/// <summary>
/// "Notify 2" => Sounds.Notify2
/// </summary>
public static SoundsEnum getSoundFromSoundName(string sSoundName)
{
sSoundName = sSoundName.Trim();
Dbg.assert(soundsToString.ContainsValue(sSoundName));
foreach (var kvp in soundsToString)
{
if (kvp.Value == sSoundName)
{
return(kvp.Key);
}
}
Dbg.onDebugError("Wrong sound name: " + sSoundName);
return(SoundsEnum.None);
}
/// <summary>
/// Save to disk
/// </summary>
public static void save()
{
Dbg.assert(bStatsLoaded, "Trying to save stats without loading them first," +
" might delete all stats this way");
if (!bStatsLoaded)
{
return;
}
//var comment = ";playerIndex(0-4)/s0_res/s1_res/s2_res/s3_res/k_res/pip?/duration/date/BP/killer_surv_name/";
var ver = "ver=1.0";
var result = ver + "\n\n";
using (StreamWriter file = new StreamWriter(filePath))
{
foreach (var game in Stats.getGames())
{
var gameResult = "";
try
{
gameResult = game.getStringForSaving();
}
catch (Exception e)
{
Dbg.onDebugError("Error saving stats line: " + e.ToString());
}
// Make more readable
gameResult = gameResult.Replace(gameFieldsSeparator, " " + gameFieldsSeparator + " ");
result = result + "\n" + gameResult;
// write line by line, in case we get an error and lose some data
file.WriteLine(gameResult);
file.Flush();
}
//file.Write( result );
}
}
public GameRole getMyGameRole()
{
// Get player role in this game
switch (myPlayerIndex)
{
case PlayerIndex.Killer:
return(GameRole.Killer);
case PlayerIndex.Survivor1:
case PlayerIndex.Survivor2:
case PlayerIndex.Survivor3:
case PlayerIndex.Survivor4:
return(GameRole.Survivor);
case PlayerIndex.Error:
default:
Dbg.onDebugError("Invalid selected player index");
break;
}
return(GameRole.Error);
}
/// <summary>
/// Get string for saving to disk
/// </summary>
public string getStringForSaving()
{
// Player index
var playerIndexEnum = getSelectedPlayerIndex();
int playerIndex = ( int )playerIndexEnum;
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndexEnum);
string surv1Result = _resultIconToString(getSurvivorResultIcon(0));
string surv2Result = _resultIconToString(getSurvivorResultIcon(1));
string surv3Result = _resultIconToString(getSurvivorResultIcon(2));
string surv4Result = _resultIconToString(getSurvivorResultIcon(3));
string killerResult = "";
string pipResult = "";
string gameDuration = "";
string myCharacterName = "";
return(StatSaver.lineGameStat + StatSaver.lineNameSeparator + StatSaver.gameLinePlayerIndexField +
StatSaver.gameFieldValueSeparator + playerIndex + StatSaver.gameFieldsSeparator +
StatSaver.gameLineSurvivor1ResultField + StatSaver.gameFieldValueSeparator +
surv1Result + StatSaver.gameFieldsSeparator + StatSaver.gameLineSurvivor2ResultField +
StatSaver.gameFieldValueSeparator + surv2Result + StatSaver.gameFieldsSeparator +
StatSaver.gameLineSurvivor3ResultField + StatSaver.gameFieldValueSeparator + surv3Result +
StatSaver.gameFieldsSeparator + StatSaver.gameLineSurvivor4ResultField +
StatSaver.gameFieldValueSeparator + surv4Result + StatSaver.gameFieldsSeparator +
// Killer result
StatSaver.gameLineKillerField + StatSaver.gameFieldValueSeparator + killerResult + StatSaver.gameFieldsSeparator +
// Pipped?
"p" + StatSaver.gameFieldValueSeparator + pipResult + StatSaver.gameFieldsSeparator +
// Game type
getKeyValuePair(StatSaver.gameLineGameType, this.getGameType().ToString()) +
// Bloodpoints
getKeyValuePair(StatSaver.gameLineSurvivor1BP, getBpAmount(PlayerIndex.Survivor1).ToString()) +
getKeyValuePair(StatSaver.gameLineSurvivor2BP, getBpAmount(PlayerIndex.Survivor2).ToString()) +
getKeyValuePair(StatSaver.gameLineSurvivor3BP, getBpAmount(PlayerIndex.Survivor3).ToString()) +
getKeyValuePair(StatSaver.gameLineSurvivor4BP, getBpAmount(PlayerIndex.Survivor4).ToString()) +
getKeyValuePair(StatSaver.gameLineKillerBP, getBpAmount(PlayerIndex.Killer).ToString()) +
//StatSaver.gameLineBloodpoints + StatSaver.gameFieldValueSeparator + getMyBpAmount() + StatSaver.gameFieldsSeparator +
// Match duration
StatSaver.gameLineMatchDuration + StatSaver.gameFieldValueSeparator + gameDuration + StatSaver.gameFieldsSeparator +
// Date
StatSaver.gameLineDate + StatSaver.gameFieldValueSeparator + Utils.getCurrentDateAsString(this.getDate()) + StatSaver.gameFieldsSeparator +
// Name of Killer/Survivor played this game
"n" + StatSaver.gameFieldValueSeparator + myCharacterName);
string getKeyValuePair(string keyOfValue, string value)
{
return(keyOfValue + StatSaver.gameFieldValueSeparator + value + StatSaver.gameFieldsSeparator);
}
string _resultIconToString(EndgameSurvivorIcon icon)
{
string result = "error";
if (icon == EndgameSurvivorIcon.Escaped)
{
result = StatSaver.gameLineSurvivorResultEscaped;
}
else if (icon == EndgameSurvivorIcon.KilledSacrificed)
{
result = StatSaver.gameLineSurvivorResultSacrificed;
}
else if (icon == EndgameSurvivorIcon.KilledBleedoutOrMoried)
{
result = StatSaver.gameLineSurvivorResultMoried;
}
else if (icon == EndgameSurvivorIcon.DCed)
{
result = StatSaver.gameLineSurvivorResultDCed;
}
else if (icon == EndgameSurvivorIcon.SurvIconStillPlaying)
{
result = StatSaver.gameLineSurvivorResultStillPlaying;
}
else
{
// in a custom game this player spot might not be filled, if not
// all 4 survivors are playing
if (this.getGameType() == Stats.GameType.CustomGame)
{
result = StatSaver.gameLineSurvivorResultNoPlayer;
}
else
{
Dbg.onDebugError("Wrong result: " + icon.ToString());
}
}
return(result);
}
}
