public void ÜberprüftKarten(IKarte karte)
{
LegbareKarten = new List <IKarte>();
foreach (IKarte k in Karten)
{
if (k.Farbe == karte.Farbe)
{
LegbareKarten.Add(k);
}
else if (k.Typ == karte.Typ)
{
if (k.Typ == KartenTyp.Zahl)
{
if (((ZahlKarte)k).Zahl == ((ZahlKarte)karte).Zahl)
{
LegbareKarten.Add(k);
}
}
else
{
LegbareKarten.Add(k);
}
}
else if (k.Typ == KartenTyp.VierZiehen || k.Typ == KartenTyp.Farbwechsel)
{
LegbareKarten.Add(k);
}
}
}
private void LegtKarte(IKarte karte)
{
if (AktiverSpieler.Ziehen != true || karte.Typ == KartenTyp.Ziehen || karte.Typ == KartenTyp.VierZiehen)
{
AktiverSpieler.Karten.Remove(karte);
GelegteKarten.Add(karte);
NichtGelegt = false;
}
}
private void KIMachtZug()
{
if (vierziehenAktiv)
{
((KI)AktiverSpieler).ZiehtKarte(Stapel);
((KI)AktiverSpieler).ZiehtKarte(Stapel);
((KI)AktiverSpieler).ZiehtKarte(Stapel);
((KI)AktiverSpieler).ZiehtKarte(Stapel);
KartenZiehen = 0;
NichtGelegt = false;
vierziehenAktiv = false;
}
else
{
((KI)AktiverSpieler).ÜberprüftKarten(GelegteKarten.Last());
IKarte gelegteKarteSpieler = ((KI)AktiverSpieler).LegtKarte();
if (VersuchtKarteLegen(gelegteKarteSpieler))
{
if (gelegteKarteSpieler.Typ == KartenTyp.VierZiehen)
{
vierziehenAktiv = true;
KartenZiehen += 4;
gelegteKarteSpieler.Farbe = KartenFarbe.Blau;
}
else if (gelegteKarteSpieler.Typ == KartenTyp.Farbwechsel)
{
gelegteKarteSpieler.Farbe = KartenFarbe.Blau;
}
LegtKarte(gelegteKarteSpieler);
}
else
{
if (((KI)AktiverSpieler).Ziehen != true)
{
GenugKartenImStapel();
((KI)AktiverSpieler).ZiehtKarte(Stapel);
((KI)AktiverSpieler).CardIndex = null;
NächsterSpieler();
}
}
}
}
//Methode zum Legen ohne Nachzudenken
public IKarte LegtKarte()
{
if (LegbareKarten.Count > 0)
{
IKarte k = LegbareKarten[0];
if (k.Typ == KartenTyp.Farbwechsel || k.Typ == KartenTyp.VierZiehen)
{
Random random = new Random();
int rnd = random.Next(1, 5);
switch (rnd)
{
case 1:
k.Farbe = KartenFarbe.Gelb;
break;
case 2:
k.Farbe = KartenFarbe.Blau;
break;
case 3:
k.Farbe = KartenFarbe.Rot;
break;
case 4:
k.Farbe = KartenFarbe.Gruen;
break;
default:
k.Farbe = KartenFarbe.Gruen;
break;
}
}
Karten.Remove(k);
return(k);
}
else
{
return(Karten[0]);
}
}
public void TeileSpielStand(IKarte gelegteKarte, bool aktiv, List <ISpieler> mitspieler)
{
int startIndexSelber = mitspieler.IndexOf(this);
List <object> objSpieler = new List <object>();
for (int i = startIndexSelber + 1; i < mitspieler.Count + startIndexSelber; i++)
{
var toogle = false;
if (mitspieler[i % mitspieler.Count] == mitspieler.First())
{
toogle = true;
}
if (mitspieler[i % mitspieler.Count].Name != Name)
{
objSpieler.Add(new { name = mitspieler[i % mitspieler.Count].Name, karten = mitspieler[i % mitspieler.Count].Karten.Count, aktiv = toogle });
}
}
var obj = new { aktuelleKarte = gelegteKarte, aktiv = aktiv, hand = Karten, name = Name, alleSpieler = objSpieler };
var json = new JavaScriptSerializer().Serialize(obj);
Socket.Send(json);
}
private void Spielzug()
{
if (AllSpieler.Count == 1)
{
SpielNeustart();
}
AktiverSpieler = AllSpieler.First();
if (AktiverSpieler.Aussetzen == true)
{
if (AktiverSpieler.Ki == true)
{
((KI)AktiverSpieler).Aussetzen = false;
}
else
{
((Spieler)AktiverSpieler).Aussetzen = false;
}
NächsterSpieler();
}
foreach (ISpieler temp in AllSpieler)
{
if (temp.Ki == false)
{
if (temp == AktiverSpieler)
{
temp.TeileSpielStand(GelegteKarten.Last(), true, AllSpieler);
}
else
{
temp.TeileSpielStand(GelegteKarten.Last(), false, AllSpieler);
}
}
}
if (AktiverSpieler.Ki)
{
Stopwatch st = new Stopwatch();
st.Start();
while (st.ElapsedMilliseconds < 1500)
{
}
st.Stop();
}
NichtGelegt = true;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
while (stopWatch.ElapsedMilliseconds < 20000 && NichtGelegt)
{
if (AktiverSpieler.Ki == true)
{
KIMachtZug();
break;
}
else if (AktiverSpieler.CardIndex != null)
{
IKarte gelegteKarteSpieler = AktiverSpieler.Karten[(int)AktiverSpieler.CardIndex];
if (VersuchtKarteLegen(gelegteKarteSpieler))
{
if (gelegteKarteSpieler.Farbe == KartenFarbe.Schwarz || gelegteKarteSpieler.Typ == KartenTyp.VierZiehen)
{
int blauCounter = 0;
int rotCounter = 0;
int gelbCounter = 0;
int grünCounter = 0;
foreach (IKarte zk in AktiverSpieler.Karten)
{
switch (zk.Farbe)
{
case KartenFarbe.Gelb:
gelbCounter++;
break;
case KartenFarbe.Rot:
rotCounter++;
break;
case KartenFarbe.Blau:
blauCounter++;
break;
case KartenFarbe.Gruen:
grünCounter++;
break;
default:
break;
}
}
if (blauCounter > rotCounter && blauCounter > grünCounter && blauCounter > gelbCounter)
{
gelegteKarteSpieler.Farbe = KartenFarbe.Blau;
}
else if (rotCounter > blauCounter && rotCounter > grünCounter && rotCounter > gelbCounter)
{
gelegteKarteSpieler.Farbe = KartenFarbe.Rot;
}
else if (grünCounter > rotCounter && grünCounter > blauCounter && grünCounter > gelbCounter)
{
gelegteKarteSpieler.Farbe = KartenFarbe.Gruen;
}
else
{
gelegteKarteSpieler.Farbe = KartenFarbe.Gelb;
}
if (gelegteKarteSpieler.Typ == KartenTyp.VierZiehen)
{
vierziehenAktiv = true;
KartenZiehen += 4;
}
LegtKarte(gelegteKarteSpieler);
}
else
{
LegtKarte(gelegteKarteSpieler);
}
break;
}
else
{
if (vierziehenAktiv)
{
for (int i = 0; i < KartenZiehen; i++)
{
GenugKartenImStapel();
AktiverSpieler.ZiehtKarte(Stapel);
}
KartenZiehen = 0;
vierziehenAktiv = false;
((Spieler)AktiverSpieler).Ziehen = false;
((Spieler)AktiverSpieler).CardIndex = null;
}
else
{
if (AktiverSpieler.Ziehen == true)
{
break;
}
GenugKartenImStapel();
AktiverSpieler.ZiehtKarte(Stapel);
((Spieler)AktiverSpieler).CardIndex = null;
}
NächsterSpieler();
}
}
}
if (GelegteKarten.Last().Typ == KartenTyp.Ziehen && !NichtGelegt)
{
if (AllSpieler[1].Ki)
{
((KI)AllSpieler[1]).Ziehen = true;
}
else
{
((Spieler)AllSpieler[1]).Ziehen = true;
}
if (AktiverSpieler.Ki)
{
((KI)AktiverSpieler).Ziehen = false;
}
else
{
((Spieler)AktiverSpieler).Ziehen = false;
}
KartenZiehen += 2;
}
else if (KartenZiehen != 0)
{
if (NichtGelegt)
{
for (int i = 0; i < KartenZiehen; i++)
{
GenugKartenImStapel();
AktiverSpieler.ZiehtKarte(Stapel);
}
vierziehenAktiv = false;
KartenZiehen = 0;
if (AktiverSpieler.Ki)
{
((KI)AktiverSpieler).Ziehen = false;
}
else
{
((Spieler)AktiverSpieler).Ziehen = false;
}
}
}
else if (KartenZiehen == 0 && NichtGelegt)
{
GenugKartenImStapel();
AktiverSpieler.ZiehtKarte(Stapel);
}
stopWatch.Stop();
if (AktiverSpieler.Karten.Count == 0)
{
SpielerGewinnt();
AktiverSpieler.HastGewonnen();
Spielzug();
}
if (AllSpieler.Count > 1)
{
if (!AktiverSpieler.Ki)
{
((Spieler)AktiverSpieler).CardIndex = null;
}
NächsterSpieler();
}
}
public bool VersuchtKarteLegen(IKarte karte)
{
IKarte obersteKarte = GelegteKarten.Last();
//Schwarze Karten noch nicht da
if (vierziehenAktiv)
{
return(false);
}
if (karte.Farbe == obersteKarte.Farbe)
{
if (karte.Typ == KartenTyp.Richtungswechsel)
{
Richtungswechsel();
}
else if (karte.Typ == KartenTyp.Aussetzen)
{
if (AllSpieler[1].Ki)
{
((KI)AllSpieler[1]).Aussetzen = true;
}
else
{
((Spieler)AllSpieler[1]).Aussetzen = true;
}
}
return(true);
}
else if (karte.Typ == KartenTyp.Zahl && obersteKarte.Typ == KartenTyp.Zahl)
{
ZahlKarte zk = (ZahlKarte)karte;
ZahlKarte zk2 = (ZahlKarte)obersteKarte;
if (zk.Zahl == zk2.Zahl)
{
return(true);
}
}
else if (karte.Typ == KartenTyp.Ziehen && obersteKarte.Typ == KartenTyp.Ziehen)
{
return(true);
}
else if (karte.Typ == KartenTyp.Richtungswechsel && obersteKarte.Typ == KartenTyp.Richtungswechsel)
{
Richtungswechsel();
return(true);
}
else if (karte.Typ == KartenTyp.Aussetzen && obersteKarte.Typ == KartenTyp.Aussetzen)
{
if (AllSpieler[1].Ki)
{
((KI)AllSpieler[1]).Aussetzen = true;
}
else
{
((Spieler)AllSpieler[1]).Aussetzen = true;
}
return(true);
}
else if (karte.Farbe == KartenFarbe.Schwarz)
{
return(true);
}
return(false);
}
public void TeileSpielStand(IKarte gelegteKarte, bool aktiv, List <ISpieler> mitspieler)
{
}
