/// <summary>
/// Given survivor index, calculate vertical position of his result icon (escaped/killed/DC)
/// </summary>
public static int getEndgameVerticalIconOffsetForPlayer(PlayerIndex survivorIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(survivorIndex);
var resolution = ScreenCapture.getScreenshotResolutionAsString();
int vOffset = Gfx.verticalOffsetBetweenEndscorePlayerIcons[resolution][( int )survivorIndex];
//int curVerticalIconOffset = 0;
//switch ( survivorIndex )
//{
// case PlayerIndex.Survivor1:
// curVerticalIconOffset = 0;
// break;
// case PlayerIndex.Survivor2:
// curVerticalIconOffset = vOffset;
// break;
// case PlayerIndex.Survivor3:
// curVerticalIconOffset = 2 * vOffset;
// break;
// case PlayerIndex.Survivor4:
// curVerticalIconOffset = 3 * vOffset - 3;
// break;
// case PlayerIndex.Killer:
// curVerticalIconOffset = 4 * vOffset - 5;
// break;
// default:
// Debug.Assert( false, "hasEndgameScoreboardSurv1EscapeIcon() - wrong player index" );
// break;
//}
return(vOffset);
}
/// <summary>
/// We can only be missing digits at the beginning (because the number is small),
/// not in the center, or at the end. E.g. "33333" - valid,
/// "33_33" - not valid, "3333_" - not valid
/// </summary>
public static bool isDigitSequenceNotInterrupting(List <DigitEnum> digits, PlayerIndex playerIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
// Must have 5 digits for BP score
Dbg.assert(digits.Count == 5);
bool bSequenceStarted = false;
DigitEnum firstDigit = DigitEnum.Error;
DigitPosition firstDigitIndex = DigitPosition.Error;
// From left to right - For all digits in list see if sequence interrupts
for (int d = ( int )DigitPosition.DigitPos0; d <= (int)DigitPosition.DigitPos4; d++)
{
Dbg.assertDigitEnumIsInRange(digits[d]);
// We previously found a valid digit, must be followed by digits until the end
// If it's not then we have an error
if (bSequenceStarted && digits[d] == DigitEnum.Error)
{
//Dbg.onError( "Wrong BP digit sequence at pos: " + d.ToString() +
// " for player: " + playerIndex.ToString() );
return(false);
}
// Did we find the first valid digit?
if (!bSequenceStarted && digits[d] != DigitEnum.Error)
{
firstDigit = digits[d];
firstDigitIndex = ( DigitPosition )d;
bSequenceStarted = true;
}
}
// We can only have '0' at the beginning if it's the last digit (usually on DC)
if (firstDigit == DigitEnum.Digit0)
{
if (firstDigitIndex != DigitPosition.DigitPos4)
{
return(false);
}
}
return(true);
}
//public static int getHorizontalDigitOffsetForPlayer(PlayerIndex playerIndex, DigitPosition digitPos )
//{
// // We might have casted it from an int, check if it's inside enum range
// Dbg.assertPlayerIndexIsInRangeAndNotInvalid( playerIndex );
// Dbg.assertDigitPosEnumIsInRangeAndNotInvalid( digitPos );
// string resolution = ScreenCapture.getScreenshotResolutionAsString();
// //horizontalDigitOffset[ ( int )DigitPosition.DigitPos0 ] = 661; // Left-most digit
// //horizontalDigitOffset[ ( int )DigitPosition.DigitPos1 ] = 683;
// //horizontalDigitOffset[ ( int )DigitPosition.DigitPos2 ] = 715;
// //horizontalDigitOffset[ ( int )DigitPosition.DigitPos3 ] = 738;
// //horizontalDigitOffset[ ( int )DigitPosition.DigitPos4 ] = 760; // Right-most digit
// switch ( playerIndex )
// {
// case PlayerIndex.Survivor1:
// case PlayerIndex.Survivor2:
// case PlayerIndex.Survivor3:
// case PlayerIndex.Survivor4:
// return horizontalDigitOffset[ resolution ][( int )digitPos ];
// case PlayerIndex.Killer:
// // All digits except for the first one are moved by 1 pixel for killer
// if ( digitPos == DigitPosition.DigitPos0 )
// return horizontalDigitOffset[ resolution ][ ( int )digitPos ];
// return horizontalDigitOffset[ resolution ][ ( int )digitPos ] + 1;
// default:
// Dbg.onError( "Invalid player" );
// break;
// }
// Dbg.onError( "Error" );
// return 0;
//}
/// <summary>
/// digitIndex is 0 based
/// </summary>
public bool recognize(PlayerIndex playerIndex, DigitPosition digitPos, bool bDebug = false)
{
// We might have casted it from an int, check if it's inside enum range
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
Dbg.assertDigitPosEnumIsInRangeAndNotInvalid(digitPos);
string resolution = ScreenCapture.getScreenshotResolutionAsString();
//int verticalBeginningOfDigits = verticalPosOfFirstSurvivorBPDigit[ resolution ];
int horizontalOffset = horizontalDigitOffset[resolution][playerIndex][( int )digitPos];
int verticalOffset = verticalOffsetBetweenEndscorePlayerBpDigits[resolution][( int )playerIndex];
//// For killer it is moved 5 pixels down
//if ( playerIndex == PlayerIndex.Killer )
// verticalOffset = verticalOffset + 5;
return(base.recognize(horizontalOffset, verticalOffset, bDebug));
}
/// <summary>
/// Recognize all digits of BP score for a certain player
/// </summary>
public static int recognizePlayerBPNumber(PlayerIndex playerIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
// Get all 5 digits
var all5Digits = recognizeAllDigitsForPlayer(playerIndex);
// We recognized them correctly?
var bSequenceValid = isDigitSequenceNotInterrupting(all5Digits, playerIndex);
// Construct int from digit sequence
int resultInt = INVALID_BP_AMOUNT;
if (bSequenceValid)
{
resultInt = getIntFromDigitSequence(all5Digits);
}
return(resultInt);
}
/// <summary>
/// Take player index and index of a digit in BP score and return the digit.
/// E.g. digit at index '2' from BP score "14 356" will be '3'
/// </summary>
public static DigitEnum recognizeDigitAtDigitPosForPlayer(PlayerIndex playerIndex, DigitPosition digitPos)
{
// We might have casted it from an int, check if it's inside enum range
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
Dbg.assertDigitPosEnumIsInRangeAndNotInvalid(digitPos);
List <bool> boolDigitList = new List <bool>();
// Try to recognize ALL possible digits at that place
for (int d = 0; d <= 9; d++)
{
boolDigitList.Add(digit[d].recognize(playerIndex, digitPos));
}
Dbg.ensureMaxOneBoolIsTrue(boolDigitList);
// see which one is true, if any
DigitEnum recognizedDigit = DigitEnum.Error;
for (int d = (int)DigitEnum.Digit0; d <= (int)DigitEnum.Digit9; d++)
{
// Already set it before, so we have more than 1 value => error
if (boolDigitList[d] && recognizedDigit != DigitEnum.Error)
{
return(DigitEnum.Error);
}
if (boolDigitList[d])
{
recognizedDigit = ( DigitEnum )d;
}
}
Dbg.assertDigitEnumIsInRange(recognizedDigit);
return(recognizedDigit);
}
/// <summary>
/// Recognize DB number digit sequence for a given player
/// </summary>
public static List <DigitEnum> recognizeAllDigitsForPlayer(PlayerIndex playerIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
DigitEnum recognizedDigit = DigitEnum.Error;
List <DigitEnum> digits = new List <DigitEnum>();
//string sNumber = "";
// For all 5 digit positions
for (int digitPos = ( int )DigitPosition.DigitPos0; digitPos <= ( int )DigitPosition.DigitPos4; digitPos++)
{
recognizedDigit = recognizeDigitAtDigitPosForPlayer(playerIndex, ( DigitPosition )digitPos);
Dbg.assertDigitEnumIsInRange(recognizedDigit);
digits.Add(recognizedDigit);
//sNumber = sNumber + ( ( int )recognizedDigit ).ToString();
}
return(digits);
}
public bool isBpAmountSet(PlayerIndex playerIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
return(this.playerBpAmount[( int )playerIndex] != EndscoreBpDigitGfx.INVALID_BP_AMOUNT);
}
public int getBpAmount(PlayerIndex playerIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
return(this.playerBpAmount[(int)playerIndex]);
}
/// <summary>
/// Set BP amount for survivor or killer
/// </summary>
public void setBpAmount(PlayerIndex playerIndex, int myBpAmount)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(playerIndex);
this.playerBpAmount[( int )playerIndex] = myBpAmount;
}
/// <summary>
/// Survivor or Killer DCed
/// </summary>
public bool isPlayerDCed(int survivorIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid((PlayerIndex)survivorIndex);
return(getSurvivorResultIcon(survivorIndex) == EndgameSurvivorIcon.DCed);
}
/// <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);
}
}
/// <summary>
/// Index is 0-3 (not 1-4).
/// </summary>
public EndgameSurvivorIcon getSurvivorResultIcon(int survivorIndex)
{
Dbg.assertPlayerIndexIsInRangeAndNotInvalid(( PlayerIndex )survivorIndex);
return(this.playerIconList[survivorIndex]);
}
