public void TestBonusBuilder()
{
// arrange
var user = new UserGameKey(-1, 109);
var requestContext = new RequestContext <SpinArgs>("simulation", "Cleopatra", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
var freeSpinWheel = new FortuneChimesWheel
{
Reels = new List <int[]> {
new [] { 0, 1, 2 },
new [] { 0, 10, 1 },
new [] { 0, 10, 3 },
new [] { 0, 10, 2 },
new [] { 2, 3, 4 }
}
};
var explodingWheel = new FortuneChimesWheel
{
Reels = new List <int[]> {
new [] { 0, 1, 2 },
new [] { 0, 4, 1 },
new [] { 0, 10, 3 },
new [] { 0, 10, 2 },
new [] { 2, 3, 4 }
}
};
// Action
var freeSpin = GameReduce.DoSpin(1, requestContext, freeSpinWheel);
var expoding = GameReduce.DoSpin(1, requestContext, explodingWheel);
// Assert
Assert.IsTrue(freeSpin.HasBonus);
Assert.IsTrue(freeSpin.Bonus.ClientId == 3);
Assert.IsTrue(freeSpin.Bonus.Count == 14);
Assert.IsTrue(expoding.HasBonus);
Assert.IsTrue(expoding.Bonus.ClientId == 4);
Assert.IsTrue(expoding.Bonus.Count == 1);
}
public void TestHoneyFeatgure()
{
// arrange
var honeyItem = new HoneyItem(4, 1, new Prize(3, 0), new Prize(1, 0), 0);
var user = new UserGameKey(-1, 103);
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 25,
LineBet = 1.0m,
Multiplier = 1
};
var action = new Domain.Action(1, user, bet, 1, PlatformType.None);
// action
var state = HoneyReducer.dispatch(action, honeyItem);
var honeyState = state.BonusState as Honey;
// Assert
Assert.AreEqual(3, honeyState.Item.Count);
Assert.AreEqual(1, honeyState.Item.CurrentStep);
Assert.AreEqual(2, honeyState.Item.Pot.Count);
Assert.AreEqual(1, honeyState.Item.Pot.CurrentStep);
Assert.AreEqual(1, honeyState.Item.BeeHive.Count);
Assert.AreEqual(0, honeyState.Item.BeeHive.CurrentStep);
Assert.AreEqual(false, honeyState.Item.IsCompleted);
Assert.IsTrue(state.Result.Win > 0);
}
public void TestCreateFreeSpinBonus()
{
// Arrange
var user = new UserGameKey(-1, 80);
var result = new GeniesLuckResult()
{
BonusPositions = new List <BonusPosition> {
new BonusPosition {
Line = 1, Multiplier = 1, RowPositions = new List <int> {
0, 2, 2, 2, 0
}
}
},
Bonus = new Stake(Guid.NewGuid(), 3)
{
Count = 10
}
};
// action
var bonus = module.CreateBonus(result);
var state = ((GeniesLuckBonus)bonus.Value).State;
// Assert
Assert.AreEqual(result.Bonus.Guid, bonus.Value.Guid);
Assert.AreEqual(true, state is FreeSpin);
Assert.AreEqual(true, ((FreeSpin)state).Count == 10);
}
private GameHistory CreatGameHistory(UserGameKey userGameKey, GameResult result)
{
var history = new GameHistory
{
DateTimeUtc = result.DateTimeUtc,
GameTransactionId = result.TransactionId,
SpinTransactionId = result.SpinTransactionId,
UserId = userGameKey.UserId,
GameId = userGameKey.GameId,
Level = result.Level,
Bet = result.Bet,
Win = result.Win,
ExchangeRate = result.ExchangeRate.GetValueOrDefault(),
GameResultType = result.GameResultType,
XmlType = result.XmlType,
ResponseXml = xmlhelper.Serialize(result.ToResponseXml(ResponseXmlFormat.None)),
HistoryXml = xmlhelper.Serialize(result.ToResponseXml(ResponseXmlFormat.Legacy | ResponseXmlFormat.History)),
IsFreeGame = userGameKey.IsFreeGame,
IsHistory = result.IsHistory,
IsReport = result.IsReport,
PlatformType = result.PlatformType,
RoundId = result.RoundId
};
return(history);
}
public void TestCreateRespinSpinBonus()
{
// Arrange
var user = new UserGameKey(-1, 80);
var result = new GeniesLuckResult()
{
Wheel = new GeniesLuckWheel {
Reels = new List <int[]> {
new[] { 9, 9, 9 }, new[] { 1, 2, 3 }, new[] { 2, 3, 4 }, new[] { 4, 6, 5 }, new[] { 5, 2, 1 }
}
},
BonusPositions = new List <BonusPosition> {
new BonusPosition {
Line = 1, Multiplier = 1, RowPositions = new List <int> {
1, 0, 0, 0, 0
}
}
},
Bonus = new Stake(Guid.NewGuid(), 4)
{
Count = 3
}
};
// action
var bonus = module.CreateBonus(result);
var state = ((GeniesLuckBonus)bonus.Value).State;
// Assert
Assert.AreEqual(result.Bonus.Guid, bonus.Value.Guid);
Assert.AreEqual(true, state is ReSpin);
Assert.AreEqual(true, ((ReSpin)state).Count == 3);
}
public async Task <GameTransaction> GenerateGameTransactionId(UserGameKey userGameKey, GameTransactionType gameTransactionType)
{
if (userGameKey.IsFunPlay)
{
return new GameTransaction {
Id = 0, DateTimeUtc = DateTime.UtcNow
}
}
;
using (var db = databaseManager.GetWritableDatabase())
{
var gameTransaction = new GameTransaction
{
UserId = userGameKey.UserId,
GameId = userGameKey.GameId,
Type = gameTransactionType
};
db.GameTransactions.Add(gameTransaction);
await db.SaveChangesAsync();
return(gameTransaction);
}
}
public void TestBonusBuilder()
{
// arrange
var user = new UserGameKey(-1, 30);
var wheel1 = new List <int[]>
{
new [] { 9, 9, 9 },
new [] { 0, 10, 1 },
new [] { 0, 10, 3 },
new [] { 0, 10, 2 },
new [] { 2, 3, 4 }
};
var wheel2 = new List <int[]>
{
new [] { 0, 2, 1 },
new [] { 0, 8, 1 },
new [] { 0, 8, 3 },
new [] { 7, 8, 2 },
new [] { 2, 3, 4 }
};
var wheel3 = new List <int[]>
{
new [] { 0, 2, 1 },
new [] { 0, 9, 1 },
new [] { 0, 9, 3 },
new [] { 7, 9, 2 },
new [] { 2, 3, 4 }
};
// action
var result1 = BonusInspection.InspectFreeSpin(wheel1);
var result11 = BonusInspection.InspectSwimWear(wheel1);
var result12 = BonusInspection.InspectBodyPart(wheel1);
var result2 = BonusInspection.InspectFreeSpin(wheel2);
var result21 = BonusInspection.InspectSwimWear(wheel2);
var result22 = BonusInspection.InspectBodyPart(wheel2);
var result3 = BonusInspection.InspectFreeSpin(wheel3);
var result31 = BonusInspection.InspectSwimWear(wheel3);
var result32 = BonusInspection.InspectBodyPart(wheel3);
// Assert
Assert.IsTrue(result1.HasValue);
Assert.IsTrue(result1.ValueOrDefault().Item.Count == 4);
Assert.IsTrue(result11.None);
Assert.IsTrue(result12.None);
Assert.IsTrue(result2.None);
Assert.IsTrue(result21.HasValue);
Assert.IsTrue(result21.ValueOrDefault().Item.Count == 1);
Assert.IsTrue(result22.None);
Assert.IsTrue(result3.None);
Assert.IsTrue(result31.None);
Assert.IsTrue(result32.HasValue);
Assert.IsTrue(result32.ValueOrDefault().Item.Count == 3);
}
public void TestFreeSpinFeatgure()
{
// arrange
var freeSpin = new FreeSpin(1, 0);
var user = new UserGameKey(-1, 30);
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 30,
LineBet = 1.0m,
Multiplier = 1
};
var action = new FreeSpinAction(1, PlatformType.None, bet, () =>
{
return(new List <IReadOnlyList <int> >
{
new int[] { 1, 1, 1 },
new int[] { 2, 2, 2, 2 },
new int[] { 3, 3, 3, 3 },
new int[] { 4, 4, 4, 4 },
new int[] { 5, 5, 5 }
});
});
// action
var bikiniBeachState = FreeSpinReducer.Dispatch(freeSpin, action);
var result = bikiniBeachState.Result;
// Assert
Assert.IsTrue(bikiniBeachState.State is Finish);
Assert.AreEqual(result.Wheel[0], new[] { 1, 1, 1 });
Assert.AreEqual(result.Wheel[1], new[] { 10, 10, 10 });
Assert.AreEqual(result.Wheel[2], new[] { 3, 3, 3 });
Assert.AreEqual(result.Wheel[3], new[] { 4, 4, 4 });
Assert.AreEqual(result.Wheel[4], new[] { 5, 5, 5 });
}
public void TestCreateHoldSpinBonus()
{
// Arrange
var user = new UserGameKey(-1, 104);
var result = new Games.DragonRiches.DragonRichesResult();
var reels = new List <int[]>
{
new[] { 1, 6, 11 },
new[] { 6, 11, 11 },
new[] { 11, 10, 13 },
new[] { 9, 11, 12, },
new[] { 12, 11, 13 }
};
result.Bonus = new Stake(Guid.NewGuid(), 4)
{
Count = 3
};
result.Wheel = new Games.DragonRiches.DragonRichesWheel();
// action
var bonus = module.CreateBonus(result);
var state = ((Games.DragonRiches.DragonRichesBonus)bonus.Value).State;
// Assert
Assert.AreEqual(result.Bonus.Guid, bonus.Value.Guid);
Assert.AreEqual(true, state is Games.DragonRiches.HoldSpin);
Assert.AreEqual(false, state is Games.DragonRiches.FreeSpin);
Assert.AreEqual(false, state is Games.DragonRiches.HoldFreeSpin);
Assert.AreEqual(3, ((Games.DragonRiches.HoldSpin)state).State.Count);
}
private static BuyReelSummaryData BuyReel(int level, int purchaseReel, ReelGemResult priorSpinResult)
{
var summData = new BuyReelSummaryData {
TotalBet = 0,
IsContinuosBuyReel = true,
SpinCounter = 1
};
var user = new UserGameKey(-1, GameId)
{
Level = level
};
var requestContext = user.CreateRequestContext <SpinArgs>("monkeysmash");
var bonusRequestcontext = user.CreateRequestContext <BonusArgs>("monkeysmash");
requestContext.Parameters = new SpinArgs {
LineBet = 1,
Multiplier = 1
};
summData.TotalBet = priorSpinResult.ReelRespinCredits[purchaseReel];
var result = ReelGemsEngine.BuyReel(level, purchaseReel, priorSpinResult, requestContext);
summData.TotalWin = result.Win;
if (result.HasBonus)
{
var freeSpinResult = ExecuteFreeSpin(level, bonusRequestcontext, result);
summData.FSTotalWin += freeSpinResult.TotalWin;
summData.IsContinuosBuyReel = false;
}
return(summData);
}
public void TestCreateFreeGameBonus()
{
// Arrange
var user = new UserGameKey(-1, 3);
var result1 = new CleopatraSpinResult(user)
{
BonusPositions = new List <BonusPosition> {
new BonusPosition {
Line = 1, Multiplier = 1, RowPositions = new List <int> {
0, 2, 2, 2, 0
}
}
},
Bonus = new Stake(Guid.NewGuid(), 2)
{
Count = 4
}
};
// action
var bonus1 = module.CreateBonus(result1);
var state1 = ((CleopatraBonus)bonus1.Value).State;
// Assert
Assert.AreEqual(result1.Bonus.Guid, bonus1.Value.Guid);
Assert.AreEqual(true, state1 is FreeSpinState);
Assert.AreEqual(true, ((FreeSpinState)state1).Count == 4);
}
public decimal TestCalculateTotalBet()
{
var user = new UserGameKey(-1, 104);
var requestContext = new RequestContext <SpinArgs>("unittest", "God of Fortune", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
return(module.CalculateTotalBet(new UserGameSpinData(), requestContext));
}
public void TestBonusInspection()
{
// arrange
var expandReels = new bool[] { false, false, false, false, false };
var user = new UserGameKey(-1, 32);
var wheel1 = new List <int[]>
{
new [] { 0, 1, 2 },
new [] { 0, 7, 1 },
new [] { 4, 5, 6 },
new [] { 1, 2, 3 },
new [] { 6, 5, 4 }
};
var wheel2 = new List <int[]>
{
new [] { 0, 1, 2 },
new [] { 0, 5, 1 },
new [] { 7, 5, 6 },
new [] { 1, 2, 3 },
new [] { 6, 5, 4 }
};
var wheel3 = new List <int[]>
{
new [] { 0, 1, 2 },
new [] { 0, 2, 1 },
new [] { 4, 5, 6 },
new [] { 1, 2, 7 },
new [] { 6, 5, 4 }
};
var wheel4 = new List <int[]>
{
new [] { 0, 1, 2 },
new [] { 0, 2, 1 },
new [] { 4, 5, 6 },
new [] { 1, 2, 0 },
new [] { 6, 5, 4 }
};
// Action
var result1 = BonusInspection.InspectReSpin(wheel1, expandReels);
var result2 = BonusInspection.InspectReSpin(wheel2, expandReels);
var result3 = BonusInspection.InspectReSpin(wheel3, expandReels);
var result4 = BonusInspection.InspectReSpin(wheel4, expandReels);
// Assert
Assert.IsTrue(result1.HasValue);
Assert.IsTrue(result1.ValueOrDefault().Item.Count == 1);
Assert.IsTrue(result2.HasValue);
Assert.IsTrue(result2.ValueOrDefault().Item.Count == 1);
Assert.IsTrue(result3.HasValue);
Assert.IsTrue(result3.ValueOrDefault().Item.Count == 1);
Assert.IsTrue(result4.None);
}
public void TestCreateFreeAndReSpinGameBonus()
{
// Arrange
var user = new UserGameKey(-1, 109);
var wheel = new FortuneChimesWheel
{
Reels = new List <int[]>
{
new int[] { 1, 1, 1 },
new int[] { 2, 2, 2 },
new int[] { 10, 10, 10 },
new int[] { 4, 4, 4 },
new int[] { 5, 5, 5 }
},
Indices = new int[] { 0, 0, 0, 0, 0 }
};
var result1 = new FortuneChimesSpinResult(user)
{
Wheel = wheel,
WinPositions = new List <WinPosition>
{
new WinPosition
{
Line = 0, Count = 3, Symbol = 10, Multiplier = 1, RowPositions = new List <int> {
0, 2, 2, 2, 0
}
},
new WinPosition {
Line = 1, Count = 3, RowPositions = new List <int> {
1, 1, 1, 0, 0
}
}
},
Bonus = new Stake(Guid.NewGuid(), 3)
{
Count = 4
}
};
// action
var bonus1 = module.CreateBonus(result1);
var state1 = ((FortuneChimesBonus)bonus1.Value).State;
// Assert
Assert.AreEqual(result1.Bonus.Guid, bonus1.Value.Guid);
Assert.AreEqual(true, state1 is FreeSpinState);
Assert.AreEqual(true, ((FreeSpinState)state1).Count == 4);
Assert.AreEqual(true, !state1.IsCompleted);
Assert.AreEqual(((FreeSpinState)state1).ReSpinCollapse.Indices, wheel.Indices);
Assert.AreEqual(((FreeSpinState)state1).ReSpinCollapse.ReelsReSpin, new List <int[]>
{
new int[0],
new int[0],
new int[0],
new int[0],
new int[] { 5, 5, 5 }
});
}
public void TestReSpinFeature()
{
// arrange
var user = new UserGameKey(-1, 32);
var userSession = new UserSession
{
SessionKey = "unittest",
UserId = -1
};
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 10,
LineBet = 1.0m,
Multiplier = 1
};
var requestBonusContext = new RequestContext <BonusArgs>("unittest", "FortuneKoi", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
requestBonusContext.UserSession = userSession;
requestBonusContext.UserGameKey = user;
var bonusContext = new BonusStateContext(1, new FortuneKoiBonus {
SpinBet = bet
});
var state = new ReSpinState(new List <int[]>
{
new int[] { },
new int[] { 7, 7, 7 },
new int[] { },
new int[] { },
new int[] { }
}, new bool[] { false, true, false, false, false });
//Action
var response = state.Handle(requestBonusContext, bonusContext);
var result = response.result;
var responseXml = xmlhelper.Serialize(result.ToResponseXml(ResponseXmlFormat.None));
var element = XElement.Parse(responseXml, LoadOptions.PreserveWhitespace);
// Assert
Assert.IsNotNull(element);
Assert.IsTrue(element.Element("data").Element("spin").Element("wheels") != null);
Assert.AreEqual(result.Win, decimal.Parse(element.Element("win").Value));
Assert.AreEqual(result.Win > 0, element.Element("data").Element("spin").Element("winposition").Descendants().Count() > 0);
if (result.SpinResult.HasBonus)
{
Assert.IsNotNull(element.Element("data").Element("spin").Element("bonus"));
Assert.IsTrue(string.IsNullOrEmpty(element.Element("data").Element("spin").Element("bonusposition").Value) == false);
Assert.IsNotNull(element.Element("data").Element("spin").Element("bonusposition"));
Assert.IsTrue(element.Element("data").Element("spin").Element("bonusposition").Descendants().Count() > 0);
}
}
public void TestSpin()
{
// Arrange
var user = new UserGameKey(-1, 51);
var requestContext = new RequestContext <SpinArgs>("simulation", "FortuneKoi", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
var wheel = new FortuneKoiWheel
{
Reels = new List <int[]> {
new [] { 0, 1, 2 },
new [] { 0, 10, 1 },
new [] { 0, 10, 3 },
new [] { 0, 10, 2 },
new [] { 2, 3, 4 }
}
};
// Action
var result = GameReduce.DoSpin(1, requestContext, wheel);
var responseXml = xmlhelper.Serialize(result.ToResponseXml(ResponseXmlFormat.None));
var element = XElement.Parse(responseXml, LoadOptions.PreserveWhitespace);
var xelement = result.ToXElement();
// Assert
Assert.IsTrue(result.ToString() != null);
Assert.IsTrue(result.XmlType == XmlType.SpinXml);
Assert.IsTrue(result.GameResultType == GameResultType.SpinResult);
Assert.IsNotNull(element);
Assert.IsNotNull(xelement);
Assert.IsTrue(element.Element("wheels") != null);
Assert.IsTrue(element.Element("wheels").Attribute("val") != null);
Assert.AreEqual(element.Element("wheels").Attribute("val").Value, "0,1,2,0,10,1,0,10,3,0,10,2,2,3,4");
Assert.IsTrue(element.Element("win") != null);
Assert.AreEqual(result.Win, decimal.Parse(element.Element("win").Value));
Assert.IsTrue(element.Element("winposition") != null);
Assert.AreEqual(result.HasBonus, element.Element("bonus") != null);
Assert.AreEqual(result.HasBonus, element.Element("bonusposition") != null);
}
public void TestExplodingFeature()
{
// arrange
var user = new UserGameKey(-1, 109);
var userSession = new UserSession
{
SessionKey = "unittest",
UserId = -1
};
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 30,
LineBet = 1.0m,
Multiplier = 1
};
var requestBonusContext = new RequestContext <BonusArgs>("unittest", "FortuneChimes", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
requestBonusContext.UserSession = userSession;
requestBonusContext.UserGameKey = user;
var bonusContext = new BonusStateContext(1, new FortuneChimesBonus {
SpinBet = bet
});
var bonusPositions = new List <BonusPosition> {
new BonusPosition {
RowPositions = new List <int> {
1, 1, 1, 0, 0
}
}
};
var wheel = new FortuneChimesWheel
{
Reels = new List <int[]> {
new[] { 1, -1, -1 }, new[] { 1, -1, -1 }, new[] { 1, -1, -1 }, new[] { -1, -1, -1 }, new[] { -1, -1, -1 }
},
Indices = new int[] { 1, 2, 3, 4, 5 }
};
var reSpinCollapse = new ReSpinCollapse(bonusPositions, wheel, new List <int[]> {
new int[0], new int[0], new int[0], new int[] { -1, -2, -3 }, new int[] { -1, -2, -3 }
});
var state = new ReSpinState(reSpinCollapse);
//Action
var response = state.Handle(requestBonusContext, bonusContext);
// Assert
Assert.AreEqual(response.result.Win > 0, response.nextState is ReSpinState);
Assert.AreEqual(response.result.Win > 0, !response.nextState.IsCompleted);
Assert.AreEqual(response.result.Win == 0, response.nextState is Finish);
}
public void TestFreeSpinFeature()
{
// arrange
var wheel = new DragonRichesWheel
{
Reels = new List <int[]>(),
CoinCollapsing = new DragonRichesWheel.CoinCollapse()
};
var holdSpinItem = new FreeSpin(new State(6, 0), 0);
var user = new UserGameKey(-1, 104);
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 30,
LineBet = 1.0m,
Multiplier = 1
};
var action = new FreeSpinAction(1, PlatformType.None, bet, () => new List <IReadOnlyList <int> >
{
new List <int> {
1, 1, 1
},
new List <int> {
2, 2, 2
},
new List <int> {
3, 3, 3
},
new List <int> {
4, 4, 4
},
new List <int> {
5, 5, 5,
}
});
// action
var dragonState = FreeSpinReducer.Dispatch(holdSpinItem, action);
// Assert
if (dragonState.State is FreeSpin)
{
var freeSpinState = dragonState.State as FreeSpin;
var scatters = dragonState.Result.Wheel.Reels.Sum(ele => ele.Count(item => item == 9));
Assert.AreEqual(freeSpinState.State.Count >= 5, true);
Assert.AreEqual(false, freeSpinState.IsCompleted);
Assert.AreEqual(scatters >= 3, freeSpinState.State.Count >= 12);
}
if (dragonState.State is HoldFreeSpin)
{
var holdFreeSpinState = dragonState.State as HoldFreeSpin;
Assert.AreEqual(3, holdFreeSpinState.HoldSpin.State.Count == 3);
Assert.AreEqual(3, holdFreeSpinState.FreeSpin.State.Count == 5);
Assert.AreEqual(true, dragonState.Result.Wheel.Reels.Sum(ele => ele.Count(item => item == 12)) >= 6);
Assert.AreEqual(false, holdFreeSpinState.IsCompleted);
}
}
public Task <bool> Save(UserGameKey userGameKey, GameResult gameResult)
{
if (gameResult == null)
{
throw new ArgumentNullException("gameResult");
}
var gameHistory = CreatGameHistory(userGameKey, gameResult);
return(SaveHistory(gameHistory));
}
public void TestSpin()
{
// Arrange
var user = new UserGameKey(-1, 3);
var requestContext = new RequestContext <SpinArgs>("simulation", "Bikini Beach", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
// Action
var spin = module.ExecuteSpin(1, new UserGameSpinData(), requestContext);
var result = spin.Value as BikiniBeachResult;
// Assert
Assert.AreEqual(1, result.Level);
Assert.AreNotEqual(result.Wheel, default(BikiniBeachWheel));
Assert.IsTrue(result.Bet == 30);
if (result.HasBonus)
{
switch (result.Bonus.ClientId)
{
case 2:
Assert.AreEqual(4, result.Bonus.Count);
break;
case 3:
Assert.AreEqual(1, result.Bonus.Count);
break;
case 4:
Assert.AreEqual(3, result.Bonus.Count);
break;
}
}
}
public void TestSpin()
{
// Arrange
var user = new UserGameKey(-1, 109);
var requestContext = new RequestContext <SpinArgs>("simulation", "Cleopatra", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
var wheel = new FortuneChimesWheel
{
Reels = new List <int[]> {
new [] { 0, 1, 2 },
new [] { 0, 10, 1 },
new [] { 0, 10, 3 },
new [] { 0, 10, 2 },
new [] { 2, 3, 4 }
}
};
// Action
var result = GameReduce.DoSpin(1, requestContext, wheel);
var responseXml = xmlhelper.Serialize(result.ToResponseXml(ResponseXmlFormat.None));
var element = XElement.Parse(responseXml, LoadOptions.PreserveWhitespace);
// Assert
Assert.IsNotNull(element);
Assert.IsTrue(element.Element("wheels") != null);
Assert.AreEqual(wheel.Reels.Select(ele => string.Join(',', ele)).Aggregate((s1, s2) => string.Join(',', s1, s2)), element.Element("wheels").Attribute("val").Value);
Assert.AreEqual(result.Win > 0, element.Element("win") != null);
Assert.AreEqual(result.Win, decimal.Parse(element.Element("win").Value));
Assert.AreEqual(result.Win > 0, element.Element("winposition") != null);
Assert.AreEqual(result.HasBonus, element.Element("bonus") != null);
Assert.AreEqual(result.HasBonus, element.Element("bonusposition") != null);
}
public void TestFullCycle(int level, int betLines)
{
var timeStart = DateTime.Now;
var module = GetModule();
var targetRtpLevel = Math.Round(Config.RtpLevels.FirstOrDefault(rl => rl.Level == level && rl.Multiplier == betLines).Rtp, 2);
var totalSummaryData = new SummaryData();
var ugk = new UserGameKey()
{
UserId = -1,
GameId = module.GameId,
Level = 888
};
var reelStrip = Config.LevelReels
.FirstOrDefault(lr => lr.Level == level)
.ReelStrips
.FirstOrDefault(rs => rs.BetLines == betLines);
reelStrip.Symbols[0].ForEach(sym1 =>
{
reelStrip.Symbols[1].ForEach(sym2 =>
{
reelStrip.Symbols[2].ForEach(sym3 =>
{
var spinResult = new PandaSpinResult()
{
SpinBet = new SpinBet(ugk, PlatformType.None)
{
Lines = Config.Lines,
Multiplier = betLines,
LineBet = 1
},
Wheel = GetFullCycleWheel(Config.Lines, new List <int> {
sym1, sym2, sym3
})
}
.CalculateWin(1, betLines);
totalSummaryData.Update(spinResult);
});
});
});
totalSummaryData.DisplayData(level, timeStart, targetRtpLevel);
var resultOverallRtp = Math.Round(totalSummaryData.RtpData.OverallRtp, 2);
var isRtpEquivalent = resultOverallRtp == targetRtpLevel;
Assert.True(isRtpEquivalent, $"RTP not matching. The result is {resultOverallRtp}.");
}
public void TestHoneyFreeSpinFeature()
{
// arrange
var honeyItem = new HoneyItem(4, 3, new Prize(0, 0), new Prize(1, 0), 0);
var freeSpinItem = new BonusItem(3, 3, new Prize(2, 0), 1);
var honeyFreeSpinItem = new BearHoneyFreeSpin(honeyItem, freeSpinItem);
var user = new UserGameKey(-1, 103);
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 25,
LineBet = 1.0m,
Multiplier = 1
};
var action = new Domain.Action(1, user, bet, 1, PlatformType.None);
// action
var state = HoneyFreeSpinReducer.dispatch(action, honeyFreeSpinItem);
// Assert
Assert.AreEqual(false, state.BonusState.IsHoney);
if (state.BonusState.IsHoneyFreeSpin)
{
var honeyFreeSpinState = state.BonusState as HoneyFreeSpin;
var honey = honeyFreeSpinState.Item.Honey;
var freeSpin = honeyFreeSpinState.Item.FreeSpin;
Assert.AreEqual(4, honey.Id);
Assert.AreEqual(3, honey.Multiplier);
Assert.AreEqual(0, honey.Pot.Count);
Assert.AreEqual(1, honey.Pot.CurrentStep);
Assert.AreEqual(1, honey.BeeHive.Count);
Assert.AreEqual(0, honey.BeeHive.CurrentStep);
Assert.AreEqual(false, honey.IsCompleted);
Assert.AreEqual(3, freeSpin.Id);
Assert.AreEqual(3, freeSpin.Multiplier);
Assert.AreEqual(2, freeSpin.Prize.Count);
Assert.AreEqual(0, freeSpin.Prize.CurrentStep);
Assert.AreEqual(false, freeSpin.IsCompleted);
}
if (state.BonusState.IsFreeSpin)
{
var freeSpin = state.BonusState as FreeSpin;
Assert.AreEqual(3, freeSpin.Item.Id);
Assert.AreEqual(3, freeSpin.Item.Multiplier);
Assert.AreEqual(2, freeSpin.Item.Prize.Count);
Assert.AreEqual(0, freeSpin.Item.Prize.CurrentStep);
Assert.AreEqual(false, freeSpin.Item.IsCompleted);
Assert.AreEqual(state.Result.Win + freeSpinItem.CumulativeWin, freeSpin.Item.CumulativeWin);
}
}
public async Task <int> GetLevel(UserGameKey userGameKey)
{
if (userGameKey.Level != 0)
{
return(userGameKey.Level);
}
using (var db = databaseManager.GetWritableDatabase())
{
// TODO for funplay should move to FunplayUserService
if (!userGameKey.IsFunPlay)
{
var userGameRtpSetting = await db.UserGameRtpSettings.FindAsync(userGameKey.UserId);
if (userGameRtpSetting != null)
{
var gameRtps = await db.GameRtps.Where(g => g.GameId == userGameKey.GameId)
.OrderBy(g => g.Rtp)
.ToListAsync();
if (gameRtps.Count > 0)
{
var rtpLevel = 0;
if (userGameRtpSetting.Level > gameRtps.Count)
{
rtpLevel = gameRtps.LastOrDefault().RtpLevel;
}
else
{
rtpLevel = gameRtps.ElementAtOrDefault(userGameRtpSetting.Level - 1).RtpLevel;
}
if (rtpLevel > 0)
{
return(rtpLevel);
}
}
}
}
if (cachedSettings.Games.TryGetValue(userGameKey.GameId, out Game game))
{
return(game.RtpLevel);
}
//default RTP level
return(1);
}
}
public void TestReSpinFeature()
{
// arrange
var user = new UserGameKey(-1, 32);
var userSession = new UserSession
{
SessionKey = "unittest",
UserId = -1
};
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 10,
LineBet = 1.0m,
Multiplier = 1
};
var requestBonusContext = new RequestContext <BonusArgs>("unittest", "FortuneKoi", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
requestBonusContext.UserSession = userSession;
requestBonusContext.UserGameKey = user;
var bonusContext = new BonusStateContext(1, new FortuneKoiBonus {
SpinBet = bet
});
var state = new ReSpinState(new List <int[]> {
new [] { 0, 1, 2 },
new [] { 0, 7, 1 },
new [] { 4, 5, 6 },
new [] { 1, 2, 3 },
new [] { 6, 5, 4 }
},
new bool[] { false, true, false, false, false });
//Action
var response = state.Handle(requestBonusContext, bonusContext);
var spinResult = response.result.SpinResult;
var wheel = spinResult.Wheel;
// Assert
Assert.AreEqual(spinResult.HasBonus, !response.nextState.IsCompleted);
Assert.AreEqual(wheel[2].Any(item => item == 7) || wheel[3].Any(item => item == 7), response.nextState is ReSpinState);
Assert.AreEqual(wheel[2].All(item => item < 7) && wheel[3].All(item => item < 7), response.nextState is Finish);
}
public void TestHoldFreeSpinFeature()
{
// arrange
var coins = new DragonRichesWheel.CoinCollapse();
coins.Add(new DragonRichesWheel.CoinUnfilled(new[] { new Coin(), new Coin(1), new Coin(5) }));
coins.Add(new DragonRichesWheel.CoinUnfilled(new[] { new Coin(), new Coin(1), new Coin(5) }));
coins.Add(new DragonRichesWheel.CoinUnfilled(new[] { new Coin(), new Coin(1), new Coin(5) }));
coins.Add(new DragonRichesWheel.CoinUnfilled(new[] { new Coin(), new Coin(1), new Coin(5) }));
coins.Add(new DragonRichesWheel.CoinUnfilled(new[] { new Coin(), new Coin(), new Coin() }));
coins.TotalItems = 8;
var user = new UserGameKey(-1, 104);
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 30,
LineBet = 1.0m,
Multiplier = 1
};
var action = new HoldFreeSpinAction(1, PlatformType.None, bet);
var holdSpinItem = new HoldFreeSpin(
holdSpin: new HoldSpin(
new State(3, 0),
new List <int[]>
{
new int[3],
new int[3],
new int[3],
new int[3],
new int[3]
}, coins),
freeSpin: new FreeSpin(new State(5, 1), 1)
);
// action
var dragonState = HoldFreeSpinReducer.Dispatch(holdSpinItem, action);
var holdSpinState = dragonState.State as HoldFreeSpin;
var wheel = dragonState.Result.Wheel;
// Assert
Assert.NotNull(holdSpinState);
Assert.AreEqual(holdSpinState.HoldSpin.State.Count >= 2, true);
Assert.AreEqual(5, holdSpinState.FreeSpin.State.Count);
Assert.AreEqual(wheel.CoinCollapsing.TotalItems, wheel.Coins.Sum(reward => reward.Count(item => item > 0)));
Assert.IsTrue(dragonState.Result.Win == 0);
Assert.AreEqual(false, holdSpinState.IsCompleted);
}
public void TestSpin()
{
// Arrange
var user = new UserGameKey(-1, 104);
var requestContext = new RequestContext <SpinArgs>("simulation", "Dragon Riches", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
// Action
var spin = module.ExecuteSpin(1, new UserGameSpinData(), requestContext);
var result = spin.Value as Games.DragonRiches.DragonRichesResult;
// Assert
Assert.AreEqual(1, result.Level);
Assert.AreNotEqual(result.Wheel, default(Games.DragonRiches.DragonRichesWheel));
Assert.IsTrue(result.Bet == 30);
if (result.HasBonus)
{
if (result.Bonus.ClientId == 3)
{
Assert.AreEqual(6, result.Bonus.Count);
}
else
{
Assert.AreEqual(3, result.Bonus.ClientId);
}
}
}
public void TestSpin()
{
// Arrange
var user = new UserGameKey(-1, 51);
var requestContext = new RequestContext <SpinArgs>("simulation", "Qixi", PlatformType.None)
{
GameSetting = new GameSetting {
GameSettingGroupId = 1
},
Query = new QueryCollection {
},
};
var userSession = new UserSession
{
SessionKey = "unittest"
};
var spinArgs = new SpinArgs
{
LineBet = 1,
Multiplier = 1
};
requestContext.Parameters = spinArgs;
requestContext.UserSession = userSession;
// Action
var result = module.ExecuteSpin(1, new UserGameSpinData(), requestContext).Value as QixiSpinResult;
var responseXml = xmlhelper.Serialize(result.ToResponseXml(ResponseXmlFormat.None));
var element = XElement.Parse(responseXml, LoadOptions.PreserveWhitespace);
var xelement = result.ToXElement();
// Assert
Assert.IsTrue(result.ToString() != null);
Assert.IsTrue(result.XmlType == XmlType.SpinXml);
Assert.IsTrue(result.GameResultType == GameResultType.SpinResult);
Assert.IsNotNull(element);
Assert.IsNotNull(xelement);
Assert.IsTrue(element.Element("wheels") != null);
Assert.IsTrue(element.Element("wheels").Attribute("val") != null);
Assert.IsTrue(element.Element("wheels").Attribute("val").Value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray().Length == 15);
Assert.IsTrue(element.Element("win") != null);
Assert.AreEqual(result.Win, decimal.Parse(element.Element("win").Value));
Assert.IsTrue(element.Element("winposition") != null);
Assert.AreEqual(null, element.Element("bonus"));
Assert.AreEqual(null, element.Element("bonusposition"));
}
public void TestFreeSpinFeature()
{
// arrange
var freeSpinItem = new BonusItem(3, 3, new Prize(15, 0), 0);
var user = new UserGameKey(-1, 103);
var bet = new SpinBet(user, PlatformType.None)
{
Lines = 25,
LineBet = 1.0m,
Multiplier = 1
};
var action = new Domain.Action(1, user, bet, 1, PlatformType.None);
// action
var state = FreeSpinReducer.dispatch(action, freeSpinItem);
// Assert
Assert.AreEqual(false, state.BonusState.IsHoney);
if (state.BonusState.IsFreeSpin)
{
var freeSpinState = state.BonusState as FreeSpin;
Assert.AreEqual(3, freeSpinState.Item.Id);
Assert.AreEqual(3, freeSpinState.Item.Multiplier);
Assert.AreEqual(true, freeSpinState.Item.IsStarted);
Assert.AreEqual(14, freeSpinState.Item.Prize.Count);
Assert.AreEqual(1, freeSpinState.Item.Prize.CurrentStep);
Assert.AreEqual(false, freeSpinState.Item.IsCompleted);
}
if (state.BonusState.IsHoneyFreeSpin)
{
var honeyFreeSpinState = state.BonusState as HoneyFreeSpin;
Assert.AreEqual(4, honeyFreeSpinState.Item.Honey.Id);
Assert.AreEqual(3, honeyFreeSpinState.Item.Honey.Multiplier);
Assert.AreEqual(state.Result.Bonus.Count, honeyFreeSpinState.Item.Honey.Pot.Count);
Assert.AreEqual(true, honeyFreeSpinState.Item.Honey.Pot.Count > 0 && honeyFreeSpinState.Item.Honey.Pot.Count < 6);
Assert.AreEqual(0, honeyFreeSpinState.Item.Honey.Pot.CurrentStep);
Assert.AreEqual(1, honeyFreeSpinState.Item.Honey.BeeHive.Count);
Assert.AreEqual(0, honeyFreeSpinState.Item.Honey.BeeHive.CurrentStep);
Assert.AreEqual(state.Result.Bonus.Count + 1, honeyFreeSpinState.Item.Honey.TotalSpin);
Assert.AreEqual(14, honeyFreeSpinState.Item.FreeSpin.Prize.Count);
Assert.AreEqual(1, honeyFreeSpinState.Item.FreeSpin.Prize.CurrentStep);
Assert.AreEqual(3, honeyFreeSpinState.Item.FreeSpin.Multiplier);
Assert.AreEqual(false, honeyFreeSpinState.Item.IsCompleted);
}
}
public void TestBonusBuilder()
{
// arrange
var user = new UserGameKey(-1, 51);
var wheel1 = new List <int[]>
{
new [] { 9, 9, 9 },
new [] { 0, 10, 1 },
new [] { 0, 10, 3 },
new [] { 0, 10, 2 },
new [] { 2, 3, 4 }
};
var wheel2 = new List <int[]>
{
new [] { 0, 2, 1 },
new [] { 0, 10, 1 },
new [] { 0, 10, 3 },
new [] { 7, 8, 2 },
new [] { 2, 3, 4 }
};
var wheel3 = new List <int[]>
{
new [] { 0, 2, 1 },
new [] { 0, 9, 1 },
new [] { 0, 9, 3 },
new [] { 7, 9, 2 },
new [] { 2, 3, 4 }
};
// action
var result1 = BonusInspection.InspectFreeSpin(wheel1);
var result2 = BonusInspection.InspectFreeSpin(wheel2);
var result3 = BonusInspection.InspectSarchophagus(wheel3);
// Assert
Assert.IsTrue(result1.HasValue);
Assert.IsTrue(result1.ValueOrDefault().Item.Count == 15);
Assert.IsTrue(result2.None);
Assert.IsTrue(result3.HasValue);
Assert.IsTrue(result3.ValueOrDefault().Item.Count == 1);
}
