public DrawResponse OnDraw(VisibleBoard board, Tile tile, DrawActions suggestedActions)
{
if (suggestedActions.HasFlag(DrawActions.Tsumo))
{
return(DrawResponse.Tsumo());
}
if (suggestedActions.HasFlag(DrawActions.Riichi))
{
var tileTypeId = board.Watashi.Hand.GetHighestUkeIreDiscard();
var discard = board.Watashi.ConcealedTiles.First(i => i.TileType.TileTypeId == tileTypeId);
return(DrawResponse.Riichi(discard));
}
if (suggestedActions.HasFlag(DrawActions.KyuushuKyuuhai) && (board.Watashi.Hand.Shanten > 2 || board.Seats.Any(s => s.DeclaredRiichi)))
{
return(DrawResponse.KyuushuKyuuhai());
}
{
var tileTypeId = board.Watashi.Hand.GetHighestUkeIreDiscard();
// Prefer tsumogiri
if (tile.TileType.TileTypeId == tileTypeId)
{
return(DrawResponse.Discard(tile));
}
var discard = board.Watashi.ConcealedTiles.First(i => i.TileType.TileTypeId == tileTypeId);
return(DrawResponse.Discard(discard));
}
}
public void CanWinInDraw()
{
IPickRepository repo = new PickInMemoryRepository();
Service service = new Service(repo, new PickManual
{
Pick1 = 1,
Pick2 = 2,
Pick3 = 3,
Pick4 = 4,
Pick5 = 5
});
repo.AddPick(new Pick
{
Name = "Test",
NumberOne = 1,
NumberTwo = 2,
NumberThree = 3,
NumberFour = 4,
NumberFive = 5,
Powerball = 6
});
DrawResponse actual = service.Draw();
Assert.IsTrue(actual.Success);
}
public DrawResponse OnDraw(VisibleBoard board, Tile tile, DrawActions suggestedActions)
{
if ((suggestedActions & DrawActions.Tsumo) != 0)
{
return(DrawResponse.Tsumo());
}
if ((suggestedActions & DrawActions.KyuushuKyuuhai) != 0)
{
return(DrawResponse.KyuushuKyuuhai());
}
if ((suggestedActions & DrawActions.Kan) != 0)
{
var ankanTileType = board.Watashi.ConcealedTiles.GroupBy(t => t.TileType).FirstOrDefault(t => t.Count() == 4)?.Key;
if (ankanTileType != null)
{
return(DrawResponse.Ankan(ankanTileType));
}
var shouminkanTile = board.Watashi.ConcealedTiles.FirstOrDefault(t => board.Watashi.Melds.Any(m => m.MeldType == MeldType.Koutsu && m.LowestTile.TileType == t.TileType));
if (shouminkanTile != null)
{
return(DrawResponse.Shouminkan(tile));
}
}
return(DrawResponse.Discard(FindDiscard(board)));
}
public void NoWinnersInDraw()
{
IPickRepository repo = new PickInMemoryRepository();
Service service = new Service(repo, new PickManual());
DrawResponse actual = service.Draw();
Assert.IsFalse(actual.Success);
}
public static TDrawResponse AbstractNotSuccessAndNoErrorDrawResponse <TDrawResponse>() where TDrawResponse : DrawResponse
{
var response = new DrawResponse()
{
ErrorInfo = null,
Success = false // Testing this
};
return((TDrawResponse)Convert.ChangeType(response, typeof(TDrawResponse)));
}
public static TDrawResponse AbstractSuccessfulAndNoErrorDrawResponse <TDrawResponse>() where TDrawResponse : DrawResponse
{
var response = new DrawResponse()
{
ErrorInfo = null,
Success = true
};
return((TDrawResponse)Convert.ChangeType(response, typeof(TDrawResponse)));
}
public async Task <IActionResult> GetAllDraws()
{
var model = await _drawService.GetAllDraws();
var response = new DrawResponse
{
Code = "success",
Message = "draw.get.success",
Data = model,
};
return(Created("", response));
}
public T Draw(DrawResponse drawResponse = DrawResponse.Default)
{
if (drawResponse == DrawResponse.Default)
{
drawResponse = _defaultDrawResponse;
}
if (_tickets.Count == 0)
{
throw new InvalidOperationException("There are no prizes left.");
}
var elegibleTickets = _tickets.Select(kv => kv.Value).Where(v => v.NumberOfTickets > 0).ToArray();
int totalOfTickets = elegibleTickets.Sum(t => t.NumberOfTickets);
if (totalOfTickets == 0)
{
throw new InvalidOperationException("There are no tickets left.");
}
int winnerNumber = Convert.ToInt32(_randon.NextDouble() * totalOfTickets);
double previousSum = 0;
double sum = 0;
PrizeBag <T> winner = null;
foreach (var ticket in elegibleTickets)
{
sum += ticket.NumberOfTickets;
if (winnerNumber >= previousSum && (winnerNumber < sum || winnerNumber == totalOfTickets))
{
winner = ticket;
break;
}
previousSum = sum;
}
if (winner == null)
{
throw new SystemException("Unexpected result. No winner was found, even with tickets avaliable.");
}
if (drawResponse == DrawResponse.RemovePrize)
{
_tickets.Remove(winner.Prize.ToString().ToLowerInvariant());
}
if (drawResponse == DrawResponse.RemoveTicket)
{
_tickets[winner.Prize.ToString().ToLowerInvariant()].NumberOfTickets -= 1;
}
return(winner.Prize);
}
public async Task <DrawResponse> OnDraw(DrawActions actions, int seatIndex)
{
var player = _players[seatIndex];
var boardView = _boardViews[seatIndex];
var tile = boardView.Watashi.CurrentDraw !;
var decider = Task.Run(() => player.OnDraw(boardView, tile, actions));
var r = await Task.WhenAny(decider, Task.Delay(DecisionTimeout));
if (r.IsCompletedSuccessfully && r is Task <DrawResponse> {
IsCompletedSuccessfully : true
} t&& t.Result.CanExecute(boardView, actions))
{
return(t.Result);
}
return(DrawResponse.Discard(tile));
}
/// <summary>
/// Ensure the draws returned from the repository is valid.
/// </summary>
private void ValidateResponse(DrawResponse drawResponse)
{
if (drawResponse == null)
{
throw new InvalidDataException("No results were returned from the data source.");
}
if (!drawResponse.Success)
{
throw new InvalidDataException("The result from the data source was not successful.", new Exception(drawResponse.ErrorInfo.DisplayMessage));
}
if (drawResponse is CurrentDrawResponse currentResponse)
{
ValidArrayNotNullOrEmpty(currentResponse.CurrentDraws);
}
if (drawResponse is OpenDrawResponse openResponse)
{
ValidArrayNotNullOrEmpty(openResponse.Draws);
}
}
public void Draw()
{
Console.Clear();
DrawResponse response = new DrawResponse();
response = service.Draw();
if (response.Success)//Display list of winner(s) and the winning number
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Winning Numbers: " + string.Join(" ", response.WinningPickArray) + " " + response.Powerball);
Console.ResetColor();
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine(response.Message);
Console.WriteLine(" ID Name ");
ConsoleIO.LineSeparator();
foreach (var p in response.WinningPicksList)
{
Console.Write(" ");
ConsoleIO.DisplayWinningPicksInfo(p, response.WinningPickArray);
Console.WriteLine();
}
}
else//display no winner or no tickets if picks is empty
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Winning Numbers: " + string.Join(" ", response.WinningPickArray) + " " + response.Powerball);
Console.ResetColor();
Console.WriteLine("---------------------------------------------------------");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(response.Message);
Console.ResetColor();
}
Console.WriteLine();
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public Lottery(DrawResponse defaultDrawResponse = DrawResponse.DoNothing) => _defaultDrawResponse = defaultDrawResponse == DrawResponse.Default
/// <summary>
/// 妥当性を検証します。
/// </summary>
/// <param name="expected">期待する状態</param>
/// <param name="actual">実際の状態</param>
private void AssertAreEqual(DrawResponse expected, DrawResponse actual)
{
Assert.AreEqual(expected.Tile, actual.Tile);
Assert.AreEqual(expected.Context, actual.Context);
Assert.AreEqual(expected.NextPosition, actual.NextPosition);
}
public DrawResponse Draw()
{
DrawResponse response = new DrawResponse();
Pick winningPick = pickGetter.PickGetter(); //computer will generate winning pick
int[] arrWinPick = winningPick.GetNumbers; //put winning pick into an array
//store winning pick array and powerball into response
response.WinningPickArray = arrWinPick;
response.Powerball = winningPick.Powerball;
//get the picks from respository
var pickLists = repo.GetPicksList();
//declare variables
List <Pick> winningPicksList;
Dictionary <int, List <Pick> > winningPicksDictionary = new Dictionary <int, List <Pick> >();
//used to keep track of any matches to winning pick
int countMatch = 0;
//no need to contine if there is no picks to compare
if (!pickLists.Any())
{
response.Success = false;
response.Message = "There were no tickets bought during the draw.";
return(response);
}
//loop through each pick object and compare their array to the winning array
foreach (var p in pickLists)
{
countMatch = 0;
foreach (var n in p.GetNumbers)
{
foreach (var d in arrWinPick)
{
if (n == d)
{
countMatch++;
}
}
}
if (countMatch > 0)//store any winning matches to a list then a dictionary
{
if (winningPicksDictionary.ContainsKey(countMatch))
{
winningPicksList = winningPicksDictionary[countMatch];
winningPicksList.Add(p);
winningPicksDictionary[countMatch] = winningPicksList;
}
else
{
winningPicksList = new List <Pick>();
winningPicksList.Add(p);
winningPicksDictionary.Add(countMatch, winningPicksList);
}
}
}
//return no winners
if (!winningPicksDictionary.Any())
{
response.Success = false;
response.Message = "There are no winners.";
return(response);
}
var winners = winningPicksDictionary.GroupBy(p => p.Key).OrderByDescending(g => g.Key).Take(1);
//store only picks with highest matches to the winning pick
winningPicksList = new List <Pick>();
foreach (var g in winners)
{
foreach (var k in g)
{
foreach (var p in k.Value)
{
winningPicksList.Add(p);
}
}
}
response.Success = true;
response.Message = "Winner(s):";
response.WinningPicksList = winningPicksList;
return(response);
}