VierGewinnt KI



  • moin, hab ja schon nen paar mal hier gepostet weil ich in letzter zeit iwelche spiele progge xD.

    Momentan sitze ich an einer Einspieler version von 4Gewinnt und brauche dementsprechend ne KI.

    Meine Grund idee war

    int KI() {
      int x, y;
      int flag;
    
      for(x=0;x<7;x++) for(y=0;y<6;y++) {
         /* Wenn Horizontal */
         if(uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]==(3*uber.Feld[x][y])&&
            uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237&&x<=3) {
    
                     if(uber.Feld[x-1][y]==32 && uber.Feld[x-1][y-1]!=32 ||
                        uber.Feld[x-1][y]==32 && y==0 ) {
                            x-=1;
                            return x;
                     }
                     else if(uber.Feld[x+3][y]==32 && uber.Feld[x+3][y-1]!=32 ||
                             uber.Feld[x+3][y]==32 && y==0) {
                            x+=3;
                            return x;
                     }
         }
         /* Wenn Vertikal */
         else if(uber.Feld[x][y]+uber.Feld[x][y+1]+uber.Feld[x][y+2]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237&&y<3) {
    
                     if(uber.Feld[x][y+3]==32 && uber.Feld[x][y+2]!=32) {
                            return x;
                     }
         }
         /* Wenn Diagonal (Schräg nach Rechts) */
         else if(uber.Feld[x][y]+uber.Feld[x+1][y+1]+uber.Feld[x+2][y+2]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237&&x<=3&&y<3) {
    
                     if(uber.Feld[x-1][y-1]==32 && uber.Feld[x-1][y-2]!=32 ||
                        uber.Feld[x-1][y-1]==32 && y==1) {
                            x-=1;
                            return x;
                     }
                     else if(uber.Feld[x+3][y+3]==32 && uber.Feld[x+3][y+2]!=32) {
                            x+=3;
                            return x;
                     }
         }
         /* Wenn Diagonal (Schräg nach Links) */
         else if(uber.Feld[x][y]+uber.Feld[x-1][y+1]+uber.Feld[x-2][y+2]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237&&x>=3&&y<3) {
    
                     if(uber.Feld[x+1][y-1]==32 && uber.Feld[x+1][y-2]!=32 ||
                        uber.Feld[x+1][y-1]==32 && y==1) {
                            x+=1;
                            return x;
                     }
                     else if(uber.Feld[x-3][y+3]==32 && uber.Feld[x-3][y+2]!=32) {
                            x-=3;
                            return x;
                     }
         }
      }
      do {          
               flag=false;
               x=rand()%7;
               x--;
               if(x>=6 || x<=0 ) flag=true;
      } while(flag==true);
      return x;
    }
    
    uber.Feld[7][6]
    

    ist mein Array für die Felder und er testet halt erstmal ob 3 Gegnerische Steine nebeneinander liegen und es vereitelbar ist, wenn das der Fall ist, tut ers auch.
    nur iwie setzt meine Ki nur auf die ersten 4 Felder, und teilweise blockt der auch nicht korrekt.

    allgemein, gibs da logisch oder syntaktisch Fehler drinne? bzw hat jemand eine bessere idee für ne ki? (die nicht alzu umständlich ist, da das nen Unterstufen Projekt ist und mein Programminiveau nicht alzu hoch ist.. da wir eigendlich nichtmal schleifen kennen) hatte scho ne idee dass er sich immer an seinen letzten, nichtblockenden stein orientiert.. weiss aber nicht ob das so das wahre ist.

    danke im vorraus für eure hilfe ^^



  • spricht man hier schon von einer KI? simple logik oder?



  • Ysparrow schrieb:

    uber.Feld[7][6]
    

    ist mein Array für die Felder

    Und dein Programm greift fröhlich zu auf uber.Feld[7][0], uber.Feld[8][0], uber.Feld[-1][0], uber.Feld[9][0], uber.Feld[0][7], uber.Feld[-1][-2] und so weiter und so weiter.

    Mach erst mal die ganzen ungültigen Zugriffe aus deinem Programm raus, dann kannst du dich darum kümmern, was es tut. Denn solange diese falschen Zugriffe drin sind, kann dein Programm sowieso alles Mögliche tun.



  • BorisDieKlinge schrieb:

    spricht man hier schon von einer KI? simple logik oder?

    Ich spiele den bot nicht und entscheidet selber welchen stein er legt -> KI. keine ki auf der welt is was anderes als logik.

    MFK schrieb:

    Ysparrow schrieb:

    uber.Feld[7][6]
    

    ist mein Array für die Felder

    Und dein Programm greift fröhlich zu auf uber.Feld[7][0], uber.Feld[8][0], uber.Feld[-1][0], uber.Feld[9][0], uber.Feld[0][7], uber.Feld[-1][-2] und so weiter und so weiter.

    Mach erst mal die ganzen ungültigen Zugriffe aus deinem Programm raus, dann kannst du dich darum kümmern, was es tut. Denn solange diese falschen Zugriffe drin sind, kann dein Programm sowieso alles Mögliche tun.

    und wo bitte schön?

    if(uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]==(3*uber.Feld[x][y])&&
            uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237
    
    &&x<=3
    
    ) {
    

    beachtet?



  • int KI() {
      int x, y;  /* zählervariablen */
      int flag;  /* true/false variable */
    
      for(x=0;x<7;x++) for(y=0;y<6;y++) {
         /* Anschlussübeprüfung (Situation _xxx oder xxx_ ) */
         /* Wenn Horizontal */
         if(uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]==(3*uber.Feld[x][y])&&
            uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237&&x<=3) {
    
                     /* _xxx */                                                       
                     if(uber.Feld[x-1][y]==32 && uber.Feld[x-1][y-1]!=32 ||
                        uber.Feld[x-1][y]==32 && y==0 ) {
                            x-=1;
                            return x;
                     }
                     /* xxx_*/
                     else if(uber.Feld[x+3][y]==32 && uber.Feld[x+3][y-1]!=32 ||
                             uber.Feld[x+3][y]==32 && y==0) {
                            x+=3;
                            return x;
                     }
         }
         /* Wenn Vertikal xxx_ (<- um 90° nach links drehn) */
         else if(uber.Feld[x][y]+uber.Feld[x][y+1]+uber.Feld[x][y+2]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x][y+1]+uber.Feld[x][y+2]>=237&&y<3) {
    
                     if(uber.Feld[x][y+3]==32 && uber.Feld[x][y+2]!=32) {
                            return x;
                     }
         }
         /* Wenn Diagonal (Schräg nach Rechts) */
         else if(uber.Feld[x][y]+uber.Feld[x+1][y+1]+uber.Feld[x+2][y+2]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x+1][y+1]+uber.Feld[x+2][y+2]>=237&&x<=3&&y<3) {
    
                     /* _xxx (<- um 45° nach links drehn) */                                                                                  
                     if(uber.Feld[x-1][y-1]==32 && uber.Feld[x-1][y-2]!=32 ||
                        uber.Feld[x-1][y-1]==32 && y==1) {
                            x-=1;
                            return x;
                     }
                     /* xxx_ (<- um 45° nach links drehn) */
                     else if(uber.Feld[x+3][y+3]==32 && uber.Feld[x+3][y+2]!=32) {
                            x+=3;
                            return x;
                     }
         }
         /* Wenn Diagonal (Schräg nach Links) */
         else if(uber.Feld[x][y]+uber.Feld[x-1][y+1]+uber.Feld[x-2][y+2]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x-1][y+1]+uber.Feld[x-2][y+2]>=237&&x>=3&&y<3) {
    
                     /* _xxx (<- um 45° nach rechts drehn) */                                                                 
                     if(uber.Feld[x+1][y-1]==32 && uber.Feld[x+1][y-2]!=32 ||
                        uber.Feld[x+1][y-1]==32 && y==1) {
                            x+=1;
                            return x;
                     }
                     /* xxx_ (<- um 45° nach rechts drehn) */
                     else if(uber.Feld[x-3][y+3]==32 && uber.Feld[x-3][y+2]!=32) {
                            x-=3;
                            return x;
                     }
         }
         /* Anschlussübeprüfung */
    
         /* Lückenüberprüfungen (Situation x_xx oder xx_x) */
         /* Wenn Horizontal x_xx */
         else if(uber.Feld[x][y]+uber.Feld[x+2][y]+uber.Feld[x+3][y]==(3*uber.Feld[x][y])&&
            uber.Feld[x][y]+uber.Feld[x+2][y]+uber.Feld[x+3][y]>=237&&x<=3) {
                            x+=1;
                            return x;
         }
         /* Wenn Horizontal xx_x */
         else if(uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+3][y]==(3*uber.Feld[x][y])&&
            uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+3][y]>=237&&x<=3) {
                            x+=2;
                            return x;
         }
         /* Wenn Diagonal (Schräg nach Rechts / x_xx [<- 45° nach links drehn]) */
         else if(uber.Feld[x][y]+uber.Feld[x+2][y+2]+uber.Feld[x+3][y+3]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x+2][y+2]+uber.Feld[x+3][y+3]>=237&&x<=3&&y<3&&
                 uber.Feld[x+1][y+1]==32 && uber.Feld[x+1][y]!=32) {
                            x+=1;
                            return x;
    
         }
         /* Wenn Diagonal (Schräg nach Rechts / xx_x [<- 45° nach links drehn]) */
         else if(uber.Feld[x][y]+uber.Feld[x+1][y+1]+uber.Feld[x+3][y+3]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x+1][y+1]+uber.Feld[x+3][y+3]>=237&&x<=3&&y<3&&
                 uber.Feld[x+2][y+2]==32&&uber.Feld[x+2][y+1]!=32) {
                            x+=2;
                            return x;
    
         }
         /* Wenn Diagonal (Schräg nach Links) / x_xx [<-45° nach rechts drehn]) */
         else if(uber.Feld[x][y]+uber.Feld[x-2][y+2]+uber.Feld[x-3][y+3]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x-2][y+2]+uber.Feld[x-3][y+3]>=237&&x>=3&&y<3&&
                 uber.Feld[x-1][y+1]==32&&uber.Feld[x-1][y]!=32) {
                            x-=1;
                            return x;
         }
         /* Wenn Diagonal (Schräg nach Links) / xx_x [<-45° nach rechts drehn]) */
         else if(uber.Feld[x][y]+uber.Feld[x-1][y+1]+uber.Feld[x-3][y+3]==(3*uber.Feld[x][y])&&
                 uber.Feld[x][y]+uber.Feld[x-1][y+1]+uber.Feld[x-3][y+3]>=237&&x>=3&&y<3&&
                 uber.Feld[x-2][y-2]==32+uber.Feld[x-2][y-1]!=32) {
                            x-=2;
                            return x;
         }
      }
      /* Else -> */
      do {          
               flag=false;
               x=rand()%7;
               x--;
               if(x>=6 || x<=0 ) flag=true;
      } while(flag==true);
      return x;
    }
    

    ist mitlerweile auch etwas anders..

    hab manchmal auch das problem dass das random partout nicht anders sein will sondern immer auf einer zahl bleibt. zb besteht der darauf 3 zu nehmen obwohl die reihe voll ist..



  • Vielleicht solltest du dann && x<=3 auch an den Anfang der if Abfrage stellen und nicht ans Ende, wenn das Programm schon auf die ungültigen Indexe zugegriffen hat. Und .. dein Code ist echt grausam zu lesen. Schonmal was von Leerzeichen gehört, damit man z.B. bei uber.Feld[x][y]+uber.Feld[x][y+1]+uber.Feld[x][y+2]==(3*uber.Feld[x][y])&&uber.Feld[x][y]+uber.Feld[x][y+1]+uber.Feld[x][y+2]>=237&&y<3 nicht erst 3 mal drüberlesen muss, um zu erkennen, wo da irgendwelche && bzw || sind?

    Warum nicht z.B.:

    uber.Feld[x][y] + uber.Feld[x][y+1] + uber.Feld[x][y+2] == (3 * uber.Feld[x][y]) && uber.Feld[x][y] + uber.Feld[x][y+1] + uber.Feld[x][y+2] >= 237 && y < 3



  • wär mir lieb wenn man mir meine frage beantwortet und nicht iwas nicht hilfreiches.

    klar is das net schön, aber was soll man machen? mein IDE zeigt das Farbtechnisch gut auseinander haltbar an und wenigstens pack ich net alles auf einmal in eine zeile gibt genug leute ina klasse die das machen.


  • Mod

    Zusammenfassen und Auslagern. Der gegenwärtige Code verliert sich in mystischen Arrayzugriffen und magischen Konstanten. Ich habe keine Lust, diesen so wie er ist zu kommentieren. Ein schneller Neuentwurf könnte so aussehen (völlig ungetestet, dafür - jedenfalls in meinen Augen - schnell verständlich und deutlich kürzer)

    // für das Feld:
    enum { xdim = 7, ydim = 6 };
    enum feld_zustand { leeres_feld, spieler_stein, computer_stein };
    
    bool ist_gueltige_position(int x, int y)
    {
        return x >= 0 && x < xdim && y >= 0 && y < ydim;
    }
    
    int spaltenfuellstand(int x) // Anzahl der vorhandenen Steine in Spalte x
    {
        assert( x >= 0 && x < xdim );
        for ( int y = 0; y < ydim; ++y )
            if ( uber.Feld[ x ][ y ] == leeres_feld )
                return y;
    }
    
    // prüft, ob von einer bestimmten Position ausgehend benachtbarte Positionen alle den gleichen Steintyp haben
    // x_richtung und y_richtung bestimmen die Position eines Steines in der Reihe relativ zum vorherigen Stein
    bool existiert_reihe(int x, int y, int x_richtung, int y_richtung, int laenge, enum feld_zustand stein_typ)
    {
        assert( -1 <= x_richtung && x_richtung <= 1 );
        assert( -1 <= y_richtung && y_richtung <= 1 );
        assert( x_richtung != 0 || y_richtung != 0 );
        if ( !ist_gueltige_postion( x, y ) || !ist_gueltige_position( x + x_richtung * laenge, y + y_richtung * laenge ) )
            return false;
        // wenn die Endpunkte im Feld liegen, gilt das für die Felder dazwischen natürlich auch
        for ( int i = 1; i <= laenge; ++i )
            if ( uber.Feld[ x + x_richtung * i ][ y + y_richtung * i ] != stein_typ )
                return false;
        return true;
    }
    
    int KI()
    {
        // wir untersuchen jede einzelne Spalte und stellen fest, ob das Setzen eines Steines in dieser Spalte
        // eine Reihe des Gegners verhindert
        for ( int x = 0; x < xdim; ++x )
        {
            int y = spaltenfuellstand( x ); // (x,y) ist jetzt die Position eines möglichen neuen Steines
            if ( y >= ydim )
                continue;                  // die Spalte ist schon voll
            if ( existiert_reihe( x, y, -1,  1, 3, spieler_stein )   // links-oben
              || existiert_reihe( x, y, -1,  0, 3, spieler_stein )   // links
              || existiert_reihe( x, y, -1, -1, 3, spieler_stein )   // links-unten
              || existiert_reihe( x, y,  0, -1, 3, spieler_stein )   // unten
              || existiert_reihe( x, y,  1, -1, 3, spieler_stein )   // rechts-unten
              || existiert_reihe( x, y,  1,  0, 3, spieler_stein )   // rechts
              || existiert_reihe( x, y,  1,  1, 3, spieler_stein ) ) // rechts-oben
    // die Richtung nach oben muss nicht getestet werden, dort können sich keine Steine befinden
                return x;
        }
    // ab hier: mach etwas Intelligentes, wenn es nichts zu blockieren gibt
    ...
    }
    

    Lückenschluss ist noch nicht enthalten, lässt sich aber durch Verallgemeinerung von existiert_reihe leicht darstellen.


  • Mod

    zum Spaß doch noch Lückenfüllen berücksichtigt, ist ja einfach genug und der Code wird nicht länger

    // für das Feld:
    enum { xdim = 7, ydim = 6 };
    enum feld_zustand { leeres_feld, spieler_stein, computer_stein };
    
    bool ist_gueltige_position(int x, int y)
    {
        return x >= 0 && x < xdim && y >= 0 && y < ydim;
    }
    
    int spaltenfuellstand(int x) // Anzahl der vorhandenen Steine in Spalte x
    {
        assert( x >= 0 && x < xdim );
        for ( int y = 0; y < ydim; ++y )
            if ( uber.Feld[ x ][ y ] == leeres_feld )
                return y;
    }
    
    bool bildet_reihe(int x, int y, int x_richtung, int y_richtung, int laenge, enum feld_zustand stein_typ)
    {
        assert( -1 <= x_richtung && x_richtung <= 1 );
        assert( -1 <= y_richtung && y_richtung <= 1 );
        assert( x_richtung != 0 || y_richtung != 0 );
        if ( !ist_gueltige_postion( x, y ) )
            return false;
        int gefundene_steine = 0;
        // wir zählen von (x,y) ausgehend, wieviele (max laenge-1) Schritte wir gehen können, bevor wir keinen passenden Stein mehr vorfinden
        for ( int i = -1; i > -laenge; --i )
            if ( ist_gueltige_position( x + x_richtung * i, y + y_richtung * i ) && uber.Feld[ x + x_richtung * i ][ y + y_richtung * i ] == stein_typ )
                ++gefundene_steine;
            else
                break;
        for ( int i = 1; i < laenge; ++i )
            if ( ist_gueltige_position( x + x_richtung * i, y + y_richtung * i ) && uber.Feld[ x + x_richtung * i ][ y + y_richtung * i ] == stein_typ )
                ++gefundene_steine;
            else
                break;
        return gefundene_steine + 1 >= laenge;
    }
    
    int KI()
    {
        // wir untersuchen jede einzelne Spalte und stellen fest, ob das Setzen eines Steines in dieser Spalte
        // eine Reihe des Gegners verhindert
        for ( int x = 0; x < xdim; ++x )
        {
            int y = spaltenfuellstand( x ); // (x,y) ist jetzt die Position eines möglichen neuen Steines
            if ( y >= ydim )
                continue;                  // die Spalte ist schon voll
            if ( bildet_reihe( x, y, -1,  1, 4, spieler_stein )   // links-oben
              || bildet_reihe( x, y, -1,  0, 4, spieler_stein )   // links
              || bildet_reihe( x, y, -1, -1, 4, spieler_stein )   // links-unten
              || bildet_reihe( x, y,  0, -1, 4, spieler_stein ) ) // unten
                return x;
        }
    // ab hier: mach etwas Intelligentes, wenn es nichts zu blockieren gibt
    ...
    }
    


  • resume: du hast eine programm alternative geschrieben mit aussnahme von dem was ich hinter fragt habe.

    Eh.. ja..



  • ysparrow schrieb:

    wär mir lieb wenn man mir meine frage beantwortet und nicht iwas nicht hilfreiches.

    Dann solltest du die Augen aufmachen.

    "Vielleicht solltest du dann && x<=3 auch an den Anfang der if Abfrage stellen und nicht ans Ende, wenn das Programm schon auf die ungültigen Indexe zugegriffen hat." sollte doch eigentlich deutlich genug gewesen sein, um dir zu sagen, dass

    ysparrow schrieb:

    if(uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]==(3*uber.Feld[x][y])&&
            uber.Feld[x][y]+uber.Feld[x+1][y]+uber.Feld[x+2][y]>=237
    
    &&x<=3
    ) {
    

    beachtet?

    falsch ist, wie MFK dir bereits sagte.



  • jaja das hab ich ja korrigiert.

    nix gegen euch hier.. aber irgendwie wenn man hier ne anfrage mit quellcode sendet bekommt man irgendwie nie ne richtige antwort. zu 90% ist es eine "dein quellcode ist sowieso scheisse/zu schlecht" antwort..

    das haupt augenmerk meines post galt ja eigendlich ob man eine alternativ ki hat (und halt ob da logische fehler sind)

    naja die schwierigkeit der jeweiligen anfragen müssten doch eig preis geben dass die Ki ein schwiegenderes thema ist.

    wäre also nett mann man mir dessen etwas helfen könnte..



  • ysparrow schrieb:

    BorisDieKlinge schrieb:

    spricht man hier schon von einer KI? simple logik oder?

    Ich spiele den bot nicht und entscheidet selber welchen stein er legt -> KI.

    Das macht deine if-else-Abfolgen noch lange zu keiner KI. Höchstens zu einer "Nach-Außen-Hin-KI".

    ysparrow schrieb:

    keine ki auf der welt is was anderes als logik.

    Bei weitem sind nicht alle Verknüpfungen von Logiken Künstl.Intelligenzen.



  • ysparrow schrieb:

    jaja das hab ich ja korrigiert.

    Dann zeig das Ergebnis dieser Korrektur, damit man endlich über Logikprobleme reden kann.

    ysparrow schrieb:

    nix gegen euch hier.. aber irgendwie wenn man hier ne anfrage mit quellcode sendet bekommt man irgendwie nie ne richtige antwort.

    Nix gegen dich, aber wenn ich so etwas lese:

    ysparrow schrieb:

    nen iwelche iwie drinne net ina is ne eig

    dann geht meine Bereitschaft, mich bei der Antwort auch nur im Geringsten anzustrengen, gegen Null.

    ysparrow schrieb:

    zu 90% ist es eine "dein quellcode ist sowieso scheisse/zu schlecht" antwort.

    Und wenn du die restlichen 10% einfach ignorierst, hilft dir das auch nicht weiter.

    ysparrow schrieb:

    das haupt augenmerk meines post galt ja eigendlich ob man eine alternativ ki hat (und halt ob da logische fehler sind)

    Das Hauptaugenmerk liegt auf den bunten Fähnchen, und ob sie farblich ansprechend arrangiert sind, nicht auf der Tatsache, dass sie in einem Haufen Kot stecken. Meinst du das in etwa so?

    ysparrow schrieb:

    naja die schwierigkeit der jeweiligen anfragen müssten doch eig preis geben dass die Ki ein schwiegenderes thema ist.

    Bahnhof?

    ysparrow schrieb:

    wäre also nett mann man mir dessen etwas helfen könnte..

    Ich hab's schonmal gesagt: Mach die gravierenden Fehler raus, dann kann man sich über Logik unterhalten. Vorher bringt das nichts.



  • blubb² schrieb:

    ysparrow schrieb:

    BorisDieKlinge schrieb:

    spricht man hier schon von einer KI? simple logik oder?

    Ich spiele den bot nicht und entscheidet selber welchen stein er legt -> KI.

    Das macht deine if-else-Abfolgen noch lange zu keiner KI. Höchstens zu einer "Nach-Außen-Hin-KI".

    ysparrow schrieb:

    keine ki auf der welt is was anderes als logik.

    Bei weitem sind nicht alle Verknüpfungen von Logiken Künstl.Intelligenzen.

    hirn fällt ja schließlich vom himmel 🙄



  • MFK schrieb:

    ysparrow schrieb:

    jaja das hab ich ja korrigiert.

    Dann zeig das Ergebnis dieser Korrektur, damit man endlich über Logikprobleme reden kann.

    ysparrow schrieb:

    nix gegen euch hier.. aber irgendwie wenn man hier ne anfrage mit quellcode sendet bekommt man irgendwie nie ne richtige antwort.

    Nix gegen dich, aber wenn ich so etwas lese:

    ysparrow schrieb:

    nen iwelche iwie drinne net ina is ne eig

    dann geht meine Bereitschaft, mich bei der Antwort auch nur im Geringsten anzustrengen, gegen Null.

    ysparrow schrieb:

    zu 90% ist es eine "dein quellcode ist sowieso scheisse/zu schlecht" antwort.

    Und wenn du die restlichen 10% einfach ignorierst, hilft dir das auch nicht weiter.

    ysparrow schrieb:

    das haupt augenmerk meines post galt ja eigendlich ob man eine alternativ ki hat (und halt ob da logische fehler sind)

    Das Hauptaugenmerk liegt auf den bunten Fähnchen, und ob sie farblich ansprechend arrangiert sind, nicht auf der Tatsache, dass sie in einem Haufen Kot stecken. Meinst du das in etwa so?

    ysparrow schrieb:

    naja die schwierigkeit der jeweiligen anfragen müssten doch eig preis geben dass die Ki ein schwiegenderes thema ist.

    Bahnhof?

    ysparrow schrieb:

    wäre also nett mann man mir dessen etwas helfen könnte..

    Ich hab's schonmal gesagt: Mach die gravierenden Fehler raus, dann kann man sich über Logik unterhalten. Vorher bringt das nichts.

    Resume deiner Antwort: Ich habe recht und ihr lösst mir nicht meine frage o.O



  • ysparrow schrieb:

    Resume deiner Antwort: Ich habe recht und ihr lösst mir nicht meine frage o.O

    Ja, wenn man's nicht schnallen will, kann man zu diesem Ergebnis kommen. Du kannst ja wiederkommen, wenn du ein zweistelliges Alter erreicht hast 🙂



  • sagt der der nicht versteht dass man auf ne frage ne antwort erwartet und kein "ich weiss es eh besser als du" wie im kindergarten.

    rofl das mit dem 2 stelligen alter geb ich an dich zurück



  • So, kommt mal wieder runter.
    Ich denke MFK hat klar gemacht, dass und warum er dir so nicht helfen will, und damit ist jetzt auch gut. 😉



  • naja ich brauch mir sowas kindisches nicht unterstellen lassen, ich belass es auch dabei.


Log in to reply