Short answer: My simulation shows DuchyDukeEmbassyWarehouse strategy winning in a 3:2 ratio over DevelopFeodum. It's a little better, but not a huge amount. Not the 9:1 ratio you were hoping for.
DuchyDukeWarehouseEmbassy vs FeodumDevelop
DuchyDukeWarehouseEmbassy won: 58.58 percent of the time.
FeodumDevelop won: 40.14 percent of the time.
Ties: 1.28 percent of the time.
Both strategies seem better than big money. That's always a good sign that they are decently coded.
DuchyDukeWarehouseEmbassy vs BigMoney
DuchyDukeWarehouseEmbassy : 62.46 percent of the time.
BigMoney: 35.65 percent of the time.
Ties: 1.89 percent of the time.
FeodumDevelop vs BigMoney
FeodumDevelop won: 72.77 percent of the time.
BigMoney won: 25.36 percent of the time.
Ties: 1.87 percent of the time.
There's a lot of details missing on how to code up the strategies. I coded up feodem/develop so it tries to obtain 12 silvers, and after that always maximizes it's points when choosing whether to trash a feodum. The feodum AI does trash coppers, but at low priority.
The simulator probably isn't replicating how you actually played though. I find that seldom does the feodom player actually make it to 8 provinces. Usually, the game piles out instead.
Example game where DuchyDuke won:
Game ended in 33 turns.
Player1 Won!
Player1 total score: 91
Copper(7), Duchy(8 ), Duke(8 ), Embassy(1), Estate(3), Silver(8 ), Warehouse(2),
Player2 total score: 72
Copper(3), Develop(2), Embassy(2), Feodum(6), Province(3), Silver(29),
Trash contains: Copper(4), Estate(3), Feodum(2),
Example game where Feodum won:
Game ended in 32 turns.
Player2 Won!
Player1 total score: 80
Copper(7), Duchy(7), Duke(8 ), Embassy(1), Estate(3), Silver(12), Warehouse(3),
Player2 total score: 87
Copper(4), Develop(2), Duchy(1), Embassy(1), Feodum(6), Province(5), Silver(27),
Trash contains: Copper(3), Estate(3), Feodum(2),
Here's what I came up with based off of your description: (hopefully you can infer from the c# code what the strategy was, cause it would be too time consuming to write up the details
)
I opened Silver/Warehouse, got a few Silvers, a single Embassy, then went hard for Duchies, then Dukes. On $4 or less I would get Silvers but I got up to three Warehouses.
private static IGetMatchingCard PurchaseOrder()
{
var highPriority = new CardPickByPriority(
CardAcceptance.For<CardTypes.Embassy>(gameState => CountAllOwned<CardTypes.Embassy>(gameState) < 1),
CardAcceptance.For<CardTypes.Duchy>(),
CardAcceptance.For<CardTypes.Duke>());
var buildOrder = new CardPickByBuildOrder(
new CardTypes.Silver(),
new CardTypes.Warehouse(),
new CardTypes.Silver(),
new CardTypes.Silver(),
new CardTypes.Silver(),
new CardTypes.Silver(),
new CardTypes.Warehouse(),
new CardTypes.Silver(),
new CardTypes.Silver(),
new CardTypes.Silver(),
new CardTypes.Silver(),
new CardTypes.Warehouse());
var lowPriority = new CardPickByPriority(
CardAcceptance.For<CardTypes.Silver>());
return new CardPickConcatenator(highPriority, buildOrder, lowPriority);
}My opponent opened Develop/Feodum, didn't collide them on the first shuffle, but looked to collide them by buying/gaining more copies of each and did a couple of times. He scooped up all the Feoda quickly, and ended up trashing three of them. I think he had 20-something Silvers total (Feoda were worth 5 each) and the Silver pile was in danger of running out by the end of the game.
private static IGetMatchingCard PurchaseOrder()
{
return new CardPickByPriority(
CardAcceptance.For<CardTypes.Province>(),
CardAcceptance.For<CardTypes.Develop>(ShouldGainDevelop),
CardAcceptance.For<CardTypes.Feodum>(ShouldGainFeodum),
CardAcceptance.For<CardTypes.Silver>());
}
private static IGetMatchingCard GainOrder()
{
return new CardPickByPriority(
CardAcceptance.For<CardTypes.Develop>(ShouldGainDevelop),
CardAcceptance.For<CardTypes.Feodum>(ShouldGainFeodum),
CardAcceptance.For<CardTypes.Silver>(),
CardAcceptance.For<CardTypes.Duchy>(),
CardAcceptance.For<CardTypes.Feodum>(),
CardAcceptance.For<CardTypes.Develop>());
}
private static CardPickByPriority TrashOrder()
{
return new CardPickByPriority(
CardAcceptance.For<CardTypes.Duchy>(),
CardAcceptance.For<CardTypes.Feodum>(ShouldTrashFeodum),
CardAcceptance.For<CardTypes.Estate>(),
CardAcceptance.For<CardTypes.Copper>());
}
private static bool ShouldGainDevelop(GameState gameState)
{
return CountAllOwned<CardTypes.Develop>(gameState) < 2 &&
CountAllOwned<CardTypes.Feodum>(gameState) >= CountAllOwned<CardTypes.Develop>(gameState);
}
private static bool ShouldPlayDevelop(GameState gameState)
{
var currentPlayer = gameState.players.CurrentPlayer;
Type result;
if (currentPlayer.Hand.Where(card => card.Is<CardTypes.Develop>()).Count() > 1)
{
result = TrashOrder().GetMatchingCard(gameState, card => currentPlayer.Hand.HasCard(card));
}
else
{
result = TrashOrder().GetMatchingCard(gameState, card => currentPlayer.Hand.HasCard(card) && !card.Is<CardTypes.Develop>());
}
return result != null;
}
private static bool ShouldTrashFeodum(GameState gameState)
{
int countFeodumRemaining = gameState.GetPile<CardTypes.Feodum>().Count();
int countSilvers = CountAllOwned<CardTypes.Silver>(gameState);
int countFeodum = CountAllOwned<CardTypes.Feodum>(gameState);
if (countSilvers < 12)
{
return true;
}
int scoreTrashNothing = CardTypes.Feodum.VictoryCountForSilver(countSilvers) * countFeodum;
int scoreTrashFeodum = CardTypes.Feodum.VictoryCountForSilver((countSilvers + 4)) * (countFeodum - 1);
return scoreTrashFeodum > scoreTrashNothing;
}
private static bool ShouldGainFeodum(GameState gameState)
{
int countFeodumRemaining = gameState.GetPile<CardTypes.Feodum>().Count();
int countSilvers = CountAllOwned<CardTypes.Silver>(gameState);
int countFeodum = CountAllOwned<CardTypes.Feodum>(gameState);
if (countSilvers < 1)
{
return false;
}
int scoreGainFeodum = CardTypes.Feodum.VictoryCountForSilver(countSilvers) * (countFeodum + 1);
int scoreGainSilver = CardTypes.Feodum.VictoryCountForSilver((countSilvers + 1)) * (countFeodum);
return scoreGainFeodum > scoreGainSilver;
}
