-         

Seite 1 von 5 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 48

Thema: schon mal festgestellt? A. Due rechnet falsch - Mega ok!

  1. #1
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.559

    schon mal festgestellt? A. Due rechnet falsch - Mega ok!

    Anzeige

    hi,
    habt ihr das auch schon mal festgestellt?
    der A. Due rechnet falsch - beim Mega ok!
    gleicher Code läuft auch als devcpp Konsolenanwendung einwandfrei - nur der Due streikt!
    Ist es ein Sketch-Compilier-Fehler? Oder ist mein Due kaputt ???

    wenn ich jetzt in beiden Programmen als Zug
    d2d4
    eingebe, klappt alles wunderbar. (in beiden Fällen score=30000 = default)

    wenn ich einen Leerstring eingebe, auch (dann rechnet er automatisch einen Zug aus).

    wenn ich aber dann, wenn Schwarz zieht,
    bei devcpp z.B. a7a6 eingebe,
    klappt es (wieder score=30000 = default)

    bei Sketch meldet er einen falschen Zug (score == 0x0f == 15)
    und weigert sich, ihn auszuführen!!
    und zwar NUR bei schwarz!!
    bei Weiß geht wieder alles !!

    ich kapiers nicht.
    ich war schon schier am verzweifeln!
    Klicke auf die Grafik für eine größere Ansicht

Name:	2162.gif
Hits:	127
Größe:	339 Bytes
ID:	29327

    Code:
    /***************************************************************************/
    /*                               micro-Max,                                */
    /* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
    /***************************************************************************/
    /* version 4.8.i  Sketch (1953 characters) features:                                 */
    /* - recursive negamax search                                              */
    /* - all-capture MVV/LVA quiescence search                                 */
    /* - (internal) iterative deepening                                        */
    /* - best-move-first 'sorting'                                             */
    /* - a hash table storing score and best move                              */
    /* - futility pruning                                                      */
    /* - king safety through magnetic, frozen king in middle-game              */
    /* - R=2 null-move pruning                                                 */
    /* - keep hash and repetition-draw detection                               */
    /* - better defense against passers through gradual promotion              */
    /* - extend check evasions in inner nodes                                  */
    /* - reduction of all non-Pawn, non-capture moves except hash move (LMR)   */
    /* - full FIDE rules (expt under-promotion) and move-legality checking     */
    
    
    #define K(A,B) *(int*)(T+A+(B&8)+S*(B&7))
    
    
    #define HTsize (1<<8) // (1<<24)
    struct HTab {
              int  K,
                   V;
              int  X,
                   Y,
                   D;
            } HTarray[HTsize];           /* hash table, HTsize entries*/
            
            
    #define MAXNODES 60000
    
    int  K,   
         Q,
         R,
         J,
         Z;
         
    long N,
         I=30000;                         /* I=80000: "infinity score" */ ;                           
    
    int 
        M=136,                           /* M=0x88   board system    */
        S=128,                           /* dummy square 0x80, highest valid square =127    */
        turn=16;             
    
    char L,
         pval[]={0,2,2,7,-1,8,12,23},                      /* relative piece values    */
         vector[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
              7,-1,11,6,8,3,6},                          /* 1st dir. in vector[] per piece*/
         
         bsetup[]={6,3,5,7,4,5,3,6},                         /* initial piece setup      */
         board[129],                                        /* board: half of 16x8+dummy*/
         T[1035];                                        /* hash translation table   */
    
    char psymbol[]= ".?+nkbrq?*?NKBRQ";
    
    char mfrom, mto;    // current ply from - to
    int  EPSQ,
         RemP;           // remove piece
    
    
    
    
    /* recursive minimax search, turn=moving side, n=depth*/
    
    int  Minimax(int  q, int  l, int  score, int  EPC, int  prev, int  hashkey)         
                           /* (q,l)=window, score, EnPass_sqr.*/
                           /* prev=prev.dest; J,Z=hashkeys; return score*/
    {
       int  j,
            r,
            m,
            v,
            d,
            h,
            i,
            F,
            G,
            V,
            P,
            f=J,
            g=Z,
            C,
            s;
       char t,
            p,
            upiece,
            x,
            y,
            X,
            Y,
            H,
            B;
       
       struct HTab *a = HTarray + (J + turn * EPC & HTsize-1);   /* lookup pos. in hash table*/
     
       char sbuf[50];
     
     
     
       q--;                                          /* adj. window: delay bonus */
       turn^=24;                                        /* change sides             */
       d=a->D;
       m=a->V;
       X=a->X;
       Y=a->Y;                  /* resume at stored depth   */
       
       if(a->K-Z|prev|                                  /* miss: other pos. or empty*/
          !(m<=q | X&8&&m>=l | X&S))                   /*   or window incompatible */
          { d=Y=0; }                                /* start iter. from scratch */
       
       X&=~M;                                        /* start at best-move hint  */
     
       while( d++ < hashkey || d<3                   /* iterative deepening loop */
         || prev&K == I
           && ( N<60000 & d<98                        /* root: deepen upto time   */
              || (K=X, L=Y&~M, d=3)
           )
         )                                          /* time's up: go do best    */
       {
          x=B=X;                                       /* start scan at prev. best */
          h=Y&S;                                       /* request try noncastl. 1st*/
          P=d<3 ? I : Minimax(-l,1-l,-score,S,0,d-3);               /* Search null move         */
          m = (-P<l | R>35) ? ( d>2 ? -I : score ) : -P;            /* Prune or stand-pat       */
          N++;                                         /* node count (for timing)  */
          do
          {
             upiece=board[x];                                   /* scan board looking for   */
             if(upiece & turn)                                  /*  own piece (inefficient!)*/
             {
                r = p = upiece&7;                               /* p = piece type (set r>0) */
                j = vector[p+16];                                 /* first step vector f.piece*/
                while(r = p>2 & r<0 ? -r : -vector[++j] )       /* loop over directions vector[] */
                {
    labelA:                                        /* resume normal after best */
                   y=x;                            /* (x,y)=move         */
                   F=G=S;                          /* (F,G)=castl.R      */
                   
                   do
                   {                                       /* y traverses ray, or:     */
                      H=y=h?Y^h:y+r;                           /* sneak in prev. best move */
                     
                      if(y&M)break;                            /* board edge hit           */
                     
                      m= EPC-S&board[EPC]&&y-EPC<2&EPC-y<2?I:m;      /* bad castling             */
                     
                      if(p<3&y==EPC)H^=16;                           /* shift capt.sqr. H if e.p.*/
                     
                      t=board[H];
                     
                      if(t&turn|p<3&!(y-x&7)-!t)break;            /* capt. own, bad pawn mode */
                      i=37*pval[t&7]+(t&192);                     /* value of capt. piece t   */
                      m=i<0?I:m;                                  /* K capture                */
                     
                      if(m>=l&d>1) goto labelC;                     /* abort on fail high       */
               
                      v=d-1?score:i-p;                             /* MVV/LVA scoring          */
                     
                      if(d-!t>1)                               /* remaining depth          */
                      {
                         v=p<6?board[x+8]-board[y+8]:0;                  /* center positional pts.   */
                         board[G]=board[H]=board[x]=0;board[y]=upiece|32;             /* do move, set non-virgin  */
                         if(!(G&M))board[F]=turn+6,v+=50;               /* castling: put R & score  */
                         v-=p-4|R>29?0:20;                              /* penalize mid-game K move */
                         
                         if(p<3)                                        /* pawns:                   */
                         {
                            v-=9*((x-2&M||board[x-2]-upiece)+              /* structure, undefended    */
                                   (x+2&M||board[x+2]-upiece)-1            /*        squares plus bias */
                                  +(board[x^16]==turn+36))                 /* kling to non-virgin King */
                                  -(R>>2);                                 /* end-game Pawn-push bonus */
                             V=y+r+1&S?647-p:2*(upiece&y+16&32);           /* promotion or 6/7th bonus */
                             board[y]+=V;
                             i+=V;                                         /* change piece, add score  */
                         }
                         
                         v+= score+i;
                         V=m>q ? m : q;                           /* new eval and alpha       */
                         J+=K(y+0,board[y])-K(x+0,upiece)-K(H+0,t); 
                         Z+=K(y+8,board[y])-K(x+8,upiece)-K(H+8,t)+G -S;  /* update hash key          */
                         C=d-1-(d>5&p>2&!t&!h);
                         C=R>29|d<3|P-I?C:d;                     /* extend 1 ply if in check */
                         do {
                            s=C>2|v>V?-Minimax(-l,-V,-v,         /* recursive eval. of reply */
                                                F,0,C):v;        /* or fail low if futile    */
                         } while( s>q & ++C<d );
                       
                         v=s;
                         if(prev&&K-I&&v+I&&x==K&y==L)              /* move pending & in root:  */
                         {
                            Q=-score-i; EPSQ=F;                            /*   exit if legal & found  */
                            a->D=99;a->V=0;                        /* lock game in hash as draw*/
                            R+=i>>7;
                            return l;                            /* captured non-P material  */
                         }
                         J=f;
                         Z=g;                                    /* restore hash key         */
                         board[G]=turn+6;
                         board[F]=board[y]=0;
                         board[x]=upiece;
                         board[H]=t;                             /* undo move,G can be dummy */
                      }
                      if(v>m)                                  /* new best, update max,best*/
                      {
                         m=v,X=x,Y=y|S&F;                      /* mark double move with S  */
                      }                       
                      if(h)
                      {
                         h=0;
                         goto labelA;                           /* redo after doing old best*/
                      }                 
                      if (
                        x+r-y|upiece&32|                             /* not 1st step,moved before*/
                        p>2 & (
                          p-4|j-7||                             /* no P & no lateral K move,*/
                          board[G=x+3^r>>1&7]-turn-6            /* no virgin R in corner G, */
                          || board[G^1] | board[G^2] )          /* no 2 empty sq. next to R */
                        )
                      {
                         t+=p<5; 
                      }                                        /* fake capt. for nonsliding*/
                      else F=y;                                /* enable e.p.              */
                     
                   } while(!t);                               /* if not capt. continue ray*/
             
                }
             }  // (upiece & turn)
         
          } while((x=x+9&~M)-B);                       /* next sqr. of board, wrap */
       
    labelC:
          if (m>I-M|m<M-I) d=98;                       /* mate holds to any depth  */
          m= m+I|P==I ? m : 0;                         /* best loses K: (stale)mate*/
         
          if(a->D<99) {                                /* protect game history     */
             a->K=Z;
             a->V=m;
             a->D=d;                       /* always store in hash tab */
             a->X=X|8*(m>q)|S*(m<l);
             a->Y=Y;                       /* move, type (bound/exact),*/
          } 
          /* uncomment for Kibitz */
          if(!((N-S)%987)) {        
            sprintf(sbuf, "searched: %d\r",N-S);
            Serial.println(sbuf);
          }
          
       }  // while (iterative deepening loop)                                           
     
       turn^=24;                                        /* change sides back        */
       mfrom=K; mto=L; 
       return m+= m<score;                                  /* delayed-loss bonus       */
    }
    
    
    
    
    
    void chess()
    {
       int  score, i;
       char sbuf[50], sbuf2[50];
       char oboard[129];
       char oldto, oldEPSQ;
       char cstring[20];
       
       K=8;
       while(K--)
       {
          board[K]=(board[K+112]=bsetup[K]+8)+8;
          board[K+16]=18;
          board[K+96]=9;                               /* initial board setup*/
          L=8;
          while(L--)board[16*L+K+8]=(K-4)*(K-4)+(L-3.5)*(L-3.5);     /* center-pts table   */
       }                                                             /*(in unused half board[])*/
       N=1035;
       while(N-->M)T[N]=rand()>>9;
       
                                                                    /* play loop          */
       while(1)                                               
       {
         N=-1;
         
         Serial.print("\n");
         while(++N<121) {                                            /* print board */
             sprintf(sbuf," %c", N&8 && (N+=7) ? 10 : psymbol[board[N]&15]); 
             Serial.print(sbuf);
         }
         
         if(turn==16) sprintf(sbuf,"\n>  WHITE: ");  else sprintf(sbuf,"\n>   BLACK:  ");  
         Serial.print(sbuf);
         
         i = 0;        
         strcpy(cstring,"");
         do   {
           while (Serial.available()==0);       
           cstring[i] = Serial.read();     
           if(cstring[i]==13) {
             cstring[i]=0;
             break;
           }
           else i++;
         } while(i < 10);
         
         K=I;
         
         if(cstring[0]!=0) {                                   /* parse entered move */
           K= cstring[0]-16*cstring[1]+799;
           L= cstring[2]-16*cstring[3]+799;
         }    
         Serial.println();  Serial.println(cstring);  Serial.println();
         
         memcpy(oboard, board, sizeof(board));
         oldto=mto;
         oldEPSQ=EPSQ;
         
         score=Minimax(-I, I, Q, EPSQ, 1, 3);                              /* think or check & do*/     
         Serial.print("\nscore=");  Serial.println(score);  Serial.println();
        
        // if(score!=15) {                     
            RemP=S;   
            if(oboard[mto])   RemP=mto;
            if(mto==oldEPSQ)  RemP=oldto;
                                           
            sprintf(sbuf,"\n\nmoved: >> %c%c", 'a'+(mfrom&7),'8'-(mfrom>>4) );
           
            if(oboard[mto]) strcat(sbuf," X ");
            else strcat(sbuf,"-");
           
            sprintf(sbuf2,"%c%c ", 'a'+(mto&7),'8'-(mto>>4&7));
            strcat(sbuf, sbuf2);
            Serial.print(sbuf);
         
            sprintf(sbuf, " (square %d to %d ) \n", mfrom, mto);
            Serial.print("\n\nDEBUG:\n");
            sprintf(sbuf2,"  EPsq: %c%c (%d)\n  RemP: %c%c (%d)",
                             'a'+(EPSQ&7), '8'-(EPSQ>>4&7), EPSQ,
                             'a'+(RemP&7), '8'-(RemP>>4&7), RemP);
            strcat(sbuf, sbuf2);
            Serial.print(sbuf);
            Serial.print("\n\n");
        //  }
        // else printf("\n\nILLEGAL!\n");
    
       }
    }
    
    
    
    
    void setup() {
       Serial.begin(9600);    
    }
    
    
    
    void loop() {    
       chess();
       
       while(1);  
    }
    - - - Aktualisiert - - -

    hier der gegenseitig angeglichene devcpp Konsolen-Code zum Vergleich:


    Code:
    /***************************************************************************/
    /*                               micro-Max,                                */
    /* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
    /***************************************************************************/
    /* version 4.8.i (1953 characters) features:                                 */
    /* - recursive negamax search                                              */
    /* - all-capture MVV/LVA quiescence search                                 */
    /* - (internal) iterative deepening                                        */
    /* - best-move-first 'sorting'                                             */
    /* - a hash table storing score and best move                              */
    /* - futility pruning                                                      */
    /* - king safety through magnetic, frozen king in middle-game              */
    /* - R=2 null-move pruning                                                 */
    /* - keep hash and repetition-draw detection                               */
    /* - better defense against passers through gradual promotion              */
    /* - extend check evasions in inner nodes                                  */
    /* - reduction of all non-Pawn, non-capture moves except hash move (LMR)   */
    /* - full FIDE rules (expt under-promotion) and move-legality checking     */
    
    
    #define K(A,B) *(int*)(T+A+(B&8)+S*(B&7))
    
    
    #define HTsize (1<<8) // (1<<24)
    struct HTab {
              int  K,
                   V;
              int  X,
                   Y,
                   D;
            } HTarray[HTsize];           /* hash table, HTsize entries*/
            
            
    #define MAXNODES 60000
    
    int  K,  
         Q,
         R,
         J,
         Z;
         
    long N,
         I=30000;                         /* I=80000: "infinity score" */ ;                           
    
    int M=136,                           /* M=0x88   board system    */
        S=128,                           /* dummy square 0x80, highest valid square =127    */
        turn=16;             
    
    char L,
         pval[]={0,2,2,7,-1,8,12,23},                      /* relative piece values    */
         vector[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
              7,-1,11,6,8,3,6},                          /* 1st dir. in vector[] per piece*/
         
         bsetup[]={6,3,5,7,4,5,3,6},                         /* initial piece setup      */
         board[129],                                        /* board: half of 16x8+dummy*/
         T[1035];                                        /* hash translation table   */
    
    char psymbol[]= ".?+nkbrq?*?NKBRQ";
    
    char mfrom, mto;    // current ply from - to
    int  EPSQ,
         RemP;           // remove piece
    
    
    
    
    /* recursive minimax search, turn=moving side, n=depth*/
    
    int Minimax(int q, int l, int score, int EPC, int prev, int hashkey)         
                           /* (q,l)=window, score, EnPass_sqr.*/
                           /* prev=prev.dest; J,Z=hashkeys; return score*/
    {
       int  j,
            r,
            m,
            v,
            d,
            h,
            i,
            F,
            G,
            V,
            P,
            f=J,
            g=Z,
            C,
            s;
       char t,
            p,
            upiece,
            x,
            y,
            X,
            Y,
            H,
            B;
       
       struct HTab *a = HTarray + (J + turn * EPC & HTsize-1);   /* lookup pos. in hash table*/
     
     
     
     
     
       q--;                                          /* adj. window: delay bonus */
       turn^=24;                                        /* change sides             */
       d=a->D;
       m=a->V;
       X=a->X;
       Y=a->Y;                  /* resume at stored depth   */
       
       if(a->K-Z|prev|                                  /* miss: other pos. or empty*/
          !(m<=q | X&8&&m>=l | X&S))                   /*   or window incompatible */
          { d=Y=0; }                                /* start iter. from scratch */
       
       X&=~M;                                        /* start at best-move hint  */
     
       while( d++ < hashkey || d<3                   /* iterative deepening loop */
         || prev&K == I
           && ( N<60000 & d<98                        /* root: deepen upto time   */
              || (K=X, L=Y&~M, d=3)
           )
         )                                          /* time's up: go do best    */
       {
          x=B=X;                                       /* start scan at prev. best */
          h=Y&S;                                       /* request try noncastl. 1st*/
          P=d<3 ? I : Minimax(-l,1-l,-score,S,0,d-3);               /* Search null move         */
          m = (-P<l | R>35) ? ( d>2 ? -I : score ) : -P;            /* Prune or stand-pat       */
          N++;                                         /* node count (for timing)  */
          do
          {
             upiece=board[x];                                   /* scan board looking for   */
             if(upiece & turn)                                  /*  own piece (inefficient!)*/
             {
                r = p = upiece&7;                               /* p = piece type (set r>0) */
                j = vector[p+16];                                 /* first step vector f.piece*/
                while(r = p>2 & r<0 ? -r : -vector[++j] )       /* loop over directions vector[] */
                {
    labelA:                                        /* resume normal after best */
                   y=x;                            /* (x,y)=move         */
                   F=G=S;                          /* (F,G)=castl.R      */
                   
                   do
                   {                                       /* y traverses ray, or:     */
                      H=y=h?Y^h:y+r;                           /* sneak in prev. best move */
                     
                      if(y&M)break;                            /* board edge hit           */
                     
                      m= EPC-S&board[EPC]&&y-EPC<2&EPC-y<2?I:m;      /* bad castling             */
                     
                      if(p<3&y==EPC)H^=16;                           /* shift capt.sqr. H if e.p.*/
                     
                      t=board[H];
                     
                      if(t&turn|p<3&!(y-x&7)-!t)break;            /* capt. own, bad pawn mode */
                      i=37*pval[t&7]+(t&192);                     /* value of capt. piece t   */
                      m=i<0?I:m;                                  /* K capture                */
                     
                      if(m>=l&d>1) goto labelC;                     /* abort on fail high       */
               
                      v=d-1?score:i-p;                             /* MVV/LVA scoring          */
                     
                      if(d-!t>1)                               /* remaining depth          */
                      {
                         v=p<6?board[x+8]-board[y+8]:0;                  /* center positional pts.   */
                         board[G]=board[H]=board[x]=0;board[y]=upiece|32;             /* do move, set non-virgin  */
                         if(!(G&M))board[F]=turn+6,v+=50;               /* castling: put R & score  */
                         v-=p-4|R>29?0:20;                              /* penalize mid-game K move */
                         
                         if(p<3)                                        /* pawns:                   */
                         {
                            v-=9*((x-2&M||board[x-2]-upiece)+              /* structure, undefended    */
                                   (x+2&M||board[x+2]-upiece)-1            /*        squares plus bias */
                                  +(board[x^16]==turn+36))                 /* kling to non-virgin King */
                                  -(R>>2);                                 /* end-game Pawn-push bonus */
                             V=y+r+1&S?647-p:2*(upiece&y+16&32);           /* promotion or 6/7th bonus */
                             board[y]+=V;
                             i+=V;                                         /* change piece, add score  */
                         }
                         
                         v+= score+i;
                         V=m>q ? m : q;                           /* new eval and alpha       */
                         J+=K(y+0,board[y])-K(x+0,upiece)-K(H+0,t); 
                         Z+=K(y+8,board[y])-K(x+8,upiece)-K(H+8,t)+G -S;  /* update hash key          */
                         C=d-1-(d>5&p>2&!t&!h);
                         C=R>29|d<3|P-I?C:d;                     /* extend 1 ply if in check */
                         do {
                            s=C>2|v>V?-Minimax(-l,-V,-v,         /* recursive eval. of reply */
                                                F,0,C):v;        /* or fail low if futile    */
                         } while( s>q & ++C<d );
                       
                         v=s;
                         if(prev&&K-I&&v+I&&x==K&y==L)              /* move pending & in root:  */
                         {
                            Q=-score-i; EPSQ=F;                            /*   exit if legal & found  */
                            a->D=99;a->V=0;                        /* lock game in hash as draw*/
                            R+=i>>7;
                            return l;                            /* captured non-P material  */
                         }
                         J=f;
                         Z=g;                                    /* restore hash key         */
                         board[G]=turn+6;
                         board[F]=board[y]=0;
                         board[x]=upiece;
                         board[H]=t;                             /* undo move,G can be dummy */
                      }
                      if(v>m)                                  /* new best, update max,best*/
                      {
                         m=v,X=x,Y=y|S&F;                      /* mark double move with S  */
                      }                       
                      if(h)
                      {
                         h=0;
                         goto labelA;                           /* redo after doing old best*/
                      }                 
                      if (
                        x+r-y|upiece&32|                             /* not 1st step,moved before*/
                        p>2 & (
                          p-4|j-7||                             /* no P & no lateral K move,*/
                          board[G=x+3^r>>1&7]-turn-6            /* no virgin R in corner G, */
                          || board[G^1] | board[G^2] )          /* no 2 empty sq. next to R */
                        )
                      {
                         t+=p<5; 
                      }                                        /* fake capt. for nonsliding*/
                      else F=y;                                /* enable e.p.              */
                     
                   } while(!t);                               /* if not capt. continue ray*/
             
                }
             }  // (upiece & turn)
         
          } while((x=x+9&~M)-B);                       /* next sqr. of board, wrap */
       
    labelC:
          if (m>I-M|m<M-I) d=98;                       /* mate holds to any depth  */
          m= m+I|P==I ? m : 0;                         /* best loses K: (stale)mate*/
         
          if(a->D<99) {                                /* protect game history     */
             a->K=Z;
             a->V=m;
             a->D=d;                       /* always store in hash tab */
             a->X=X|8*(m>q)|S*(m<l);
             a->Y=Y;                       /* move, type (bound/exact),*/
          } 
          /* uncomment for Kibitz */
          if(!((N-S)%987)) printf("searched: %d\r",N-S);
          /*
          if(prev){
               printf("%2d ply, %9d searched, score=%6d by %c%c%c%c\n", d-1, N-S, m,
                       'a'+(X&7),'8'-(X>>4),'a'+(Y&7),'8'-(Y>>4&7));       /*    encoded in X S,8 bits   
          }   
          */
       }  // while (iterative deepening loop)                                           
     
       turn^=24;                                        /* change sides back        */
       mfrom=K; mto=L; 
       return m+= m<score;                                  /* delayed-loss bonus       */
    }
    
    
    
    
    
    
    main()
    {
       int  score;
       char sbuf[50], sbuf2[50];
       char oboard[129];
       char oldto, oldEPSQ;
       int  *key;
       int  cstring[20];
       
       K=8;
       while(K--)
       {
          board[K]=(board[K+112]=bsetup[K]+8)+8;
          board[K+16]=18;
          board[K+96]=9;                               /* initial board setup*/
          L=8;
          while(L--)board[16*L+K+8]=(K-4)*(K-4)+(L-3.5)*(L-3.5);     /* center-pts table   */
       }                                                             /*(in unused half board[])*/
       N=1035;
       while(N-->M)T[N]=rand()>>9;
       
                                                                    /* play loop          */
       while(1)                                               
       {
         N=-1;
         
         printf("\n");
         while(++N<121) {                                            /* print board */
             printf(" %c", N&8 && (N+=7) ? 10 : psymbol[board[N]&15]); 
         }
         
         if(turn==16) printf("\n>  WHITE: ");  else printf("\n>   BLACK:  ");
         
         key=cstring;     
         while( (*key++ =getchar() ) > 10 );                 /* read input line    */
         K=I;                                                /* invalid move       */
         
         if(*cstring-10) {                                   /* parse entered move */
           K= cstring[0]-16*cstring[1]+799;
           L= cstring[2]-16*cstring[3]+799;
         }
         
         memcpy(oboard, board, sizeof(board));
         oldto=mto;
         oldEPSQ=EPSQ;
         score=Minimax(-I,I,Q,EPSQ,1,3);                              /* think or check & do*/     
         printf("\n\nscore=%d\n", score); 
        // if(score!=15) {                     
            RemP=S;   
            if(oboard[mto])   RemP=mto;
            if(mto==oldEPSQ)  RemP=oldto;
                                           
            sprintf(sbuf,"\n\nmoved: >> %c%c", 'a'+(mfrom&7),'8'-(mfrom>>4) );
           
            if(oboard[mto]) strcat(sbuf," X ");
            else strcat(sbuf,"-");
           
            sprintf(sbuf2,"%c%c ", 'a'+(mto&7),'8'-(mto>>4&7));
            strcat(sbuf, sbuf2);
            printf(sbuf);
         
            sprintf(sbuf, " (square %d to %d ) \n", mfrom, mto);
            printf("\n\nDEBUG:\n");
            sprintf(sbuf2,"  EPsq: %c%c (%d)\n  RemP: %c%c (%d)",
                             'a'+(EPSQ&7), '8'-(EPSQ>>4&7), EPSQ,
                             'a'+(RemP&7), '8'-(RemP>>4&7), RemP);
            strcat(sbuf, sbuf2);
            printf(sbuf);
            printf("\n\n");
       //  }
        // else printf("\n\nILLEGAL!\n");
    
       }
    }
    - - - Aktualisiert - - -

    update:
    Sketch 1.5.8 installiert (vorher 1.5.6) - selber Fehler beim Due,
    Mega immer noch ok!

    MIST!

    Kann bitte mal jemand den Code auf einem eigenen Due mal ausprobieren?
    Geändert von HaWe (15.11.2014 um 23:40 Uhr)

  2. #2
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    13.01.2014
    Beiträge
    398
    Blog-Einträge
    3
    Das ist definitiv kein Quelltext, den man (ich) auf Anhieb versteht.

    Der Mega hat 8Bit Register, der Due hat nen 32Bit ARM-Controller. Ich rate mal, dass das Problem daher rührt. Ich würde mal mit sizeof() die Datentypengrößen testen.
    Sowas:
    void setup() {
    Serial.begin(9600);
    Serial.print("sizeof(HTarray[0]) = ");Serial.println(sizeof(HTarray[0]));
    Serial.print("sizeof(char) = ");Serial.println(sizeof(char));
    Serial.print("sizeof(int*) = ");Serial.println(sizeof(int*));
    //...
    }

    }

  3. #3
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.559
    ich übergebe ja nur Zahlen (2 isolierte char für das Quadrat, wie z.B. d 2 oder a 7), das kann doch nichts mit der Größe für integer (16 oder 32 bit ) zu tun haben?

    Außerdem läuft ja der Code sowohl auf dem 8-bit AVR als auch auf meinem PC (32 oder 64 bit, kA), nur der ARM macht Mist.

    Es hilft wirklich nur austesten, es kann ja nur ein Compilerfehler oder ein Hardwarefehler sein.
    Compilerfehler müsste jeder mit der 1.5.8 Version anchvollziehen können, Hardwarefehler ist sicher abhängig von Klon oder original (ich habe einen China-Klon).

  4. #4
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    599
    Hallo,

    ändert sich etwas, wenn du in dem Code für den Due mal alle int durch int16_t ersetzt ?

    Oder wenn du ganz oben, vor das #define eine Zeile mit
    #pragma pack(1)
    einfügst ?
    Geändert von Mxt (16.11.2014 um 09:41 Uhr)

  5. #5
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.559
    keine Änderung mit int16_t
    der PC mit devcpp nutzt aber auch int32 i.Ggs. zu int16 beim AVR.

    #pragma pack(1) bringt auch keine Änderung.


    immer serselbe Fehler:
    Eröffnung:

    Weiss: d2d4
    OK


    Schwarz: a7a6
    bei Due: Fehler, wird nicht angenommen / nicht ausgeführt
    bei allen anderen: OK.

    stattdessen automove: bei allen ok




    wieder weiß:
    c2c4 bei allen ok

    wieder Schwarz:
    korrekte manuelle Züge klappen nicht bei Due, aber klappen bei allen anderen.
    automatische Züge klappen weiterhin.


    man braucht also zum Testen nur die folgenden 2 Schritte:

    Code:
    Weiss: 
    d2d4 
    
    
    Schwarz:
    a7a6
    testet es doch mal bitte auf euren Dues,
    und ggf. auch auf euren Megas zum Vergleich!

  6. #6
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    13.01.2014
    Beiträge
    398
    Blog-Einträge
    3
    Schau doch mal, ob die Eingabe vom Due genauso aufgenommen wird, wie beim Mega.
    Code:
    ...
    do   {
           while (Serial.available()==0);       
           cstring[i] = Serial.read();     
           if(cstring[i]==13) {
             cstring[i]=0;
             break;
           }
           else i++;
         } while(i < 10);
         
         K=I;
         
         if(cstring[0]!=0) {                                   /* parse entered move */
           K= cstring[0]-16*cstring[1]+799;
           L= cstring[2]-16*cstring[3]+799;
         }    
    
         // DEBUG Ausgabe
         Serial.print("DEBUG cstring : "); Serial.println(cstring);
         Serial.print("DEBUG K: "); Serial.println(K);
         Serial.print("DEBUG L: "); Serial.println(L);
         Serial.println();  Serial.println(cstring);  Serial.println();
    ...

  7. #7
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.559
    bei Sketch immer das gleiche, leider stellt Sketch die Nummern als Buchstaben dar (32== Leerzeichen!!)
    (da lobe ich mir die ANSI-C-Ausgabe mit printf)

    habe jetzt deine Debug Zeilen angepasst, Ergebnis folgt...

    Serial.print("DEBUG cstring : "); Serial.println(cstring);
    sprintf(sbuf,"\n DEBUG K: %d \n DEBUG L: %d \n", K, L);
    Serial.print(sbuf);

    edit: im ANSI-C-Code:
    printf(" DEBUG %c%c%c%c \n DEBUG K: %d \n DEBUG L: %d \n", cstring[0],cstring[1],cstring[2],cstring[3], K, L);

    - - - Aktualisiert - - -

    Code:
    Mega:
    ======
    
    
     r n b q k b n r 
     + + + + + + + + 
     . . . . . . . . 
     . . . . . . . . 
     . . . . . . . . 
     . . . . . . . . 
     * * * * * * * * 
     R N B Q K B N R 
    
    >  WHITE: DEBUG cstring : d2d4
    
     DEBUG K: 99  
     DEBUG L: 67 
    
    d2d4
    
    
    score=30000
    
    
    
    moved: >> d2-d4 
    
    DEBUG:
     (square 99 to 67 ) 
      EPsq: d3 (83)
      RemP: a8 (128)
    
    
     r n b q k b n r 
     + + + + + + + + 
     . . . . . . . . 
     . . . . . . . . 
     . . . * . . . . 
     . . . . . . . . 
     * * * . * * * * 
     R N B Q K B N R 
    
    >   BLACK:  DEBUG cstring : a7a6
    
     DEBUG K: 16  
     DEBUG L: 32 
    
    a7a6
    
    
    score=30000
    
    
    
    moved: >> a7-a6 
    
    DEBUG:
     (square 16 to 32 ) 
      EPsq: a8 (128)
      RemP: a8 (128)
    
    
     r n b q k b n r 
     . + + + + + + + 
     + . . . . . . . 
     . . . . . . . . 
     . . . * . . . . 
     . . . . . . . . 
     * * * . * * * * 
     R N B Q K B N R 
    
    >  WHITE: //<<<<<<<<<<<<<<<<<< korrekt ausgeführt, wieder WEISS am Zug!
    
    
    
    
    
    //--------------------------------------------------------------
    
    
    
    Due:
    ====
    
    
     r n b q k b n r 
     + + + + + + + + 
     . . . . . . . . 
     . . . . . . . . 
     . . . . . . . . 
     . . . . . . . . 
     * * * * * * * * 
     R N B Q K B N R 
    
    >  WHITE: DEBUG cstring : d2d4
    
     DEBUG K: 99  
     DEBUG L: 67 
    
    d2d4
    
    
    score=30000
    
    
    
    moved: >> d2-d4 
    
    DEBUG:
     (square 99 to 67 ) 
      EPsq: d3 (83)
      RemP: a8 (128)
    
    
     r n b q k b n r 
     + + + + + + + + 
     . . . . . . . . 
     . . . . . . . . 
     . . . * . . . . 
     . . . . . . . . 
     * * * . * * * * 
     R N B Q K B N R 
    
    >   BLACK:  DEBUG cstring : a7a6
    
     DEBUG K: 16  
     DEBUG L: 32 
    
    a7a6
    
    
    score=15
    
    
    
    moved: >> a7-a6 
    
    DEBUG:
     (square 16 to 32 ) 
      EPsq: d3 (83)
      RemP: a8 (128)
    
    
     r n b q k b n r 
     + + + + + + + + 
     . . . . . . . . 
     . . . . . . . . 
     . . . * . . . . 
     . . . . . . . . 
     * * * . * * * * 
     R N B Q K B N R 
    
    >   BLACK:  //<<<<<<<<<<<<<<<<<< nicht ausgeführt, bleibt hier hängen
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    //--------------------------------------------------------------
    
    devcpp:
    =======
    
    
     r n b q k b n r
     + + + + + + + +
     . . . . . . . .
     . . . . . . . .
     . . . . . . . .
     . . . . . . . .
     * * * * * * * *
     R N B Q K B N R
    
    >  WHITE: d2d4
    d
     DEBUG K: 99
     DEBUG L: 67
    
    
    score=30000
    
    
    moved: >> d2-d4
    
    DEBUG:
     (square 99 to 67 )
      EPsq: d3 (83)
      RemP: a8 (128)
    
    
     r n b q k b n r
     + + + + + + + +
     . . . . . . . .
     . . . . . . . .
     . . . * . . . .
     . . . . . . . .
     * * * . * * * *
     R N B Q K B N R
    
    >   BLACK:  a7a6
    a
     DEBUG K: 16
     DEBUG L: 32
    
    
    score=30000
    
    
    moved: >> a7-a6
    
    DEBUG:
     (square 16 to 32 )
      EPsq: a8 (128)
      RemP: a8 (128)
    
    
     r n b q k b n r
     . + + + + + + +
     + . . . . . . .
     . . . . . . . .
     . . . * . . . .
     . . . . . . . .
     * * * . * * * *
     R N B Q K B N R
    
    >  WHITE:  //<<<<<<<<<<<<<<<<<< korrekt ausgeführt, wieder WEISS am Zug!
    K und L (Zug von K nach L) stimmen bei Sketch und devcpp alle überein .




    edit: Debugstring für ANSI C geändert:
    printf(" DEBUG %c%c%c%c \n DEBUG K: %d \n DEBUG L: %d \n", cstring[0],cstring[1],cstring[2],cstring[3], K, L);
    Eingabestring ist im Original-Code ein int-array, kein char-array! Immerhin stimmt aber auch immer das Ergebnis für K und L.
    Er müsste bei devcpp eigtl auch von cstring in iarray o.ä. umbenannt werden.
    Ich finde allerdings schon, dass hier die Zugeingabe von Muller ein wenig zu sehr "obfuscated" ist, man müsste das mal verbessern - ist momentan aber nicht das Problem.)
    Geändert von HaWe (16.11.2014 um 13:37 Uhr)

  8. #8
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    599
    Der Code scheint in der Tat irgendeine Plattformabhängigkeit zu haben.

    Ich habe mir den zweiten Quelltext aus dem ersten Posting (ursprünglich für devcpp) geschnappt und mit Visual Studio unter Windows (als 32-Bit) und mit dem g++ unter Ubuntu auf dem Beaglebone Black übersetzt.

    Auch da bekomme ich nach BLACK: a7a6 auf dem Laptop den Score 30000 und unter Linux den Score 15.

    ====

    Zwei Nachträge:

    1) Am g++ liegt es nicht, mit CLang kommt das selbe Ergebnis (allerdings 18 Warnungen zum Quelltext ...)

    2) Eventuell liegt es an Dingen wie diesem:
    Code:
    #define K(A,B) *(int*)(T+A+(B&8)+S*(B&7))
    Da werden irgendwelche Adressen berechnet, möglicherweise werden da Dinge gemacht, die auf ARM so nicht gelten.
    Geändert von Mxt (16.11.2014 um 12:55 Uhr) Grund: Noch was ausprobiert

  9. #9
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.559
    danke, das ist ja schon mal sehr interessant mit Laptop vs. Beaglebone.

    was er hier allerdings macht mit den ganzen Pointern

    #define K(A,B) *(int*)(T+A+( B&8 )+S*( B&7 ))

    ist mir selber völlig unklar.

    wenn man das mal in vernünftigen Code ohne Pointer übersetzen könnte, könnte man mal gucken....

  10. #10
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    13.01.2014
    Beiträge
    398
    Blog-Einträge
    3
    #define K(A,B) *(int*)(T+A+( B&8 )+S*( B&7 ))

    ist im Prinzip das gleiche wie

    #define K(A,B) (int)(T+A+( B&8 )+S*( B&7 ))

    Warum die Indirektion über den Inhaltsoperator eines Int-Pointers ( *(int*) ) gewählt wurde, ist mir schleierhaft.
    Am Ende ist es ein einfacher Int-Cast...

Seite 1 von 5 123 ... LetzteLetzte

Ähnliche Themen

  1. Arduino Mega/Due: i2c Master port multiplexen
    Von HaWe im Forum Suche bestimmtes Bauteil bzw. Empfehlung
    Antworten: 42
    Letzter Beitrag: 12.10.2014, 13:51
  2. Schon wieder: Problem mit I2C (c, mega8, mega 32)
    Von avrrobot im Forum C - Programmierung (GCC u.a.)
    Antworten: 6
    Letzter Beitrag: 19.01.2012, 20:10
  3. mega 128 hängt sich auf /oder schon tod?
    Von demlinger im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 13
    Letzter Beitrag: 09.09.2007, 20:34
  4. Rechnet der AVR falsch oder bin in ich nur zu dumm ?
    Von NumberFive im Forum C - Programmierung (GCC u.a.)
    Antworten: 9
    Letzter Beitrag: 11.02.2005, 14:35
  5. Schon mal an eine Ethernetschnittstelle gedacht?
    Von roboguy im Forum Elektronik
    Antworten: 10
    Letzter Beitrag: 27.10.2004, 22:40

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •