private (ISpinResult spin, bool success, string message) SpinInner()
{
var spinable = IsSpinable();
if (!spinable.valid)
{
return(null, spinable.valid, spinable.message);
}
var dimmensions = GenerateDimensions();
var winninDimensions = GetWinningDimensions(dimmensions);
_currentWin = Math.Round(winninDimensions.Sum(d => d.Symbols.Sum(s => s.Coefficient)) * _stake, 2, MidpointRounding.AwayFromZero);
_balance = Math.Round(_balance - _stake + _currentWin, 2, MidpointRounding.AwayFromZero);
var spinResult = new SpinResult()
{
Date = DateTime.Now,
Balance = _balance,
Stake = _stake,
Win = _currentWin,
Dimensions = dimmensions
};
return(spinResult, true, "Spinned");
}
// Start is called before the first frame update
void Start()
{
sR = FindObjectOfType <SpinResult>();
check = false;
//Result after the wheel spins
if (winner)
{
rouletteValue = 7;
}
else
{
rouletteValue = Random.Range(0, 36);
}
//Wheel rotation values
xAngle = 0;
yAngle = 0;
zAngle = 0;
spinTimer = 0;
wheelSpinning = true;
check = false;
}
private int CalculateReward(SpinResult spinResult, int creditAmount)
{
if (spinResult.Slot1 == spinResult.Slot2 && spinResult.Slot2 == spinResult.Slot3)
{
switch (spinResult.Slot1)
{
case SlotState.Seven:
return(creditAmount == 3 ? 1500 : 300 * creditAmount);
case SlotState.ThreeBar:
return(100 * creditAmount);
case SlotState.TwoBar:
return(50 * creditAmount);
case SlotState.OneBar:
return(25 * creditAmount);
case SlotState.Cherry:
return(5 * creditAmount);
case SlotState.Blank:
return(2 * creditAmount);
default:
return(0);
}
}
return(0);
}
private void UpdateSummaryData(SummaryData sdata, SpinResult sr)
{
var alchemySpinResult = sr as FountainOfFortuneSpinResult;
sdata.SpinCounter++;
sdata.TotalBet += alchemySpinResult.SpinBet.TotalBet;
sdata.TotalWin += alchemySpinResult.Win;
}
private void UpdateSummaryData(SummaryData sdata, SpinResult sr)
{
var FaFaZhuSpinResult = sr as FaFaZhuSpinResult;
sdata.SpinCounter++;
sdata.TotalBet += FaFaZhuSpinResult.SpinBet.TotalBet;
sdata.TotalWin += FaFaZhuSpinResult.Win;
}
private void UpdateSummaryData(SummaryData sdata, SpinResult sr)
{
var alchemySpinResult = sr as AlchemyReelsCollapsingSpinResult;
sdata.SpinCounter++;
sdata.TotalBet += alchemySpinResult.SpinBet.TotalBet;
sdata.TotalWin += alchemySpinResult.Win;
}
private void UpdateSummaryData(SummaryData sdata, SpinResult sr)
{
var alchemySpinResult = sr as ChessRoyaleSpinResult;
sdata.SpinCounter++;
sdata.TotalBet += alchemySpinResult.SpinBet.TotalBet;
sdata.TotalWin += alchemySpinResult.Win;
}
private void UpdateSummaryData(SummaryData sdata, SpinResult sr)
{
var SpaceNeonSpinResult = sr as SpaceNeonSpinResult;
sdata.SpinCounter++;
sdata.TotalBet += SpaceNeonSpinResult.SpinBet.TotalBet;
sdata.TotalWin += SpaceNeonSpinResult.Win;
}
private void UpdateFaFaZhuSummaryData(SummaryData sd, SpinResult sr)
{
var FaFaZhuSpinResult = sr as FaFaZhuSpinResult;
foreach (var wp in FaFaZhuSpinResult.WinPositions)
{
var vcounter = sd.WinCounter;
vcounter[wp.Win] = vcounter.ContainsKey(wp.Win) ? vcounter[wp.Win] + 1 : 1;
}
}
public static SpinViewModel Create(SpinResult spinResult)
{
return(new SpinViewModel
{
RewardAmount = spinResult.RewardAmount,
Slot1 = spinResult.Slot1,
Slot2 = spinResult.Slot2,
Slot3 = spinResult.Slot3
});
}
private void UpdateAlchemyReelsSummaryData(SummaryData sd, SpinResult sr)
{
var alchemySpinResult = sr as AlchemyReelsCollapsingSpinResult;
foreach (var wp in alchemySpinResult.WinPositions)
{
var scatter = wp.Line == 0;
var vcounter = scatter ? sd.ScatterCounter : sd.WinCounter;
vcounter[wp.Win] = vcounter.ContainsKey(wp.Win) ? vcounter[wp.Win] + 1 : 1;
}
}
protected override State DoProcess()
{
Output.Inform("Spinning...");
SpinResult spinResult = _spin.Execute();
Logger.LogInformation("Spin resulted in coefficient {0}.", spinResult.Coefficient);
Amount profit = Wallet.EndStake(spinResult.Coefficient);
Logger.LogInformation("Spin profit is {1} {2}.", profit, Wallet.Currency);
Output.Inform($"You won {profit} {Wallet.Currency}.");
return(States.StakeOrWithdraw);
}
private void UpdateChessRoyaleSummaryData(SummaryData sd, SpinResult sr)
{
var alchemySpinResult = sr as ChessRoyaleSpinResult;
foreach (var wp in alchemySpinResult.WinPositions)
{
var scatter = wp.Line == 0;
var vcounter = scatter ? sd.ScatterCounter : sd.WinCounter;
vcounter[wp.Win] = vcounter.ContainsKey(wp.Win) ? vcounter[wp.Win] + 1 : 1;
//var counter80 = sd.WinCounter.Where(x => x.Key == 80).FirstOrDefault().Value;
}
//Console.WriteLine($"Reesl: {AlchemyReelsCommon.Rows[0]}; {AlchemyReelsCommon.Rows[1]}; {AlchemyReelsCommon.Rows[2]}");
}
public SpinResult Spin(int creditAmount)
{
Random random = new Random();
int slot1 = random.Next(0, slotStates.Count - 1);
int slot2 = random.Next(0, slotStates.Count - 1);
int slot3 = random.Next(0, slotStates.Count - 1);
var spinResult = new SpinResult
{
Slot1 = slotStates[slot1],
Slot2 = slotStates[slot2],
Slot3 = slotStates[slot3],
};
spinResult.RewardAmount = CalculateReward(spinResult, creditAmount);
return(spinResult);
}
/// <summary>
/// Performs a spin and logs the spin result
/// </summary>
/// <returns>The spin result</returns>
public async Task <SpinResult> Spin()
{
Console.WriteLine();
Log.Info("Spinning");
var response = await _client.GetStringAsync(_config.SpinUrl);
var spin = new SpinResult(response);
if (spin.Code != "aaa")
{
Console.WriteLine($"\tSpin Code: {spin.Code}");
Console.WriteLine($"\tSpins Left: {spin.SpinsLeft}");
Console.WriteLine($"\tAmount Won: {spin.AmountWon}");
Console.WriteLine($"\tETH Balance: {spin.EthBalance}");
Console.WriteLine($"\tUSD Balance: {spin.UsdBalance:C2}");
Console.WriteLine($"\tWinner? {spin.IsWinner}");
Console.WriteLine($"\tPayout Percentage: {spin.PayoutPercentage}");
Console.WriteLine($"\tPlay Minigame? {spin.Minigame}");
_amountWon += spin.AmountWon;
}
else
{
Log.Info("Lost");
Log.Info($"Spins Left: {spin.SpinsLeft}");
Log.Info($"ETH Balance: {spin.EthBalance}");
Log.Info($"USD Balance: {spin.UsdBalance:C2}");
}
if (spin.IsWinner)
{
_timesWon++;
}
if (spin.Minigame)
{
await ChestGame();
}
Console.WriteLine();
Console.WriteLine("--------------------------------");
return(spin);
}
public SpinResult Spin(decimal amount)
{
var symbolsGrid = new List <List <Symbol> >();
double winCoefficient = 0;
for (int i = 0; i < COLUMN_NUMBER; i++)
{
List <Symbol> symbols = m_SymbolGenerator.GenerateSymbols(ROW_NUMBER);
symbolsGrid.Add(symbols);
winCoefficient += m_CoefficientCalculator.CalculateCoefficient(symbols);
}
var winValue = (decimal)winCoefficient * amount;
m_Player.Balance += winValue;
var spinResult = new SpinResult(symbolsGrid, winValue, m_Player.Balance, true);
return(spinResult);
}
public async Task UpdateLastSpinData(UserSession userSession, Game game, SpinResult spinResult)
{
var user = userSession.User;
var spinData = new UserGameSpinData()
{
UserId = user.Id,
GameId = game.Id,
Data = spinResult.ToByteArray()
};
if (userSession.IsFunPlay)
{
var key = userSession.SessionKey + "_" + game.Id.ToString();
await cache.SetAsync(key, spinData, new DistributedCacheEntryOptions
{
SlidingExpiration = TimeSpan.FromMinutes(5)
});
}
else
{
using (var db = databaseManager.GetWritableDatabase())
{
var lastSpin = await db.UserGameSpinDatas
.Where(x => x.UserId == user.Id)
.Where(x => x.GameId == game.Id)
.AsNoTracking()
.FirstOrDefaultAsync();
if (lastSpin == null)
{
db.UserGameSpinDatas.Add(spinData);
}
else
{
lastSpin.Data = spinData.Data;
db.UserGameSpinDatas.Update(lastSpin);
}
await db.SaveChangesAsync();
}
}
}
public Result <Bonus, ErrorCode> CreateBonus(SpinResult spinResult)
{
var result = spinResult as BullRushSpinResult;
Bonus bonus;
try
{
if (result.IsRacing)
{
bonus = BullRushFreeSpinFeature.CreateBonus(result);
}
else if (result.IsInnerWheelBonus)
{
bonus = BullRushJackPotFeature.CreateBonus(result);
}
else
{
return(ErrorCode.NonexistenceBonus);
}
result.BonusElement = new BullRushBonusElement {
Id = bonus.Id, Value = bonus.Guid.ToString("N")
};
result.Bonus = new BonusStruct()
{
Id = bonus.Id,
};
}
catch (Exception ex)
{
logger.LogError("[Determine Freespin Bonus]: Create bonus position wrongly");
logger.LogError(ex, ex.Message);
return(ErrorCode.NonexistenceBonus);
}
return(bonus);
}
public async Task <Result <IGameResult, ErrorCode> > Spin(RequestContext <SpinArgs> requestContext)
{
using (logger.BeginScope(new Dictionary <string, object>
{
["SessionKey"] = requestContext.UserSession.SessionKey,
["UserId"] = requestContext.UserSession.UserId,
["GameKey"] = requestContext.GameKey,
["Platform"] = requestContext.Platform,
["BettingLines"] = requestContext.Parameters.BettingLines,
["LineBet"] = requestContext.Parameters.LineBet,
["Multiplier"] = requestContext.Parameters.Multiplier
}))
{
var module = gameModules.GetModule(requestContext.GameKey);
var userSession = requestContext.UserSession;
SpinResult result = null;
var level = await userService.GetLevel(requestContext.UserGameKey);
try
{
var transaction = await transactionService.GenerateGameTransactionId(requestContext.UserGameKey, GameTransactionType.Spin);
requestContext.GameTransaction = transaction;
var roundId = await transactionService.GenerateAutoNumber(CounterType.RoundId);
requestContext.CurrentRound = roundId;
var lastSpinData = await userService.GetLastSpinData(userSession, requestContext.Game);
var totalBet = module.CalculateTotalBet(lastSpinData, requestContext);
logger.LogInformation("User spin on level {Level}, trx id {GameTransactionId}, round {CurrentRoundId}, total bet {TotalBet}", level, transaction.Id, roundId, totalBet);
var deductBet = await payoutService.DeductBetFromWallet(requestContext, totalBet);
// TODO we should check the wallet result if it's success
var spinResult = module.ExecuteSpin(level, lastSpinData, requestContext);
if (spinResult.IsError)
{
return(spinResult.Error);
}
result = spinResult.Value;
result.Bet = totalBet;
result.RoundId = roundId;
result.TransactionId = transaction.Id;
result.UniqueID = result.TransactionId.ToString();
result.DateTimeUtc = transaction.DateTimeUtc;
result.ExchangeRate = deductBet.ExchangeRate;
result.Balance = Balance.Create(deductBet.Balance);
if (result.HasBonus)
{
logger.LogInformation("User got bonus");
var bonusCreated = module.CreateBonus(result);
if (bonusCreated.IsError)
{
logger.LogWarning("Create bonus got error {Error} with {SpinResult}", bonusCreated.Error, JsonHelper.FullString(result));
return(ErrorCode.InternalError);
}
var bonus = bonusCreated.Value;
bonus.SpinTransactionId = transaction.Id;
bonus.GameResult = result;
var entity = new BonusEntity
{
UserId = userSession.UserId,
GameId = requestContext.Game.Id,
Guid = bonus.Guid.ToString("N"),
Data = bonus.ToByteArray(),
BonusType = bonus.GetType().Name,
Version = 3,
IsOptional = bonus.IsOptional,
IsStarted = bonus.IsStarted,
RoundId = roundId,
BetReference = deductBet.BetReference
};
await bonusService.UpdateBonus(userSession, entity);
await userService.UpdateGameState(requestContext, UserGameState.ForBonus(roundId));
}
else
{
await userService.UpdateGameState(requestContext, UserGameState.ForNormal(roundId));
}
var paied = await payoutService.PayoutToUser(requestContext, result, new BonusExtraInfo { RoundId = roundId, BetId = deductBet.BetReference }, !result.HasBonus, deductBet.Guid);
result.ExchangeRate = deductBet.ExchangeRate;
result.Balance = Balance.Create(paied.Balance);
await transactionService.ProfileSpinBet(requestContext);
await userService.UpdateLastSpinData(userSession, requestContext.Game, result);
if (!userSession.IsFunPlay)
{
await userService.UpdateUserGameData(new UserGameData
{
UserId = userSession.UserId,
GameId = requestContext.Game.Id,
Bet = requestContext.Parameters.LineBet,
Lines = requestContext.Game.Lines,
});
}
}
catch (InsufficientBalanceException ex)
{
logger.LogInformation(ex, ex.Message);
return(ErrorCode.InsufficientCredit);
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
throw;
}
finally
{
await TrySaveGameHistory(requestContext, result);
}
return(result);
}
}
public void TestFreeGameFullCycle(int gameId, int level, string reelStripId)
{
var timeStart = DateTime.Now;
var module = SimulationHelper.GetModule(gameId);
var configuration = new Configuration();
var targetRtpLevel = Math.Round(configuration.RtpLevels.FirstOrDefault(rl => rl.Level == level).Rtp, 2);
var totalSummaryData = new SummaryData();
var spinRequestContext = SimulationHelper.GetMockSpinRequestContext(gameId);
var bonusRequestContext = SimulationHelper.GetMockBonusRequestContext(0, gameId);
var targetWheel = MainGameEngine.GetTargetWheel(level, configuration, reelStripId);
var userGameKey = new UserGameKey()
{
UserId = -1,
GameId = gameId,
Level = level
};
var spinBet = MainGameEngine.GenerateSpinBet(spinRequestContext);
var wheel = new Wheel(Game.WheelWidth, Game.WheelHeight)
{
ReelStripsId = reelStripId
};
for (var reel1 = 0; reel1 < targetWheel[0].Count; reel1++)
{
for (var reel2 = 0; reel2 < targetWheel[1].Count; reel2++)
{
for (var reel3 = 0; reel3 < targetWheel[2].Count; reel3++)
{
for (var reel4 = 0; reel4 < targetWheel[3].Count; reel4++)
{
for (var reel5 = 0; reel5 < targetWheel[4].Count; reel5++)
{
wheel.Reels[0] = SimulationHelper.GetReelRange(targetWheel[0], reel1);
wheel.Reels[1] = SimulationHelper.GetReelRange(targetWheel[1], reel2);
wheel.Reels[2] = SimulationHelper.GetReelRange(targetWheel[2], reel3);
wheel.Reels[3] = SimulationHelper.GetReelRange(targetWheel[3], reel4);
wheel.Reels[4] = SimulationHelper.GetReelRange(targetWheel[4], reel5);
var topIndices = new List <int> {
reel1, reel2, reel3, reel4, reel5
};
var avalancheMultiplier = configuration.BonusConfig.FreeSpin.Multipliers.First();
var winPositions = MainGameEngine.GenerateWinPositions(configuration.Payline, configuration.PayTable, wheel, spinBet.LineBet, spinBet.Lines, avalancheMultiplier);
var bonusPositions = MainGameEngine.GenerateBonusPositions(wheel);
var spinResult = new SpinResult(spinBet, wheel, topIndices, winPositions, bonusPositions, avalancheMultiplier)
{
PlatformType = spinRequestContext.Platform,
Level = level
};
totalSummaryData.Update(spinResult);
if (spinResult.HasBonus)
{
var bonus = module.CreateBonus(spinResult).Value;
if (bonus is FreeSpinBonus)
{
bonus = CollapsingBonusEngine.CreateCollapsingSpinBonus(spinResult);
}
var collapsingSpinBonus = bonus as CollapsingSpinBonus;
while (!bonus.IsCompleted)
{
var previousSpinResult = collapsingSpinBonus.PreviousGameResult == null ? collapsingSpinBonus.SpinResult : collapsingSpinBonus.PreviousSpinResult;
var referenceWheel = MainGameEngine.GetTargetWheel(level, configuration, previousSpinResult.Wheel.ReelStripsId);
var collapsingSpinResult = CollapsingBonusEngine.CreateCollapsingSpinResult(
previousSpinResult,
referenceWheel,
configuration.BonusConfig.FreeSpin.Multipliers,
configuration.Payline,
configuration.PayTable);
collapsingSpinBonus.UpdateBonus(collapsingSpinResult);
var bonusResult = CollapsingBonusEngine.CreateCollapsingBonusResult(collapsingSpinBonus, collapsingSpinResult);
totalSummaryData.UpdateBonus(bonusResult);
bonus = bonusResult.Bonus;
}
}
}
}
}
}
}
totalSummaryData.DisplayData(level, timeStart, targetRtpLevel);
var resultOverallRtp = Math.Round(totalSummaryData.RtpData.OverallRtp, 2);
var isWithinRtp = totalSummaryData.RtpData.OverallRtp >= targetRtpLevel - 0.5m && totalSummaryData.RtpData.OverallRtp <= targetRtpLevel + 0.5m;
Assert.True(isWithinRtp, $"RTP not matching. The result is {resultOverallRtp}. Expected is {targetRtpLevel}");
}
public void TestMainGameFullCycle(int gameId, int level, string reelStripId)
{
var timeStart = DateTime.Now;
var module = SimulationHelper.GetModule(gameId);
var configuration = new Configuration();
var targetRtpLevel = Math.Round(configuration.RtpLevels.FirstOrDefault(rl => rl.Level == level).Rtp, 2);
var totalSummaryData = new SummaryData();
var spinRequestContext = SimulationHelper.GetMockSpinRequestContext(gameId);
var bonusRequestContext = SimulationHelper.GetMockBonusRequestContext(0, gameId);
var targetWheel = MainGameEngine.GetTargetWheel(level, configuration, reelStripId);
var userGameKey = new UserGameKey()
{
UserId = -1,
GameId = gameId,
Level = level
};
var spinBet = MainGameEngine.GenerateSpinBet(spinRequestContext);
var wheel = new Wheel(Game.WheelWidth, Game.WheelHeight)
{
ReelStripsId = reelStripId
};
for (var reel1 = 0; reel1 < targetWheel[0].Count; reel1++)
{
for (var reel2 = 0; reel2 < targetWheel[1].Count; reel2++)
{
for (var reel3 = 0; reel3 < targetWheel[2].Count; reel3++)
{
for (var reel4 = 0; reel4 < targetWheel[3].Count; reel4++)
{
for (var reel5 = 0; reel5 < targetWheel[4].Count; reel5++)
{
wheel.Reels[0] = SimulationHelper.GetReelRange(targetWheel[0], reel1);
wheel.Reels[1] = SimulationHelper.GetReelRange(targetWheel[1], reel2);
wheel.Reels[2] = SimulationHelper.GetReelRange(targetWheel[2], reel3);
wheel.Reels[3] = SimulationHelper.GetReelRange(targetWheel[3], reel4);
wheel.Reels[4] = SimulationHelper.GetReelRange(targetWheel[4], reel5);
var topIndices = MainGameEngine.GenerateRandomWheelIndices(targetWheel);
var stackedReels = MainGameEngine.GetStackedSymbols(wheel);
var bonusPositions = MainGameEngine.GenerateBonusPositions(wheel);
var hasWildStackedReels = stackedReels.Any(sr => sr.Symbol == Symbols.Wild);
var multiplier = hasWildStackedReels ? configuration.StackedWildMultiplier : spinBet.Multiplier;
if (stackedReels.Any(sr => sr.Symbol == Symbols.Mystery)) /// Calculate wins with replaced mystery symbols
{
var replacementSymbol = MainGameEngine.GetMysterySymbolReplacement(configuration.MysterySymbolReplacementWeights);
var replacedMysterySymbolWheel = MainGameEngine.GenerateReplacedMysterySymbolWheel(configuration, wheel, replacementSymbol);
var winPositions = MainGameEngine.GenerateWinPositions(
configuration.Payline,
configuration.PayTable,
replacedMysterySymbolWheel,
spinBet.LineBet,
spinBet.Lines,
multiplier);
var spinResult = new SpinResult(level, spinBet, wheel, winPositions, bonusPositions, multiplier, replacementSymbol);
totalSummaryData.Update(spinResult);
}
else /// Calculate wins with initial wheel
{
var winPositions = MainGameEngine.GenerateWinPositions(
configuration.Payline,
configuration.PayTable,
wheel,
spinBet.LineBet,
spinBet.Lines,
multiplier);
var spinResult = new SpinResult(level, spinBet, wheel, winPositions, bonusPositions, multiplier);
totalSummaryData.Update(spinResult);
}
}
}
}
}
}
totalSummaryData.DisplayData(level, timeStart, targetRtpLevel);
var resultOverallRtp = Math.Round(totalSummaryData.RtpData.OverallRtp, 2);
var isWithinRtp = totalSummaryData.RtpData.OverallRtp >= targetRtpLevel - 0.5m && totalSummaryData.RtpData.OverallRtp <= targetRtpLevel + 0.5m;
Assert.True(isWithinRtp, $"RTP not matching. The result is {resultOverallRtp}. Expected is {targetRtpLevel}");
}
public SpinResult Spin(long accountId, string accountName, int roomId, MoneyType moneyType, string lineData)
{
String s = "[tamquoc] Spin play: " +
"\r\naccountId: " + accountId +
"\r\naccountName: " + accountName +
"\r\nroomId: " + roomId +
"\r\nmoneyType: " + moneyType +
"\r\nlineData: " + lineData;
var roomValue = GetBetValueByRoom(roomId);
var totalBetValue = lineData.Split(',').Length *roomValue;
var slotsData = _testService.IsTestAccount(accountName) ? _testService.GetTestData() : _slotsGeneService.GenerateSlotsData();
var newSlotsData = _slotsGeneService.HandleSlotsData(slotsData);
var slotMachine = new SlotMachine();
var prizeLines = slotMachine.GetLinesPrize(newSlotsData, roomValue, lineData, out var isJackpot, out var payLinePrizeValue);
var countBonus = slotsData.Count(x => x == 3); // Đếm biểu tượng bonus
var countScatter = slotsData.Count(x => x == 2); // đếm biểu tượng freeSpins
BonusGame bonusGame = null;
// Tạo Bonus Game nếu có
if (countBonus >= 3)
{
bonusGame = _bonusGeneService.GenerateBonusGame(totalBetValue, countBonus - 2);
s += "\r\nWin bonus: " + JsonConvert.SerializeObject(bonusGame);
}
var addFreeSpins = 0;
if (countScatter >= 3)
{
addFreeSpins = (countScatter - 2) * 4; // Thêm lượt FreeSpins
s += "\r\nWin Free spin: " + addFreeSpins;
}
var inputSpinData = new InputSpinData()
{
AccountId = accountId,
AccountName = accountName,
MoneyType = moneyType,
AddFreeSpins = addFreeSpins,
RoomId = roomId,
IsJackpot = isJackpot,
SlotsData = string.Join(",", slotsData.Select(x => x.ToString())),
TotalBonusValue = countBonus > 3 ? bonusGame.TotalPrizeValue : 0,
TotalPrizeValue = payLinePrizeValue,
LineData = lineData,
TotalBetValue = totalBetValue
};
var outputSpinData = _dbService.Spin(inputSpinData);
if (outputSpinData.ResponseStatus < 0)
{
if (outputSpinData.ResponseStatus == -90) // Limit Fund
{
return(new SpinResult()
{
SpinId = outputSpinData.SpinId,
SlotsData = _missData[RandomUtil.NextInt(0, _missData.Length)],
AddFreeSpin = 0,
PrizeLines = new List <PrizeLine>(),
Balance = outputSpinData.Balance,
FreeSpins = outputSpinData.FreeSpins,
Jackpot = outputSpinData.Jackpot,
ResponseStatus = 1
});
}
return(new SpinResult()
{
ResponseStatus = outputSpinData.ResponseStatus
});
}
if (countBonus >= 3)
{
_dbService.CreateBonusGame(moneyType, outputSpinData.SpinId, roomId, accountId, accountName, totalBetValue, bonusGame.BonusData, bonusGame.Mutiplier, bonusGame.TotalPrizeValue, out var bonusResponse);
}
UpdateCacheJackpot(roomId, outputSpinData.Jackpot, moneyType); // Cập nhật jackpot cho cache
var totalPrizeValue = payLinePrizeValue + outputSpinData.TotalJackpotValue;
HonorHandler.Instance.SaveHonor(accountName, roomId, totalPrizeValue, inputSpinData.IsJackpot ? 1 : 2); // Luu vinh danh
var d = new SpinResult()
{
SpinId = outputSpinData.SpinId,
SlotsData = slotsData,
AddFreeSpin = addFreeSpins,
IsJackpot = isJackpot,
PrizeLines = prizeLines,
BonusGame = bonusGame,
TotalPrizeValue = payLinePrizeValue + outputSpinData.TotalJackpotValue,
TotalPaylinePrizeValue = payLinePrizeValue,
TotalJackpotValue = outputSpinData.TotalJackpotValue,
Balance = outputSpinData.Balance,
FreeSpins = outputSpinData.FreeSpins,
Jackpot = outputSpinData.Jackpot,
ResponseStatus = outputSpinData.ResponseStatus
};
s += "\r\nResponse: " + JsonConvert.SerializeObject(d);
NLogManager.LogMessage(s);
return(d);
}
public void TestFullCycle(int gameId, int level)
{
var timeStart = DateTime.Now;
var module = SimulationHelper.GetModule(gameId);
var configuration = new Configuration();
var targetRtpLevel = Math.Round(configuration.RtpLevels.FirstOrDefault(rl => rl.Level == level).Rtp, 2);
var totalSummaryData = new SummaryData();
var spinRequestContext = SimulationHelper.GetMockSpinRequestContext(gameId);
var bonusRequestContext = SimulationHelper.GetMockBonusRequestContext(gameId, 0);
var targetWheel = MainGameEngine.GetTargetWheel(level, configuration);
var userGameKey = new UserGameKey()
{
UserId = -1,
GameId = gameId,
Level = level
};
var spinBet = MainGameEngine.GenerateSpinBet(spinRequestContext);
var wheel = new Wheel(Game.WheelWidth, Game.WheelHeight);
for (var reel1 = 0; reel1 < targetWheel[0].Count; reel1++)
{
for (var reel2 = 0; reel2 < targetWheel[1].Count; reel2++)
{
for (var reel3 = 0; reel3 < targetWheel[2].Count; reel3++)
{
wheel.Reels[0] = SimulationHelper.GetReelRange(targetWheel[0], reel1);
wheel.Reels[1] = SimulationHelper.GetReelRange(targetWheel[1], reel2);
wheel.Reels[2] = SimulationHelper.GetReelRange(targetWheel[2], reel3);
var topIndices = new List <int> {
reel1, reel2, reel3
};
var winPositions = MainGameEngine.GenerateWinPositions(configuration.Payline, configuration.PayTable, wheel, spinBet.LineBet, spinBet.Lines, spinBet.Multiplier);
var stackedReels = MainGameEngine.GetStackedReels(wheel, configuration.PayTable);
var bonusPositions = MainGameEngine.GenerateBonusPositions(stackedReels);
var spinResult = new SpinResult(spinBet, wheel, winPositions, bonusPositions)
{
PlatformType = spinRequestContext.Platform,
Level = level
};
totalSummaryData.Update(spinResult);
if (spinResult.HasBonus)
{
var bonus = module.CreateBonus(spinResult).Value;
while (!bonus.IsCompleted)
{
var bonusResult = SimulationHelper.ExecuteBonus(level, bonus, bonusRequestContext, configuration).Value;
totalSummaryData.UpdateBonus(bonusResult);
bonus = bonusResult.Bonus;
}
}
}
}
}
totalSummaryData.DisplayData(level, timeStart, targetRtpLevel);
var resultOverallRtp = Math.Round(totalSummaryData.RtpData.OverallRtp, 2);
var isWithinRtp = totalSummaryData.RtpData.OverallRtp >= targetRtpLevel - 0.5m && totalSummaryData.RtpData.OverallRtp <= targetRtpLevel + 0.5m;
Assert.True(isWithinRtp, $"RTP not matching. The result is {resultOverallRtp}. Expected is {targetRtpLevel}");
}
public void FullCycle(int gameId, int level)
{
var timeStart = DateTime.Now;
var module = SimulationHelper.GetModule(gameId);
var configuration = module.Configuration;
var targetRtpLevel = Math.Round(configuration.RtpLevels.FirstOrDefault(rl => rl.Level == level).Rtp, 2);
var totalSummaryData = new SummaryData();
var spinRequestContext = SimulationHelper.GetMockSpinRequestContext(gameId);
var targetWheel = MainGameEngine.GetTargetWheel(level, configuration);
var userGameKey = new UserGameKey()
{
UserId = -1,
GameId = gameId,
Level = level
};
var spinBet = MainGameEngine.GenerateSpinBet(spinRequestContext);
var wheel = new Wheel(Game.WheelWidth, Game.WheelHeight);
for (var reel1 = 0; reel1 < targetWheel[0].Count; reel1++)
{
for (var reel2 = 0; reel2 < targetWheel[1].Count; reel2++)
{
for (var reel3 = 0; reel3 < targetWheel[2].Count; reel3++)
{
for (var reel4 = 0; reel4 < targetWheel[3].Count; reel4++)
{
for (var reel5 = 0; reel5 < targetWheel[4].Count; reel5++)
{
wheel.Reels[0] = SimulationHelper.GetReelRange(targetWheel[0], reel1);
wheel.Reels[1] = SimulationHelper.GetReelRange(targetWheel[1], reel2);
wheel.Reels[2] = SimulationHelper.GetReelRange(targetWheel[2], reel3);
wheel.Reels[3] = SimulationHelper.GetReelRange(targetWheel[3], reel4);
wheel.Reels[4] = SimulationHelper.GetReelRange(targetWheel[4], reel5);
var expandedWheel = ExpandingWildsEngine.GenerateWheelWithExpandedWilds(wheel, configuration);
var winPositions = MainGameEngine.GenerateWinPositions(
configuration.Payline,
configuration.PayTable,
expandedWheel,
spinBet.LineBet,
spinBet.Lines,
spinBet.Multiplier);
var spinResult = new SpinResult(spinBet, wheel, winPositions)
{
PlatformType = spinRequestContext.Platform,
Level = level
};
totalSummaryData.Update(spinResult);
}
}
}
}
}
totalSummaryData.DisplayData(level, timeStart, targetRtpLevel);
var resultOverallRtp = Math.Round(totalSummaryData.RtpData.OverallRtp, 2);
var isWithinRtp = totalSummaryData.RtpData.OverallRtp >= targetRtpLevel - 0.5m && totalSummaryData.RtpData.OverallRtp <= targetRtpLevel + 0.5m;
Assert.True(isWithinRtp, $"RTP not matching. The result is {resultOverallRtp}. Expected is {targetRtpLevel}");
}
