/// <summary>
/// Diese Methode verwaltet ein einfaches Verhör zwischen zwei Strategien
/// </summary>
static void VerhörEinfach()
{
// Überschrift
WriteTrennstrich();
Console.WriteLine(spielModi[0]);
WriteTrennstrich();
// Auswahl der beiden Strategie, der Rundenanzahl sowie der Schwere der Verstöße
int st1 = 0, st2 = 0;
StrategieAuswahl(ref st1, ref st2);
int runde, schwere;
runde = VerwaltungKram.EingabeZahlMinMax("Rundenanzahl: ", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Schwere der Verstöße (0 = Leicht, 1 = Mittel, 2 = Schwer): ", 0, 3);
// Holt die beiden Strategien aus der Collection.
BasisStrategie strategie1 = _strategien[st1];
BasisStrategie strategie2 = _strategien[st2];
// Überschrift
WriteTrennstrich();
Console.WriteLine("Verhör");
WriteTrennstrich();
// Starten des Verhörs mit gegebenen Faktoren
int punkte1 = 0, punkte2 = 0;
Verhoer2Strategien(strategie1, strategie2, runde, schwere, ref punkte1, ref punkte2);
// Ausgabe des Siegers
WriteLeerzeile();
Siegerehrung(strategie1.Name(), strategie2.Name(), punkte1, punkte2);
}
/// <summary>
/// Fragt gegnerische Strategie, Länge, Schwere und Spielername ab und startet den Verhör.
/// </summary>
static void PlayerVsStrategie()
{
//Rundenstart
try { Console.Clear(); }
catch (IOException e) { }
int st;
int runde, schwere;
string spieler;
Console.WriteLine("Willkommen zum Verhör gegen eine Strategie\nStrategien:");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
st = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen verhoert werden?", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0=leicht | 1=mittel | 2=schwer)", 0, 3);
Console.WriteLine("Geben sie ihren Spielernamen ein: ");
spieler = Console.ReadLine();
PlayerVerhoer(st, runde, schwere, spieler);
//Rundenende
Console.ReadKey();
try { Console.Clear(); }
catch (IOException e) { }
}
public static void Start(List <BasisStrategie> strategien)
{
_strategien = strategien;
int st1, st2;
int runde;
Verbrechen verbrechen;
Console.WriteLine("Willkommen zum Verhör zwischen 2 Strategien");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
Console.WriteLine("Wählen Sie ihre 2 Strategien:");
st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, _strategien.Count);
while (st1 == st2)
{
Console.WriteLine("Du hast die gleichen Strategien gewählt, dies kann zu Problemen führen,\nwenn die Strategien zum Beispiel auf den gleichen Rundenzähler zugreifen.\nAuf Grund dessen haben wir die Möglichkeit ausgeschaltet, bitte fahre fort..\n");
st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, _strategien.Count);
}
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen diese verhört werden?", 1, 101);
verbrechen = (Verbrechen)VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (2=schwer)", 0, 3);
Verhoer(st1, st2, runde, verbrechen);
}
/// <summary>
/// Startet ein Spiel mit neuer Wahl für Rundenanzahl und Schwere.
/// </summary>
/// <param name="spiel"></param>
/// <param name="st1"></param>
/// <param name="st2"></param>
/// <param name="lastGame"></param>
static void Spiel(int spiel, int st1, int st2, bool lastGame)
{
int punkte1 = 0, punkte2 = 0;
BasisStrategie strategie1 = _strategien[st1];
BasisStrategie strategie2 = _strategien[st2];
int runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen diese verhört werden?", 1, 101);
int schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0=leicht | 1=mittel | 2=schwer)", 0, 3);
Verhoer(spiel, ref strategie1, ref strategie2, runde, schwere, ref punkte1, ref punkte2);
//ausgabe
Console.WriteLine($"Spiel {spiel}:");
Console.WriteLine($"{strategie1.Name()} hat {punkte1} Punkte erhalten.");
Console.WriteLine($"{strategie2.Name()} hat {punkte2} Punkte erhalten.");
if (lastGame)
{
if (punkte1 < punkte2)
{
Console.WriteLine("Somit hat {0} gewonnen.", strategie1.Name());
}
else if (punkte1 == punkte2)
{
Console.WriteLine("Somit steht es unentschieden.");
}
else
{
Console.WriteLine("Somit hat {0} gewonnen.", strategie2.Name());
}
}
}
static void AutomatischerVerhoerer()
{
//0=leicht, 1=mittel, 2=schwer
int schwere = 0;
automatischesVerhoer = true;
//reset punkte
gesamtPunkte1 = 0;
gesamtPunkte2 = 0;
Console.WriteLine("Willkommen zum Verhör zwischen 2 Strategien");
// Auflistung der Strategien
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
// Wählen der 2 Strategien
Console.WriteLine("Wählen Sie ihre 2 Gefangene:");
int st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
int st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, _strategien.Count);
//für jeden Schwierigkeitsgrad 1 Durchlauf
for (int a = 0; a < 3; a++)
{
//beginnt mit 5 Runden
int runde = 5;
//jeweils 1 Durchlauf für 5, 25, 100 Runden
for (int b = 0; b < 3; b++)
{
//setzt Punkte für jede Runde zurück
punkte1 = 0;
punkte2 = 0;
//startet das Verhoer
Verhoer(st1, st2, runde, schwere);
PunkteAnpassen(ref runde);
gesamtPunkte1 += punkte1;
gesamtPunkte2 += punkte2;
}
schwere++;
}
BasisStrategie strategie1 = _strategien[st1];
BasisStrategie strategie2 = _strategien[st2];
Console.WriteLine("---------------------------------------------------");
Console.WriteLine();
Console.WriteLine($"{strategie1.Name()} hat insgesamt {gesamtPunkte1} Punkte erhalten.");
Console.WriteLine($"{strategie2.Name()} hat insgesamt {gesamtPunkte2} Punkte erhalten.");
Console.WriteLine("Somit hat {0} gewonnen.", gesamtPunkte1 < gesamtPunkte2 ? strategie1.Name() : strategie2.Name());
Console.WriteLine();
}
/// <summary>
/// Fragt 2 Strategien, Länge und Schwere ab.
/// </summary>
static void Gefangene2Strats()
{
int runde, schwere;
Console.WriteLine("\nWillkommen zum Verhör zwischen 2 Strategien!");
(BasisStrategie strategie1, BasisStrategie strategie2) = Utility.Auswahl2Strats();
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen diese verhört werden?", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0=leicht, 1=mittel, 2=schwer)", 0, 3);
(int punkte1, int punkte2) = VerhoerVerwaltung.Verhoer(strategie1, strategie2, runde, schwere);
if (punkte1 < punkte2)
{
Console.WriteLine("\nSomit hat {0} gewonnen.", strategie1.Name());
}
if (punkte1 > punkte2)
{
Console.WriteLine("\nSomit hat {0} gewonnen.", strategie2.Name());
}
if (punkte1 == punkte2)
{
Console.WriteLine("\nUnentschieden.");
}
}
/// <summary>
/// Fragt 2 Strategien, Länge und Schwere ab.
/// </summary>
static void Gefangene2()
{
int st1, st2;
int runde, schwere;
// Überschrift
writeTrennstrich();
Console.WriteLine(spielModi[0]);
writeTrennstrich();
// Auswahl der beiden Strategie, der Rundenanzahl sowie der Schwere der Verstöße
Console.WriteLine("Bitte wähle deine 2 Strategien:");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
Console.WriteLine();
st1 = VerwaltungKram.EingabeZahlMinMax("1. Strategie: ", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("2. Strategie: ", 0, _strategien.Count);
runde = VerwaltungKram.EingabeZahlMinMax("Rundenanzahl: ", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Schwere der Verstöße (0 = Leicht, 1 = Mittel, 2 = Schwer): ", 0, 3);
writeLeerzeile();
// Starten des Verhörs mit gegebenen Faktoren
Verhoer(st1, st2, runde, schwere);
}
/// <summary>
/// Diese Methode gibt dem Benutzer die Möglichkeit, eine Strategie auszuwählen.
/// </summary>
/// <param name="st1">Id der Strategie</param>
static void StrategieAuswahl(ref int st1)
{
Console.WriteLine("Bitte wähle eine gegnerische Strategie:");
WriteStrategien();
WriteLeerzeile();
st1 = VerwaltungKram.EingabeZahlMinMax("Gegnerische Strategie: ", 0, _strategien.Count);
}
/// <summary>
/// Diese Methode gibt dem Benutzer die Möglichkeit, zwei Strategien auszuwählen.
/// </summary>
/// <param name="st1">Id der ersten Strategie</param>
/// <param name="st2">Id der zweiten Strategie</param>
static void StrategieAuswahl(ref int st1, ref int st2)
{
Console.WriteLine("Bitte wähle 2 Strategien:");
WriteStrategien();
WriteLeerzeile();
st1 = VerwaltungKram.EingabeZahlMinMax("1. Strategie: ", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("2. Strategie: ", 0, _strategien.Count);
}
public static void Start(List <BasisStrategie> strategien)
{
_strategien = strategien;
Punkte = new int[_strategien.Count];
var verbrechen = (Verbrechen)VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (2=schwer)", 0, 3);
Console.WriteLine("\nStarte Spiellog:\n------------------------------------------------------------------------------------------------------------------------\n");
_strategien.ForEach(x => Verhoer(Pos, 9, verbrechen));
Pos = 0;
Ergebnis();
}
/// <summary>
/// Diese Methode verwaltet ein Verhör zwischen dem Benutzer und einer gegnerischen Strategie
/// </summary>
static void VerhörMitBenutzer()
{
// Überschrift
WriteTrennstrich();
Console.WriteLine(spielModi[2]);
WriteTrennstrich();
// Auswahl der gegnerischen Strategie, Rundenanzahl sowie Schwere
int st1 = 0;
StrategieAuswahl(ref st1);
int runden, schwere;
runden = VerwaltungKram.EingabeZahlMinMax("Rundenanzahl: ", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Schwere der Verstöße (0 = Leicht, 1 = Mittel, 2 = Schwer): ", 0, 3);
// Holt die gegnerische Strategie aus der Collection.
BasisStrategie strategie1 = _strategien[st1];
// Überschrift
WriteTrennstrich();
Console.WriteLine("Verhör");
WriteTrennstrich();
// gegnerische Strategien über den Start informieren (Also es wird die Startmethode aufgerufen)
strategie1.Start(runden, schwere);
// Start der Verhöre
int alteBenutzerReaktion = BasisStrategie.NochNichtVerhoert;
int punkte1 = 0, punkte2 = 0;
for (int i = 0; i < runden; i++)
{
Console.WriteLine("Runde " + (i + 1) + ":");
int benutzerReaktion = VerwaltungKram.EingabeZahlMinMax(" Deine Reaktion (0=Kooperieren, 1=Verraten): ", 0, 2);
//Gegnerische Strategie wird verhört
int aktReaktion1 = strategie1.Verhoer(alteBenutzerReaktion);
Console.WriteLine($" Gegnerische Strategie ('{strategie1.Name()}'): " + aktReaktion1);
//Punkte werden berechnet
VerhoerPunkte(schwere, aktReaktion1, benutzerReaktion, ref punkte1, ref punkte2);
//Reaktion für den nächsten Durchlauf merken
alteBenutzerReaktion = benutzerReaktion;
}
// Ausgabe des Siegers
WriteLeerzeile();
Siegerehrung(strategie1.Name(), "Benutzer", punkte1, punkte2);
}
public static BasisStrategie AuswahlStrat()
{
int st;
Console.WriteLine("Wählen Sie ihre gegnerische Strategien:");
for (int i = 0; i < VerwaltungProgramm._strategien.Count; i++)
{
Console.WriteLine($"{i} - {VerwaltungProgramm._strategien[i].Name()}");
}
st = VerwaltungKram.EingabeZahlMinMax("Auswahl: ", 0, VerwaltungProgramm._strategien.Count);
BasisStrategie strategie = VerwaltungProgramm._strategien[st];
return(strategie);
}
static void ManAgainstMachine()
{
int st;
int runde, schwere;
Console.WriteLine("Willkommen zum Verhör zwischen Nutzer und einer Strategie");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
st = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die Strategie, gegen die Sie spielen wollen: ", 0, _strategien.Count);
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen diese verhört werden?", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0=leicht, 1=mittel, 2=schwer)", 0, 3);
VerhoerMitUser(st, runde, schwere);
}
/// <summary>
/// Fragt 2 Strategien und Schwere ab und spielt ein best of nine.
/// </summary>
static void BestOfNine()
{
int st1, st2;
int schwere;
int winCount1 = 0;
int winCount2 = 0;
Console.WriteLine("Willkommen zum Best of 9 zwischen 2 Strategien");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
Console.WriteLine("Wählen Sie ihre 2 Strategien:");
st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, _strategien.Count);
schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0=leicht, 1=mittel, 2=schwer)", 0, 3);
for (int i = 1; i < 9; i++)
{
int result = VerhoerReturn(st1, st2, 9, schwere);
switch (result)
{
case 1:
winCount1 += 1;
break;
case 2:
winCount2 += 1;
break;
}
}
if (winCount1 > winCount2)
{
Console.WriteLine("Der Spieler 1 hat mit {0} Runden gewonnen", winCount1);
}
else if (winCount1 == winCount2)
{
Console.WriteLine("Die beiden Spieler haben unentschieden gespielt");
}
else
{
Console.WriteLine("Der Spieler 2 hat mit {0} Runden gewonnen", winCount2);
}
}
public static (BasisStrategie, BasisStrategie) Auswahl2Strats()
{
int st1, st2;
Console.WriteLine("Wählen Sie ihre 2 Strategien:");
for (int i = 0; i < VerwaltungProgramm._strategien.Count; i++)
{
Console.WriteLine($"{i} - {VerwaltungProgramm._strategien[i].Name()}");
}
st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, VerwaltungProgramm._strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, VerwaltungProgramm._strategien.Count);
//holt die beiden Strategien aus der Collection.
BasisStrategie strategie1 = VerwaltungProgramm._strategien[st1];
BasisStrategie strategie2 = VerwaltungProgramm._strategien[st2];
return(strategie1, strategie2);
}
/// <summary>
/// Fragt 2 Strategien, Länge und Schwere ab.
/// </summary>
static void Gefangene2()
{
int st1, st2;
int runde, schwere;
Console.WriteLine("Willkommen zum Verhör zwischen 2 Strategien");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
Console.WriteLine("Wählen Sie ihre 2 Strategien:");
st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, _strategien.Count);
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen diese verhört werden?", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0 = leicht, 1 = mittel schwer, 2=schwer)", 0, 3);
Verhoer(st1, st2, runde, schwere);
}
public static void Start(List <BasisStrategie> strategien)
{
_strategien = strategien;
int st1;
int runde;
string playername;
Verbrechen verbrechen;
Console.WriteLine($"\nWillkommen zum Verhör\nWähle deinen Namen: ");
playername = Console.ReadLine();
Console.WriteLine("\nNun beginnt das Verhör zwischen Spieler und Strategie.\nGegen welche Strategie möchtest du spielen?");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
st1 = VerwaltungKram.EingabeZahlMinMax(string.Empty, 0, _strategien.Count);
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen diese verhört werden?", 1, 101);
verbrechen = (Verbrechen)VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (2=schwer)", 0, 3);
VerhoerSGS(st1, playername, runde, verbrechen);
}
/// <summary>
/// Fragt 2 Strategien, Länge und Schwere ab.
/// </summary>
static void Gefangene2()
{
//Rundenstart
try { Console.Clear(); }
catch (IOException e) { }
int st1, st2;
int spiele;
Console.WriteLine("Willkommen zum Verhör zwischen 2 Strategien\nStrategien:");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
Console.WriteLine("\nWählen Sie ihre 2 Strategien:");
st1 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 1. Strategie", 0, _strategien.Count);
st2 = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die 2. Strategie", 0, _strategien.Count);
spiele = VerwaltungKram.EingabeZahlMinMax("Wie viele Spiele sollen gespielt werden?", 1, 10);
for (int i = 0; i < spiele; ++i)
{
Spiel(i, st1, st2, i == spiele - 1);
}
}
static void MenschGegenMaschine()
{
int maschine;
int runde, schwere;
Console.Clear();
Console.WriteLine("Willkommen bei Mensch vs. Maschine.");
for (int i = 0; i < _strategien.Count; i++)
{
Console.WriteLine($"{i} - {_strategien[i].Name()}");
}
// Anforderung von Benutzereingaben
maschine = VerwaltungKram.EingabeZahlMinMax("Wählen Sie die Strategie ihres Gegners aus", 0, _strategien.Count);
runde = VerwaltungKram.EingabeZahlMinMax("Wie viele Runden sollen verhört werden?", 1, 101);
schwere = VerwaltungKram.EingabeZahlMinMax("Wie schwer sind die Verstöße? (0=leicht, 1=mittel, 2=schwer)", 0, 3);
//holt die gewählte Maschinenstrategie aus der Collection.
BasisStrategie strategieMaschine = _strategien[maschine];
int reaktionMaschine = BasisStrategie.NochNichtVerhoert;
int reaktionMensch = BasisStrategie.NochNichtVerhoert;
//Aufruf der Start-Methode der Maschinenstrategie
strategieMaschine.Start(runde, schwere);
Console.Clear();
// Start der Verhörung
for (int i = 0; i < runde; i++)
{
Console.Clear();
Console.Write("Sie spielen auf");
switch (schwere)
{
case 0:
Console.WriteLine(" leicht.");
break;
case 1:
Console.WriteLine(" mittel.");
break;
case 2:
Console.WriteLine(" schwer");
break;
}
Console.WriteLine("Verbleibende Runden: " + (runde - i - 1));
switch (reaktionMaschine)
{
case 0:
Console.WriteLine("In der letzten Runde hat ihr Gegner kooperiert.");
break;
case 1:
Console.WriteLine("In der letzten Runde hat ihr Gegner verraten.");
break;
}
//beide verhören
int aktReaktionMensch = VerwaltungKram.EingabeZahlMinMax("Welche Aktion möchten Sie diese Runde wählen? [0] Kooperieren [1] Verraten", 0, 2);
int aktReaktionMaschine = strategieMaschine.Verhoer(reaktionMensch);
// Punktberechnung
switch (schwere)
{
case 0:
Leicht(aktReaktionMaschine, aktReaktionMensch);
break;
case 1:
Mittel(aktReaktionMaschine, aktReaktionMensch);
break;
case 2:
Schwer(aktReaktionMaschine, aktReaktionMensch);
break;
}
// Zuweisung der letzten Reaktion der beiden für den nächsten Durchlauf
reaktionMaschine = aktReaktionMaschine;
reaktionMensch = aktReaktionMensch;
}
Console.Clear();
Console.WriteLine("Punkte der Maschine: " + punkte1);
Console.WriteLine("Punkte des Menschen: " + punkte2);
if (punkte1 > punkte2)
{
Console.WriteLine("Der Mensch hat gewonnen!");
}
else if (punkte2 > punkte1)
{
Console.WriteLine("Die Maschine hat gewonnen!");
}
else
{
Console.WriteLine("Es ist ein Unentschieden!");
}
Console.Read();
}
/// <summary>
/// Startet ein Verhör zwischen der Strategie an der Position st und dem Benutzer über die Länge von runde und der Schwere schwere
/// </summary>
/// <param name="st"></param>
/// <param name="runde"></param>
/// <param name="schwere"></param>
static void VerhoerMitUser(int st, int runde, int schwere)
{
//holt die Strategie aus der Collection.
BasisStrategie strategie = _strategien[st];
//setzt Startwerte
int reaktionUser = BasisStrategie.NochNichtVerhoert;
int reaktionCPU = BasisStrategie.NochNichtVerhoert;
int punkte1 = 0, punkte2 = 0;
//die Strategie über den Start informieren (Also es wird die Startmethode aufgerufen)
strategie.Start(runde, schwere);
if (runde == 1)
{
Console.WriteLine($"Verhör zwischen Benutzer und {strategie.Name()} für {runde} Runde.");
}
else
{
Console.WriteLine($"Verhör zwischen Benutzer und {strategie.Name()} für {runde} Runden.");
}
//start
for (int i = 0; i < runde; i++)
{
Console.WriteLine($"Runde {i + 1}");
//beide verhören
int aktReaktionUser;
switch (reaktionCPU)
{
default:
aktReaktionUser = VerwaltungKram.EingabeZahlMinMax($"Ihr Gegenüber wurde noch nicht verhöhrt. Geben Sie die Tat zu? (0 = Abstreiten, 1 = Gestehen)", 0, 2);
break;
case BasisStrategie.Kooperieren:
aktReaktionUser = VerwaltungKram.EingabeZahlMinMax($"Ihr Gegenüber streitet die Tat ab. Geben Sie die Tat zu? (0 = Abstreiten, 1 = Gestehen)", 0, 2);
break;
case BasisStrategie.Verrat:
aktReaktionUser = VerwaltungKram.EingabeZahlMinMax($"Ihr Gegenüber hat die Tat gestanden. Geben Sie die Tat zu? (0 = Abstreiten, 1 = Gestehen)", 0, 2);
break;
}
int aktReaktionCPU = strategie.Verhoer(reaktionUser);
//punkte berechnen
switch (schwere)
{
case 0:
VerhoerLeichtPunkte(aktReaktionUser, aktReaktionCPU, ref punkte1, ref punkte2);
break;
case 1:
VerhoerMittelPunkte(aktReaktionUser, aktReaktionCPU, ref punkte1, ref punkte2);
break;
case 2:
VerhoerSchwerPunkte(aktReaktionUser, aktReaktionCPU, ref punkte1, ref punkte2);
break;
}
//reaktion für den nächsten durchlauf merken
reaktionUser = aktReaktionUser;
reaktionCPU = aktReaktionCPU;
}
//ausgabe
Console.WriteLine($"Benutzer hat {punkte1} Punkte erhalten.");
Console.WriteLine($"{strategie.Name()} hat {punkte2} Punkte erhalten.");
if (punkte1 < punkte2)
{
Console.WriteLine("Somit hat Benutzer gewonnen.");
}
else
{
Console.WriteLine("Somit hat {0} gewonnen.", strategie.Name());
}
}
static void VerhoerSGS(int st1, string playername, int runde, Verbrechen verbrechen)
{
IVerbrechensModus strafe;
//holt die gegnerische Strategie aus der Collection.
BasisStrategie strategie1 = _strategien[st1];
//setzt Startwerte
int reaktion1 = BasisStrategie.NochNichtVerhoert;
int spielerReaktion = BasisStrategie.NochNichtVerhoert;
int punkte1 = 0, punkte2 = 0;
//beide Strategien über den Start informieren (Also es wird die Startmethode aufgerufen)
//strategie1.Start(runde, schwere);
//strategie2.Start(runde, schwere);
//Schwere
strafe = VerbrechensModus.Set(verbrechen);
Console.WriteLine($"Verhör zwischen {playername} und {strategie1.Name()} für {runde} Runden mit der Schwere {verbrechen}.");
//start
for (int i = 0; i < runde; i++)
{
int aktReaktion1 = strategie1.Verhoer(spielerReaktion);
if (i > 0)
{
switch (VerwaltungKram.EingabeZahlMinMax($"{strategie1.Name()} hat {(reaktion1 == 1 ? "dich " : string.Empty)}letzte Runde {(reaktion1 == 0 ? "kooperiert" : "verraten")}, wie möchtest du reagieren?\n[0] Kooperieren\n[1] Verraten", 0, 2))
{
case 0:
spielerReaktion = BasisStrategie.Kooperieren;
break;
case 1:
spielerReaktion = BasisStrategie.Verrat;
break;
}
}
else
{
//Console.WriteLine("Erste Runde, womit moechtest du anfangen?\n[0] Verraten\n[1] Kooperieren");
switch (VerwaltungKram.EingabeZahlMinMax("Erste Runde, womit möchtest du anfangen?\n[0] Kooperieren\n[1] Verraten", 0, 2))
{
case 0:
spielerReaktion = BasisStrategie.Kooperieren;
break;
case 1:
spielerReaktion = BasisStrategie.Verrat;
break;
}
}
int aktSpielerReaktion = spielerReaktion;
if (aktReaktion1 == -1 || aktSpielerReaktion == -1)
{
Console.WriteLine(@"Fehler, Methode ""Verhör"" hat Fehlercode -1 zurückgegeben");
//Hier soll das Programm restartet werden
}
//punkte berechnen
strafe.VerhoerSchwerpunkt(aktReaktion1, aktSpielerReaktion, ref punkte1, ref punkte2);
Console.WriteLine($"Der Punktestand beträgt:\n\t{playername} - {punkte2}\n\t{strategie1.Name()} - {punkte1}\nWobei du{(aktSpielerReaktion == 1 ? " ihn" : string.Empty)} {(aktSpielerReaktion == 1 ? "verraten" : "kooperiert")} hast und {(aktReaktion1 == aktSpielerReaktion ? (aktReaktion1 == 1 ? "er dich auch" : "er auch") : aktReaktion1 == 1 ? "er dich verraten hat" : "er kooperiert hat")}.\n");
//reaktion für den nächsten durchlauf merken
reaktion1 = aktReaktion1;
spielerReaktion = aktSpielerReaktion;
}
//ausgabe
Console.WriteLine($"{strategie1.Name()} hat {punkte1} Punkte erhalten.");
Console.WriteLine($"{playername} hat {punkte2} Punkte erhalten.");
if (punkte1 < punkte2)
{
Console.WriteLine($"Somit hat {strategie1.Name()} gewonnen.");
}
else if (punkte1 == punkte2)
{
Console.WriteLine($"Somit gibt es ein unentschieden zwischen {strategie1.Name()} und {playername}.");
}
else
{
Console.WriteLine($"Somit hat {playername} gewonnen.\n");
}
}
