예제 #1
0
파일: KI.cs 프로젝트: Grohedal/UNO_yea
 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);
         }
     }
 }
예제 #2
0
 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;
     }
 }
예제 #3
0
 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();
             }
         }
     }
 }
예제 #4
0
파일: KI.cs 프로젝트: Grohedal/UNO_yea
        //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]);
            }
        }
예제 #5
0
파일: Spieler.cs 프로젝트: Grohedal/UNO_yea
        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);
        }
예제 #6
0
        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();
            }
        }
예제 #7
0
        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);
        }
예제 #8
0
파일: KI.cs 프로젝트: Grohedal/UNO_yea
 public void TeileSpielStand(IKarte gelegteKarte, bool aktiv, List <ISpieler> mitspieler)
 {
 }