예제 #1
0
        private decimal TestPayout(string strwheel, decimal betperline, Func <int, int, int[], Wheel> wheelEncoding)
        {
            var sdt = DateTime.Now;

            var serviceProvider = new ServiceCollection()
                                  .AddLogging()
                                  .BuildServiceProvider();
            var logFactory = serviceProvider.GetService <ILoggerFactory>();
            var logger     = logFactory.CreateLogger <ChessRoyaleModule>();

            var chessRoyaleModule = new ChessRoyaleModule(logger);

            var        totalWin         = 0m;
            List <int> maxIndexPosition = new List <int>();
            RequestContext <SpinArgs> requestContext = new RequestContext <SpinArgs>("", ChessRoyaleConfiguration.GameName, PlatformType.Web);
            var summData = new SummaryData();

            Assert.That(strwheel, Is.Not.Null.Or.Empty);

            string[] arrstr = strwheel.Split(',');
            int[]    arr    = Array.ConvertAll(arrstr, int.Parse);

            UserGameKey ugk = new UserGameKey()
            {
                UserId = -1,
                GameId = ChessRoyaleConfiguration.GameId,
                Level  = 1
            };

            SpinBet sb = new SpinBet(ugk, PlatformType.None)
            {
                LineBet    = 1,
                Credits    = 0,
                Lines      = ChessRoyaleConfiguration.Lines,
                Multiplier = 1
            };

            requestContext.Currency = new Currency()
            {
                Id = sb.CurrencyId
            };
            requestContext.Parameters = new SpinArgs()
            {
                LineBet = sb.LineBet, BettingLines = sb.Lines
            };
            requestContext.GameSetting = new GameSetting()
            {
                GameSettingGroupId = sb.GameSettingGroupId
            };

            ChessRoyaleSpinResult sr = new ChessRoyaleSpinResult(ugk)
            {
                SpinBet = new SpinBet(ugk, PlatformType.None)
                {
                    Lines      = ChessRoyaleConfiguration.Lines,
                    Multiplier = 1,
                    LineBet    = betperline
                },

                Wheel = wheelEncoding(ChessRoyaleConfiguration.Width, ChessRoyaleConfiguration.Height, arr)
            };


            totalWin = ChessRoyaleCommon.CalculateWin(sr, 1);

            if (sr.HasBonus)
            {
                var bonusCreated = chessRoyaleModule.CreateBonus(sr);

                var bonus = bonusCreated.Value;

                bonus.SpinTransactionId = sr.TransactionId;
                bonus.GameResult        = sr;

                RequestContext <BonusArgs> requestBonusContext = new RequestContext <BonusArgs>("", ChessRoyaleConfiguration.GameName, PlatformType.Web);

                requestBonusContext.Currency = new Currency()
                {
                    Id = sb.CurrencyId
                };
                requestBonusContext.Parameters = new BonusArgs()
                {
                    Bonus = "CollapsingSpin"
                };
                requestBonusContext.GameSetting = new GameSetting()
                {
                    GameSettingGroupId = sb.GameSettingGroupId
                };

                BonusResult bonusResult;
                int         step = bonus.CurrentStep;

                do
                {
                    var entity = new BonusEntity
                    {
                        UserId     = ugk.UserId,
                        GameId     = ChessRoyaleConfiguration.GameId,
                        Guid       = bonus.Guid.ToString("N"),
                        Data       = bonus.ToByteArray(),
                        BonusType  = bonus.GetType().Name,
                        Version    = 2,
                        IsOptional = bonus.IsOptional,
                        IsStarted  = bonus.IsStarted,
                        RoundId    = sr.RoundId
                    };

                    bonusResult = chessRoyaleModule.ExecuteBonus(ChessRoyaleConfiguration.LevelOne, entity, requestBonusContext).Value;
                    var chessRoyaleFreeSpinResult = bonusResult as ChessRoyaleFreeSpinResult;

                    var win = chessRoyaleFreeSpinResult.Win;

                    if (win > 0)
                    {
                        totalWin += win;
                    }

                    bonus = bonusResult.Bonus;
                }while (!bonusResult.IsCompleted && bonusResult.Bonus != null);
            }

            Console.WriteLine($"Win            : {totalWin}");
            return(totalWin);
        }
        public void TestChessRoyale(int gameId, int level, string currencyCode, int numusers, int numItrPerUser, decimal bet, int lines, int mp)
        {
            var sdt = DateTime.Now;

            var serviceProvider = new ServiceCollection()
                                  .AddLogging()
                                  .BuildServiceProvider();
            var logFactory = serviceProvider.GetService <ILoggerFactory>();
            var logger     = logFactory.CreateLogger <ChessRoyaleModule>();

            var chessRoyaleModule = new ChessRoyaleModule(logger);
            var maxWin            = 0m;
            //ChessRoyaleCommon.CreateWheels(new List<int>() { 3, 3, 3 });
            //ChessRoyaleCommon.CreatePayLine();
            var summData = new SummaryData();
            var users    = GenerateUsers(gameId, numusers, level);
            var sbs      = GenerateUserBets(users, bet, lines, mp);

            RequestContext <SpinArgs> requestContext = new RequestContext <SpinArgs>("", ChessRoyaleConfiguration.GameName, PlatformType.Web);

            RequestContext <BonusArgs> requestBonusContext = new RequestContext <BonusArgs>("", ChessRoyaleConfiguration.GameName, PlatformType.Web);

            Parallel.ForEach(users,
                             () => new SummaryData(),
                             (key, state, sdata) =>
            {
                var sb = sbs[key.UserId];
                requestContext.Currency = new Currency()
                {
                    Id = sb.CurrencyId
                };
                requestContext.Parameters = new SpinArgs()
                {
                    LineBet = sb.LineBet, BettingLines = sb.Lines
                };
                requestContext.GameSetting = new GameSetting()
                {
                    GameSettingGroupId = sb.GameSettingGroupId
                };

                for (var i = 0; i < numItrPerUser; ++i)
                {
                    var sr = chessRoyaleModule.ExecuteSpin(level, new UserGameSpinData(), requestContext).Value as ChessRoyaleSpinResult;

                    if (sr.Win > maxWin)
                    {
                        maxWin = sr.Win;
                    }

                    UpdateSummaryData(sdata, sr);
                    UpdateChessRoyaleSummaryData(sdata, sr);

                    if (sr.HasBonus)
                    {
                        var bonusCreated = chessRoyaleModule.CreateBonus(sr);

                        var bonus = bonusCreated.Value;

                        bonus.SpinTransactionId = sr.TransactionId;
                        bonus.GameResult        = sr;

                        requestBonusContext.Currency = new Currency()
                        {
                            Id = sb.CurrencyId
                        };
                        requestBonusContext.Parameters = new BonusArgs()
                        {
                            Bonus = "FreeSpin"
                        };
                        requestBonusContext.GameSetting = new GameSetting()
                        {
                            GameSettingGroupId = sb.GameSettingGroupId
                        };

                        BonusResult bonusResult;
                        int step = bonus.CurrentStep;
                        do
                        {
                            var entity = new BonusEntity
                            {
                                UserId     = key.UserId,
                                GameId     = ChessRoyaleConfiguration.GameId,
                                Guid       = bonus.Guid.ToString("N"),
                                Data       = bonus.ToByteArray(),
                                BonusType  = bonus.GetType().Name,
                                Version    = 2,
                                IsOptional = bonus.IsOptional,
                                IsStarted  = bonus.IsStarted,
                                RoundId    = sr.RoundId
                            };

                            //bonusEntity = bonusEntityCached.FromByteArray<BonusEntity>();

                            bonusResult = chessRoyaleModule.ExecuteBonus(level, entity, requestBonusContext).Value;
                            var chessRoyaleFreeSpinResult = bonusResult.Bonus.GameResult as ChessRoyaleFreeSpinResult;

                            UpdateSummaryDataFS(sdata, chessRoyaleFreeSpinResult);

                            step = bonusResult.Step + 1;

                            if (bonusResult.ErrorCode != 0)
                            {
                                Console.WriteLine(String.Format("BonusError Code: {0}", bonusResult.ErrorCode));
                            }

                            bonus = bonusResult.Bonus;
                        }while (!bonusResult.IsCompleted && bonusResult.Bonus != null);
                    }
                }

                return(sdata);
            },
                             sdata =>
            {
                lock (summData)
                {
                    summData.Sum(sdata);
                }
            });

            DisplayChessRoyaleSummaryData(level, bet, lines, summData, sdt, maxWin, null);
        }