public static Contract FindOptimalContract(int[,] lewy, vulnerabilties vul, positions dealer)
{
DeefFinesseAnalize df = new DeefFinesseAnalize(lewy, vul, dealer);
df.FindOptimalContract();
return(df.optimalContract);
}
/// <summary>
/// Tworzy ramkę tytułową w rozkładzie. Ustawie szerokość krawędzi(na sztywno), kolor ramy wg zmiennej kolor_ramy_rozkladu.
/// Formatuje całą tabele, tworzy napisy(na sztywno) można wpłynąć na założenia i nr rozdania.
/// </summary>
/// <param name="cell">Komórka tabeli do której chcemy wpisać tą ramkę </param>
/// <param name="nr"> Cyfra, która ma stac przy nr rozdania</param>
/// <param name="zalozenia">Załozenie do wypisania - enmum vulnerabilities</param>
/// <returns></returns>
protected void CreateFrame(ref Cell cell, int nr, vulnerabilties zalozenia, Font fRozd = null, Font fVul = null)
{
if (fRozd == null)
{
fRozd = Czcionki.font_normalBold;
}
if (fVul == null)
{
fVul = Czcionki.font_smallbold;
}
Paragraph naglowek1 = new Paragraph();
string rozdanie_string = napis_rozdanie + nr;
//Formatowanie ramki
cell.Borders.Width = rozkladKart_borders;
cell.Shading.Color = kolor_ramy_rozkladu;
// Formatowanie napisu rozdanie
naglowek1 = cell.AddParagraph();
naglowek1.Format.Alignment = ParagraphAlignment.Center;
naglowek1.Format.Font = fRozd;
naglowek1.AddText(rozdanie_string);
naglowek1.AddLineBreak(); naglowek1.AddLineBreak();
// Formatowanie napisu zalozenia
Paragraph naglowek2 = new Paragraph();
naglowek2 = cell.AddParagraph();
naglowek2.Format.Font = fVul;
naglowek2.Format.Alignment = ParagraphAlignment.Center;
string zal_ = "";
zal_ = napis_zalozenia[(int)zalozenia];
// Przyklad korzysci z zastosowania typu wyliczeniowego, a raczej z wpisania czegos w zalozenia
//if (InfoBridge.NS_partia[nr] == 0 && InfoBridge.WE_partia[nr] == 0) zal_ = zalozenie[0];
//if (InfoBridge.NS_partia[nr] == 1 && InfoBridge.WE_partia[nr] == 0) zal_ = zalozenie[1];
//if (InfoBridge.NS_partia[nr] == 0 && InfoBridge.WE_partia[nr] == 1) zal_ = zalozenie[2];
//if (InfoBridge.NS_partia[nr] == 1 && InfoBridge.WE_partia[nr] == 1) zal_ = zalozenie[3];
naglowek2.AddText(zal_);
cell.VerticalAlignment = VerticalAlignment.Center;
}
protected static vulnerabilties rzutujpartie(string input)
{
input = input.ToUpper();
vulnerabilties output = vulnerabilties.none;
if (input == "N")
{
return(vulnerabilties.ns);
}
if (input == "E")
{
return(vulnerabilties.we);
}
if (input == "B")
{
return(vulnerabilties.both);
}
return(output);
}
/// <summary>
/// Tworzy całą tabelę z rozkładem. Szerokość danych kolumn zalezy od zmiennej szerokosc_kolumny_rozkladu. Odległość rozkładu od krawędzi dla
/// ręki N wynosi 0.5(gora, dol) lewa i prawa jest zalezna od szerokosci kolumny, analogicznie inne. Ustawia środkową komórką na ramkę.
/// Foramtuje tabele
/// </summary>
/// <param name="rozklad">Rozklad wg struktury RozkladKart do wydrukowania</param>
/// <param name="nr">Nr potrzebny do ramki</param>
/// <param name="vul">Zalozenia potrzebne do ramki</param>
/// <returns></returns>
public Table PrintBoardRozklad(RozkladKart rozklad, int nr, vulnerabilties vul)
{
Table table = new Table();
//table.Borders.Width = 1.0;
//table.Borders.Color = Colors.Red;
double spaceBA = 0.3;
Column column1 = table.AddColumn(Unit.FromCentimeter(szerokosc_kolumny_rozkladu));
Column column2 = table.AddColumn(Unit.FromCentimeter(szerokosc_kolumny_rozkladu));
Column column3 = table.AddColumn(Unit.FromCentimeter(szerokosc_kolumny_rozkladu));
table.Format.Alignment = ParagraphAlignment.Justify;
/////////////////////////////////N//////////////////////////////
Row row = table.AddRow();
Paragraph p = row.Cells[1].AddParagraph();
double margin = (szerokosc_kolumny_rozkladu - 2.8) / 2;
p.Format.LeftIndent = Unit.FromCentimeter(margin);
p.Format.RightIndent = Unit.FromCentimeter(margin / 2);
p.Format.SpaceBefore = Unit.FromCentimeter(spaceBA);
p.Format.SpaceAfter = Unit.FromCentimeter(spaceBA);
WriteHand(rozklad.N, p);
// p.AddLineBreak();
/////////////////////////////////W//////////////////////////////
Row row2 = table.AddRow();
p = row2[0].AddParagraph();
p.Format.LeftIndent = Unit.FromCentimeter(margin * 2);
p.Format.SpaceBefore = Unit.FromCentimeter(spaceBA);
p.Format.SpaceAfter = Unit.FromCentimeter(spaceBA);
WriteHand(rozklad.W, p);
/////////////////////////////////E//////////////////////////////
p = row2[2].AddParagraph();
p.Format.LeftIndent = Unit.FromCentimeter(0.5);
p.Format.SpaceBefore = Unit.FromCentimeter(spaceBA);
p.Format.SpaceAfter = Unit.FromCentimeter(spaceBA);
WriteHand(rozklad.E, p);
/////////////////////////////////////S//////////////////////////////////////////////
Row row3 = table.AddRow();
p = row3[1].AddParagraph();
p.Format.LeftIndent = Unit.FromCentimeter(margin);
p.Format.RightIndent = Unit.FromCentimeter(margin / 2);
p.Format.SpaceBefore = Unit.FromCentimeter(spaceBA);
p.Format.SpaceAfter = Unit.FromCentimeter(spaceBA);
WriteHand(rozklad.S, p);
Cell cell = new Cell();
cell = row2.Cells[1];
CreateFrame(ref cell, nr, vul);
//ustawienie ramki tabeli
// table.SetEdge(0, 0, 3, 1, Edge.Box, BorderStyle.None, 0.0, Colors.White);
return(table);
}
public DeefFinesseAnalize(int[,] lewy_, vulnerabilties vul_, positions dealer_)
{
lewy = lewy_;
vul = vul_;
dealer = dealer_;
}
}//koniec funkcji
public static Contract zabawaMAX(int[,] lewy, vulnerabilties vul)
{
List <int[]> tabela = new List <int[]>();
int[] tmpgracz = { 3, 1, 4, 2 };
for (int i = 0; i < 4; i++)
{
int[] tabelaGracz = new int[35];
for (int l = 0; l < 7; l++)
{
for (int s = 0; s < 5; s++)
{
// tu wyliczam ile za kontrakt na danym levelu
Contract c = new Contract();
c.level = l + 1;
c.suit = (suits)(s + 1);
c.declarer = (positions)(tmpgracz[i]); // tu oddac tabele konwersujaca
c.tricks = lewy[i, s] - 6 - c.level;
if (c.tricks < 0)
{
c.dbl = true;
}
tabelaGracz[l * 5 + s] = c.CalculateScore(false);
}
}
tabela.Add(tabelaGracz);
}
int[] tabelaNS = new int[35];
int[] tabelaEW = new int[35];
// budowa powyzszych tabel
for (int i = 0; i < 35; i++)
{
if (tabela[0][i] > tabela[1][i])
{
tabelaNS[i] = tabela[0][i];
}
else
{
tabelaNS[i] = tabela[1][i];
}
if (tabela[2][i] > tabela[3][i])
{
tabelaEW[i] = tabela[2][i];
}
else
{
tabelaEW[i] = tabela[3][i];
}
}
int max = 0;
int top = 12345;
for (int i = 0; i < 35;)
{
if (tabelaNS[i] > max)
{
max = tabelaNS[i];
top = i;
}
if (-tabelaEW[i] < max)
{
max = -tabelaEW[i];
top = -i;
}
i++;
}
Contract res = new Contract();
res.level = Math.Abs(top) / 5 + 1;
int suit = (Math.Abs(top) % 5 + 1);
res.suit = (suits)suit;
bool nsplay = (top > 0);
if (nsplay)
{
res.declarer = positions.N;
if (tabelaNS[Math.Abs(top)] < 0)
{
res.dbl = true;
}
}
else
{
res.declarer = positions.S;
if (tabelaEW[Math.Abs(top)] < 0)
{
res.dbl = true;
}
}
res.score = max;
return(res);
}
public static Contract wyliczMinimaksTeoretyczny(int[,] lewy, vulnerabilties vul)
{
bool partiaNS = false, partiaEW = false;
int[] tmpgracz = { 3, 1, 4, 2 };
Contract maxNSContract = new Contract();
Contract maxEWContract = new Contract();
Contract result;
if ((vul == vulnerabilties.ns) || vul == vulnerabilties.both)
{
partiaNS = true;
}
if ((vul == vulnerabilties.we) || vul == vulnerabilties.both)
{
partiaEW = true;
}
// szukam ile w ataku moze ugrac NS
int maxNS = 0;
for (int gracz = 0; gracz < 2; gracz++)
{
for (int i = 0; i < 5; i++)
{
Contract c = new Contract();
c.level = lewy[gracz, i] - 6;
c.suit = (suits)(i + 1);
c.declarer = (positions)(tmpgracz[gracz]);
int score = c.CalculateScore(partiaNS);
if (score > maxNS)
{
maxNS = score;
maxNSContract = c;
}
}
}
// szukam ile w ataku mozna ugrac EW
int maxEW = 0;
for (int gracz = 2; gracz < 4; gracz++)
{
for (int i = 4; i >= 0; i--)
{
Contract c = new Contract();
c.level = lewy[gracz, i] - 6;
c.suit = (suits)(i + 1);
c.declarer = (positions)(tmpgracz[gracz]);
int score = c.CalculateScore(partiaEW);
if (score > maxEW)
{
maxEW = score;
maxEWContract = c;
}
}
}
//sprawdzam obrony
Contract obronaTop = null;
if (maxNSContract > maxEWContract)
{
//obronaTop = maxNSContract;
maxNS = -maxNS;
result = maxNSContract;
//sprawdz czy EW ma obronę
Contract obrona = maxNSContract;
for (int i = 0; i < 5; i++)
{
obrona++;
obrona.tricks = -obrona.level - 6 + lewy[2, ((int)obrona.suit - 1)];
obrona.declarer = positions.E;
obrona.dbl = true;
int score = obrona.CalculateScore(partiaEW);
if (score > maxNS)
{
maxNS = score;
obronaTop = new Contract();
obronaTop.level = obrona.level;
obronaTop.suit = obrona.suit;
obronaTop.declarer = obrona.declarer;
obronaTop.dbl = true;
obronaTop.tricks = obrona.tricks;
}
obrona.declarer = positions.W;
obrona.tricks = -obrona.level - 6 + lewy[3, ((int)obrona.suit - 1)];
score = obrona.CalculateScore(partiaEW);
if (score > maxNS)
{
maxNS = score;
obronaTop = new Contract();
obronaTop.level = obrona.level;
obronaTop.suit = obrona.suit;
obronaTop.declarer = obrona.declarer;
obronaTop.dbl = true;
obronaTop.tricks = obrona.tricks;
}
}
if (obronaTop == null)
{
result = maxNSContract;
}
}
else
{
// obronaTop = maxEWContract;
maxEW = -maxEW;
//sprawdz czy NS ma obronę
Contract obrona = maxEWContract;
result = maxNSContract;
for (int i = 0; i < 5; i++)
{
obrona++;
obrona.tricks = -obrona.level - 6 + lewy[0, ((int)obrona.suit - 1)];
obrona.declarer = positions.N;
obrona.dbl = true;
int score = obrona.CalculateScore(partiaNS);
if (score > maxEW)
{
maxEW = score;
obronaTop = new Contract();
obronaTop.level = obrona.level;
obronaTop.suit = obrona.suit;
obronaTop.declarer = obrona.declarer;
obronaTop.dbl = true;
obronaTop.tricks = obrona.tricks;
}
obrona.declarer = positions.W;
obrona.tricks = -obrona.level - 6 + lewy[1, ((int)obrona.suit - 1)];
score = obrona.CalculateScore(partiaNS);
if (score > maxEW)
{
maxEW = score;
obronaTop = new Contract();
obronaTop.level = obrona.level;
obronaTop.suit = obrona.suit;
obronaTop.declarer = obrona.declarer;
obronaTop.dbl = true;
obronaTop.tricks = obrona.tricks;
}
}
if (obronaTop == null)
{
result = maxEWContract;
}
}
return(obronaTop);
}//koniec funkcji
public static void wyliczMinimkaksTeoretyczny10(int[,] lewy, vulnerabilties vul)
{
int maxNS = 0;
Contract maxNSContract = new Contract();
int[] tmpgracz = { 3, 1, 4, 2 };
// minimaks dodatni dla NS
for (int gracz = 0; gracz < 2; gracz++)
{
for (int i = 4; i >= 0; i--)
{
Contract c = new Contract();
bool partia = false;
if ((vul == vulnerabilties.ns) || (vul == vulnerabilties.both))
{
partia = true;
}
c.level = lewy[gracz, i] - 6;
c.suit = (suits)(i + 1);
c.declarer = (positions)(tmpgracz[gracz]);
int score = c.CalculateScore(partia);
if (score > maxNS)
{
maxNS = score;
maxNSContract = c;
}
}
}
// minimaks dodatni dla EW
int maxEW = 0;
Contract maxEWContract = new Contract();
for (int gracz = 2; gracz < 4; gracz++)
{
for (int i = 4; i >= 0; i--)
{
Contract c = new Contract();
bool partia = false;
if ((vul == vulnerabilties.we) || (vul == vulnerabilties.both))
{
partia = true;
}
c.level = lewy[gracz, i] - 6;
c.suit = (suits)(i + 1);
c.declarer = (positions)(tmpgracz[gracz]);
int score = c.CalculateScore(partia);
if (score > maxEW)
{
maxEW = score;
maxEWContract = c;
}
}
}
bool atakNS;
int obronaScore = -maxNS;
suits Superobrona = suits.diamond;
if (maxNSContract > maxEWContract)
{
atakNS = true;
Contract obrona = maxNSContract;
bool partia = false;
if ((vul == vulnerabilties.we) || (vul == vulnerabilties.both))
{
partia = true;
}
// sprawdzam czy na EW jest obrona
for (int i = 0; i < 5; i++)
{
obrona++;
obrona.declarer = positions.W;
obrona.tricks = -obrona.level - 6 + lewy[3, ((int)obrona.suit - 1)];
obrona.dbl = true;
int s = obrona.CalculateScore(partia);
if (s > obronaScore)
{
Superobrona = obrona.suit;
obronaScore = s;
}
obrona.declarer = positions.E;
obrona.tricks = -obrona.level - 6 + lewy[2, ((int)obrona.suit - 1)];
obrona.dbl = true;
s = obrona.CalculateScore(partia);
if (s > obronaScore)
{
obronaScore = s;
Superobrona = obrona.suit;
}
}
}
else
{
atakNS = false;
}
}
