4. Pokerbot

Pokerbot

  • D

    nochmal lol

    0
  • V

    Taurus1985 schrieb:

    @volkard
    Ich wollte dann mit goto arbeiten.

    Hab ich auch heute. Es geht mir nicht um irgendwelche Dogmen der Heiligen Strukturierten Programmierung, sondern auch erstmal darum, daß es geht.

    #include <iostream>
#include <algorithm>
using namespace std;

int main(){
	int digits[9]={1,2,3,4,5,6,7,8,9,};
	do{
		for(int i=1;i<=9;++i)
			if(accumulate(digits,digits+i,0,[](int x,int d){return 10*x+d;})%i!=0)
				goto nix;
		for(auto d:digits)
			cout<<d;
		cout<<'\n';
		nix:;
	}while(next_permutation(begin(digits),end(digits)));
}

    Von mir kriegste keine Tipps mehr.

    0

  • Hallo Taurus1985,

    nur so als Tipp: einzelnen Methoden oder Funktionen sollten i.d.R. nicht größer als eine Bildschirmseite sein (also max. 20 - 40 Zeilen) - und jetzt schau dir deinen Code noch mal an 😉

    Und die ganzen "Magic Numbers" wirst du selber auch nach ein paar Wochen nicht mehr verstehen.

    "Copy & Paste"-Code ist das grausamste was es in der Programmierung gibt. Leider meinen Anfänger wohl, viel Code wäre guter Code. Aber genau das Gegenteil ist der Fall!

    0
  • T

    So ich hab das Problem durch herumprobieren gelöst.

    Warum es jetzt geht ist mir zwar schleierhaft aber es funktioniert.

    Ich hab einfach bei allen Assen den Pixel Patch(pp1-pp5) angewendet.

    if (pc1 == 16777215 && pc2 == 0 && pc3 == 16777215 && pp1 == 0 || pc1 == 16777215 && pc2 == 255 && pc3 == 16777215 && pp1 == 255  || pc1 == 16382463 && pc2 == 255 && pc3 == 16777215 && pp1 == 255)
                {
                    //MessageBox.Show("2");

                    if (ps1 == 16777215 && ps2 == 255)
                    { label5.Text = ("Herz Ass"); }

                    if (ps1 == 255 && ps2 == 255)
                    { label5.Text = ("Karo Ass"); }

                    if (ps1 == 0 && ps2 == 0)
                    { label5.Text = ("Pik Ass"); }

                    if (ps1 == 0 && ps2 == 16777215)
                    { label5.Text = ("Kreuz Ass"); }
                }
    0
  • T

    @Th69

    Mir ist es schleierhaft wie ich den ganzen Code in eine Bildschirm Seite quetschen kann.

    0

  • Mach dir ein hübsches Array mit "card detection rules".
    Dann machst du ne Schleife die alle Rules durchgeht und prüft ob die Rule "erfüllt" ist.

    Also Sinngemäss:

    List<CardDetectionRule> CardDetectionRules = new List<CardDetectionRule>()
    {
        new CardDetectionRule(...),
        new CardDetectionRule(...),
        new CardDetectionRule(...),
        ...
    };

    CardDetectionRule DetectCard(DatenstrukturMitDenPixeldaten pixelHaufen)
    {
        foreach (var rule in CardDetectionRules) // Ja, ich weiss dass man das mit LINQ als Einzeiler schreiben kann
            if (rule.Matches(pixelHaufen))
                return rule;
        return null;
    }

    Wenn die Initialisierung von "CardDetectionRules" dabei zu riesig wird, z.B. weil der Konsturktoraufruf einer einzelnen CardDetectionRule schon mehrere Zeilen braucht, dann teil es weiter auf:

    CardDetectionRule AceOfSpadesDetectionRule = new CardDetectionRule
    (
        ...
        ...
    );
    CardDetectionRule AceOfHeartsDetectionRule = new CardDetectionRule
    (
        ...
        ...
    );

    List<CardDetectionRule> CardDetectionRules = new List<CardDetectionRule>()
    {
        AceOfSpadesDetectionRule,
        AceOfHeartsDetectionRule,
        ...
    };

    uswusf.

    0
  • B

    Sag mal wann und wo dein super Poker Bot spielt?
    Ich will gegen den spielen. xD

    0
  • T

    Danke @hustbaer

    @Bassmaster

    Ich denke mal das ich noch ein wenig brauche, weil bin ja erst bei der Kartenerkennung.

    0
  • ?

    Taurus1985 schrieb:

    Warum es jetzt geht ist mir zwar schleierhaft aber es funktioniert.

    Wenn Du nicht weißt warum es funktioniert, dann funktioniert es auch nicht sondern liefert bestenfalls zufällig ein Ergebnis das so aussieht wie Du glaubst das es sein sollte wenn es funktionieren würde.

    0
  • T

    Ich wollte eigentlich nur bei der 4 die Karten checken, aber da ich jetzt das Ass auch mit drin habe, geht es wundersamer weise und es scheint auch kein Zufalls Ergebnis zu sein. Ich hab das nämlich schon getestet.

    0

  • Taurus1985 schrieb:

    wundersamer weise und es scheint auch kein Zufalls

    Du hast nicht verstanden was dir gesagt wurde 🙄

    0
  • *

    loks schrieb:

    Wenn Du nicht weißt warum es funktioniert, dann funktioniert es auch nicht sondern liefert bestenfalls zufällig ein Ergebnis das so aussieht wie Du glaubst das es sein sollte wenn es funktionieren würde.

    @loks: Schön gesagt.. 🙂 solltest Philosoph werden. 😉

    Darf ich das in meine Signatur nehmen?? Gefällt mir sehr gut.

    0
  • T

    Hat jemand eine Idee, wie man so was vereinfachen kann, weil das wird echt ein Mammut Code. 😃

    //Karten

            // Kreuz 2 = 1,      Karo 2 = 2,     Pik 2 = 3,     Herz 2 = 4,
            // Kreuz 3 = 5,      Karo 3 = 6,     Pik 3 = 7,     Herz 3 = 8,
            // Kreuz 4 = 9,      Karo 4 = 10,    Pik 4 = 11,    Herz 4 = 12,
            // Kreuz 5 = 13,     Karo 5 = 14,    Pik 5 = 15,    Herz 5 = 16, 
            // Kreuz 6 = 17,     Karo 6 = 18,    Pik 6 = 19,    Herz 6 = 20,
            // Kreuz 7 = 21,     Karo 7 = 22,    Pik 7 = 23,    Herz 7 = 24,
            // Kreuz 8 = 25,     Karo 8 = 26,    Pik 8 = 27,    Herz 8 = 28,
            // Kreuz 9 = 29,     Karo 9 = 30,    Pik 9 = 31,    Herz 9 = 32,
            // Kreuz 10 = 33,    Karo 10 = 34,   Pik 10 = 35,   Herz 10 = 36,
            // Kreuz Bube = 37,  Karo Bube = 38, Pik Bube = 39, Herz Bube = 40,
            // Kreuz Dame = 41,  Karo Dame = 42, Pik Dame = 43, Herz Dame = 44,
            // Kreuz König = 45  Karo König =46, Pik König =47, Herz König = 48,
            // Kreuz Ass = 49,   Karo Ass =50,   Pik Ass = 51,  Herz Ass = 52.

            //int Karte1 = 0;
            //int Karte2 = 0;
            //int Karte3 = 0;
            //int Karte4 = 0;
            //int Karte5 = 0;
            //int EigeneKarte1 = 0;
            //int EigeneKarte2 = 0;

            //Vergleich ob ein Pärchen da ist

            if (   EigeneKarte1 == 1 && EigeneKarte2 == 1 || EigeneKarte1 == 2 && EigeneKarte2 == 2
                || EigeneKarte1 == 3 && EigeneKarte2 == 3 || EigeneKarte1 == 4 && EigeneKarte2 == 4
                || EigeneKarte1 == 5 && EigeneKarte2 == 5 || EigeneKarte1 == 6 && EigeneKarte2 == 6
                || EigeneKarte1 == 7 && EigeneKarte2 == 7 || EigeneKarte1 == 8 && EigeneKarte2 == 8
                || EigeneKarte1 == 9 && EigeneKarte2 == 9 || EigeneKarte1 == 10 && EigeneKarte2 == 10
                || EigeneKarte1 == 11 && EigeneKarte2 == 11 || EigeneKarte1 == 12 && EigeneKarte2 == 12
                || EigeneKarte1 == 13 && EigeneKarte2 == 13 || EigeneKarte1 == 14 && EigeneKarte2 == 14
                || EigeneKarte1 == 15 && EigeneKarte2 == 15 || EigeneKarte1 == 16 && EigeneKarte2 == 16
                || EigeneKarte1 == 17 && EigeneKarte2 == 17 || EigeneKarte1 == 18 && EigeneKarte2 == 18
                || EigeneKarte1 == 19 && EigeneKarte2 == 19 || EigeneKarte1 == 20 && EigeneKarte2 == 20
                || EigeneKarte1 == 21 && EigeneKarte2 == 21 || EigeneKarte1 == 22 && EigeneKarte2 == 22)
            {
                label14.Text = ("Ein Paar");
            }

    Der Vergleich für das Pärchen ist auch nicht ganz fertig.

    0
  • T

    Hab da auch einen Fehler gemacht, fällt mir gerade auf.

    0
  • T

    So ist besser. Gibt es denn da irgendwas wie man das vereinfachen kann?

    //Karten

            // Kreuz 2 = 1,      Karo 2 = 2,     Pik 2 = 3,     Herz 2 = 4,
            // Kreuz 3 = 5,      Karo 3 = 6,     Pik 3 = 7,     Herz 3 = 8,
            // Kreuz 4 = 9,      Karo 4 = 10,    Pik 4 = 11,    Herz 4 = 12,
            // Kreuz 5 = 13,     Karo 5 = 14,    Pik 5 = 15,    Herz 5 = 16, 
            // Kreuz 6 = 17,     Karo 6 = 18,    Pik 6 = 19,    Herz 6 = 20,
            // Kreuz 7 = 21,     Karo 7 = 22,    Pik 7 = 23,    Herz 7 = 24,
            // Kreuz 8 = 25,     Karo 8 = 26,    Pik 8 = 27,    Herz 8 = 28,
            // Kreuz 9 = 29,     Karo 9 = 30,    Pik 9 = 31,    Herz 9 = 32,
            // Kreuz 10 = 33,    Karo 10 = 34,   Pik 10 = 35,   Herz 10 = 36,
            // Kreuz Bube = 37,  Karo Bube = 38, Pik Bube = 39, Herz Bube = 40,
            // Kreuz Dame = 41,  Karo Dame = 42, Pik Dame = 43, Herz Dame = 44,
            // Kreuz König = 45  Karo König =46, Pik König =47, Herz König = 48,
            // Kreuz Ass = 49,   Karo Ass =50,   Pik Ass = 51,  Herz Ass = 52.

            //int Karte1 = 0;
            //int Karte2 = 0;
            //int Karte3 = 0;
            //int Karte4 = 0;
            //int Karte5 = 0;
            //int EigeneKarte1 = 0;
            //int EigeneKarte2 = 0;

            //Vergleich ob ein Pärchen da ist

            if (   EigeneKarte1 == 1 && EigeneKarte2 == 2 || EigeneKarte1 == 1 && EigeneKarte2 == 3//Karten Vergleich für Pärchen 2
                || EigeneKarte1 == 1 && EigeneKarte2 == 4 || EigeneKarte1 == 2 && EigeneKarte2 == 1
                || EigeneKarte1 == 3 && EigeneKarte2 == 1 || EigeneKarte1 == 4 && EigeneKarte2 == 1
                || EigeneKarte1 == 2 && EigeneKarte2 == 3 || EigeneKarte1 == 2 && EigeneKarte2 == 4
                || EigeneKarte1 == 3 && EigeneKarte2 == 2 || EigeneKarte1 == 4 && EigeneKarte2 == 2
                || EigeneKarte1 == 3 && EigeneKarte2 == 4 || EigeneKarte1 == 4 && EigeneKarte2 == 3

                || EigeneKarte1 == 5 && EigeneKarte2 == 6 || EigeneKarte1 == 5 && EigeneKarte2 == 7//Karten Vergleich für Pärchen 3
                || EigeneKarte1 == 5 && EigeneKarte2 == 8 || EigeneKarte1 == 6 && EigeneKarte2 == 5
                || EigeneKarte1 == 7 && EigeneKarte2 == 5 || EigeneKarte1 == 8 && EigeneKarte2 == 5
                || EigeneKarte1 == 6 && EigeneKarte2 == 7 || EigeneKarte1 == 6 && EigeneKarte2 == 8
                || EigeneKarte1 == 7 && EigeneKarte2 == 6 || EigeneKarte1 == 8 && EigeneKarte2 == 6
                || EigeneKarte1 == 7 && EigeneKarte2 == 8 || EigeneKarte1 == 8 && EigeneKarte2 == 7

                || EigeneKarte1 == 9 && EigeneKarte2 == 10 || EigeneKarte1 == 9 && EigeneKarte2 == 11//Karten Vergleich für Pärchen 4
                || EigeneKarte1 == 9 && EigeneKarte2 == 12 || EigeneKarte1 == 10 && EigeneKarte2 == 9
                || EigeneKarte1 == 10 && EigeneKarte2 == 11 || EigeneKarte1 == 10 && EigeneKarte2 == 12
                || EigeneKarte1 == 11 && EigeneKarte2 == 9 || EigeneKarte1 == 11 && EigeneKarte2 == 10
                || EigeneKarte1 == 11 && EigeneKarte2 == 12 || EigeneKarte1 == 12 && EigeneKarte2 == 9
                || EigeneKarte1 == 12 && EigeneKarte2 == 10 || EigeneKarte1 == 12 && EigeneKarte2 == 11)
            {
                label14.Text = ("Ein Paar");
            }
    0
  • B

    (EigeneKarte1-1)/4 == (EigeneKarte2-1)/4

    Mit etwas sinnvollerem Datendesign, sprich: Nicht einfach alle Karten der Reihe nach durchnummerieren, sondern als Paar (Farbe, Typ) auffassen, wär das noch einfacher.

    0

  • Was Array-Index und Sortierung angeht... das kann man auch "schön" machen:

    enum Suit : byte
    {
        Hearts,
        Diamonds,
        Clubs,
        Spades,
    }

    enum Rank : byte
    {
        R2, R3, R4, R5, R6, R7, R8, R9, R10,
        Jack,
        Queen,
        King,
        Ace,
        ValueCount,
    }

    struct Card
    {
        public Suit Suit;
        public Rank Rank;

        // Das mit global:: ist ausm Stegreif, ggf. nachbessern falls die Syntax nicht passt
        public int ArrayIndex { get { return (int)Suit * global::MyNamespace.Rank.ValueCount + (int)Rank; } }

        public Card(Suit suit, Rank rank)
        {
            Suit = suit;
            Rank = rank;
        }

        // Wenn man es brauch auch gerne
        public static Card FromArrayIndex(int index)
        {
            return new Card(
                (global::MyNamespace.Suit)(index / global::MyNamespace.Rank.ValueCount),
                (global::MyNamespace.Rank)(index % global::MyNamespace.Rank.ValueCount));
        }
    }

    void Foo()
    {
        List<Card> cards = ...
        cards.Sort((a, b) => a.ArrayIndex.CompareTo(b.ArrayIndex));
    }

    Oder, noch besser, man implementiert für Card gleich IComparable<Card> .

    0
  • T

    Dann hätte ich aber viel Arbeit mit der Umwandlung der Karten Erkennung, die ja mit Pixeln arbeitet und dort müsste ich dann mehr Arbeit investieren, um eine Struktur zu erschaffen.

    Ich müsste dann halt erst mal die Karten vorsortieren, weil ich habe schon im Code für jede einzelne Karte eine Erkennung.

    Ich glaube schon fast das mir nichts anderes übrig bleibt.

    0
  • T

    Danke aber für die Tipps.

    0
  • B

    Taurus1985 schrieb:

    Dann hätte ich aber viel Arbeit mit der Umwandlung der Karten Erkennung

    Nicht vergleichbar mit der Arbeit, die du dir jetzt schon freiwillig aufhalst.

    0
Anmelden zum Antworten