public CorrectViewModelTest()
{
_teams = GenerateTeamList();
_enabledTeams = new Teams();
foreach(Team team in _teams)
{
if (team.TeamEnabled)
{
_enabledTeams.Add(team);
}
}
_quizzes = GenerateQuizzesList();
_rounds = _quizzes.Where(q => q.QuizEnabled).FirstOrDefault().QuizRounds;
_teamServiceMock = new Mock<ITeamService>();
_teamServiceMock.Setup(tS => tS.GetAllTeams()).ReturnsAsync(_teams);
_teamServiceMock.Setup(tS => tS.PatchTeamScore(It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(true);
_roundServiceMock = new Mock<IRoundService>();
_roundServiceMock.Setup(rS => rS.GetAllRoundsByEnabledQuiz()).ReturnsAsync(_rounds);
_navigationServiceExMock = new Mock<INavigationServiceEx>();
_sut = new CorrectViewModel(_teamServiceMock.Object, _roundServiceMock.Object, _navigationServiceExMock.Object);
}
public int Throw(int number = 10)
{
Round last = Rounds.Last();
if (last.FirstThrow == 0)
{
last.FirstThrow = number;
Sum += number;
}
else
{
if (number == 10)
{
last.IsStrike = true;
last.SecondThrow = 0;
}
else
{
last.SecondThrow = number;
Sum += number;
}
if (last.FirstThrow + last.SecondThrow == 10 && last.IsStrike == false)
{
last.IsSpare = true;
}
last.RoundPoints = last.FirstThrow + last.SecondThrow;
AddSpareBonus();
AddStrikeBonus();
Rounds.Add(new Round());
}
return(number);
}
public void AddRound_Click(object sender, RoutedEventArgs e)
{
try
{
if (r_Count > 5)
{
throw new Exception();
}
{
Warning2.Visibility = Visibility.Collapsed;
TextBox t = new TextBox();
t.Name = "Round" + r_Count;
t.PlaceholderText = "Round " + r_Count;
t.HorizontalAlignment = HorizontalAlignment.Stretch;
t.VerticalAlignment = VerticalAlignment.Stretch;
t.Height = 100;
t.TextWrapping = TextWrapping.Wrap;
t.Margin = new Thickness(0, 10, 0, 0);
t.Foreground = TextBox1.Foreground;
Rounds.Children.Add(t);
Rounds.UpdateLayout();
r_Count++;
}
}
catch (Exception)
{
Warning2.Text = "Can not add more than 5 rounds";
Warning2.Visibility = Visibility.Visible;
}
}
/// <summary>
/// Add a given Poker round to the Player
/// </summary>
/// <param name="convertedRound">
/// The converted Round.
/// </param>
public IConvertedPokerPlayer Add(IConvertedPokerRound convertedRound)
{
try
{
if (convertedRound == null)
{
throw new ArgumentNullException("convertedRound");
}
if (Rounds.Count < 4)
{
Rounds.Add(convertedRound);
}
else
{
throw new ArgumentOutOfRangeException("convertedRound");
}
}
catch (Exception excep)
{
Log.Error("Unexpected", excep);
}
return(this);
}
public Round Run(IEnumerable <UserInGame> userGames)
{
if (!_gameStarted)
{
throw new GameNotStartedException();
}
if (TotalRounds == CurrentRound)
{
throw new GameOverException();
}
var randomNumber = _randomGenerator.Generate(_maxGuessNo);
var winner = userGames
.Select(u =>
new
{
Id = u.UserId,
Diff = Math.Abs(u.Number - randomNumber)
})
.OrderBy(a => a.Diff)
.First();
CurrentRound++;
RoundsLeft--;
var lastRound = TotalRounds == CurrentRound;
var newRound = new Round(Id, randomNumber, winner.Id, CurrentRound, lastRound);
Rounds.Add(newRound);
return(newRound);
}
private bool ManageRoundRemoval(RoundBase round)
{
bool containsSoughtRound = Rounds.Contains(round);
if (containsSoughtRound)
{
bool removalSuccessful = Rounds.Remove(round);
if (removalSuccessful)
{
round.MarkForDeletion();
bool stillContainsRounds = Rounds.Count > 0;
if (stillContainsRounds)
{
GetFirstRound().Construct();
}
FindIssues();
return(true);
}
}
return(false);
}
private void handleGamble(RaycastHit hit)
{
// Do Gamble
tankClicked = hit.transform.gameObject;
CoordinateSet currentTankCoordinates = new CoordinateSet((int)tankClicked.transform.position.x, (int)tankClicked.transform.position.z);
Tank currentTank = gs.getPlayerTank(playerTurn, currentTankCoordinates);
// If the player didn't choose one of their own tanks, or if that tank is dead, just ignore
if (currentTank.isDead() || currentTank.getPlayer().getPlayerColor() != playerTurn)
{
tankClicked = null;
return;
}
string powerup = gs.playerGamble(playerTurn, currentTankCoordinates);
// Print log message
Debug.Log("Player " + playerTurn + "'s gamble results in: " + powerup);
// Update the state
tankClicked = null;
round = Rounds.Move;
changeTurns();
printTurn();
gs.updatePlayerHealthBars(hpController);
updateTooltips("Move1");
numGambles++;
gs.toggleTankRings(redTanks, new CoordinateSet(-1, -1), false);
gs.toggleTankRings(blueTanks, new CoordinateSet(-1, -1), false);
}
public void ThrowRound(int number = 10)
{
Round round = new Round();
AddStrikeBonus();
int firtsThrow = Throw(number);
int secondThrow;
AddSpareBonus();
if (firtsThrow == 10)
{
round.IsStrike = true;
secondThrow = 0;
}
else
{
secondThrow = Throw(firtsThrow);
}
if (firtsThrow + secondThrow == 10 && round.IsStrike == false)
{
round.IsSpare = true;
}
round.FirstThrow = firtsThrow;
round.SecondThrow = secondThrow;
round.RoundPoints = firtsThrow + secondThrow;
Rounds.Add(round);
}
public CcjRound GetCurrentInputRegisterableRound()
{
using (RoundsListLock.Lock())
{
return(Rounds.First(x => x.Status == CcjRoundStatus.Running && x.Phase == CcjRoundPhase.InputRegistration)); // not FirstOrDefault, it must always exist
}
}
public IEnumerable <CcjRound> GetRunningRounds()
{
using (RoundsListLock.Lock())
{
return(Rounds.Where(x => x.Status == CcjRoundStatus.Running).ToArray());
}
}
public async Task <ActionResult> Post([FromBody] Rounds round)
{
context.Round.Add(round);
await context.SaveChangesAsync();
return(new CreatedAtRouteResult("GetRound", new { id = round.Id }, round));
}
public void StartNewRound()
{
var newRound = new Round();
Rounds.Add(newRound);
_currentRound = newRound;
}
public void LockPlayerList()
{
if (Players.Count % 2 != 0)
{
throw new InvalidOperationException("No se puede bloquear la lista de jugadores con un número impar.");
}
if (Players.Count == 0)
{
throw new InvalidOperationException("No se puede bloquear la lista de jugadores sin tener al menos uno.");
}
SaveWithBackup("prelock");
PlayerListLocked = true;
Rounds.ToList().ForEach((round) =>
{
round.Active = false;
round.OnPropertyChanged("Active");
});
Rounds.First().Active = true;
Rounds.First().OnPropertyChanged("Active");
OnPropertyChanged("PlayerListLocked");
Save();
}
public CcjRound TryGetRound(string roundHash)
{
using (RoundsListLock.Lock())
{
return(Rounds.SingleOrDefault(x => x.RoundHash == roundHash));
}
}
private void OnRoundsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
RaisePropertyChanged(() => MostDamageWeapon);
RaisePropertyChanged(() => WinStatus);
ClutchWonCount = Players.Sum(p => p.ClutchWonCount);
ClutchCount = Players.Sum(p => p.ClutchCount);
ClutchLostCount = Players.Sum(p => p.ClutchLostCount);
if (Rounds.Any())
{
KillPerRound = GetKillPerRound();
DeathPerRound = GetKillPerRound();
AssistPerRound = GetAssistPerRound();
MvpCount = Players.Sum(p => p.RoundMvpCount);
DeathPerRound = Math.Round((double)DeathCount / Rounds.Count, 2);
}
if (Players.Any())
{
float totalHltv = Players.Sum(player => player.RatingHltv);
AverageHltvRating = totalHltv / Players.Count;
decimal totalEseaRws = Players.Sum(player => player.EseaRws);
AverageEseaRws = Math.Round(totalEseaRws / Players.Count, 2);
}
}
public IEnumerable <Money> GetAllQueuedCoinAmounts()
{
lock (StateLock)
{
return(WaitingList.Keys.Concat(Rounds.SelectMany(x => x.CoinsRegistered)).Select(x => x.Amount).ToArray());
}
}
void Update()
{
if (round == Rounds.Startup)
{
if (gamepad1.GetButtonDown("Start") || gamepad2.GetButtonDown("Start"))
{
round = Rounds.Wait;
roundCorWait = StartCoroutine(WaitCor());
}
}
if (round == Rounds.Fight)
{
if (health1 == 0)
{
round = Rounds.End;
StartCoroutine(EndGame(player2));
}
if (health2 == 0)
{
round = Rounds.End;
StartCoroutine(EndGame(player1));
}
}
ElevatorFeedback();
}
public CcjRound TryGetRound(long roundId)
{
using (RoundsListLock.Lock())
{
return(Rounds.SingleOrDefault(x => x.RoundId == roundId));
}
}
public IEnumerable <OutPoint> GetSpentCoins()
{
lock (StateLock)
{
return(WaitingList.Keys.Concat(Rounds.SelectMany(x => x.CoinsRegistered)).Where(x => x.IsSpent()).Select(x => x.OutPoint).ToArray());
}
}
public bool Contains(SmartCoin coin)
{
lock (StateLock)
{
return(WaitingList.ContainsKey(coin) || Rounds.Any(x => x.CoinsRegistered.Contains(coin)));
}
}
public static void highlightValidTiles(ArrayList listOfTileCoordinates, Rounds round)
{
GameObject grid = GameObject.FindGameObjectWithTag("Grid");
GameObject child;
MeshRenderer meshRenderer;
CoordinateSet currentCoordinates;
for (int i = 0; i < grid.transform.childCount; i++)
{
child = grid.transform.GetChild(i).gameObject;
meshRenderer = child.GetComponent <MeshRenderer>();
for (int j = 0; j < listOfTileCoordinates.Count; j++)
{
currentCoordinates = (CoordinateSet)listOfTileCoordinates[j];
if ((int)child.transform.position.x == currentCoordinates.getX() && (int)child.transform.position.z == currentCoordinates.getY())
{
if (round == Rounds.Move)
{
meshRenderer.material.color = Color.gray;
}
else if (round == Rounds.Attack)
{
meshRenderer.material.color = Color.red;
}
}
}
}
}
public IEnumerable <OutPoint> GetAllRegisteredCoins()
{
lock (StateLock)
{
return(Rounds.SelectMany(x => x.CoinsRegistered).Select(x => x.OutPoint).ToArray());
}
}
public Money SumAllQueuedCoinAmounts()
{
lock (StateLock)
{
return(WaitingList.Keys.Concat(Rounds.SelectMany(x => x.CoinsRegistered)).Sum(x => x.Amount));
}
}
public int CountAllQueuedCoins()
{
lock (StateLock)
{
return(WaitingList.Count + Rounds.Sum(x => x.CoinsRegistered.Count()));
}
}
public async Task <RoundState[]> GetStatusAsync(CancellationToken cancellationToken)
{
using (await AsyncLock.LockAsync(cancellationToken).ConfigureAwait(false))
{
return(Rounds.Select(x => RoundState.FromRound(x)).ToArray());
}
}
public SmartCoin GetSingleOrDefaultCoin(OutPoint coinReference)
{
lock (StateLock)
{
return(WaitingList.Keys.Concat(Rounds.SelectMany(x => x.CoinsRegistered)).SingleOrDefault(x => x.OutPoint == coinReference));
}
}
public static void Prefix(UnitEntityData initiator, BlueprintUnit blueprint, Vector3 position, ref Rounds duration, ref int level, RuleSummonUnit __instance)
{
Mod.Debug($"old duration: {duration} level: {level} \n mult: {settings.summonDurationMultiplier1} levelInc: {settings.summonLevelModifier1}\n initiatior: {initiator} tweakTarget: {settings.summonTweakTarget1} shouldTweak: {UnitEntityDataUtils.CheckUnitEntityData(initiator, settings.summonTweakTarget1)}");
if (UnitEntityDataUtils.CheckUnitEntityData(initiator, settings.summonTweakTarget1))
{
if (settings.summonDurationMultiplier1 != 1)
{
duration = new Rounds(Convert.ToInt32(duration.Value * settings.summonDurationMultiplier1));
}
if (settings.summonLevelModifier1 != 0)
{
level = Math.Max(0, Math.Min(level + (int)settings.summonLevelModifier1, 20));
}
}
else if (UnitEntityDataUtils.CheckUnitEntityData(initiator, settings.summonTweakTarget2))
{
if (settings.summonDurationMultiplier2 != 1)
{
duration = new Rounds(Convert.ToInt32(duration.Value * settings.summonDurationMultiplier2));
}
if (settings.summonLevelModifier2 >= 0)
{
level = Math.Max(0, Math.Min(level + (int)settings.summonLevelModifier1, 20));
}
}
Mod.Debug($"new duration: {duration} level: {level}");
if (settings.toggleMakeSummmonsControllable)
{
SummonedByPlayerFaction = initiator.IsPlayerFaction;
}
Mod.Debug("Initiator: " + initiator.CharacterName + $"(PlayerFaction : {initiator.IsPlayerFaction})" + "\nBlueprint: " + blueprint.CharacterName + "\nDuration: " + duration.Value);
}
public async Task MakeSureTwoRunningRoundsAsync()
{
using (await RoundsListLock.LockAsync())
{
int runningRoundCount = Rounds.Count(x => x.Status == CcjRoundStatus.Running);
if (runningRoundCount == 0)
{
var round = new CcjRound(RpcClient, UtxoReferee, RoundConfig);
round.CoinJoinBroadcasted += Round_CoinJoinBroadcasted;
round.StatusChanged += Round_StatusChangedAsync;
await round.ExecuteNextPhaseAsync(CcjRoundPhase.InputRegistration);
Rounds.Add(round);
var round2 = new CcjRound(RpcClient, UtxoReferee, RoundConfig);
round2.StatusChanged += Round_StatusChangedAsync;
round2.CoinJoinBroadcasted += Round_CoinJoinBroadcasted;
await round2.ExecuteNextPhaseAsync(CcjRoundPhase.InputRegistration);
Rounds.Add(round2);
}
else if (runningRoundCount == 1)
{
var round = new CcjRound(RpcClient, UtxoReferee, RoundConfig);
round.StatusChanged += Round_StatusChangedAsync;
round.CoinJoinBroadcasted += Round_CoinJoinBroadcasted;
await round.ExecuteNextPhaseAsync(CcjRoundPhase.InputRegistration);
Rounds.Add(round);
}
}
}
// load rounds for compo
public async Task ExecuteLoadRoundsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
//DoStuff
Rounds = await azureService.GetRoundsForCompetition(SelectedCompetition?.CompetitionId);
IsBusy = false;
if (Rounds.Count > 0)
{
// set round pref on dropdown
string roundId = Preferences.Get("RoundId", null);
if (roundId != null)
{
var round = Rounds.FirstOrDefault(o => o.RoundId == roundId);
if (round != null)
{
SelectedRound = round;
Debug.WriteLine("Set SelectedRound to " + round.CourseName);
}
}
}
}
public async Task MakeSureTwoRunningRoundsAsync(Money feePerInputs = null, Money feePerOutputs = null)
{
using (await RoundsListLock.LockAsync())
{
int runningRoundCount = Rounds.Count(x => x.Status == CcjRoundStatus.Running);
int confirmationTarget = await AdjustConfirmationTargetAsync(lockCoinJoins : true);
if (runningRoundCount == 0)
{
var round = new CcjRound(RpcClient, UtxoReferee, RoundConfig, confirmationTarget, RoundConfig.ConfirmationTarget.Value, RoundConfig.ConfirmationTargetReductionRate.Value);
round.CoinJoinBroadcasted += Round_CoinJoinBroadcasted;
round.StatusChanged += Round_StatusChangedAsync;
await round.ExecuteNextPhaseAsync(CcjRoundPhase.InputRegistration, feePerInputs, feePerOutputs);
Rounds.Add(round);
var round2 = new CcjRound(RpcClient, UtxoReferee, RoundConfig, confirmationTarget, RoundConfig.ConfirmationTarget.Value, RoundConfig.ConfirmationTargetReductionRate.Value);
round2.StatusChanged += Round_StatusChangedAsync;
round2.CoinJoinBroadcasted += Round_CoinJoinBroadcasted;
await round2.ExecuteNextPhaseAsync(CcjRoundPhase.InputRegistration, feePerInputs, feePerOutputs);
Rounds.Add(round2);
}
else if (runningRoundCount == 1)
{
var round = new CcjRound(RpcClient, UtxoReferee, RoundConfig, confirmationTarget, RoundConfig.ConfirmationTarget.Value, RoundConfig.ConfirmationTargetReductionRate.Value);
round.StatusChanged += Round_StatusChangedAsync;
round.CoinJoinBroadcasted += Round_CoinJoinBroadcasted;
await round.ExecuteNextPhaseAsync(CcjRoundPhase.InputRegistration, feePerInputs, feePerOutputs);
Rounds.Add(round);
}
}
}
public static PokerHandHistory.Card[] Board(this PokerHand hand, Rounds round)
{
switch (round)
{
case Rounds.PREFLOP: return new PokerHandHistory.Card[0];
case Rounds.FLOP: return new PokerHandHistory.Card[] { hand.Flop.CommunityCards[0], hand.Flop.CommunityCards[1], hand.Flop.CommunityCards[2] };
case Rounds.TURN: return new PokerHandHistory.Card[] { hand.Flop.CommunityCards[0], hand.Flop.CommunityCards[1], hand.Flop.CommunityCards[2], hand.Turn.CommunityCards[0] };
case Rounds.RIVER: return new PokerHandHistory.Card[] { hand.Flop.CommunityCards[0], hand.Flop.CommunityCards[1], hand.Flop.CommunityCards[2], hand.Turn.CommunityCards[0], hand.River.CommunityCards[0] };
default: throw new Exception("Unknown round: " + round.ToString());
}
}
public void Parse(string response)
{
XmlDocument xml = new XmlDocument(); //* create an xml document object.
XmlTextReader xmlTextReader = new XmlTextReader(new StringReader(response));
xml.Load(xmlTextReader);
try
{
XmlNodeList xmlRounds = xml.SelectNodes("GetLeagueRounds/Rounds/Round");
rounds = RoundParsing.ParseRounds(xmlRounds);
}
catch
{
throw new InvalidStateException("Answer from the server is not well-formed.");
}
}
public static Rounds ParseRounds(XmlNodeList roundsNodeList)
{
Rounds rounds = new Rounds();
if (roundsNodeList.Count > 0)
{
foreach (XmlNode round in roundsNodeList)
{
int roundID = int.Parse(round["ID"].InnerText);
TimeSpan bestTime;
if (!TimeSpan.TryParse(round["BestTime"].InnerText, out bestTime))
{
bestTime = TimeSpan.Zero;
}
rounds.Add(new Round(roundID, round["Name"].InnerText, round["Variant"].InnerText, bestTime));
}
}
return rounds;
}
/// <summary>
/// Converts the board cards to a ulong mask for analysis.
/// </summary>
/// <param name="hand">The hand to convert.</param>
/// <param name="round">The maximum round to include in the board mask.</param>
/// <returns>A ulong mask for use in analysis.</returns>
public static ulong BoardMask(this PokerHand hand, Rounds round)
{
ulong result = 0UL;
for (int i = 1; i <= (int)round; i++)
result |= hand.Rounds[i].CommunityCards.ToMask();
return result;
}
public weka.core.Instances[] GenerateFeatures(IEnumerable<PokerHand> hands, Rounds roundFilter = Rounds.NONE, bool regression = false)
{
weka.core.Instances[] data = regression ? GenerateRegressionInstances((int)roundFilter)
: new weka.core.Instances[] { GenerateClassifierInstances((int)roundFilter) };
foreach(var hand in hands)
{
for (int rIdx = 0; rIdx < hand.Rounds.Length; rIdx++)
{
// Optionally filter out rounds
if (roundFilter != Rounds.NONE && roundFilter != (Rounds)rIdx)
continue;
if(hand.Rounds[rIdx] == null || hand.Rounds[rIdx].Actions == null)
continue;
for (int aIdx = 0; aIdx < hand.Rounds[rIdx].Actions.Length; aIdx++)
if (hand.Rounds[rIdx].Actions[aIdx].Player == hand.Hero)
for(int dIdx = 0; dIdx < data.Length; dIdx++)
{
var inst = GenerateFeatures(hand, rIdx, aIdx, data[dIdx], !regression);
if(regression)
{
switch (hand.Rounds[rIdx].Actions[aIdx].Type)
{
case ActionType.Bet:
case ActionType.Raise: inst.setClassValue(dIdx == 2 ? 1 : 0);
break;
case ActionType.Call:
case ActionType.Check: inst.setClassValue(dIdx == 1 ? 1 : 0);
break;
case ActionType.Fold: inst.setClassValue(dIdx == 0 ? 1 : 0);
break;
default:
break;
}
}
data[dIdx].add(inst);
}
}
}
return data;
}
public weka.core.Instances GenerateClassifierFeatures(IEnumerable<PokerHand> hands, Rounds roundFilter = Rounds.NONE)
{
var data = GenerateClassifierInstances((int)roundFilter);
foreach(var hand in hands)
{
for (int rIdx = 0; rIdx < hand.Rounds.Length; rIdx++)
{
// Optionally filter out rounds
if (roundFilter != Rounds.NONE && roundFilter != (Rounds)rIdx)
continue;
if(hand.Rounds[rIdx] == null || hand.Rounds[rIdx].Actions == null)
continue;
for (int aIdx = 0; aIdx < hand.Rounds[rIdx].Actions.Length; aIdx++)
if (hand.Rounds[rIdx].Actions[aIdx].Player == hand.Hero)
data.add(GenerateFeatures(hand, rIdx, aIdx, data));
}
}
return data;
}
private void recursiveBuildTree(Node root, int player, Rounds round,
double pot, int[] bets, Dictionary<string, int> indexes)
{
if (root.terminal)
return;
_playerStates.Add(root.playerView());
List<Node> children = new List<Node>();
int pIdx = player - 1;
int nextPlayer = player == 1 ? 2 : 1;
// Can we raise?
if (bets.Max() < _maxBetLevel[(int)round])
{
var betNode = new Node()
{
action = Actions.Raise,
board = root.board,
hole1 = root.hole1,
hole2 = root.hole2,
round = round,
terminal = false,
isAction = true,
player = nextPlayer,
sequence = root.sequence + 'r'
};
SetNodeIndex(betNode, root, indexes);
int prevBets = bets[pIdx];
int betsToAdd = bets.Max() - prevBets + 1;//may need to add either 1 or 2 bets
bets[pIdx] = bets.Max() + 1;
recursiveBuildTree(betNode, player == 1 ? 2 : 1, round, pot + _betSize[(int)round] * betsToAdd, bets, indexes);
bets[pIdx] = prevBets;
children.Add(betNode);
}
// Can we fold?
if(bets.Max() > 0)
{
var foldNode = new Node()
{
action = Actions.Fold,
board = root.board,
hole1 = root.hole1,
hole2 = root.hole2,
round = round,
// take back the uncalled bet and return the payoff as half the pot
payoff = (pot - _betSize[(int)round]) / (player == 1 ? -2.0 : 2.0),
terminal = true,
isAction = true,
player = nextPlayer,
sequence = root.sequence + 'f'
};
SetNodeIndex(foldNode, root, indexes);
children.Add(foldNode);
}
// If we call, is the round over?
var callNode = new Node()
{
action = Actions.Call,
board = root.board,
hole1 = root.hole1,
hole2 = root.hole2,
round = round,
isAction = true,
player = nextPlayer,
sequence = root.sequence + 'c'
};
if (bets.Max() == 0 && player == 1)// first to act in a round can check
{
callNode.terminal = false;
recursiveBuildTree(callNode, 2, round, pot, bets, indexes);
}
else if (round == Rounds.Preflop) // calling a bet preflop
{
callNode.sequence += '/';
callNode.round = Rounds.Flop;
callNode.player = 1;
int callAmt = root.action == Actions.Raise ? _betSize[0] : 0;
recursiveBuildTree(callNode, 1, Rounds.Flop, pot + callAmt, new int[] { 0, 0 }, indexes);
}
else // calling a flop bet and seeing a showdown
{
callNode.terminal = true;
double finalPot = (bets.Max() == 0 ? pot : pot + _betSize[1]) / 2.0;
if (callNode.hole1 == callNode.hole2) // draw
callNode.payoff = 0;
else if (callNode.hole1 == callNode.board) // p1 pair
callNode.payoff = finalPot;
else if (callNode.hole2 == callNode.board) // p2 pair
callNode.payoff = -finalPot;
else if(callNode.hole1 > callNode.hole2) // p1 high card with no pairs on board
callNode.payoff = finalPot;
else // p2 high card with no pairs on board
callNode.payoff = -finalPot;
}
SetNodeIndex(callNode, root, indexes);
children.Add(callNode);
root.children = children.ToArray();
}
static void Main(string[] args)
{
// Console.WriteLine("**** WARNING: HARD CODED PARAMETERS IN USE ****");
// args= @"/Users/wesley/Dropbox/Public/hands.xml /Users/wesley/poker/classifiers/datasets/river.arff -round river -regression".Split();
#region Validate parameters
if (args.Length < 2)
{
Console.WriteLine("Format: HoldemFeatures.exe <input> <output> [-option1 ...]");
Console.WriteLine("Options:");
// Delimiter
Console.WriteLine("[d, delim, delimiter] <arg1>".PadRight(30) + "Sets the delimiter character for the output file.");
Console.WriteLine("".PadRight(30) + "Setting arg1 to tab or \t will set the delimiter as tabs.");
Console.WriteLine("".PadRight(30) + "Default: ,");
// Round
Console.WriteLine("[r, round] <arg1>".PadRight(30) + "Filters the actions to only those in the given round.");
Console.WriteLine("".PadRight(30) + "Options: preflop, flop, turn, river, none");
Console.WriteLine("".PadRight(30) + "Default: none (all rounds)");
// Convert features to numeric values
Console.WriteLine("[num, numeric]".PadRight(30) + "Automatically converts all features to numeric values.");
Console.WriteLine("Default: disabled.".PadLeft(30));
// Convert features to numeric values
Console.WriteLine("[format] <arg1>".PadRight(30) + "Sets the file format to save to.");
Console.WriteLine("".PadRight(30) + "Options: arff, csv");
Console.WriteLine("Default: arff.".PadLeft(30));
Console.WriteLine("[regress, regression]".PadRight(30) + "Generates datasets for regression rather than classification.");
Console.WriteLine("Default: disabled (classification)".PadLeft(30));
return;
}
for (int i = 2; i < args.Length; i++)
{
if (args[i][0] != '-')
continue;
string flag = args[i].Substring(1).ToLower();
switch (flag)
{
case "delim":
case "d":
case "delimiter": DELIMITER = args[++i];
string delim = DELIMITER.ToLower();
if (delim == "tab" || delim == "tabs" || delim == "\\t")
DELIMITER = "\t";
break;
case "round":
case "r": ROUND_FILTER = (Rounds)Enum.Parse(typeof(Rounds), args[++i], true);
featureGen.SkipMissingFeatures = true;
break;
case "num":
case "numeric": featureGen.ConvertFeaturesToNumeric = true;
break;
case "format": FILE_FORMAT = args[++i].ToLower();
if(FILE_FORMAT != "csv" && FILE_FORMAT != "arff")
{
Console.WriteLine("Unknown file format: {0}. Options are csv or arff", FILE_FORMAT);
return;
}
break;
case "regression":
case "regress": REGRESSION = true;
break;
default:
Console.WriteLine("Unknown flag: {0}", flag);
return;
}
}
string inFilename = args[0];
if (!File.Exists(inFilename))
{
Console.WriteLine("No input file found at {0}", inFilename);
return;
}
#endregion
#region Read in all hands
Console.Write("Loading hand histories... ");
PokerHandXML hands;
using (TextReader reader = new StreamReader(inFilename))
{
XmlSerializer ser = new XmlSerializer(typeof(PokerHandXML));
hands = (PokerHandXML)ser.Deserialize(reader);
}
Console.WriteLine("done.");
Console.WriteLine("Loaded {0} hand{1}.", hands.Hands.Length, hands.Hands.Length == 1 ? "" : "s");
#endregion
#region Iterate over every hero action and generate features
Console.WriteLine("Generating features...");
weka.core.Instances[] features = featureGen.GenerateFeatures(hands.Hands, ROUND_FILTER, REGRESSION);
Console.WriteLine("done.");
Console.WriteLine("Generated {0} features for {1} decision{2}", features[0].numAttributes(), features[0].numInstances(), features[0].numInstances() == 1 ? "" : "s");
#endregion
#region Write the results to a delimited file
Console.Write("Writing results to file... ");
if(REGRESSION)
{
string filename = args[1].Insert(args[1].IndexOf('.'), "_{0}");
writeFile(features[0], string.Format(filename, "fold"));
writeFile(features[1], string.Format(filename, "call"));
writeFile(features[2], string.Format(filename, "raise"));
}
else
writeFile(features[0], args[1]);
Console.WriteLine("done.");
#endregion
}