public async Task TournamentController_BidContest()
{
Log.Level = 5;
var t = await TournamentLoader.LoadAsync(File.OpenRead("uBidParscore.pbn"));
var c = new TournamentController(t, new ParticipantInfo()
{
PlayerNames = new Participant("North", "East", "South", "West"), ConventionCardNS = "RoboBridge", ConventionCardWE = "RoboBridge", UserId = Guid.NewGuid()
}, BridgeEventBus.MainEventBus);
var r = new SeatCollection <BridgeRobot>(new BridgeRobot[] { new TestRobot(Seats.North, BridgeEventBus.MainEventBus), new TestRobot(Seats.East, BridgeEventBus.MainEventBus), new TestRobot(Seats.South, BridgeEventBus.MainEventBus), new TestRobot(Seats.West, BridgeEventBus.MainEventBus) });
await c.StartTournamentAsync();
Assert.AreEqual <int>(1, t.Boards[0].Results.Count);
Assert.AreEqual <int>(2, t.Boards[0].Results[0].Contract.Bid.Hoogte);
Assert.IsFalse(t.Boards[0].Results[0].Play.PlayEnded);
var whoseTurn = t.Boards[0].Dealer;
foreach (var bid in t.Boards[0].Results[0].Auction.Bids)
{
if (!whoseTurn.IsSameDirection(t.Boards[0].Results[0].Auction.Opener))
{
Assert.IsTrue(bid.IsPass, "no overcalls");
}
whoseTurn = whoseTurn.Next();
}
}
public async Task Serializable_PbnTournament()
{
var t = await TournamentLoader.LoadAsync(File.OpenRead("uBidParscore.pbn"));
var serializer = new DataContractSerializer(typeof(PbnTournament));
using (var stream = File.Create("tournament.xml"))
{
using (var xdw = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
serializer.WriteObject(xdw, t);
}
}
var tournamentXml = await File.OpenText("tournament.xml").ReadToEndAsync();
Debug.WriteLine(tournamentXml);
Tournament t2;
using (var fs = File.OpenRead("tournament.xml"))
{
var reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
t2 = (Tournament)serializer.ReadObject(reader);
}
Assert.AreEqual(t.Boards[0], t2.Boards[0]);
//Assert.AreEqual(t.Boards[0].DoubleDummyTricks[Seats.North][Suits.Spades], t2.Boards[0].DoubleDummyTricks[Seats.North][Suits.Spades]);
}
public async Task Tournament_Load_uBid()
{
var originalTournament = await TournamentLoader.LoadAsync(File.OpenRead("uBidParscore.pbn"));
Assert.IsFalse(originalTournament.AllowOvercalls, "OvercallsAllowed");
Pbn2Tournament.Save(originalTournament, File.Create("t1.pbn"));
var newFile = await File.OpenText("t1.pbn").ReadToEndAsync();
Assert.IsTrue(newFile.Contains("DoubleDummyTricks"), "DoubleDummyTricks");
//Assert.IsTrue(newFile.Contains("OptimumResultTable"), "OptimumResultTable");
}
public void HostTournament(string pbnTournament)
{
this.HostedTournament = TournamentLoader.LoadAsync(File.OpenRead(pbnTournament)).Result;
this.c = new TMController(this, this.HostedTournament, new ParticipantInfo()
{
ConventionCardNS = this.clients[Seats.North].teamName, ConventionCardWE = this.clients[Seats.East].teamName, MaxThinkTime = 120, UserId = Guid.NewGuid(), PlayerNames = new Participant(this.clients[Seats.North].teamName, this.clients[Seats.East].teamName, this.clients[Seats.North].teamName, this.clients[Seats.East].teamName)
}, this.EventBus);
this.allReadyForStartOfBoard = false;
this.ThinkTime[Directions.NorthSouth].Reset();
this.ThinkTime[Directions.EastWest].Reset();
this.c.StartTournament();
}
public static Tournament TournamentLoad(string fileName)
{
if (fileName.StartsWith("http://"))
{
var url = new Uri(fileName);
var req = WebRequest.Create(url);
var resp = req.GetResponse();
var stream = resp.GetResponseStream();
return(TournamentLoader.LoadAsync(stream).Result);
}
else
{
return(TournamentLoader.LoadAsync(File.OpenRead(fileName)).Result);
}
}
public async Task TournamentController_Run()
{
Log.Level = 4;
var t = await TournamentLoader.LoadAsync(File.OpenRead("WC2005final01.pbn"));
var c = new TournamentController(t, new ParticipantInfo()
{
PlayerNames = new Participant("North", "East", "South", "West"), ConventionCardNS = "RoboBridge", ConventionCardWE = "RoboBridge", UserId = Guid.NewGuid()
}, BridgeEventBus.MainEventBus);
var r = new SeatCollection <BridgeRobot>(new BridgeRobot[] { new TestRobot(Seats.North, BridgeEventBus.MainEventBus), new TestRobot(Seats.East, BridgeEventBus.MainEventBus), new TestRobot(Seats.South, BridgeEventBus.MainEventBus), new TestRobot(Seats.West, BridgeEventBus.MainEventBus) });
await c.StartTournamentAsync();
Assert.AreEqual <int>(3, t.Boards[0].Results.Count);
Assert.AreEqual <int>(5, t.Boards[0].Results[0].Contract.Bid.Hoogte);
Assert.IsTrue(t.Boards[0].Results[0].Play.PlayEnded);
Assert.IsFalse(t.Boards[0].Results[2].Auction.Bids[0].IsPass); // opening
Assert.IsFalse(t.Boards[0].Results[2].Auction.Bids[1].IsPass); // overcall
}
static void Main(string[] args)
{
try
{
var settings = ExecutionSettings.FromJsonFile(_settingsFile);
settings.ApplyOverrides(args);
settings.Validate();
settings.Print();
Console.WriteLine("Starting detection engine:");
Console.WriteLine("* Loading format data");
ArchetypeFormat format = Formats.FromJson.Loader.GetFormat(settings.FormatDataFolder, settings.Format);
ArchetypeFormat referenceFormat = null;
if (!String.IsNullOrEmpty(settings.ReferenceFormat))
{
referenceFormat = Formats.FromJson.Loader.GetFormat(settings.FormatDataFolder, settings.ReferenceFormat);
}
Console.WriteLine("* Loading meta information");
DateTime startDate = format.Metas.First().StartDate.AddDays(1);
string metaFilter = String.Empty;
if (!String.IsNullOrEmpty(settings.Meta))
{
if (settings.Meta.ToLowerInvariant() == "current")
{
metaFilter = format.Metas.Where(m => m.StartDate.AddDays(1) < DateTime.UtcNow).Last().Name;
}
else
{
metaFilter = settings.Meta;
}
var meta = format.Metas.FirstOrDefault(m => m.Name.Contains(metaFilter, StringComparison.InvariantCultureIgnoreCase));
if (meta != null)
{
startDate = meta.StartDate.AddDays(1);
}
}
Console.WriteLine("* Loading tournaments");
Tournament[] tournaments = settings.TournamentFolder.SelectMany(c => TournamentLoader.GetTournamentsByDate(c, startDate, t =>
{
foreach (string filter in settings.Filter)
{
if (!t.Contains(filter, StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
}
foreach (string exclude in settings.Exclude)
{
if (t.Contains(exclude, StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
}
return(true);
})).ToArray();
Record[] records = RecordLoader.GetRecords(tournaments, format, referenceFormat, settings.IncludeDecklists, settings.MaxDecksPerEvent);
if (!String.IsNullOrEmpty(metaFilter))
{
records = records.Where(r => r.Meta.Contains(metaFilter, StringComparison.InvariantCultureIgnoreCase)).ToArray();
if (!String.IsNullOrEmpty(settings.MetaWeek))
{
int metaWeekFilter;
if (settings.MetaWeek.ToLowerInvariant() == "current")
{
metaWeekFilter = records.Max(r => r.Week);
}
else
{
metaWeekFilter = Int32.Parse(settings.MetaWeek);
}
records = records.Where(r => r.Week == metaWeekFilter).ToArray();
}
}
if (!String.IsNullOrEmpty(settings.Archetype))
{
records = records.Where(r => r.Archetype.Archetype.Contains(settings.Archetype, StringComparison.InvariantCultureIgnoreCase)).ToArray();
}
if (settings.Card != null && settings.IncludeDecklists)
{
foreach (string card in settings.Card)
{
records = records.Where(r =>
r.Mainboard.Any(c => c.Card.Equals(card, StringComparison.InvariantCultureIgnoreCase)) ||
r.Sideboard.Any(c => c.Card.Equals(card, StringComparison.InvariantCultureIgnoreCase))
).ToArray();
}
}
if (settings.ExcludeCard != null && settings.IncludeDecklists)
{
foreach (string card in settings.ExcludeCard)
{
records = records.Where(r =>
!r.Mainboard.Any(c => c.Card.Equals(card, StringComparison.InvariantCultureIgnoreCase)) &&
!r.Sideboard.Any(c => c.Card.Equals(card, StringComparison.InvariantCultureIgnoreCase))
).ToArray();
}
}
if (records.Length == 0)
{
Console.WriteLine("No records found with the current filters");
}
else
{
if (settings.Action == ExecutionAction.Compare)
{
records = records.Where(r => !r.Archetype.Equals(r.ReferenceArchetype)).ToArray();
}
IOutput output;
switch (settings.Output)
{
case ExecutionOutput.Csv:
Console.WriteLine("Saving data to CSV file");
output = new CsvOutput();
break;
case ExecutionOutput.Json:
Console.WriteLine("Saving data to JSON file");
output = new JsonOutput();
break;
case ExecutionOutput.Console:
default:
output = new ConsoleOutput();
break;
}
output.Write(records, settings.Action, settings.OutputFile);
}
if (settings.MetaBreakdown)
{
PrintBreakdown(records, settings);
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
if (ex is ValidationException)
{
Console.WriteLine(_usage);
}
}
}
