public void RouletteGameTest()
{
var ott = new RouletteGame();
Assert.AreEqual(38, ott.RouletteNumbers.Length);
// Test RouletteGame has generated valid bin numbers
CollectionAssert.AreEquivalent(Enumerable.Range(0, 38).ToArray(),
ott.RouletteNumbers.Select(x => (int)x.Val).ToArray());
// Test RouletteGame actually generates random bins each time
{
var randomBins = new List <RouletteNumber>();
for (int i = 0; i < 10; i++)
{
randomBins.Add(ott.SpinWheel());
}
CollectionAssert.AreNotEquivalent(Enumerable.Range(0, 10).ToArray(),
randomBins.Select(x => (int)x.Val).ToArray());
bool isRigged = false;
foreach (var b in randomBins)
{
isRigged = randomBins.FindAll(x => x == b).Count > 5;
if (isRigged)
{
break;
}
}
Assert.IsFalse(isRigged);
}
}
public void setup()
{
rsRoulette = new RouletteStub();
bsBet = new BetStub();
uisStub = new UIStub();
rgTestObj = new RouletteGame(rsRoulette, uisStub);
}
public void Setup()
{
// Arrange
_roulette = Substitute.For <IRoulette>();
_uut = new RouletteGame(_roulette);
_roulette.GetResult().Returns(new Field(4, Field.Black));
}
public void Setup()
{
_roulette = Substitute.For <IRoulette>();
_uut = new RouletteGame(_roulette);
_roulette.GetResult().Returns(new Field(2, Field.Black));
_fieldBet = Substitute.For <IFieldBet>();
_fieldBet.PlayerName.Returns("TestPlayer");
}
private double HandleNo7StraightWins(RouletteGame rouletteGame, Player player, int betStartAmount,
ref PocketColor lastHitColor, ref int blackStraightWins, ref int redStraightWins)
{
W = PreventImpossibleBet(player.Budget, W);
var result = SpinRouletteWithExceptionHandling(rouletteGame, new ColorBet(W, PocketColor.Red));
lastHitColor =
HandleRegularResult(betStartAmount, result, lastHitColor, ref blackStraightWins, ref redStraightWins);
return(result);
}
public override StrategyResult Execute(RouletteGame rouletteGame, int betStartAmount)
{
C = 0;
W = betStartAmount;
double minBet = betStartAmount,
maxBet = betStartAmount,
startBudget = Player.Budget,
minBudget = Player.Budget,
maxBudget = Player.Budget;
List <double> bets = new List <double>();
int redStraightWins = 0, blackStraightWins = 0;
PocketColor lastHitColor = PocketColor.Green;
for (int i = 0; i < Cycles; i++)
{
double result = 0;
if (redStraightWins == 7)
{
redStraightWins = Handle7RedStraightWins(rouletteGame, Player, out lastHitColor, out result);
}
else if (blackStraightWins == 7)
{
blackStraightWins = Handle7BlackStraightWins(rouletteGame, Player, out lastHitColor, out result);
}
else
{
result = HandleNo7StraightWins(rouletteGame, Player, betStartAmount, ref lastHitColor, ref blackStraightWins, ref redStraightWins);
}
Player.Budget += result;
CyclesRan++;
CollectStats(W, bets, ref maxBet, ref minBet, ref minBudget, ref maxBudget, Player.Budget);
if (Player.IsBroke)
{
break;
}
}
return(new StrategyResult()
{
EndBudget = Player.Budget,
Strategy = "Waiting",
CyclesRan = Cycles,
MaxBet = maxBet,
MinBet = minBet,
AllBets = bets,
StartBudget = startBudget,
Name = Player.Name,
MaxBudget = maxBudget,
MinBudget = minBudget
});
}
private int Handle7RedStraightWins(RouletteGame rouletteGame, Player player, out PocketColor lastHitColor,
out double result)
{
var redStraightWins = 0;
lastHitColor = PocketColor.Green;
W = PreventImpossibleBet(player.Budget, W);
result = SpinRouletteWithExceptionHandling(rouletteGame, new ColorBet(W, PocketColor.Black));
return(redStraightWins);
}
static void Main()
{
RouletteGame roulette = new RouletteGame();
Player1 player1 = new Player1(roulette, "Kirill", "Korzun", 1);
Player2 player2 = new Player2(roulette, "Oleg", "Olegich", 12);
roulette.SimulateGame();
Console.ReadLine();
}
public override StrategyResult Execute(RouletteGame rouletteGame, int betStartAmount)
{
InitSequence(betStartAmount);
double minBet = betStartAmount,
maxBet = betStartAmount,
startBudget = Player.Budget,
minBudget = Player.Budget,
maxBudget = Player.Budget;
List <double> bets = new List <double>();
for (int i = 0; i < Cycles; i++)
{
// Sequence is finished
if (_sequence.Count == 0)
{
break;
}
W = _sequence.Count == 1 ? _sequence.First() : _sequence.First() + _sequence.Last();
W = PreventImpossibleBet(Player.Budget, W);
double result = SpinRouletteWithExceptionHandling(rouletteGame, new ColorBet(W, PocketColor.Red));
UpdateSequenceAccordingToResult(result);
Player.Budget += result;
CyclesRan++;
CollectStats(W, bets, ref maxBet, ref minBet, ref minBudget, ref maxBudget, Player.Budget);
if (Player.IsBroke)
{
break;
}
}
return(new StrategyResult()
{
EndBudget = Player.Budget,
Strategy = "Cancellation",
CyclesRan = CyclesRan,
MaxBet = maxBet,
MinBet = minBet,
AllBets = bets,
StartBudget = startBudget,
Name = Player.Name,
MaxBudget = maxBudget,
MinBudget = minBudget
});
}
protected double SpinRouletteWithExceptionHandling(RouletteGame rouletteGame, Bet bet)
{
double result = 0.0;
try
{
result = rouletteGame.PlaceBetAndSpin(bet);
WPrevious = W;
}
catch (ArgumentException)
{
bet.Amount = WPrevious;
result = rouletteGame.PlaceBetAndSpin(bet);
W = WPrevious;
}
return(result);
}
public override StrategyResult Execute(RouletteGame rouletteGame, int betStartAmount)
{
W = betStartAmount;
D = 0;
double minBet = betStartAmount,
maxBet = betStartAmount,
startBudget = Player.Budget,
minBudget = Player.Budget,
maxBudget = Player.Budget;
List <double> bets = new List <double>();
for (int i = 0; i < Cycles; i++)
{
Bet bet = new ColorBet(W, PocketColor.Red);
W = PreventImpossibleBet(Player.Budget, W);
double result = SpinRouletteWithExceptionHandling(rouletteGame, new ColorBet(W, PocketColor.Red));
UpdateWagerAndStraightWinsAccordingToResult(betStartAmount, result);
Player.Budget += result;
CyclesRan++;
CollectStats(W, bets, ref maxBet, ref minBet, ref minBudget, ref maxBudget, Player.Budget);
if (Player.IsBroke)
{
break;
}
}
return(new StrategyResult()
{
EndBudget = Player.Budget,
Strategy = "1-3-2-6",
CyclesRan = Cycles,
MaxBet = maxBet,
MinBet = minBet,
AllBets = bets,
StartBudget = startBudget,
Name = Player.Name,
MaxBudget = maxBudget,
MinBudget = minBudget
});
}
private static void Main()
{
var game = new RouletteGame(new Roulette(new Randomzier(), new FieldFactory()));
game.OpenBets();
game.PlaceBet(new ColorBet("Player 1", 100, Field.Black));
game.PlaceBet(new ColorBet("Player 1", 100, Field.Red));
game.PlaceBet(new EvenOddBet("Player 2", 100, true));
game.PlaceBet(new EvenOddBet("Player 2", 100, false));
for (uint i = 0; i < 36; i++)
{
game.PlaceBet(new FieldBet("Player 3", 100, i));
}
game.CloseBets();
game.SpinRoulette();
game.PayUp();
}
static void Main(string[] args)
{
var game = new RouletteGame(new Roulette(new StandardFieldFactory(), new MyRandom()));
game.OpenBets();
game.PlaceBet(new ColorBet("Player 1", 100, Field.Black));
game.PlaceBet(new ColorBet("Player 1", 100, Field.Red));
game.PlaceBet(new EvenOddBet("Player 2", 100, true));
game.PlaceBet(new EvenOddBet("Player 2", 100, false));
for (uint i = 0; i < 36; i++)
{
game.PlaceBet(new FieldBet("Player 3", 100, i));
}
game.CloseBets();
game.SpinRoulette();
game.PayUp();
Console.ReadKey();
}
public KamoteStrategy(RouletteGame game, GameParams gameParam)
: base(game, gameParam)
{
}
public void InitRouletteGame(int?minimumBid, int?maximumBid)
{
_rouletteGame = RouletteGameFactory.Create(minimumBid, maximumBid);
}
public void teardown()
{
rgTestObj = null;
uisStub = null;
bsBet = null;
rsRoulette = null;
}
public Martingale(RouletteGame game, GameParams gameParam)
: base(game, gameParam)
{
}
public OneThreeTwoFourDozensMartingale(RouletteGame game, GameParams gameParams, Color color, int martingaleLimit)
: base(game, gameParams)
{
Color = color;
MartingaleLimit = martingaleLimit;
}
public OneThreeTwoFourDozensChangeColor(RouletteGame game, GameParams gameParams, Color color)
: base(game, gameParams)
{
Color = color;
}
public TheoryOfNineAndOneThreeTwoFour(RouletteGame game, GameParams gameParam)
: base(game, gameParam)
{
}
public void Init()
{
var uut = new RouletteGame(new Roulette());
_game = uut;
}
public OneThreeTwoFour(RouletteGame game, GameParams gameParam, Color color)
: base(game, gameParam)
{
Color = color;
}
public abstract StrategyResult Execute(RouletteGame rouletteGame, int betStartAmount);
public StrategyBase(RouletteGame game, GameParams gameParam)
{
GameParams = gameParam;
Game = game;
}
public TheoryOfNine(RouletteGame game, GameParams gameParam)
: base(game, gameParam)
{
}
