protected virtual bool TryDecryptBody(PokerKingPackage package, Process process, IEmulatorService emulatorService, bool withRepeat = true)
{
try
{
if (!userTokens.TryGetValue(package.UserId, out string token))
{
withRepeat = false;
LogProvider.Log.Info(Logger, $"Token for user #{package.UserId} not found");
// read token from emulator
var loginResponses = emulatorService.ExecuteAdbCommand(process,
Encoding.ASCII.GetString(arg1),
Encoding.ASCII.GetString(arg2));
foreach (var loginResponseXml in loginResponses)
{
if (!PKLoginResponse.TryParse(loginResponseXml, out PKLoginResponse loginResponse))
{
LogProvider.Log.Warn(Logger, $"Failed to parse token for user #{package.UserId} from response.");
continue;
}
userTokens.AddOrUpdate(loginResponse.UserId, loginResponse.UserToken, (dictKey, oldValue) => loginResponse.UserToken);
LogProvider.Log.Info(Logger, $"Token for user #{loginResponse.UserId} has been updated.");
if (loginResponse.UserId == package.UserId)
{
token = loginResponse.UserToken;
}
}
if (string.IsNullOrEmpty(token))
{
LogProvider.Log.Warn(Logger, $"Failed to find token for user #{package.UserId}.");
return(false);
}
}
var key = Encoding.ASCII.GetBytes(token);
package.Body = PKCipherHelper.Decode(key, package.Body);
return(true);
}
catch (Exception e)
{
if (withRepeat)
{
LogProvider.Log.Warn(Logger, $"Failed to read the body of user #{package.UserId} room #{package.RoomId}. Removing invalid token.");
userTokens.TryRemove(package.UserId, out string removeToken);
return(TryDecryptBody(package, process, emulatorService, false));
}
LogProvider.Log.Error(Logger, $"Couldn't read the body of {package.PackageType} user #{package.UserId} room #{package.RoomId}", e);
}
return(false);
}
/// <summary>
/// Checks whenever the specified package has to be processed
/// </summary>
/// <param name="package">Package to check</param>
/// <returns></returns>
protected static bool IsAllowedPackage(PokerKingPackage package)
{
switch (package.PackageType)
{
case PackageType.NoticeBuyin:
case PackageType.NoticeGameAnte:
case PackageType.NoticeGameBlind:
case PackageType.NoticeGameCommunityCards:
case PackageType.NoticeGameElectDealer:
case PackageType.NoticeGameHoleCard:
case PackageType.NoticeGamePost:
case PackageType.NoticeGameRoundEnd:
case PackageType.NoticeGameSettlement:
case PackageType.NoticeGameShowCard:
case PackageType.NoticeGameShowDown:
case PackageType.NoticeGameSnapShot:
case PackageType.NoticePlayerAction:
case PackageType.NoticePlayerShowCard:
case PackageType.NoticePlayerStayPosition:
case PackageType.NoticeResetGame:
case PackageType.NoticeStartGame:
case PackageType.NoticeQuickLeave:
case PackageType.RequestLeaveRoom:
case PackageType.RequestJoinRoom:
case PackageType.RequestQuickFold:
return(true);
default:
return(false);
}
}
public bool IsRoomSnapShotAvailable(PokerKingPackage package)
{
if (package == null || package.RoomId == 0)
{
return(false);
}
return(roomsData.ContainsKey(package.RoomId));
}
private void ParsePackage <T>(PokerKingPackage package, Action <T> action)
{
if (!SerializationHelper.TryDeserialize(package.Body, out T packageBody))
{
throw new DHInternalException(new NonLocalizableString($"Failed to deserialize package of {package.PackageType} type."));
}
action?.Invoke(packageBody);
}
public NoticeGameSnapShot GetNoticeRoomSnapShot(PokerKingPackage package)
{
if (package == null || package.RoomId == 0 ||
!roomsData.TryGetValue(package.RoomId, out NoticeGameSnapShot noticeGameSnapShot))
{
return(null);
}
return(noticeGameSnapShot);
}
/// <summary>
/// Parses package body into the specified type <see cref="{T}"/>, then performs <paramref name="onSuccess"/> if parsing succeed,
/// or <paramref name="onFail"/> if parsing failed
/// </summary>
/// <typeparam name="T">Type of the package body</typeparam>
/// <param name="package">Package to parse</param>
/// <param name="onSuccess">Action to perform if parsing succeed</param>
/// <param name="onFail">Action to perform if parsing failed</param>
protected virtual void ParsePackage <T>(PokerKingPackage package, Action <T> onSuccess, Action onFail)
{
if (SerializationHelper.TryDeserialize(package.Body, out T packageBody))
{
onSuccess?.Invoke(packageBody);
return;
}
LogProvider.Log.Warn(Logger, $"Failed to deserialize {typeof(T)} package for user #{package.UserId} room #{package.RoomId}");
onFail?.Invoke();
}
public void LogPackage(CapturedPacket capturedPacket, PokerKingPackage package)
{
var port = destinationPorts.Contains(capturedPacket.Destination.Port) ? capturedPacket.Destination.Port : capturedPacket.Source.Port;
if (!loggers.TryGetValue(port, out DebugPKLogger logger))
{
logger = new DebugPKLogger(port);
loggers.Add(port, logger);
}
protectedLogger = logger;
base.LogPackage(package);
}
private PokerKingPackage BuildPackage <T>(PKTestSourcePacket packet)
{
var contentObject = JsonConvert.DeserializeObject <T>(packet.Content.ToString(), new StringEnumConverter());
Assert.IsNotNull(contentObject, $"Content object of {typeof(T)} must be not null.");
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, contentObject);
var bytes = ms.ToArray();
var package = new PokerKingPackage
{
PackageType = packet.PackageType,
Body = bytes,
Timestamp = packet.Time
};
return(package);
}
}
public void CleanFastFoldRooms(PokerKingPackage package, int identifier, out List <HandHistory> handHistories)
{
handHistories = new List <HandHistory>();
if (!userPackages.TryGetValue(identifier, out Dictionary <int, List <PokerKingPackage> > roomsPackages))
{
fastFoldRoomByUser.Remove(package.UserId);
return;
}
foreach (var packages in roomsPackages.Values)
{
var handHistory = BuildHand(packages, identifier, package.UserId, true);
if (handHistory != null)
{
handHistories.Add(handHistory);
}
}
fastFoldRoomByUser.Remove(package.UserId);
}
protected virtual void LogPackage <T>(PokerKingPackage package)
{
try
{
#if DEBUG
if (!SerializationHelper.TryDeserialize(package.Body, out T packageContent))
{
LogProvider.Log.Warn(Logger, $"Failed to deserialize {typeof(T)} package");
}
var packageJson = new PackageJson <T>
{
PackageType = package.PackageType,
Content = packageContent,
Time = package.Timestamp,
UserId = package.UserId,
RoomId = package.RoomId,
IsFastFold = package.IsFastFold
};
var json = JsonConvert.SerializeObject(packageJson, Formatting.Indented, new StringEnumConverter());
protectedLogger.Log(json);
#else
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, package);
var packageBytes = ms.ToArray();
var logText = Encoding.UTF8.GetString(packageBytes);
protectedLogger.Log(logText);
}
#endif
}
catch (Exception e)
{
LogProvider.Log.Error(Logger, "Failed to log package", e);
}
}
public bool TryBuild(PokerKingPackage package, int identifier, out HandHistory handHistory)
{
handHistory = null;
if (package == null || identifier == 0)
{
return(false);
}
if (package.PackageType == PackageType.NoticeGameSnapShot)
{
ParsePackage <NoticeGameSnapShot>(package, x => ProcessNoticeGameSnapShot(x, package));
return(false);
}
if (!userPackages.TryGetValue(identifier, out Dictionary <int, List <PokerKingPackage> > roomPackages))
{
roomPackages = new Dictionary <int, List <PokerKingPackage> >();
userPackages.Add(identifier, roomPackages);
}
if (!roomPackages.TryGetValue(package.RoomId, out List <PokerKingPackage> packages))
{
packages = new List <PokerKingPackage>();
roomPackages.Add(package.RoomId, packages);
}
packages.Add(package);
if (package.PackageType == PackageType.NoticeGameSettlement)
{
handHistory = BuildHand(packages, identifier, package.UserId);
}
return(handHistory != null);
}
protected virtual void ExportHandHistory(PokerKingPackage package, HandHistory handHistory, IntPtr windowHandle,
ConcurrentDictionary <long, List <HandHistoryData> > handHistoriesToProcess, bool unexpectedRoomDetected)
{
var handHistoryData = new HandHistoryData
{
Uuid = package.UserId,
HandHistory = handHistory,
WindowHandle = !unexpectedRoomDetected ? windowHandle : IntPtr.Zero
};
if (!pkCatcherService.CheckHand(handHistory))
{
LogProvider.Log.Info(Logger, $"License doesn't support cash hand {handHistory.HandId}. [BB={handHistory.GameDescription.Limit.BigBlind}]");
if (handHistoryData.WindowHandle != IntPtr.Zero)
{
SendPreImporedData("Notifications_HudLayout_PreLoadingText_PK_NoLicense", windowHandle);
}
return;
}
ExportHandHistory(handHistoryData, handHistoriesToProcess);
}
protected override void LogPackage(PokerKingPackage package)
{
}
public new void ParsePackage <T>(PokerKingPackage package, Action <T> onSuccess, Action onFail)
{
base.ParsePackage(package, onSuccess, onFail);
}
private void ProcessNoticeGameSnapShot(NoticeGameSnapShot noticeGameSnapShot, PokerKingPackage package)
{
if (package.IsFastFold && !fastFoldRoomByUser.ContainsKey(package.UserId))
{
fastFoldRoomByUser[package.UserId] = noticeGameSnapShot.RoomId;
}
if (!roomsData.ContainsKey(noticeGameSnapShot.RoomId))
{
roomsData.Add(noticeGameSnapShot.RoomId, noticeGameSnapShot);
LogProvider.Log.Info(CustomModulesNames.PKCatcher, $"Snapshot of room {noticeGameSnapShot.RoomId} has been stored.");
return;
}
roomsData[noticeGameSnapShot.RoomId] = noticeGameSnapShot;
LogProvider.Log.Info(CustomModulesNames.PKCatcher, $"Snapshot of room {noticeGameSnapShot.RoomId} has been updated.");
}
public new static bool IsAllowedPackage(PokerKingPackage package)
{
return(PKImporter.IsAllowedPackage(package));
}
private void ProcessNoticeGameBlind(NoticeGameBlind noticeGameBlind, HandHistory handHistory, PokerKingPackage package)
{
if (!roomsData.TryGetValue(noticeGameBlind.RoomId, out NoticeGameSnapShot noticeGameSnapShot))
{
throw new HandBuilderException(handHistory.HandId, $"NoticeGameSnapShot has not been found for room #{noticeGameBlind.RoomId}.");
}
var gameRoomInfo = noticeGameSnapShot.Params ?? throw new HandBuilderException(handHistory.HandId, "NoticeGameSnapShot.Params must be not empty.");
var ante = Math.Abs(handHistory.HandActions.Where(x => x.HandActionType == HandActionType.ANTE).MaxOrDefault(x => x.Amount));
if (ante != 0)
{
ante = ante < gameRoomInfo.RuleAnteAmount ? gameRoomInfo.RuleAnteAmount : ante;
}
TableType tableType;
if (package.IsFastFold)
{
tableType = TableType.FromTableTypeDescriptions(TableTypeDescription.FastFold);
}
else
{
tableType = TableType.FromTableTypeDescriptions(gameRoomInfo.GameMode == 3 ? TableTypeDescription.ShortDeck : TableTypeDescription.Regular);
}
handHistory.GameDescription = new GameDescriptor(
EnumPokerSites.PokerKing,
GameType.NoLimitHoldem,
Limit.FromSmallBlindBigBlind(noticeGameBlind.SBAmount, noticeGameBlind.BBAmount, Currency.YUAN, ante != 0, ante),
tableType,
SeatType.FromMaxPlayers(gameRoomInfo.PlayerCountMax), null);
handHistory.GameDescription.Identifier = package.IsFastFold && fastFoldRoomByUser.ContainsKey(package.UserId) ?
fastFoldRoomByUser[package.UserId] : noticeGameBlind.RoomId;
handHistory.TableName = gameRoomInfo.GameName;
if (noticeGameBlind.SBAmount > 0)
{
handHistory.HandActions.Add(new HandAction(GetPlayerName(handHistory, noticeGameBlind.SBSeatId + 1),
HandActionType.SMALL_BLIND,
noticeGameBlind.SBAmount,
Street.Preflop));
}
handHistory.HandActions.Add(new HandAction(GetPlayerName(handHistory, noticeGameBlind.BBSeatId + 1),
HandActionType.BIG_BLIND,
noticeGameBlind.BBAmount,
Street.Preflop));
var maxStraddleAmount = 0;
if (noticeGameBlind.StraddleSeatList != null && noticeGameBlind.StraddleSeatList.Length > 0 &&
noticeGameBlind.StraddleAmountList != null && noticeGameBlind.StraddleAmountList.Length == noticeGameBlind.StraddleSeatList.Length)
{
for (var straddleIndex = 0; straddleIndex < noticeGameBlind.StraddleSeatList.Length; straddleIndex++)
{
var straddleSeat = noticeGameBlind.StraddleSeatList[straddleIndex];
var straddleAmount = noticeGameBlind.StraddleAmountList[straddleIndex];
if (straddleSeat < 0 || straddleAmount <= 0)
{
continue;
}
handHistory.HandActions.Add(new HandAction(GetPlayerName(handHistory, straddleSeat + 1),
HandActionType.STRADDLE,
straddleAmount,
Street.Preflop));
if (maxStraddleAmount < straddleAmount)
{
maxStraddleAmount = straddleAmount;
}
handHistory.GameDescription.IsStraddle = true;
}
}
if (noticeGameBlind.PostSeatList != null)
{
var postAmount = handHistory.GameDescription.IsStraddle ? maxStraddleAmount : noticeGameBlind.BBAmount;
foreach (var postSeat in noticeGameBlind.PostSeatList)
{
handHistory.HandActions.Add(new HandAction(GetPlayerName(handHistory, postSeat + 1),
HandActionType.POSTS,
postAmount,
Street.Preflop));
}
}
}
private IEnumerable <PokerKingPackage> ReadPackages(string folder)
{
var packages = new List <PokerKingPackage>();
var jsonFile = Path.Combine(TestDataFolder, folder, SourceJsonFile);
FileAssert.Exists(jsonFile);
PKTestSourceObject testSourceObject = null;
try
{
var jsonFileContent = File.ReadAllText(jsonFile);
testSourceObject = JsonConvert.DeserializeObject <PKTestSourceObject>(jsonFileContent, new StringEnumConverter());
}
catch (Exception e)
{
Assert.Fail($"{ExpectedResultFile} in {folder} has not been deserialized: {e}");
}
Assert.IsNotNull(testSourceObject);
foreach (var packet in testSourceObject.Packets)
{
PokerKingPackage package = null;
switch (packet.PackageType)
{
case PackageType.RequestLeaveRoom:
package = BuildPackage <RequestLeaveRoom>(packet);
break;
case PackageType.NoticeStartGame:
package = BuildPackage <NoticeStartGame>(packet);
break;
case PackageType.NoticeResetGame:
package = BuildPackage <NoticeResetGame>(packet);
break;
case PackageType.NoticeGamePost:
package = BuildPackage <NoticeGamePost>(packet);
break;
case PackageType.NoticeGameAnte:
package = BuildPackage <NoticeGameAnte>(packet);
break;
case PackageType.NoticeGameElectDealer:
package = BuildPackage <NoticeGameElectDealer>(packet);
break;
case PackageType.NoticeGameBlind:
package = BuildPackage <NoticeGameBlind>(packet);
break;
case PackageType.NoticeGameHoleCard:
package = BuildPackage <NoticeGameHoleCard>(packet);
break;
case PackageType.NoticePlayerAction:
package = BuildPackage <NoticePlayerAction>(packet);
break;
case PackageType.NoticeGameRoundEnd:
package = BuildPackage <NoticeGameRoundEnd>(packet);
break;
case PackageType.NoticeGameCommunityCards:
package = BuildPackage <NoticeGameCommunityCards>(packet);
break;
case PackageType.NoticeGameShowCard:
package = BuildPackage <NoticeGameShowCard>(packet);
break;
case PackageType.NoticeGameSettlement:
package = BuildPackage <NoticeGameSettlement>(packet);
break;
case PackageType.NoticeGameShowDown:
package = BuildPackage <NoticeGameShowDown>(packet);
break;
case PackageType.NoticePlayerStayPosition:
package = BuildPackage <NoticePlayerStayPosition>(packet);
break;
case PackageType.NoticePlayerShowCard:
package = BuildPackage <NoticePlayerShowCard>(packet);
break;
case PackageType.NoticeBuyin:
package = BuildPackage <NoticeBuyin>(packet);
break;
case PackageType.NoticeGameSnapShot:
package = BuildPackage <NoticeGameSnapShot>(packet);
break;
case PackageType.RequestHeartBeat:
package = BuildPackage <RequestHeartBeat>(packet);
break;
default:
Assert.Fail($"Unsupported package type: {packet.PackageType}");
break;
}
Assert.IsNotNull(package);
packages.Add(package);
}
return(packages);
}
private void AssertPackage <T>(PokerKingPackage package, CapturedPacket capturedPacket)
{
Assert.IsTrue(SerializationHelper.TryDeserialize(package.Body, out T packageContent), $"Failed to deserialize {typeof(T)} package [ticks={capturedPacket.CreatedTimeStamp.Ticks}, userid={package.UserId}]");
}
private void AssertPackage(PokerKingPackage package, CapturedPacket capturedPacket)
{
switch (package.PackageType)
{
case PackageType.RequestLeaveRoom:
AssertPackage <RequestLeaveRoom>(package, capturedPacket);
break;
case PackageType.NoticeStartGame:
AssertPackage <NoticeStartGame>(package, capturedPacket);
break;
case PackageType.NoticeResetGame:
AssertPackage <NoticeResetGame>(package, capturedPacket);
break;
case PackageType.NoticeGamePost:
AssertPackage <NoticeGamePost>(package, capturedPacket);
break;
case PackageType.NoticeGameAnte:
AssertPackage <NoticeGameAnte>(package, capturedPacket);
break;
case PackageType.NoticeGameElectDealer:
AssertPackage <NoticeGameElectDealer>(package, capturedPacket);
break;
case PackageType.NoticeGameBlind:
AssertPackage <NoticeGameBlind>(package, capturedPacket);
break;
case PackageType.NoticeGameHoleCard:
AssertPackage <NoticeGameHoleCard>(package, capturedPacket);
break;
case PackageType.NoticePlayerAction:
AssertPackage <NoticePlayerAction>(package, capturedPacket);
break;
case PackageType.NoticeGameRoundEnd:
AssertPackage <NoticeGameRoundEnd>(package, capturedPacket);
break;
case PackageType.NoticeGameCommunityCards:
AssertPackage <NoticeGameCommunityCards>(package, capturedPacket);
break;
case PackageType.NoticeGameShowCard:
AssertPackage <NoticeGameShowCard>(package, capturedPacket);
break;
case PackageType.NoticeGameSettlement:
AssertPackage <NoticeGameSettlement>(package, capturedPacket);
break;
case PackageType.NoticeGameShowDown:
AssertPackage <NoticeGameShowDown>(package, capturedPacket);
break;
case PackageType.NoticePlayerStayPosition:
AssertPackage <NoticePlayerStayPosition>(package, capturedPacket);
break;
case PackageType.NoticePlayerShowCard:
AssertPackage <NoticePlayerShowCard>(package, capturedPacket);
break;
case PackageType.NoticeBuyin:
AssertPackage <NoticeBuyin>(package, capturedPacket);
break;
case PackageType.NoticeGameSnapShot:
AssertPackage <NoticeGameSnapShot>(package, capturedPacket);
break;
case PackageType.RequestHeartBeat:
AssertPackage <RequestHeartBeat>(package, capturedPacket);
break;
case PackageType.NoticeQuickLeave:
AssertPackage <NoticeQuickLeave>(package, capturedPacket);
break;
case PackageType.RequestQuickFold:
AssertPackage <RequestQuickFold>(package, capturedPacket);
break;
}
}
protected virtual void LogPackage(PokerKingPackage package)
{
switch (package.PackageType)
{
case PackageType.RequestLeaveRoom:
LogPackage <RequestLeaveRoom>(package);
break;
case PackageType.NoticeStartGame:
LogPackage <NoticeStartGame>(package);
break;
case PackageType.NoticeResetGame:
LogPackage <NoticeResetGame>(package);
break;
case PackageType.NoticeGamePost:
LogPackage <NoticeGamePost>(package);
break;
case PackageType.NoticeGameAnte:
LogPackage <NoticeGameAnte>(package);
break;
case PackageType.NoticeGameElectDealer:
LogPackage <NoticeGameElectDealer>(package);
break;
case PackageType.NoticeGameBlind:
LogPackage <NoticeGameBlind>(package);
break;
case PackageType.NoticeGameHoleCard:
LogPackage <NoticeGameHoleCard>(package);
break;
case PackageType.NoticePlayerAction:
LogPackage <NoticePlayerAction>(package);
break;
case PackageType.NoticeGameRoundEnd:
LogPackage <NoticeGameRoundEnd>(package);
break;
case PackageType.NoticeGameCommunityCards:
LogPackage <NoticeGameCommunityCards>(package);
break;
case PackageType.NoticeGameShowCard:
LogPackage <NoticeGameShowCard>(package);
break;
case PackageType.NoticeGameSettlement:
LogPackage <NoticeGameSettlement>(package);
break;
case PackageType.NoticeGameShowDown:
LogPackage <NoticeGameShowDown>(package);
break;
case PackageType.NoticePlayerStayPosition:
LogPackage <NoticePlayerStayPosition>(package);
break;
case PackageType.NoticePlayerShowCard:
LogPackage <NoticePlayerShowCard>(package);
break;
case PackageType.NoticeBuyin:
LogPackage <NoticeBuyin>(package);
break;
case PackageType.NoticeGameSnapShot:
LogPackage <NoticeGameSnapShot>(package);
break;
case PackageType.RequestHeartBeat:
LogPackage <RequestHeartBeat>(package);
break;
case PackageType.RequestQuickFold:
LogPackage <RequestQuickFold>(package);
break;
case PackageType.NoticeQuickLeave:
LogPackage <NoticeQuickLeave>(package);
break;
}
}
